@bobfrankston/mailx 1.0.12 → 1.0.13

package/packages/mailx-api/node_modules/nodemailer/lib/base64/index.js

@@ -1,139 +0,0 @@
-'use strict';
-
-const Transform = require('stream').Transform;
-
-/**
- * Encodes a Buffer into a base64 encoded string
- *
- * @param {Buffer} buffer Buffer to convert
- * @returns {String} base64 encoded string
- */
-function encode(buffer) {
-    if (typeof buffer === 'string') {
-        buffer = Buffer.from(buffer, 'utf-8');
-    }
-
-    return buffer.toString('base64');
-}
-
-/**
- * Adds soft line breaks to a base64 string
- *
- * @param {String} str base64 encoded string that might need line wrapping
- * @param {Number} [lineLength=76] Maximum allowed length for a line
- * @returns {String} Soft-wrapped base64 encoded string
- */
-function wrap(str, lineLength) {
-    str = (str || '').toString();
-    lineLength = lineLength || 76;
-
-    if (str.length <= lineLength) {
-        return str;
-    }
-
-    let result = [];
-    let pos = 0;
-    let chunkLength = lineLength * 1024;
-    while (pos < str.length) {
-        let wrappedLines = str.substr(pos, chunkLength).replace(new RegExp('.{' + lineLength + '}', 'g'), '$&\r\n');
-        result.push(wrappedLines);
-        pos += chunkLength;
-    }
-
-    return result.join('');
-}
-
-/**
- * Creates a transform stream for encoding data to base64 encoding
- *
- * @constructor
- * @param {Object} options Stream options
- * @param {Number} [options.lineLength=76] Maximum length for lines, set to false to disable wrapping
- */
-class Encoder extends Transform {
-    constructor(options) {
-        super();
-        this.options = options || {};
-
-        if (this.options.lineLength !== false) {
-            this.options.lineLength = this.options.lineLength || 76;
-        }
-
-        this._curLine = '';
-        this._remainingBytes = false;
-
-        this.inputBytes = 0;
-        this.outputBytes = 0;
-    }
-
-    _transform(chunk, encoding, done) {
-        if (encoding !== 'buffer') {
-            chunk = Buffer.from(chunk, encoding);
-        }
-
-        if (!chunk || !chunk.length) {
-            return setImmediate(done);
-        }
-
-        this.inputBytes += chunk.length;
-
-        if (this._remainingBytes && this._remainingBytes.length) {
-            chunk = Buffer.concat([this._remainingBytes, chunk], this._remainingBytes.length + chunk.length);
-            this._remainingBytes = false;
-        }
-
-        if (chunk.length % 3) {
-            this._remainingBytes = chunk.slice(chunk.length - (chunk.length % 3));
-            chunk = chunk.slice(0, chunk.length - (chunk.length % 3));
-        } else {
-            this._remainingBytes = false;
-        }
-
-        let b64 = this._curLine + encode(chunk);
-
-        if (this.options.lineLength) {
-            b64 = wrap(b64, this.options.lineLength);
-
-            let lastLF = b64.lastIndexOf('\n');
-            if (lastLF < 0) {
-                this._curLine = b64;
-                b64 = '';
-            } else {
-                this._curLine = b64.substring(lastLF + 1);
-                b64 = b64.substring(0, lastLF + 1);
-
-                if (b64 && !b64.endsWith('\r\n')) {
-                    b64 += '\r\n';
-                }
-            }
-        } else {
-            this._curLine = '';
-        }
-
-        if (b64) {
-            this.outputBytes += b64.length;
-            this.push(Buffer.from(b64, 'ascii'));
-        }
-
-        setImmediate(done);
-    }
-
-    _flush(done) {
-        if (this._remainingBytes && this._remainingBytes.length) {
-            this._curLine += encode(this._remainingBytes);
-        }
-
-        if (this._curLine) {
-            this.outputBytes += this._curLine.length;
-            this.push(Buffer.from(this._curLine, 'ascii'));
-            this._curLine = '';
-        }
-        done();
-    }
-}
-
-module.exports = {
-    encode,
-    wrap,
-    Encoder
-};

package/packages/mailx-api/node_modules/nodemailer/lib/dkim/index.js

