eml-parser-qaap 1.1.15

package/lib/bundle.iife.js

@@ -0,0 +1,1431 @@
+(function (exports, jsBase64, textEncoding) {
+	'use strict';
+
+	/**
+	 * Encodes an unicode string into an Uint8Array object as UTF-8
+	 *
+	 * @param {String} str String to be encoded
+	 * @return {Uint8Array} UTF-8 encoded typed array
+	 */
+	var encode = function (str, fromCharset) {
+	    if (fromCharset === void 0) { fromCharset = 'utf-8'; }
+	    return new textEncoding.TextEncoder(fromCharset).encode(str);
+	};
+	var arr2str = function (arr) {
+	    var CHUNK_SZ = 0x8000;
+	    var strs = [];
+	    for (var i = 0; i < arr.length; i += CHUNK_SZ) {
+	        strs.push(String.fromCharCode.apply(null, arr.subarray(i, i + CHUNK_SZ)));
+	    }
+	    return strs.join('');
+	};
+	/**
+	 * Decodes a string from Uint8Array to an unicode string using specified encoding
+	 *
+	 * @param {Uint8Array} buf Binary data to be decoded
+	 * @param {String} Binary data is decoded into string using this charset
+	 * @return {String} Decoded string
+	 */
+	function decode(buf, fromCharset) {
+	    if (fromCharset === void 0) { fromCharset = 'utf-8'; }
+	    var charsets = [
+	        { charset: normalizeCharset(fromCharset), fatal: false },
+	        { charset: 'utf-8', fatal: true },
+	        { charset: 'iso-8859-15', fatal: false },
+	    ];
+	    for (var _i = 0, charsets_1 = charsets; _i < charsets_1.length; _i++) {
+	        var _a = charsets_1[_i], charset = _a.charset, fatal = _a.fatal;
+	        try {
+	            return new textEncoding.TextDecoder(charset, { fatal: fatal }).decode(buf);
+	            // eslint-disable-next-line no-empty
+	        }
+	        catch (e) { }
+	    }
+	    return arr2str(buf); // all else fails, treat it as binary
+	}
+	/**
+	 * Convert a string from specific encoding to UTF-8 Uint8Array
+	 *
+	 * @param {String|Uint8Array} data Data to be encoded
+	 * @param {String} Source encoding for the string (optional for data of type String)
+	 * @return {Uint8Array} UTF-8 encoded typed array
+	 */
+	var convert = function (data, fromCharset) {
+	    return typeof data === 'string' ? encode(data) : encode(decode(data, fromCharset));
+	};
+	function normalizeCharset(charset) {
+	    if (charset === void 0) { charset = 'utf-8'; }
+	    var match;
+	    if ((match = charset.match(/^utf[-_]?(\d+)$/i))) {
+	        return 'UTF-' + match[1];
+	    }
+	    if ((match = charset.match(/^win[-_]?(\d+)$/i))) {
+	        return 'WINDOWS-' + match[1];
+	    }
+	    if ((match = charset.match(/^latin[-_]?(\d+)$/i))) {
+	        return 'ISO-8859-' + match[1];
+	    }
+	    return charset;
+	}
+
+	/**
+	 * Gets the boundary name
+	 * @param contentType - string
+	 */
+	function getBoundary(contentType) {
+	    var match = /(?:B|b)oundary=(?:'|")?(.+?)(?:'|")?(\s*;[\s\S]*)?$/g.exec(contentType);
+	    return match ? match[1] : undefined;
+	}
+	//Gets the character encoding name for iconv, e.g. 'iso-8859-2' -> 'iso88592'
+	function getCharsetName(charset) {
+	    return charset.toLowerCase().replace(/[^0-9a-z]/g, '');
+	}
+	//Generates a random id
+	function guid() {
+	    return 'xxxxxxxxxxxx-4xxx-yxxx-xxxxxxxxxxxx'
+	        .replace(/[xy]/g, function (c) {
+	        var r = (Math.random() * 16) | 0, v = c == 'x' ? r : (r & 0x3) | 0x8;
+	        return v.toString(16);
+	    })
+	        .replace('-', '');
+	}
+	//Word-wrap the string 's' to 'i' chars per row
+	function wrap(s, i) {
+	    var a = [];
+	    do {
+	        a.push(s.substring(0, i));
+	    } while ((s = s.substring(i, s.length)) != '');
+	    return a.join('\r\n');
+	}
+	/**
+	 * Decodes mime encoded string to an unicode string
+	 *
+	 * @param {String} str Mime encoded string
+	 * @param {String} [fromCharset='UTF-8'] Source encoding
+	 * @return {String} Decoded unicode string
+	 */
+	function mimeDecode(str, fromCharset) {
+	    if (str === void 0) { str = ''; }
+	    if (fromCharset === void 0) { fromCharset = 'UTF-8'; }
+	    var encodedBytesCount = (str.match(/=[\da-fA-F]{2}/g) || []).length;
+	    var buffer = new Uint8Array(str.length - encodedBytesCount * 2);
+	    for (var i = 0, len = str.length, bufferPos = 0; i < len; i++) {
+	        var hex = str.substr(i + 1, 2);
+	        var chr = str.charAt(i);
+	        if (chr === '=' && hex && /[\da-fA-F]{2}/.test(hex)) {
+	            buffer[bufferPos++] = parseInt(hex, 16);
+	            i += 2;
+	        }
+	        else {
+	            buffer[bufferPos++] = chr.charCodeAt(0);
+	        }
+	    }
+	    return decode(buffer, fromCharset);
+	}
+	/**
+	 * converting strings from gbk to utf-8
+	 */
+	var GB2312UTF8 = {
+	    Dig2Dec: function (s) {
+	        var retV = 0;
+	        if (s.length == 4) {
+	            for (var i = 0; i < 4; i++) {
+	                retV += eval(s.charAt(i)) * Math.pow(2, 3 - i);
+	            }
+	            return retV;
+	        }
+	        return -1;
+	    },
+	    Hex2Utf8: function (s) {
+	        var retS = '';
+	        var tempS = '';
+	        var ss = '';
+	        if (s.length == 16) {
+	            tempS = '1110' + s.substring(0, 4);
+	            tempS += '10' + s.substring(4, 10);
+	            tempS += '10' + s.substring(10, 16);
+	            var sss = '0123456789ABCDEF';
+	            for (var i = 0; i < 3; i++) {
+	                retS += '%';
+	                ss = tempS.substring(i * 8, (eval(i.toString()) + 1) * 8);
+	                retS += sss.charAt(this.Dig2Dec(ss.substring(0, 4)));
+	                retS += sss.charAt(this.Dig2Dec(ss.substring(4, 8)));
+	            }
+	            return retS;
+	        }
+	        return '';
+	    },
+	    Dec2Dig: function (n1) {
+	        var s = '';
+	        var n2 = 0;
+	        for (var i = 0; i < 4; i++) {
+	            n2 = Math.pow(2, 3 - i);
+	            if (n1 >= n2) {
+	                s += '1';
+	                n1 = n1 - n2;
+	            }
+	            else {
+	                s += '0';
+	            }
+	        }
+	        return s;
+	    },
+	    Str2Hex: function (s) {
+	        var c = '';
+	        var n;
+	        var ss = '0123456789ABCDEF';
+	        var digS = '';
+	        for (var i = 0; i < s.length; i++) {
+	            c = s.charAt(i);
+	            n = ss.indexOf(c);
+	            digS += this.Dec2Dig(eval(n.toString()));
+	        }
+	        return digS;
+	    },
+	    GB2312ToUTF8: function (s1) {
+	        var s = escape(s1);
+	        var sa = s.split('%');
+	        var retV = '';
+	        if (sa[0] != '') {
+	            retV = sa[0];
+	        }
+	        for (var i = 1; i < sa.length; i++) {
+	            if (sa[i].substring(0, 1) == 'u') {
+	                retV += this.Hex2Utf8(this.Str2Hex(sa[i].substring(1, 5)));
+	                if (sa[i].length) {
+	                    retV += sa[i].substring(5);
+	                }
+	            }
+	            else {
+	                retV += unescape('%' + sa[i]);
+	                if (sa[i].length) {
+	                    retV += sa[i].substring(5);
+	                }
+	            }
+	        }
+	        return retV;
+	    },
+	    UTF8ToGB2312: function (str1) {
+	        var substr = '';
+	        var a = '';
+	        var b = '';
+	        var c = '';
+	        var i = -1;
+	        i = str1.indexOf('%');
+	        if (i == -1) {
+	            return str1;
+	        }
+	        while (i != -1) {
+	            if (i < 3) {
+	                substr = substr + str1.substr(0, i - 1);
+	                str1 = str1.substr(i + 1, str1.length - i);
+	                a = str1.substr(0, 2);
+	                str1 = str1.substr(2, str1.length - 2);
+	                if ((parseInt('0x' + a) & 0x80) === 0) {
+	                    substr = substr + String.fromCharCode(parseInt('0x' + a));
+	                }
+	                else if ((parseInt('0x' + a) & 0xe0) === 0xc0) {
+	                    //two byte
+	                    b = str1.substr(1, 2);
+	                    str1 = str1.substr(3, str1.length - 3);
+	                    var widechar = (parseInt('0x' + a) & 0x1f) << 6;
+	                    widechar = widechar | (parseInt('0x' + b) & 0x3f);
+	                    substr = substr + String.fromCharCode(widechar);
+	                }
+	                else {
+	                    b = str1.substr(1, 2);
+	                    str1 = str1.substr(3, str1.length - 3);
+	                    c = str1.substr(1, 2);
+	                    str1 = str1.substr(3, str1.length - 3);
+	                    var widechar = (parseInt('0x' + a) & 0x0f) << 12;
+	                    widechar = widechar | ((parseInt('0x' + b) & 0x3f) << 6);
+	                    widechar = widechar | (parseInt('0x' + c) & 0x3f);
+	                    substr = substr + String.fromCharCode(widechar);
+	                }
+	            }
+	            else {
+	                substr = substr + str1.substring(0, i);
+	                str1 = str1.substring(i);
+	            }
+	            i = str1.indexOf('%');
+	        }
+	        return substr + str1;
+	    },
+	};
+
+	/**
+	 * Converts tokens for a single address into an address object
+	 *
+	 * @param {Array} tokens Tokens object
+	 * @return {Object} Address object
+	 */
+	function _handleAddress(tokens) {
+	    var token;
+	    var isGroup = false;
+	    var state = 'text';
+	    var address;
+	    var addresses = [];
+	    var data = {
+	        address: [],
+	        comment: [],
+	        group: [],
+	        text: [],
+	    };
+	    var i;
+	    var len;
+	    // Filter out <addresses>, (comments) and regular text
+	    for (i = 0, len = tokens.length; i < len; i++) {
+	        token = tokens[i];
+	        if (token.type === 'operator') {
+	            switch (token.value) {
+	                case '<':
+	                    state = 'address';
+	                    break;
+	                case '(':
+	                    state = 'comment';
+	                    break;
+	                case ':':
+	                    state = 'group';
+	                    isGroup = true;
+	                    break;
+	                default:
+	                    state = 'text';
+	            }
+	        }
+	        else if (token.value) {
+	            if (state === 'address') {
+	                // handle use case where unquoted name includes a "<"
+	                // Apple Mail truncates everything between an unexpected < and an address
+	                // and so will we
+	                token.value = token.value.replace(/^[^<]*<\s*/, '');
+	            }
+	            data[state].push(token.value);
+	        }
+	    }
+	    // If there is no text but a comment, replace the two
+	    if (!data.text.length && data.comment.length) {
+	        data.text = data.comment;
+	        data.comment = [];
+	    }
+	    if (isGroup) {
+	        // http://tools.ietf.org/html/rfc2822#appendix-A.1.3
+	        data.text = data.text.join(' ');
+	        addresses.push({
+	            name: data.text || (address && address.name),
+	            group: data.group.length ? addressparser(data.group.join(',')) : [],
+	        });
+	    }
+	    else {
+	        // If no address was found, try to detect one from regular text
+	        if (!data.address.length && data.text.length) {
+	            for (i = data.text.length - 1; i >= 0; i--) {
+	                if (data.text[i].match(/^[^@\s]+@[^@\s]+$/)) {
+	                    data.address = data.text.splice(i, 1);
+	                    break;
+	                }
+	            }
+	            var _regexHandler = function (address) {
+	                if (!data.address.length) {
+	                    data.address = [address.trim()];
+	                    return ' ';
+	                }
+	                else {
+	                    return address;
+	                }
+	            };
+	            // still no address
+	            if (!data.address.length) {
+	                for (i = data.text.length - 1; i >= 0; i--) {
+	                    // fixed the regex to parse email address correctly when email address has more than one @
+	                    data.text[i] = data.text[i].replace(/\s*\b[^@\s]+@[^\s]+\b\s*/, _regexHandler).trim();
+	                    if (data.address.length) {
+	                        break;
+	                    }
+	                }
+	            }
+	        }
+	        // If there's still is no text but a comment exixts, replace the two
+	        if (!data.text.length && data.comment.length) {
+	            data.text = data.comment;
+	            data.comment = [];
+	        }
+	        // Keep only the first address occurence, push others to regular text
+	        if (data.address.length > 1) {
+	            data.text = data.text.concat(data.address.splice(1));
+	        }
+	        // Join values with spaces
+	        data.text = data.text.join(' ');
+	        data.address = data.address.join(' ');
+	        if (!data.address && isGroup) {
+	            return [];
+	        }
+	        else {
+	            address = {
+	                address: data.address || data.text || '',
+	                name: data.text || data.address || '',
+	            };
+	            if (address.address === address.name) {
+	                if ((address.address || '').match(/@/)) {
+	                    address.name = '';
+	                }
+	                else {
+	                    address.address = '';
+	                }
+	            }
+	            addresses.push(address);
+	        }
+	    }
+	    return addresses;
+	}
+	/**
+	 * Creates a Tokenizer object for tokenizing address field strings
+	 *
+	 * @constructor
+	 * @param {String} str Address field string
+	 */
+	var Tokenizer = /** @class */ (function () {
+	    function Tokenizer(str) {
+	        this.str = (str || '').toString();
+	        this.operatorCurrent = '';
+	        this.operatorExpecting = '';
+	        this.node = null;
+	        this.escaped = false;
+	        this.list = [];
+	        /**
+	         * Operator tokens and which tokens are expected to end the sequence
+	         */
+	        this.operators = {
+	            '"': '"',
+	            '(': ')',
+	            '<': '>',
+	            ',': '',
+	            ':': ';',
+	            // Semicolons are not a legal delimiter per the RFC2822 grammar other
+	            // than for terminating a group, but they are also not valid for any
+	            // other use in this context.  Given that some mail clients have
+	            // historically allowed the semicolon as a delimiter equivalent to the
+	            // comma in their UI, it makes sense to treat them the same as a comma
+	            // when used outside of a group.
+	            ';': '',
+	        };
+	    }
+	    /**
+	     * Tokenizes the original input string
+	     *
+	     * @return {Array} An array of operator|text tokens
+	     */
+	    Tokenizer.prototype.tokenize = function () {
+	        var chr, list = [];
+	        for (var i = 0, len = this.str.length; i < len; i++) {
+	            chr = this.str.charAt(i);
+	            this.checkChar(chr);
+	        }
+	        this.list.forEach(function (node) {
+	            node.value = (node.value || '').toString().trim();
+	            if (node.value) {
+	                list.push(node);
+	            }
+	        });
+	        return list;
+	    };
+	    /**
+	     * Checks if a character is an operator or text and acts accordingly
+	     *
+	     * @param {String} chr Character from the address field
+	     */
+	    Tokenizer.prototype.checkChar = function (chr) {
+	        if (this.escaped) ;
+	        else if (chr === this.operatorExpecting) {
+	            this.node = {
+	                type: 'operator',
+	                value: chr,
+	            };
+	            this.list.push(this.node);
+	            this.node = null;
+	            this.operatorExpecting = '';
+	            this.escaped = false;
+	            return;
+	        }
+	        else if (!this.operatorExpecting && chr in this.operators) {
+	            this.node = {
+	                type: 'operator',
+	                value: chr,
+	            };
+	            this.list.push(this.node);
+	            this.node = null;
+	            this.operatorExpecting = this.operators[chr];
+	            this.escaped = false;
+	            return;
+	        }
+	        else if (['"', "'"].includes(this.operatorExpecting) && chr === '\\') {
+	            this.escaped = true;
+	            return;
+	        }
+	        if (!this.node) {
+	            this.node = {
+	                type: 'text',
+	                value: '',
+	            };
+	            this.list.push(this.node);
+	        }
+	        if (chr === '\n') {
+	            // Convert newlines to spaces. Carriage return is ignored as \r and \n usually
+	            // go together anyway and there already is a WS for \n. Lone \r means something is fishy.
+	            chr = ' ';
+	        }
+	        if (chr.charCodeAt(0) >= 0x21 || [' ', '\t'].includes(chr)) {
+	            // skip command bytes
+	            this.node.value += chr;
+	        }
+	        this.escaped = false;
+	    };
+	    return Tokenizer;
+	}());
+	/**
+	 * Parses structured e-mail addresses from an address field
+	 *
+	 * Example:
+	 *
+	 *    'Name <address@domain>'
+	 *
+	 * will be converted to
+	 *
+	 *     [{name: 'Name', address: 'address@domain'}]
+	 *
+	 * @param {String} str Address field
+	 * @return {Array} An array of address objects
+	 */
+	function addressparser(str, options) {
+	    options = options || {};
+	    var tokenizer = new Tokenizer(str);
+	    var tokens = tokenizer.tokenize();
+	    var addresses = [];
+	    var address = [];
+	    var parsedAddresses = [];
+	    tokens.forEach(function (token) {
+	        if (token.type === 'operator' && (token.value === ',' || token.value === ';')) {
+	            if (address.length) {
+	                addresses.push(address);
+	            }
+	            address = [];
+	        }
+	        else {
+	            address.push(token);
+	        }
+	    });
+	    if (address.length) {
+	        addresses.push(address);
+	    }
+	    addresses.forEach(function (address) {
+	        address = _handleAddress(address);
+	        if (address.length) {
+	            parsedAddresses = parsedAddresses.concat(address);
+	        }
+	    });
+	    if (options.flatten) {
+	        var addresses_1 = [];
+	        var walkAddressList_1 = function (list) {
+	            list.forEach(function (address) {
+	                if (address.group) {
+	                    return walkAddressList_1(address.group);
+	                }
+	                else {
+	                    addresses_1.push(address);
+	                }
+	            });
+	        };
+	        walkAddressList_1(parsedAddresses);
+	        return addresses_1;
+	    }
+	    return parsedAddresses;
+	}
+
+	/**
+	 * @author superchow
+	 * @emil superchow@live.cn
+	 */
+	/**
+	 * log for test
+	 */
+	var verbose = false;
+	var defaultCharset = 'utf-8';
+	/**
+	 * create a boundary
+	 */
+	function createBoundary() {
+	    return '----=' + guid();
+	}
+	/**
+	 * Builds e-mail address string, e.g. { name: 'PayPal', email: 'noreply@paypal.com' } => 'PayPal' <noreply@paypal.com>
+	 * @param {String|EmailAddress|EmailAddress[]|null} data
+	 */
+	function toEmailAddress(data) {
+	    var email = '';
+	    if (typeof data === 'undefined') ;
+	    else if (typeof data === 'string') {
+	        email = data;
+	    }
+	    else if (typeof data === 'object') {
+	        if (Array.isArray(data)) {
+	            email += data
+	                .map(function (item) {
+	                var str = '';
+	                if (item.name) {
+	                    str += '"' + item.name.replace(/^"|"\s*$/g, '') + '" ';
+	                }
+	                if (item.email) {
+	                    str += '<' + item.email + '>';
+	                }
+	                return str;
+	            })
+	                .filter(function (a) { return a; })
+	                .join(', ');
+	        }
+	        else {
+	            if (data) {
+	                if (data.name) {
+	                    email += '"' + data.name.replace(/^"|"\s*$/g, '') + '" ';
+	                }
+	                if (data.email) {
+	                    email += '<' + data.email + '>';
+	                }
+	            }
+	        }
+	    }
+	    return email;
+	}
+	/**
+	 * Gets character set name, e.g. contentType='.....charset='iso-8859-2'....'
+	 * @param {String} contentType
+	 * @returns {String|undefined}
+	 */
+	function getCharset(contentType) {
+	    var match = /charset\s*=\W*([\w\-]+)/g.exec(contentType);
+	    return match ? match[1] : undefined;
+	}
+	/**
+	 * Gets name and e-mail address from a string, e.g. 'PayPal' <noreply@paypal.com> => { name: 'PayPal', email: 'noreply@paypal.com' }
+	 * @param {String} raw
+	 * @returns { EmailAddress | EmailAddress[] | null}
+	 */
+	function getEmailAddress(rawStr) {
+	    var raw = unquoteString(rawStr);
+	    var parseList = addressparser(raw);
+	    var list = parseList.map(function (v) { return ({ name: v.name, email: v.address }); });
+	    //Return result
+	    if (list.length === 0) {
+	        return null; //No e-mail address
+	    }
+	    if (list.length === 1) {
+	        return list[0]; //Only one record, return as object, required to preserve backward compatibility
+	    }
+	    return list; //Multiple e-mail addresses as array
+	}
+	/**
+	 * decode one joint
+	 * @param {String} str
+	 * @returns {String}
+	 */
+	function decodeJoint(str) {
+	    var match = /=\?([^?]+)\?(B|Q)\?(.+?)(\?=)/gi.exec(str);
+	    if (match) {
+	        var charset = getCharsetName(match[1] || defaultCharset); //eq. match[1] = 'iso-8859-2'; charset = 'iso88592'
+	        var type = match[2].toUpperCase();
+	        var value = match[3];
+	        if (type === 'B') {
+	            //Base64
+	            if (charset === 'utf8') {
+	                return decode(encode(jsBase64.Base64.fromBase64(value.replace(/\r?\n/g, ''))), 'utf8');
+	            }
+	            else {
+	                return decode(jsBase64.Base64.toUint8Array(value.replace(/\r?\n/g, '')), charset);
+	            }
+	        }
+	        else if (type === 'Q') {
+	            //Quoted printable
+	            return unquotePrintable(value, charset, true);
+	        }
+	    }
+	    return str;
+	}
+	/**
+	 * decode section
+	 * @param {String} str
+	 * @returns {String}
+	 */
+	function unquoteString(str) {
+	    var regex = /=\?([^?]+)\?(B|Q)\?(.+?)(\?=)/gi;
+	    var decodedString = str || '';
+	    var spinOffMatch = decodedString.match(regex);
+	    if (spinOffMatch) {
+	        spinOffMatch.forEach(function (spin) {
+	            decodedString = decodedString.replace(spin, decodeJoint(spin));
+	        });
+	    }
+	    return decodedString.replace(/\r?\n/g, '');
+	}
+	/**
+	 * Decodes 'quoted-printable'
+	 * @param {String} value
+	 * @param {String} charset
+	 * @param {String} qEncoding whether the encoding is RFC-2047’s Q-encoding, meaning special handling of underscores.
+	 * @returns {String}
+	 */
+	function unquotePrintable(value, charset, qEncoding) {
+	    //Convert =0D to '\r', =20 to ' ', etc.
+	    // if (!charset || charset == "utf8" || charset == "utf-8") {
+	    //   return value
+	    //     .replace(/=([\w\d]{2})=([\w\d]{2})=([\w\d]{2})/gi, function (matcher, p1, p2, p3, offset, string) {
+	    if (qEncoding === void 0) { qEncoding = false; }
+	    //     })
+	    //     .replace(/=([\w\d]{2})=([\w\d]{2})/gi, function (matcher, p1, p2, offset, string) {
+	    //     })
+	    //     .replace(/=([\w\d]{2})/gi, function (matcher, p1, offset, string) { return String.fromCharCode(parseInt(p1, 16)); })
+	    //     .replace(/=\r?\n/gi, ""); //Join line
+	    // } else {
+	    //   return value
+	    //     .replace(/=([\w\d]{2})=([\w\d]{2})/gi, function (matcher, p1, p2, offset, string) {
+	    //     })
+	    //     .replace(/=([\w\d]{2})/gi, function (matcher, p1, offset, string) {
+	    //      })
+	    //     .replace(/=\r?\n/gi, ''); //Join line
+	    // }
+	    var rawString = value
+	        .replace(/[\t ]+$/gm, '') // remove invalid whitespace from the end of lines
+	        .replace(/=(?:\r?\n|$)/g, ''); // remove soft line breaks
+	    if (qEncoding) {
+	        rawString = rawString.replace(/_/g, decode(new Uint8Array([0x20]), charset));
+	    }
+	    return mimeDecode(rawString, charset);
+	}
+	/**
+	 * Parses EML file content and returns object-oriented representation of the content.
+	 * @param {String} eml
+	 * @param {OptionOrNull | CallbackFn<ParsedEmlJson>} options
+	 * @param {CallbackFn<ParsedEmlJson>} callback
+	 * @returns {string | Error | ParsedEmlJson}
+	 */
+	function parse(eml, options, callback) {
+	    //Shift arguments
+	    if (typeof options === 'function' && typeof callback === 'undefined') {
+	        callback = options;
+	        options = null;
+	    }
+	    if (typeof options !== 'object') {
+	        options = { headersOnly: false };
+	    }
+	    var error;
+	    var result = {};
+	    try {
+	        if (typeof eml !== 'string') {
+	            throw new Error('Argument "eml" expected to be string!');
+	        }
+	        var lines = eml.split(/\r?\n/);
+	        result = parseRecursive(lines, 0, result, options);
+	    }
+	    catch (e) {
+	        error = e;
+	    }
+	    callback && callback(error, result);
+	    return error || result || new Error('read EML failed!');
+	}
+	/**
+	 * Parses EML file content.
+	 * @param {String[]} lines
+	 * @param {Number}   start
+	 * @param {Options}  options
+	 * @returns {ParsedEmlJson}
+	 */
+	function parseRecursive(lines, start, parent, options) {
+	    var boundary = null;
+	    var lastHeaderName = '';
+	    var findBoundary = '';
+	    var insideBody = false;
+	    var insideBoundary = false;
+	    var isMultiHeader = false;
+	    var isMultipart = false;
+	    var checkedForCt = false;
+	    var ctInBody = false;
+	    parent.headers = {};
+	    //parent.body = null;
+	    function complete(boundary) {
+	        //boundary.part = boundary.lines.join("\r\n");
+	        boundary.part = {};
+	        parseRecursive(boundary.lines, 0, boundary.part, options);
+	        delete boundary.lines;
+	    }
+	    //Read line by line
+	    for (var i = start; i < lines.length; i++) {
+	        var line = lines[i];
+	        //Header
+	        if (!insideBody) {
+	            //Search for empty line
+	            if (line == '') {
+	                insideBody = true;
+	                if (options && options.headersOnly) {
+	                    break;
+	                }
+	                //Expected boundary
+	                var ct = parent.headers['Content-Type'] || parent.headers['Content-type'];
+	                if (!ct) {
+	                    if (checkedForCt) {
+	                        insideBody = !ctInBody;
+	                    }
+	                    else {
+	                        checkedForCt = true;
+	                        var lineClone = Array.from(lines);
+	                        var string = lineClone.splice(i).join('\r\n');
+	                        var trimmedStrin = string.trim();
+	                        if (trimmedStrin.indexOf('Content-Type') === 0 || trimmedStrin.indexOf('Content-type') === 0) {
+	                            insideBody = false;
+	                            ctInBody = true;
+	                        }
+	                        else {
+	                            console.warn('Warning: undefined Content-Type');
+	                        }
+	                    }
+	                }
+	                else if (/^multipart\//g.test(ct)) {
+	                    var b = getBoundary(ct);
+	                    if (b && b.length) {
+	                        findBoundary = b;
+	                        isMultipart = true;
+	                        parent.body = [];
+	                    }
+	                }
+	                continue;
+	            }
+	            //Header value with new line
+	            var match = /^\s+([^\r\n]+)/g.exec(line);
+	            if (match) {
+	                if (isMultiHeader) {
+	                    parent.headers[lastHeaderName][parent.headers[lastHeaderName].length - 1] += '\r\n' + match[1];
+	                }
+	                else {
+	                    parent.headers[lastHeaderName] += '\r\n' + match[1];
+	                }
+	                continue;
+	            }
+	            //Header name and value
+	            match = /^([\w\d\-]+):\s*([^\r\n]*)/gi.exec(line);
+	            if (match) {
+	                lastHeaderName = match[1];
+	                if (parent.headers[lastHeaderName]) {
+	                    //Multiple headers with the same name
+	                    isMultiHeader = true;
+	                    if (typeof parent.headers[lastHeaderName] == 'string') {
+	                        parent.headers[lastHeaderName] = [parent.headers[lastHeaderName]];
+	                    }
+	                    parent.headers[lastHeaderName].push(match[2]);
+	                }
+	                else {
+	                    //Header first appeared here
+	                    isMultiHeader = false;
+	                    parent.headers[lastHeaderName] = match[2];
+	                }
+	                continue;
+	            }
+	        }
+	        //Body
+	        else {
+	            //Multipart body
+	            if (isMultipart) {
+	                //Search for boundary start
+	                //Updated on 2019-10-12: A line before the boundary marker is not required to be an empty line
+	                //if (lines[i - 1] == "" && line.indexOf("--" + findBoundary) == 0 && !/\-\-(\r?\n)?$/g.test(line)) {
+	                if (line.indexOf('--' + findBoundary) == 0 && !/\-\-(\r?\n)?$/g.test(line)) {
+	                    insideBoundary = true;
+	                    //Complete the previous boundary
+	                    if (boundary && boundary.lines) {
+	                        complete(boundary);
+	                    }
+	                    //Start a new boundary
+	                    var match = /^\-\-([^\r\n]+)(\r?\n)?$/g.exec(line);
+	                    boundary = { boundary: match[1], lines: [] };
+	                    parent.body.push(boundary);
+	                    continue;
+	                }
+	                if (insideBoundary) {
+	                    //Search for boundary end
+	                    if ((boundary === null || boundary === void 0 ? void 0 : boundary.boundary) && lines[i - 1] == '' && line.indexOf('--' + findBoundary + '--') == 0) {
+	                        insideBoundary = false;
+	                        complete(boundary);
+	                        continue;
+	                    }
+	                    if ((boundary === null || boundary === void 0 ? void 0 : boundary.boundary) && line.indexOf('--' + findBoundary + '--') == 0) {
+	                        continue;
+	                    }
+	                    boundary === null || boundary === void 0 ? void 0 : boundary.lines.push(line);
+	                }
+	            }
+	            else {
+	                //Solid string body
+	                parent.body = lines.splice(i).join('\r\n');
+	                break;
+	            }
+	        }
+	    }
+	    //Complete the last boundary
+	    if (parent.body && parent.body.length && parent.body[parent.body.length - 1].lines) {
+	        complete(parent.body[parent.body.length - 1]);
+	    }
+	    return parent;
+	}
+	/**
+	 * Convert BoundaryRawData to BoundaryConvertedData
+	 * @param {BoundaryRawData} boundary
+	 * @returns {BoundaryConvertedData} Obj
+	 */
+	function completeBoundary(boundary) {
+	    if (!boundary || !boundary.boundary) {
+	        return null;
+	    }
+	    var lines = boundary.lines || [];
+	    var result = {
+	        boundary: boundary.boundary,
+	        part: {
+	            headers: {},
+	        },
+	    };
+	    var lastHeaderName = '';
+	    var insideBody = false;
+	    var childBoundary;
+	    for (var index = 0; index < lines.length; index++) {
+	        var line = lines[index];
+	        if (!insideBody) {
+	            if (line === '') {
+	                insideBody = true;
+	                continue;
+	            }
+	            var match = /^([\w\d\-]+):\s*([^\r\n]*)/gi.exec(line);
+	            if (match) {
+	                lastHeaderName = match[1];
+	                result.part.headers[lastHeaderName] = match[2];
+	                continue;
+	            }
+	            //Header value with new line
+	            var lineMatch = /^\s+([^\r\n]+)/g.exec(line);
+	            if (lineMatch) {
+	                result.part.headers[lastHeaderName] += '\r\n' + lineMatch[1];
+	                continue;
+	            }
+	        }
+	        else {
+	            // part.body
+	            var match = /^\-\-([^\r\n]+)(\r?\n)?$/g.exec(line);
+	            var childBoundaryStr = getBoundary(result.part.headers['Content-Type'] || result.part.headers['Content-type']);
+	            if (match && line.indexOf('--' + childBoundaryStr) === 0 && !childBoundary) {
+	                childBoundary = { boundary: match ? match[1] : '', lines: [] };
+	                continue;
+	            }
+	            else if (!!childBoundary && childBoundary.boundary) {
+	                if (lines[index - 1] === '' && line.indexOf('--' + childBoundary.boundary) === 0) {
+	                    var child = completeBoundary(childBoundary);
+	                    if (child) {
+	                        if (Array.isArray(result.part.body)) {
+	                            result.part.body.push(child);
+	                        }
+	                        else {
+	                            result.part.body = [child];
+	                        }
+	                    }
+	                    else {
+	                        result.part.body = childBoundary.lines.join('\r\n');
+	                    }
+	                    // next line child
+	                    if (!!lines[index + 1]) {
+	                        childBoundary.lines = [];
+	                        continue;
+	                    }
+	                    // end line child And this boundary's end
+	                    if (line.indexOf('--' + childBoundary.boundary + '--') === 0 && lines[index + 1] === '') {
+	                        childBoundary = undefined;
+	                        break;
+	                    }
+	                }
+	                childBoundary.lines.push(line);
+	            }
+	            else {
+	                result.part.body = lines.splice(index).join('\r\n');
+	                break;
+	            }
+	        }
+	    }
+	    return result;
+	}
+	/**
+	 * buid EML file by ReadedEmlJson or EML file content
+	 * @param {ReadedEmlJson} data
+	 * @param {BuildOptions | CallbackFn<string> | null} options
+	 * @param {CallbackFn<string>} callback
+	 */
+	function build(data, options, callback) {
+	    //Shift arguments
+	    if (typeof options === 'function' && typeof callback === 'undefined') {
+	        callback = options;
+	        options = null;
+	    }
+	    var error;
+	    var eml = '';
+	    var EOL = '\r\n'; //End-of-line
+	    try {
+	        if (!data) {
+	            throw new Error('Argument "data" expected to be an object! or string');
+	        }
+	        if (typeof data === 'string') {
+	            var readResult = read(data);
+	            if (typeof readResult === 'string') {
+	                throw new Error(readResult);
+	            }
+	            else if (readResult instanceof Error) {
+	                throw readResult;
+	            }
+	            else {
+	                data = readResult;
+	            }
+	        }
+	        if (!data.headers) {
+	            throw new Error('Argument "data" expected to be has headers');
+	        }
+	        if (typeof data.subject === 'string') {
+	            data.headers['Subject'] = data.subject;
+	        }
+	        if (typeof data.from !== 'undefined') {
+	            data.headers['From'] = toEmailAddress(data.from);
+	        }
+	        if (typeof data.to !== 'undefined') {
+	            data.headers['To'] = toEmailAddress(data.to);
+	        }
+	        if (typeof data.cc !== 'undefined') {
+	            data.headers['Cc'] = toEmailAddress(data.cc);
+	        }
+	        // if (!data.headers['To']) {
+	        //   throw new Error('Missing "To" e-mail address!');
+	        // }
+	        var emlBoundary = getBoundary(data.headers['Content-Type'] || data.headers['Content-type'] || '');
+	        var hasBoundary = false;
+	        var boundary = createBoundary();
+	        var multipartBoundary = '';
+	        if (data.multipartAlternative) {
+	            multipartBoundary = '' + (getBoundary(data.multipartAlternative['Content-Type']) || '');
+	            hasBoundary = true;
+	        }
+	        if (emlBoundary) {
+	            boundary = emlBoundary;
+	            hasBoundary = true;
+	        }
+	        else {
+	            data.headers['Content-Type'] = data.headers['Content-type'] || 'multipart/mixed;' + EOL + 'boundary="' + boundary + '"';
+	            // Restrained
+	            // hasBoundary = true;
+	        }
+	        //Build headers
+	        var keys = Object.keys(data.headers);
+	        for (var i = 0; i < keys.length; i++) {
+	            var key = keys[i];
+	            var value = data.headers[key];
+	            if (typeof value === 'undefined') {
+	                continue; //Skip missing headers
+	            }
+	            else if (typeof value === 'string') {
+	                eml += key + ': ' + value.replace(/\r?\n/g, EOL + '  ') + EOL;
+	            }
+	            else {
+	                //Array
+	                for (var j = 0; j < value.length; j++) {
+	                    eml += key + ': ' + value[j].replace(/\r?\n/g, EOL + '  ') + EOL;
+	                }
+	            }
+	        }
+	        if (data.multipartAlternative) {
+	            eml += EOL;
+	            eml += '--' + emlBoundary + EOL;
+	            eml += 'Content-Type: ' + data.multipartAlternative['Content-Type'].replace(/\r?\n/g, EOL + '  ') + EOL;
+	        }
+	        //Start the body
+	        eml += EOL;
+	        //Plain text content
+	        if (data.text) {
+	            // Encode opened and self headers keeped
+	            if (typeof options === 'object' && !!options && options.encode && data.textheaders) {
+	                eml += '--' + boundary + EOL;
+	                for (var key in data.textheaders) {
+	                    if (data.textheaders.hasOwnProperty(key)) {
+	                        eml += key + ": " + data.textheaders[key].replace(/\r?\n/g, EOL + '  ');
+	                    }
+	                }
+	            }
+	            else if (hasBoundary) {
+	                // else Assembly
+	                eml += '--' + (multipartBoundary ? multipartBoundary : boundary) + EOL;
+	                eml += 'Content-Type: text/plain; charset="utf-8"' + EOL;
+	            }
+	            eml += EOL + data.text;
+	            eml += EOL;
+	        }
+	        //HTML content
+	        if (data.html) {
+	            // Encode opened and self headers keeped
+	            if (typeof options === 'object' && !!options && options.encode && data.textheaders) {
+	                eml += '--' + boundary + EOL;
+	                for (var key in data.textheaders) {
+	                    if (data.textheaders.hasOwnProperty(key)) {
+	                        eml += key + ": " + data.textheaders[key].replace(/\r?\n/g, EOL + '  ');
+	                    }
+	                }
+	            }
+	            else if (hasBoundary) {
+	                eml += '--' + (multipartBoundary ? multipartBoundary : boundary) + EOL;
+	                eml += 'Content-Type: text/html; charset="utf-8"' + EOL;
+	            }
+	            if (verbose) {
+	                console.info("line 765 " + hasBoundary + ", emlBoundary: " + emlBoundary + ", multipartBoundary: " + multipartBoundary + ", boundary: " + boundary);
+	            }
+	            eml += EOL + data.html;
+	            eml += EOL;
+	        }
+	        //Append attachments
+	        if (data.attachments) {
+	            for (var i = 0; i < data.attachments.length; i++) {
+	                var attachment = data.attachments[i];
+	                eml += '--' + boundary + EOL;
+	                eml += 'Content-Type: ' + (attachment.contentType.replace(/\r?\n/g, EOL + '  ') || 'application/octet-stream') + EOL;
+	                eml += 'Content-Transfer-Encoding: base64' + EOL;
+	                eml +=
+	                    'Content-Disposition: ' +
+	                        (attachment.inline ? 'inline' : 'attachment') +
+	                        '; filename="' +
+	                        (attachment.filename || attachment.name || 'attachment_' + (i + 1)) +
+	                        '"' +
+	                        EOL;
+	                if (attachment.cid) {
+	                    eml += 'Content-ID: <' + attachment.cid + '>' + EOL;
+	                }
+	                eml += EOL;
+	                if (typeof attachment.data === 'string') {
+	                    var content = jsBase64.Base64.toBase64(attachment.data);
+	                    eml += wrap(content, 72) + EOL;
+	                }
+	                else {
+	                    //Buffer
+	                    // Uint8Array to string by new TextEncoder
+	                    var content = decode(attachment.data);
+	                    eml += wrap(content, 72) + EOL;
+	                }
+	                eml += EOL;
+	            }
+	        }
+	        //Finish the boundary
+	        if (hasBoundary) {
+	            eml += '--' + boundary + '--' + EOL;
+	        }
+	    }
+	    catch (e) {
+	        error = e;
+	    }
+	    callback && callback(error, eml);
+	    return error || eml;
+	}
+	/**
+	 * Parses EML file content and return user-friendly object.
+	 * @param {String | ParsedEmlJson} eml EML file content or object from 'parse'
+	 * @param { OptionOrNull | CallbackFn<ReadedEmlJson>} options EML parse options
+	 * @param {CallbackFn<ReadedEmlJson>} callback Callback function(error, data)
+	 */
+	function read(eml, options, callback) {
+	    //Shift arguments
+	    if (typeof options === 'function' && typeof callback === 'undefined') {
+	        callback = options;
+	        options = null;
+	    }
+	    var error;
+	    var result;
+	    //Appends the boundary to the result
+	    function _append(headers, content, result) {
+	        var contentType = headers['Content-Type'] || headers['Content-type'];
+	        var contentDisposition = headers['Content-Disposition'];
+	        var charset = getCharsetName(getCharset(contentType) || defaultCharset);
+	        var encoding = headers['Content-Transfer-Encoding'] || headers['Content-transfer-encoding'];
+	        if (typeof encoding === 'string') {
+	            encoding = encoding.toLowerCase();
+	        }
+	        if (encoding === 'base64') {
+	            if (contentType && contentType.indexOf('gbk') >= 0) {
+	                // is work?  I'm not sure
+	                content = encode(GB2312UTF8.GB2312ToUTF8(content.replace(/\r?\n/g, '')));
+	            }
+	            else {
+	                // string to Uint8Array by TextEncoder
+	                content = encode(content.replace(/\r?\n/g, ''));
+	            }
+	        }
+	        else if (encoding === 'quoted-printable') {
+	            content = unquotePrintable(content, charset);
+	        }
+	        else if (encoding && charset !== 'utf8' && encoding.search(/binary|8bit/) === 0) {
+	            //'8bit', 'binary', '8bitmime', 'binarymime'
+	            content = decode(content, charset);
+	        }
+	        if (!contentDisposition && contentType && contentType.indexOf('text/html') >= 0) {
+	            if (typeof content !== 'string') {
+	                content = decode(content, charset);
+	            }
+	            var htmlContent = content.replace(/\r\n|(&quot;)/g, '').replace(/\"/g, "\"");
+	            try {
+	                if (encoding === 'base64') {
+	                    htmlContent = jsBase64.Base64.decode(htmlContent);
+	                }
+	                else if (jsBase64.Base64.btoa(jsBase64.Base64.atob(htmlContent)) == htmlContent) {
+	                    htmlContent = jsBase64.Base64.atob(htmlContent);
+	                }
+	            }
+	            catch (error) {
+	                console.error(error);
+	            }
+	            if (result.html) {
+	                result.html += htmlContent;
+	            }
+	            else {
+	                result.html = htmlContent;
+	            }
+	            result.htmlheaders = {
+	                'Content-Type': contentType,
+	                'Content-Transfer-Encoding': encoding || '',
+	            };
+	            // self boundary Not used at conversion
+	        }
+	        else if (!contentDisposition && contentType && contentType.indexOf('text/plain') >= 0) {
+	            if (typeof content !== 'string') {
+	                content = decode(content, charset);
+	            }
+	            if (encoding === 'base64') {
+	                content = jsBase64.Base64.decode(content);
+	            }
+	            //Plain text message
+	            if (result.text) {
+	                result.text += content;
+	            }
+	            else {
+	                result.text = content;
+	            }
+	            result.textheaders = {
+	                'Content-Type': contentType,
+	                'Content-Transfer-Encoding': encoding || '',
+	            };
+	            // self boundary Not used at conversion
+	        }
+	        else {
+	            //Get the attachment
+	            if (!result.attachments) {
+	                result.attachments = [];
+	            }
+	            var attachment = {};
+	            var id = headers['Content-ID'] || headers['Content-Id'];
+	            if (id) {
+	                attachment.id = id;
+	            }
+	            var qaaapId = headers['X-Qaap-Object-Id'];
+	            if (qaaapId) {
+	                attachment.qaapId = qaaapId;
+	            }
+	            var NameContainer = ['Content-Disposition', 'Content-Type', 'Content-type'];
+	            var result_name = void 0;
+	            for (var _i = 0, NameContainer_1 = NameContainer; _i < NameContainer_1.length; _i++) {
+	                var key = NameContainer_1[_i];
+	                var name = headers[key];
+	                if (name) {
+	                    result_name = name
+	                        .replace(/(\s|'|utf-8|\*[0-9]\*)/g, '')
+	                        .split(';')
+	                        .map(function (v) { return /name[\*]?="?(.+?)"?$/gi.exec(v); })
+	                        .reduce(function (a, b) {
+	                        if (b && b[1]) {
+	                            a += b[1];
+	                        }
+	                        return a;
+	                    }, '');
+	                    if (result_name) {
+	                        break;
+	                    }
+	                }
+	            }
+	            if (result_name) {
+	                attachment.name = decodeURI(result_name);
+	            }
+	            var ct = headers['Content-Type'] || headers['Content-type'];
+	            if (ct) {
+	                attachment.contentType = ct;
+	            }
+	            var cd = headers['Content-Disposition'];
+	            if (cd) {
+	                attachment.inline = /^\s*inline/g.test(cd);
+	            }
+	            attachment.data = content;
+	            attachment.data64 = decode(content, charset);
+	            result.attachments.push(attachment);
+	        }
+	    }
+	    function _read(data) {
+	        if (!data) {
+	            return 'no data';
+	        }
+	        try {
+	            var result_1 = {};
+	            if (!data.headers) {
+	                throw new Error("data does't has headers");
+	            }
+	            if (data.headers['Date']) {
+	                result_1.date = new Date(data.headers['Date']);
+	            }
+	            if (data.headers['Subject']) {
+	                result_1.subject = unquoteString(data.headers['Subject']);
+	            }
+	            if (data.headers['From']) {
+	                result_1.from = getEmailAddress(data.headers['From']);
+	            }
+	            if (data.headers['To']) {
+	                result_1.to = getEmailAddress(data.headers['To']);
+	            }
+	            if (data.headers['CC']) {
+	                result_1.cc = getEmailAddress(data.headers['CC']);
+	            }
+	            if (data.headers['Cc']) {
+	                result_1.cc = getEmailAddress(data.headers['Cc']);
+	            }
+	            result_1.headers = data.headers;
+	            //Content mime type
+	            var boundary = null;
+	            var ct = data.headers['Content-Type'] || data.headers['Content-type'];
+	            if (ct && /^multipart\//g.test(ct)) {
+	                var b = getBoundary(ct);
+	                if (b && b.length) {
+	                    boundary = b;
+	                }
+	            }
+	            if (boundary && Array.isArray(data.body)) {
+	                for (var i = 0; i < data.body.length; i++) {
+	                    var boundaryBlock = data.body[i];
+	                    if (!boundaryBlock) {
+	                        continue;
+	                    }
+	                    //Get the message content
+	                    if (typeof boundaryBlock.part === 'undefined') {
+	                        verbose && console.warn('Warning: undefined b.part');
+	                    }
+	                    else if (typeof boundaryBlock.part === 'string') {
+	                        result_1.data = boundaryBlock.part;
+	                    }
+	                    else {
+	                        if (typeof boundaryBlock.part.body === 'undefined') {
+	                            verbose && console.warn('Warning: undefined b.part.body');
+	                        }
+	                        else if (typeof boundaryBlock.part.body === 'string') {
+	                            _append(boundaryBlock.part.headers, boundaryBlock.part.body, result_1);
+	                        }
+	                        else {
+	                            // keep multipart/alternative
+	                            var currentHeaders = boundaryBlock.part.headers;
+	                            var currentHeadersContentType = currentHeaders['Content-Type'] || currentHeaders['Content-type'];
+	                            if (verbose) {
+	                                console.log("line 969 currentHeadersContentType: " + currentHeadersContentType);
+	                            }
+	                            // Hasmore ?
+	                            if (currentHeadersContentType && currentHeadersContentType.indexOf('multipart') >= 0 && !result_1.multipartAlternative) {
+	                                result_1.multipartAlternative = {
+	                                    'Content-Type': currentHeadersContentType,
+	                                };
+	                            }
+	                            for (var j = 0; j < boundaryBlock.part.body.length; j++) {
+	                                var selfBoundary = boundaryBlock.part.body[j];
+	                                if (typeof selfBoundary === 'string') {
+	                                    result_1.data = selfBoundary;
+	                                    continue;
+	                                }
+	                                var headers = selfBoundary.part.headers;
+	                                var content = selfBoundary.part.body;
+	                                if (Array.isArray(content)) {
+	                                    content.forEach(function (bound) {
+	                                        _append(bound.part.headers, bound.part.body, result_1);
+	                                    });
+	                                }
+	                                else {
+	                                    _append(headers, content, result_1);
+	                                }
+	                            }
+	                        }
+	                    }
+	                }
+	            }
+	            else if (typeof data.body === 'string') {
+	                _append(data.headers, data.body, result_1);
+	            }
+	            return result_1;
+	        }
+	        catch (e) {
+	            return e;
+	        }
+	    }
+	    if (typeof eml === 'string') {
+	        var parseResult = parse(eml, options);
+	        if (typeof parseResult === 'string' || parseResult instanceof Error) {
+	            error = parseResult;
+	        }
+	        else {
+	            var readResult = _read(parseResult);
+	            if (typeof readResult === 'string' || readResult instanceof Error) {
+	                error = readResult;
+	            }
+	            else {
+	                result = readResult;
+	            }
+	        }
+	    }
+	    else if (typeof eml === 'object') {
+	        var readResult = _read(eml);
+	        if (typeof readResult === 'string' || readResult instanceof Error) {
+	            error = readResult;
+	        }
+	        else {
+	            result = readResult;
+	        }
+	    }
+	    else {
+	        error = new Error('Missing EML file content!');
+	    }
+	    callback && callback(error, result);
+	    return error || result || new Error('read EML failed!');
+	}
+	//  const GBKUTF8 = GB2312UTF8;
+	//  const parseEml = parse;
+	//  const readEml = read;
+	//  const buildEml = build;
+
+	Object.defineProperty(exports, 'Base64', {
+		enumerable: true,
+		get: function () {
+			return jsBase64.Base64;
+		}
+	});
+	exports.GBKUTF8 = GB2312UTF8;
+	exports.buildEml = build;
+	exports.completeBoundary = completeBoundary;
+	exports.convert = convert;
+	exports.createBoundary = createBoundary;
+	exports.decode = decode;
+	exports.encode = encode;
+	exports.getBoundary = getBoundary;
+	exports.getCharset = getCharset;
+	exports.getEmailAddress = getEmailAddress;
+	exports.mimeDecode = mimeDecode;
+	exports.parseEml = parse;
+	exports.readEml = read;
+	exports.toEmailAddress = toEmailAddress;
+	exports.unquotePrintable = unquotePrintable;
+	exports.unquoteString = unquoteString;
+
+	return exports;
+
+}({}, Base64 || (window || this).Base64, {
+					TextEncoder: (window || this)['TextEncoder'],
+					TextDecoder: (window || this)['TextDecoder'],
+				}));