postal-mime 2.0.0 → 2.0.2

package/.prettierrc.cjs

@@ -0,0 +1,8 @@
+module.exports = {
+    printWidth: 160,
+    tabWidth: 4,
+    singleQuote: true,
+    endOfLine: 'lf',
+    trailingComma: 'none',
+    arrowParens: 'avoid'
+};

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [2.0.2](https://github.com/postalsys/postal-mime/compare/v2.0.1...v2.0.2) (2023-12-08)
+
+
+### Bug Fixes
+
+* **test:** Added a tests runner and some tests ([8c6f7fb](https://github.com/postalsys/postal-mime/commit/8c6f7fb495b0158756fc11482a717e8081cede86))
+* **test:** Added test action ([c43c086](https://github.com/postalsys/postal-mime/commit/c43c0865dae74a7f20e32885a5860d8654f0c932))
+
+## [2.0.1](https://github.com/postalsys/postal-mime/compare/v2.0.0...v2.0.1) (2023-11-05)
+
+
+### Bug Fixes
+
+* **npm:** DO not ignore src folder when publishing to npm ([ef8a2df](https://github.com/postalsys/postal-mime/commit/ef8a2df8d65be3dcfc52784c5c73c79f820c1c82))
+
 ## [2.0.0](https://github.com/postalsys/postal-mime/compare/v1.1.0...v2.0.0) (2023-11-03)
 
 

package/README.md

@@ -4,8 +4,6 @@ Email parser for browser environments.
 
 PostalMime can be run in the main web thread or from Web Workers.
 
-PostalMime can be bundled using WebPack. In fact the distribution file is also built with WebPack.
-
 ## Source
 
 Source code is available from [Github](https://github.com/postalsys/postal-mime).

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "postal-mime",
-    "version": "2.0.0",
+    "version": "2.0.2",
     "description": "Email parser for browser environments",
     "main": "./src/postal-mime.js",
     "exports": {
@@ -9,7 +9,7 @@
     "type": "module",
     "types": "postal-mime.d.ts",
     "scripts": {
-        "test": "eslint",
+        "test": "eslint && node --test",
         "update": "rm -rf node_modules package-lock.json && ncu -u && npm install"
     },
     "keywords": [
@@ -27,9 +27,9 @@
     "license": "MIT-0",
     "devDependencies": {
         "cross-blob": "3.0.2",
-        "eslint": "8.52.0",
+        "eslint": "8.55.0",
         "eslint-cli": "1.1.1",
-        "iframe-resizer": "4.3.7",
+        "iframe-resizer": "4.3.9",
         "cross-env": "7.0.3"
     }
 }

package/postal-mime.d.ts

@@ -23,7 +23,7 @@ export type Email = {
 	replyTo?: Address[];
 	deliveredTo?: string;
 	returnPath?: string;
-	to: Address[];
+	to?: Address[];
 	cc?: Address[];
 	bcc?: Address[];
 	subject?: string;

package/src/address-parser.js

@@ -0,0 +1,321 @@
+import { decodeWords } from './decode-strings.js';
+
+/**
+ * Converts tokens for a single address into an address object
+ *
+ * @param {Array} tokens Tokens object
+ * @return {Object} Address object
+ */
+function _handleAddress(tokens) {
+    let token;
+    let isGroup = false;
+    let state = 'text';
+    let address;
+    let addresses = [];
+    let data = {
+        address: [],
+        comment: [],
+        group: [],
+        text: []
+    };
+    let i;
+    let 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: decodeWords(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;
+                }
+            }
+
+            let _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 && /^=\?[^=]+?=$/.test(data.text.trim())) {
+            // try to extract words from text content
+            const parsedSubAddresses = addressParser(decodeWords(data.text));
+            if (parsedSubAddresses && parsedSubAddresses.length) {
+                return parsedSubAddresses;
+            }
+        }
+
+        if (!data.address && isGroup) {
+            return [];
+        } else {
+            address = {
+                address: data.address || data.text || '',
+                name: decodeWords(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
+ */
+class Tokenizer {
+    constructor(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
+     */
+    tokenize() {
+        let chr,
+            list = [];
+        for (let i = 0, len = this.str.length; i < len; i++) {
+            chr = this.str.charAt(i);
+            this.checkChar(chr);
+        }
+
+        this.list.forEach(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
+     */
+    checkChar(chr) {
+        if (this.escaped) {
+            // ignore next condition blocks
+        } 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;
+    }
+}
+
+/**
+ * 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 || {};
+
+    let tokenizer = new Tokenizer(str);
+    let tokens = tokenizer.tokenize();
+
+    let addresses = [];
+    let address = [];
+    let parsedAddresses = [];
+
+    tokens.forEach(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(address => {
+        address = _handleAddress(address);
+        if (address.length) {
+            parsedAddresses = parsedAddresses.concat(address);
+        }
+    });
+
+    if (options.flatten) {
+        let addresses = [];
+        let walkAddressList = list => {
+            list.forEach(address => {
+                if (address.group) {
+                    return walkAddressList(address.group);
+                } else {
+                    addresses.push(address);
+                }
+            });
+        };
+        walkAddressList(parsedAddresses);
+        return addresses;
+    }
+
+    return parsedAddresses;
+}
+
+// expose to the world
+export default addressParser;

package/src/base64-decoder.js

@@ -0,0 +1,50 @@
+import { decodeBase64, blobToArrayBuffer } from './decode-strings.js';
+
+export default class Base64Decoder {
+    constructor(opts) {
+        opts = opts || {};
+
+        this.decoder = opts.decoder || new TextDecoder();
+
+        this.maxChunkSize = 100 * 1024;
+
+        this.chunks = [];
+
+        this.remainder = '';
+    }
+
+    update(buffer) {
+        let str = this.decoder.decode(buffer);
+
+        if (/[^a-zA-Z0-9+\/]/.test(str)) {
+            str = str.replace(/[^a-zA-Z0-9+\/]+/g, '');
+        }
+
+        this.remainder += str;
+
+        if (this.remainder.length >= this.maxChunkSize) {
+            let allowedBytes = Math.floor(this.remainder.length / 4) * 4;
+            let base64Str;
+
+            if (allowedBytes === this.remainder.length) {
+                base64Str = this.remainder;
+                this.remainder = '';
+            } else {
+                base64Str = this.remainder.substr(0, allowedBytes);
+                this.remainder = this.remainder.substr(allowedBytes);
+            }
+
+            if (base64Str.length) {
+                this.chunks.push(decodeBase64(base64Str));
+            }
+        }
+    }
+
+    finalize() {
+        if (this.remainder && !/^=+$/.test(this.remainder)) {
+            this.chunks.push(decodeBase64(this.remainder));
+        }
+
+        return blobToArrayBuffer(new Blob(this.chunks, { type: 'application/octet-stream' }));
+    }
+}