@@ -1,253 +0,0 @@
-'use strict';
-
-// FIXME:
-// replace this Transform mess with a method that pipes input argument to output argument
-
-const MessageParser = require('./message-parser');
-const RelaxedBody = require('./relaxed-body');
-const sign = require('./sign');
-const PassThrough = require('stream').PassThrough;
-const fs = require('fs');
-const path = require('path');
-const crypto = require('crypto');
-
-const DKIM_ALGO = 'sha256';
-const MAX_MESSAGE_SIZE = 2 * 1024 * 1024; // buffer messages larger than this to disk
-
-/*
-// Usage:
-
-let dkim = new DKIM({
-    domainName: 'example.com',
-    keySelector: 'key-selector',
-    privateKey,
-    cacheDir: '/tmp'
-});
-dkim.sign(input).pipe(process.stdout);
-
-// Where inputStream is a rfc822 message (either a stream, string or Buffer)
-// and outputStream is a DKIM signed rfc822 message
-*/
-
-class DKIMSigner {
-    constructor(options, keys, input, output) {
-        this.options = options || {};
-        this.keys = keys;
-
-        this.cacheTreshold = Number(this.options.cacheTreshold) || MAX_MESSAGE_SIZE;
-        this.hashAlgo = this.options.hashAlgo || DKIM_ALGO;
-
-        this.cacheDir = this.options.cacheDir || false;
-
-        this.chunks = [];
-        this.chunklen = 0;
-        this.readPos = 0;
-        this.cachePath = this.cacheDir
-            ? path.join(this.cacheDir, 'message.' + Date.now() + '-' + crypto.randomBytes(14).toString('hex'))
-            : false;
-        this.cache = false;
-
-        this.headers = false;
-        this.bodyHash = false;
-        this.parser = false;
-        this.relaxedBody = false;
-
-        this.input = input;
-        this.output = output;
-        this.output.usingCache = false;
-
-        this.hasErrored = false;
-
-        this.input.on('error', err => {
-            this.hasErrored = true;
-            this.cleanup();
-            output.emit('error', err);
-        });
-    }
-
-    cleanup() {
-        if (!this.cache || !this.cachePath) {
-            return;
-        }
-        fs.unlink(this.cachePath, () => false);
-    }
-
-    createReadCache() {
-        // pipe remainings to cache file
-        this.cache = fs.createReadStream(this.cachePath);
-        this.cache.once('error', err => {
-            this.cleanup();
-            this.output.emit('error', err);
-        });
-        this.cache.once('close', () => {
-            this.cleanup();
-        });
-        this.cache.pipe(this.output);
-    }
-
-    sendNextChunk() {
-        if (this.hasErrored) {
-            return;
-        }
-
-        if (this.readPos >= this.chunks.length) {
-            if (!this.cache) {
-                return this.output.end();
-            }
-            return this.createReadCache();
-        }
-        let chunk = this.chunks[this.readPos++];
-        if (this.output.write(chunk) === false) {
-            return this.output.once('drain', () => {
-                this.sendNextChunk();
-            });
-        }
-        setImmediate(() => this.sendNextChunk());
-    }
-
-    sendSignedOutput() {
-        let keyPos = 0;
-        let signNextKey = () => {
-            if (keyPos >= this.keys.length) {
-                this.output.write(this.parser.rawHeaders);
-                return setImmediate(() => this.sendNextChunk());
-            }
-            let key = this.keys[keyPos++];
-            let dkimField = sign(this.headers, this.hashAlgo, this.bodyHash, {
-                domainName: key.domainName,
-                keySelector: key.keySelector,
-                privateKey: key.privateKey,
-                headerFieldNames: this.options.headerFieldNames,
-                skipFields: this.options.skipFields
-            });
-            if (dkimField) {
-                this.output.write(Buffer.from(dkimField + '\r\n'));
-            }
-            return setImmediate(signNextKey);
-        };
-
-        if (this.bodyHash && this.headers) {
-            return signNextKey();
-        }
-
-        this.output.write(this.parser.rawHeaders);
-        this.sendNextChunk();
-    }
-
-    createWriteCache() {
-        this.output.usingCache = true;
-        // pipe remainings to cache file
-        this.cache = fs.createWriteStream(this.cachePath);
-        this.cache.once('error', err => {
-            this.cleanup();
-            // drain input
-            this.relaxedBody.unpipe(this.cache);
-            this.relaxedBody.on('readable', () => {
-                while (this.relaxedBody.read() !== null) {
-                    // do nothing
-                }
-            });
-            this.hasErrored = true;
-            // emit error
-            this.output.emit('error', err);
-        });
-        this.cache.once('close', () => {
-            this.sendSignedOutput();
-        });
-        this.relaxedBody.removeAllListeners('readable');
-        this.relaxedBody.pipe(this.cache);
-    }
-
-    signStream() {
-        this.parser = new MessageParser();
-        this.relaxedBody = new RelaxedBody({
-            hashAlgo: this.hashAlgo
-        });
-
-        this.parser.on('headers', value => {
-            this.headers = value;
-        });
-
-        this.relaxedBody.on('hash', value => {
-            this.bodyHash = value;
-        });
-
-        this.relaxedBody.on('readable', () => {
-            let chunk;
-            if (this.cache) {
-                return;
-            }
-            while ((chunk = this.relaxedBody.read()) !== null) {
-                this.chunks.push(chunk);
-                this.chunklen += chunk.length;
-                if (this.chunklen >= this.cacheTreshold && this.cachePath) {
-                    return this.createWriteCache();
-                }
-            }
-        });
-
-        this.relaxedBody.on('end', () => {
-            if (this.cache) {
-                return;
-            }
-            this.sendSignedOutput();
-        });
-
-        this.parser.pipe(this.relaxedBody);
-        setImmediate(() => this.input.pipe(this.parser));
-    }
-}
-
-class DKIM {
-    constructor(options) {
-        this.options = options || {};
-        this.keys = [].concat(
-            this.options.keys || {
-                domainName: options.domainName,
-                keySelector: options.keySelector,
-                privateKey: options.privateKey
-            }
-        );
-    }
-
-    sign(input, extraOptions) {
-        let output = new PassThrough();
-        let inputStream = input;
-        let writeValue = false;
-
-        if (Buffer.isBuffer(input)) {
-            writeValue = input;
-            inputStream = new PassThrough();
-        } else if (typeof input === 'string') {
-            writeValue = Buffer.from(input);
-            inputStream = new PassThrough();
-        }
-
-        let options = this.options;
-        if (extraOptions && Object.keys(extraOptions).length) {
-            options = {};
-            Object.keys(this.options || {}).forEach(key => {
-                options[key] = this.options[key];
-            });
-            Object.keys(extraOptions || {}).forEach(key => {
-                if (!(key in options)) {
-                    options[key] = extraOptions[key];
-                }
-            });
-        }
-
-        let signer = new DKIMSigner(options, this.keys, inputStream, output);
-        setImmediate(() => {
-            signer.signStream();
-            if (writeValue) {
-                setImmediate(() => {
-                    inputStream.end(writeValue);
-                });
-            }
-        });
-
-        return output;
-    }
-}
-
-module.exports = DKIM;

package/packages/mailx-api/node_modules/nodemailer/lib/dkim/message-parser.js

@@ -1,155 +0,0 @@
-'use strict';
-
-const Transform = require('stream').Transform;
-
-/**
- * MessageParser instance is a transform stream that separates message headers
- * from the rest of the body. Headers are emitted with the 'headers' event. Message
- * body is passed on as the resulting stream.
- */
-class MessageParser extends Transform {
-    constructor(options) {
-        super(options);
-        this.lastBytes = Buffer.alloc(4);
-        this.headersParsed = false;
-        this.headerBytes = 0;
-        this.headerChunks = [];
-        this.rawHeaders = false;
-        this.bodySize = 0;
-    }
-
-    /**
-     * Keeps count of the last 4 bytes in order to detect line breaks on chunk boundaries
-     *
-     * @param {Buffer} data Next data chunk from the stream
-     */
-    updateLastBytes(data) {
-        let lblen = this.lastBytes.length;
-        let nblen = Math.min(data.length, lblen);
-
-        // shift existing bytes
-        for (let i = 0, len = lblen - nblen; i < len; i++) {
-            this.lastBytes[i] = this.lastBytes[i + nblen];
-        }
-
-        // add new bytes
-        for (let i = 1; i <= nblen; i++) {
-            this.lastBytes[lblen - i] = data[data.length - i];
-        }
-    }
-
-    /**
-     * Finds and removes message headers from the remaining body. We want to keep
-     * headers separated until final delivery to be able to modify these
-     *
-     * @param {Buffer} data Next chunk of data
-     * @return {Boolean} Returns true if headers are already found or false otherwise
-     */
-    checkHeaders(data) {
-        if (this.headersParsed) {
-            return true;
-        }
-
-        let lblen = this.lastBytes.length;
-        let headerPos = 0;
-        this.curLinePos = 0;
-        for (let i = 0, len = this.lastBytes.length + data.length; i < len; i++) {
-            let chr;
-            if (i < lblen) {
-                chr = this.lastBytes[i];
-            } else {
-                chr = data[i - lblen];
-            }
-            if (chr === 0x0a && i) {
-                let pr1 = i - 1 < lblen ? this.lastBytes[i - 1] : data[i - 1 - lblen];
-                let pr2 = i > 1 ? (i - 2 < lblen ? this.lastBytes[i - 2] : data[i - 2 - lblen]) : false;
-                if (pr1 === 0x0a) {
-                    this.headersParsed = true;
-                    headerPos = i - lblen + 1;
-                    this.headerBytes += headerPos;
-                    break;
-                } else if (pr1 === 0x0d && pr2 === 0x0a) {
-                    this.headersParsed = true;
-                    headerPos = i - lblen + 1;
-                    this.headerBytes += headerPos;
-                    break;
-                }
-            }
-        }
-
-        if (this.headersParsed) {
-            this.headerChunks.push(data.slice(0, headerPos));
-            this.rawHeaders = Buffer.concat(this.headerChunks, this.headerBytes);
-            this.headerChunks = null;
-            this.emit('headers', this.parseHeaders());
-            if (data.length - 1 > headerPos) {
-                let chunk = data.slice(headerPos);
-                this.bodySize += chunk.length;
-                // this would be the first chunk of data sent downstream
-                setImmediate(() => this.push(chunk));
-            }
-            return false;
-        } else {
-            this.headerBytes += data.length;
-            this.headerChunks.push(data);
-        }
-
-        // store last 4 bytes to catch header break
-        this.updateLastBytes(data);
-
-        return false;
-    }
-
-    _transform(chunk, encoding, callback) {
-        if (!chunk || !chunk.length) {
-            return callback();
-        }
-
-        if (typeof chunk === 'string') {
-            chunk = Buffer.from(chunk, encoding);
-        }
-
-        let headersFound;
-
-        try {
-            headersFound = this.checkHeaders(chunk);
-        } catch (E) {
-            return callback(E);
-        }
-
-        if (headersFound) {
-            this.bodySize += chunk.length;
-            this.push(chunk);
-        }
-
-        setImmediate(callback);
-    }
-
-    _flush(callback) {
-        if (this.headerChunks) {
-            let chunk = Buffer.concat(this.headerChunks, this.headerBytes);
-            this.bodySize += chunk.length;
-            this.push(chunk);
-            this.headerChunks = null;
-        }
-        callback();
-    }
-
-    parseHeaders() {
-        let lines = (this.rawHeaders || '').toString().split(/\r?\n/);
-        for (let i = lines.length - 1; i > 0; i--) {
-            if (/^\s/.test(lines[i])) {
-                lines[i - 1] += '\n' + lines[i];
-                lines.splice(i, 1);
-            }
-        }
-        return lines
-            .filter(line => line.trim())
-            .map(line => ({
-                key: line.substr(0, line.indexOf(':')).trim().toLowerCase(),
-                line
-            }));
-    }
-}
-
-module.exports = MessageParser;

package/packages/mailx-api/node_modules/nodemailer/lib/dkim/relaxed-body.js

@@ -1,154 +0,0 @@
-'use strict';
-
-// streams through a message body and calculates relaxed body hash
-
-const Transform = require('stream').Transform;
-const crypto = require('crypto');
-
-class RelaxedBody extends Transform {
-    constructor(options) {
-        super();
-        options = options || {};
-        this.chunkBuffer = [];
-        this.chunkBufferLen = 0;
-        this.bodyHash = crypto.createHash(options.hashAlgo || 'sha1');
-        this.remainder = '';
-        this.byteLength = 0;
-
-        this.debug = options.debug;
-        this._debugBody = options.debug ? [] : false;
-    }
-
-    updateHash(chunk) {
-        let bodyStr;
-
-        // find next remainder
-        let nextRemainder = '';
-
-        // This crux finds and removes the spaces from the last line and the newline characters after the last non-empty line
-        // If we get another chunk that does not match this description then we can restore the previously processed data
-        let state = 'file';
-        for (let i = chunk.length - 1; i >= 0; i--) {
-            let c = chunk[i];
-
-            if (state === 'file' && (c === 0x0a || c === 0x0d)) {
-                // do nothing, found \n or \r at the end of chunk, stil end of file
-            } else if (state === 'file' && (c === 0x09 || c === 0x20)) {
-                // switch to line ending mode, this is the last non-empty line
-                state = 'line';
-            } else if (state === 'line' && (c === 0x09 || c === 0x20)) {
-                // do nothing, found ' ' or \t at the end of line, keep processing the last non-empty line
-            } else if (state === 'file' || state === 'line') {
-                // non line/file ending character found, switch to body mode
-                state = 'body';
-                if (i === chunk.length - 1) {
-                    // final char is not part of line end or file end, so do nothing
-                    break;
-                }
-            }
-
-            if (i === 0) {
-                // reached to the beginning of the chunk, check if it is still about the ending
-                // and if the remainder also matches
-                if (
-                    (state === 'file' && (!this.remainder || /[\r\n]$/.test(this.remainder))) ||
-                    (state === 'line' && (!this.remainder || /[ \t]$/.test(this.remainder)))
-                ) {
-                    // keep everything
-                    this.remainder += chunk.toString('binary');
-                    return;
-                } else if (state === 'line' || state === 'file') {
-                    // process existing remainder as normal line but store the current chunk
-                    nextRemainder = chunk.toString('binary');
-                    chunk = false;
-                    break;
-                }
-            }
-
-            if (state !== 'body') {
-                continue;
-            }
-
-            // reached first non ending byte
-            nextRemainder = chunk.slice(i + 1).toString('binary');
-            chunk = chunk.slice(0, i + 1);
-            break;
-        }
-
-        let needsFixing = !!this.remainder;
-        if (chunk && !needsFixing) {
-            // check if we even need to change anything
-            for (let i = 0, len = chunk.length; i < len; i++) {
-                if (i && chunk[i] === 0x0a && chunk[i - 1] !== 0x0d) {
-                    // missing \r before \n
-                    needsFixing = true;
-                    break;
-                } else if (i && chunk[i] === 0x0d && chunk[i - 1] === 0x20) {
-                    // trailing WSP found
-                    needsFixing = true;
-                    break;
-                } else if (i && chunk[i] === 0x20 && chunk[i - 1] === 0x20) {
-                    // multiple spaces found, needs to be replaced with just one
-                    needsFixing = true;
-                    break;
-                } else if (chunk[i] === 0x09) {
-                    // TAB found, needs to be replaced with a space
-                    needsFixing = true;
-                    break;
-                }
-            }
-        }
-
-        if (needsFixing) {
-            bodyStr = this.remainder + (chunk ? chunk.toString('binary') : '');
-            this.remainder = nextRemainder;
-            bodyStr = bodyStr
-                .replace(/\r?\n/g, '\n') // use js line endings
-                .replace(/[ \t]*$/gm, '') // remove line endings, rtrim
-                .replace(/[ \t]+/gm, ' ') // single spaces
-                .replace(/\n/g, '\r\n'); // restore rfc822 line endings
-            chunk = Buffer.from(bodyStr, 'binary');
-        } else if (nextRemainder) {
-            this.remainder = nextRemainder;
-        }
-
-        if (this.debug) {
-            this._debugBody.push(chunk);
-        }
-        this.bodyHash.update(chunk);
-    }
-
-    _transform(chunk, encoding, callback) {
-        if (!chunk || !chunk.length) {
-            return callback();
-        }
-
-        if (typeof chunk === 'string') {
-            chunk = Buffer.from(chunk, encoding);
-        }
-
-        this.updateHash(chunk);
-
-        this.byteLength += chunk.length;
-        this.push(chunk);
-        callback();
-    }
-
-    _flush(callback) {
-        // generate final hash and emit it
-        if (/[\r\n]$/.test(this.remainder) && this.byteLength > 2) {
-            // add terminating line end
-            this.bodyHash.update(Buffer.from('\r\n'));
-        }
-        if (!this.byteLength) {
-            // emit empty line buffer to keep the stream flowing
-            this.push(Buffer.from('\r\n'));
-            // this.bodyHash.update(Buffer.from('\r\n'));
-        }
-
-        this.emit('hash', this.bodyHash.digest('base64'), this.debug ? Buffer.concat(this._debugBody) : false);
-        callback();
-    }
-}
-
-module.exports = RelaxedBody;