postal-mime 2.0.0 → 2.0.2

package/src/mime-node.js

@@ -0,0 +1,271 @@
+import { getDecoder, decodeParameterValueContinuations, textEncoder } from './decode-strings.js';
+import PassThroughDecoder from './pass-through-decoder.js';
+import Base64Decoder from './base64-decoder.js';
+import QPDecoder from './qp-decoder.js';
+
+export default class MimeNode {
+    constructor(opts) {
+        opts = opts || {};
+
+        this.postalMime = opts.postalMime;
+
+        this.root = !!opts.parentNode;
+        this.childNodes = [];
+        if (opts.parentNode) {
+            opts.parentNode.childNodes.push(this);
+        }
+
+        this.state = 'header';
+
+        this.headerLines = [];
+        this.decoders = new Map();
+
+        this.contentType = {
+            value: 'text/plain',
+            default: true
+        };
+
+        this.contentTransferEncoding = {
+            value: '8bit'
+        };
+
+        this.contentDisposition = {
+            value: ''
+        };
+
+        this.headers = [];
+
+        this.contentDecoder = false;
+    }
+
+    setupContentDecoder(transferEncoding) {
+        if (/base64/i.test(transferEncoding)) {
+            this.contentDecoder = new Base64Decoder();
+        } else if (/quoted-printable/i.test(transferEncoding)) {
+            this.contentDecoder = new QPDecoder({ decoder: getDecoder(this.contentType.parsed.params.charset) });
+        } else {
+            this.contentDecoder = new PassThroughDecoder();
+        }
+    }
+
+    async finalize() {
+        if (this.state === 'finished') {
+            return;
+        }
+
+        if (this.state === 'header') {
+            this.processHeaders();
+        }
+
+        // remove self from boundary listing
+        let boundaries = this.postalMime.boundaries;
+        for (let i = boundaries.length - 1; i >= 0; i--) {
+            let boundary = boundaries[i];
+            if (boundary.node === this) {
+                boundaries.splice(i, 1);
+                break;
+            }
+        }
+
+        await this.finalizeChildNodes();
+
+        this.content = this.contentDecoder ? await this.contentDecoder.finalize() : null;
+
+        this.state = 'finished';
+    }
+
+    async finalizeChildNodes() {
+        for (let childNode of this.childNodes) {
+            await childNode.finalize();
+        }
+    }
+
+    parseStructuredHeader(str) {
+        let response = {
+            value: false,
+            params: {}
+        };
+
+        let key = false;
+        let value = '';
+        let stage = 'value';
+
+        let quote = false;
+        let escaped = false;
+        let chr;
+
+        for (let i = 0, len = str.length; i < len; i++) {
+            chr = str.charAt(i);
+            switch (stage) {
+                case 'key':
+                    if (chr === '=') {
+                        key = value.trim().toLowerCase();
+                        stage = 'value';
+                        value = '';
+                        break;
+                    }
+                    value += chr;
+                    break;
+                case 'value':
+                    if (escaped) {
+                        value += chr;
+                    } else if (chr === '\\') {
+                        escaped = true;
+                        continue;
+                    } else if (quote && chr === quote) {
+                        quote = false;
+                    } else if (!quote && chr === '"') {
+                        quote = chr;
+                    } else if (!quote && chr === ';') {
+                        if (key === false) {
+                            response.value = value.trim();
+                        } else {
+                            response.params[key] = value.trim();
+                        }
+                        stage = 'key';
+                        value = '';
+                    } else {
+                        value += chr;
+                    }
+                    escaped = false;
+                    break;
+            }
+        }
+
+        // finalize remainder
+        value = value.trim();
+        if (stage === 'value') {
+            if (key === false) {
+                // default value
+                response.value = value;
+            } else {
+                // subkey value
+                response.params[key] = value;
+            }
+        } else if (value) {
+            // treat as key without value, see emptykey:
+            // Header-Key: somevalue; key=value; emptykey
+            response.params[value.toLowerCase()] = '';
+        }
+
+        if (response.value) {
+            response.value = response.value.toLowerCase();
+        }
+
+        // convert Parameter Value Continuations into single strings
+        decodeParameterValueContinuations(response);
+
+        return response;
+    }
+
+    decodeFlowedText(str, delSp) {
+        return (
+            str
+                .split(/\r?\n/)
+                // remove soft linebreaks
+                // soft linebreaks are added after space symbols
+                .reduce((previousValue, currentValue) => {
+                    if (/ $/.test(previousValue) && !/(^|\n)-- $/.test(previousValue)) {
+                        if (delSp) {
+                            // delsp adds space to text to be able to fold it
+                            // these spaces can be removed once the text is unfolded
+                            return previousValue.slice(0, -1) + currentValue;
+                        } else {
+                            return previousValue + currentValue;
+                        }
+                    } else {
+                        return previousValue + '\n' + currentValue;
+                    }
+                })
+                // remove whitespace stuffing
+                // http://tools.ietf.org/html/rfc3676#section-4.4
+                .replace(/^ /gm, '')
+        );
+    }
+
+    getTextContent() {
+        if (!this.content) {
+            return '';
+        }
+
+        let str = getDecoder(this.contentType.parsed.params.charset).decode(this.content);
+
+        if (/^flowed$/i.test(this.contentType.parsed.params.format)) {
+            str = this.decodeFlowedText(str, /^yes$/i.test(this.contentType.parsed.params.delsp));
+        }
+
+        return str;
+    }
+
+    processHeaders() {
+        for (let i = this.headerLines.length - 1; i >= 0; i--) {
+            let line = this.headerLines[i];
+            if (i && /^\s/.test(line)) {
+                this.headerLines[i - 1] += '\n' + line;
+                this.headerLines.splice(i, 1);
+            } else {
+                // remove folding and extra WS
+                line = line.replace(/\s+/g, ' ');
+                let sep = line.indexOf(':');
+                let key = sep < 0 ? line.trim() : line.substr(0, sep).trim();
+                let value = sep < 0 ? '' : line.substr(sep + 1).trim();
+                this.headers.push({ key: key.toLowerCase(), originalKey: key, value });
+
+                switch (key.toLowerCase()) {
+                    case 'content-type':
+                        if (this.contentType.default) {
+                            this.contentType = { value, parsed: {} };
+                        }
+                        break;
+                    case 'content-transfer-encoding':
+                        this.contentTransferEncoding = { value, parsed: {} };
+                        break;
+                    case 'content-disposition':
+                        this.contentDisposition = { value, parsed: {} };
+                        break;
+                    case 'content-id':
+                        this.contentId = value;
+                        break;
+                }
+            }
+        }
+
+        this.contentType.parsed = this.parseStructuredHeader(this.contentType.value);
+        this.contentType.multipart = /^multipart\//i.test(this.contentType.parsed.value)
+            ? this.contentType.parsed.value.substr(this.contentType.parsed.value.indexOf('/') + 1)
+            : false;
+
+        if (this.contentType.multipart && this.contentType.parsed.params.boundary) {
+            // add self to boundary terminator listing
+            this.postalMime.boundaries.push({
+                value: textEncoder.encode(this.contentType.parsed.params.boundary),
+                node: this
+            });
+        }
+
+        this.contentDisposition.parsed = this.parseStructuredHeader(this.contentDisposition.value);
+
+        this.contentTransferEncoding.encoding = this.contentTransferEncoding.value
+            .toLowerCase()
+            .split(/[^\w-]/)
+            .shift();
+
+        this.setupContentDecoder(this.contentTransferEncoding.encoding);
+    }
+
+    feed(line) {
+        switch (this.state) {
+            case 'header':
+                if (!line.length) {
+                    this.state = 'body';
+                    return this.processHeaders();
+                }
+                this.headerLines.push(getDecoder().decode(line));
+                break;
+            case 'body': {
+                // add line to body
+                this.contentDecoder.update(line);
+            }
+        }
+    }
+}

package/src/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "module"
+}

package/src/pass-through-decoder.js

@@ -0,0 +1,17 @@
+import { blobToArrayBuffer } from './decode-strings.js';
+
+export default class PassThroughDecoder {
+    constructor() {
+        this.chunks = [];
+    }
+
+    update(line) {
+        this.chunks.push(line);
+        this.chunks.push('\n');
+    }
+
+    finalize() {
+        // convert an array of arraybuffers into a blob and then back into a single arraybuffer
+        return blobToArrayBuffer(new Blob(this.chunks, { type: 'application/octet-stream' }));
+    }
+}

package/src/postal-mime.js

@@ -0,0 +1,395 @@
+import MimeNode from './mime-node.js';
+import { textToHtml, htmlToText, formatTextHeader, formatHtmlHeader } from './text-format.js';
+import addressParser from './address-parser.js';
+import { decodeWords, textEncoder, blobToArrayBuffer } from './decode-strings.js';
+
+export default class PostalMime {
+    constructor() {
+        this.root = this.currentNode = new MimeNode({
+            postalMime: this
+        });
+        this.boundaries = [];
+
+        this.textContent = {};
+        this.attachments = [];
+
+        this.started = false;
+    }
+
+    async finalize() {
+        // close all pending nodes
+        await this.root.finalize();
+    }
+
+    async processLine(line, isFinal) {
+        let boundaries = this.boundaries;
+
+        // check if this is a mime boundary
+        if (boundaries.length && line.length > 2 && line[0] === 0x2d && line[1] === 0x2d) {
+            // could be a boundary marker
+            for (let i = boundaries.length - 1; i >= 0; i--) {
+                let boundary = boundaries[i];
+
+                if (line.length !== boundary.value.length + 2 && line.length !== boundary.value.length + 4) {
+                    continue;
+                }
+
+                let isTerminator = line.length === boundary.value.length + 4;
+
+                if (isTerminator && (line[line.length - 2] !== 0x2d || line[line.length - 1] !== 0x2d)) {
+                    continue;
+                }
+
+                let boudaryMatches = true;
+                for (let i = 0; i < boundary.value.length; i++) {
+                    if (line[i + 2] !== boundary.value[i]) {
+                        boudaryMatches = false;
+                        break;
+                    }
+                }
+                if (!boudaryMatches) {
+                    continue;
+                }
+
+                if (isTerminator) {
+                    await boundary.node.finalize();
+
+                    this.currentNode = boundary.node.parentNode || this.root;
+                } else {
+                    // finalize any open child nodes (should be just one though)
+                    await boundary.node.finalizeChildNodes();
+
+                    this.currentNode = new MimeNode({
+                        postalMime: this,
+                        parentNode: boundary.node
+                    });
+                }
+
+                if (isFinal) {
+                    return this.finalize();
+                }
+
+                return;
+            }
+        }
+
+        this.currentNode.feed(line);
+
+        if (isFinal) {
+            return this.finalize();
+        }
+    }
+
+    readLine() {
+        let startPos = this.readPos;
+        let endPos = this.readPos;
+
+        let res = () => {
+            return {
+                bytes: new Uint8Array(this.buf, startPos, endPos - startPos),
+                done: this.readPos >= this.av.length
+            };
+        };
+
+        while (this.readPos < this.av.length) {
+            const c = this.av[this.readPos++];
+
+            if (c !== 0x0d && c !== 0x0a) {
+                endPos = this.readPos;
+            }
+
+            if (c === 0x0a) {
+                return res();
+            }
+        }
+
+        return res();
+    }
+
+    async processNodeTree() {
+        // get text nodes
+
+        let textContent = {};
+
+        let textTypes = new Set();
+        let textMap = (this.textMap = new Map());
+
+        let walk = async (node, alternative, related) => {
+            alternative = alternative || false;
+            related = related || false;
+
+            if (!node.contentType.multipart) {
+                // regular node
+
+                // is it inline message/rfc822
+                if (node.contentType.parsed.value === 'message/rfc822' && node.contentDisposition.parsed.value !== 'attachment') {
+                    const subParser = new PostalMime();
+                    node.subMessage = await subParser.parse(node.content);
+
+                    if (!textMap.has(node)) {
+                        textMap.set(node, {});
+                    }
+
+                    let textEntry = textMap.get(node);
+
+                    // default to text if there is no content
+                    if (node.subMessage.text || !node.subMessage.html) {
+                        textEntry.plain = textEntry.plain || [];
+                        textEntry.plain.push({ type: 'subMessage', value: node.subMessage });
+                        textTypes.add('plain');
+                    }
+
+                    if (node.subMessage.html) {
+                        textEntry.html = textEntry.html || [];
+                        textEntry.html.push({ type: 'subMessage', value: node.subMessage });
+                        textTypes.add('html');
+                    }
+
+                    if (subParser.textMap) {
+                        subParser.textMap.forEach((subTextEntry, subTextNode) => {
+                            textMap.set(subTextNode, subTextEntry);
+                        });
+                    }
+
+                    for (let attachment of node.subMessage.attachments || []) {
+                        this.attachments.push(attachment);
+                    }
+                }
+
+                // is it text?
+                else if (
+                    (/^text\//i.test(node.contentType.parsed.value) || node.contentType.parsed.value === 'message/delivery-status') &&
+                    node.contentDisposition.parsed.value !== 'attachment'
+                ) {
+                    let textType = node.contentType.parsed.value.substr(node.contentType.parsed.value.indexOf('/') + 1);
+                    if (node.contentType.parsed.value === 'message/delivery-status') {
+                        textType = 'plain';
+                    }
+
+                    let selectorNode = alternative || node;
+                    if (!textMap.has(selectorNode)) {
+                        textMap.set(selectorNode, {});
+                    }
+
+                    let textEntry = textMap.get(selectorNode);
+                    textEntry[textType] = textEntry[textType] || [];
+                    textEntry[textType].push({ type: 'text', value: node.getTextContent() });
+                    textTypes.add(textType);
+                }
+
+                // is it an attachment
+                else if (node.content) {
+                    let filename = node.contentDisposition.parsed.params.filename || node.contentType.parsed.params.name || null;
+                    let attachment = {
+                        filename: decodeWords(filename),
+                        mimeType: node.contentType.parsed.value,
+                        disposition: node.contentDisposition.parsed.value || null
+                    };
+
+                    if (related && node.contentId) {
+                        attachment.related = true;
+                    }
+
+                    if (node.contentId) {
+                        attachment.contentId = node.contentId;
+                    }
+
+                    attachment.content = node.content;
+
+                    this.attachments.push(attachment);
+                }
+            } else if (node.contentType.multipart === 'alternative') {
+                alternative = node;
+            } else if (node.contentType.multipart === 'related') {
+                related = node;
+            }
+
+            for (let childNode of node.childNodes) {
+                await walk(childNode, alternative, related);
+            }
+        };
+
+        await walk(this.root, false, []);
+
+        textMap.forEach(mapEntry => {
+            textTypes.forEach(textType => {
+                if (!textContent[textType]) {
+                    textContent[textType] = [];
+                }
+
+                if (mapEntry[textType]) {
+                    mapEntry[textType].forEach(textEntry => {
+                        switch (textEntry.type) {
+                            case 'text':
+                                textContent[textType].push(textEntry.value);
+                                break;
+
+                            case 'subMessage':
+                                {
+                                    switch (textType) {
+                                        case 'html':
+                                            textContent[textType].push(formatHtmlHeader(textEntry.value));
+                                            break;
+                                        case 'plain':
+                                            textContent[textType].push(formatTextHeader(textEntry.value));
+                                            break;
+                                    }
+                                }
+                                break;
+                        }
+                    });
+                } else {
+                    let alternativeType;
+                    switch (textType) {
+                        case 'html':
+                            alternativeType = 'plain';
+                            break;
+                        case 'plain':
+                            alternativeType = 'html';
+                            break;
+                    }
+
+                    (mapEntry[alternativeType] || []).forEach(textEntry => {
+                        switch (textEntry.type) {
+                            case 'text':
+                                switch (textType) {
+                                    case 'html':
+                                        textContent[textType].push(textToHtml(textEntry.value));
+                                        break;
+                                    case 'plain':
+                                        textContent[textType].push(htmlToText(textEntry.value));
+                                        break;
+                                }
+                                break;
+
+                            case 'subMessage':
+                                {
+                                    switch (textType) {
+                                        case 'html':
+                                            textContent[textType].push(formatHtmlHeader(textEntry.value));
+                                            break;
+                                        case 'plain':
+                                            textContent[textType].push(formatTextHeader(textEntry.value));
+                                            break;
+                                    }
+                                }
+                                break;
+                        }
+                    });
+                }
+            });
+        });
+
+        Object.keys(textContent).forEach(textType => {
+            textContent[textType] = textContent[textType].join('\n');
+        });
+
+        this.textContent = textContent;
+    }
+
+    async parse(buf) {
+        if (this.started) {
+            throw new Error('Can not reuse parser, create a new PostalMime object');
+        }
+        this.started = true;
+
+        // should it thrown on empty value instead?
+        buf = buf || ArrayBuffer(0);
+
+        if (typeof buf === 'string') {
+            // cast string input to ArrayBuffer
+            buf = textEncoder.encode(buf);
+        }
+
+        if (buf instanceof Blob || Object.prototype.toString.call(buf) === '[object Blob]') {
+            // can't process blob directly, cast to ArrayBuffer
+            buf = await blobToArrayBuffer(buf);
+        }
+
+        if (buf.buffer instanceof ArrayBuffer) {
+            // Node.js Buffer object or Uint8Array
+            buf = new Uint8Array(buf).buffer;
+        }
+
+        this.buf = buf;
+        this.av = new Uint8Array(buf);
+        this.readPos = 0;
+
+        while (this.readPos < this.av.length) {
+            const line = this.readLine();
+
+            await this.processLine(line.bytes, line.done);
+        }
+
+        await this.processNodeTree();
+
+        let message = {
+            headers: this.root.headers.map(entry => ({ key: entry.key, value: entry.value })).reverse()
+        };
+
+        for (let key of ['from', 'sender', 'reply-to']) {
+            let addressHeader = this.root.headers.find(line => line.key === key);
+            if (addressHeader && addressHeader.value) {
+                let addresses = addressParser(addressHeader.value);
+                if (addresses && addresses.length) {
+                    message[key.replace(/\-(.)/g, (o, c) => c.toUpperCase())] = addresses[0];
+                }
+            }
+        }
+
+        for (let key of ['delivered-to', 'return-path']) {
+            let addressHeader = this.root.headers.find(line => line.key === key);
+            if (addressHeader && addressHeader.value) {
+                let addresses = addressParser(addressHeader.value);
+                if (addresses && addresses.length && addresses[0].address) {
+                    message[key.replace(/\-(.)/g, (o, c) => c.toUpperCase())] = addresses[0].address;
+                }
+            }
+        }
+
+        for (let key of ['to', 'cc', 'bcc']) {
+            let addressHeaders = this.root.headers.filter(line => line.key === key);
+            let addresses = [];
+
+            addressHeaders
+                .filter(entry => entry && entry.value)
+                .map(entry => addressParser(entry.value))
+                .forEach(parsed => (addresses = addresses.concat(parsed || [])));
+
+            if (addresses && addresses.length) {
+                message[key] = addresses;
+            }
+        }
+
+        for (let key of ['subject', 'message-id', 'in-reply-to', 'references']) {
+            let header = this.root.headers.find(line => line.key === key);
+            if (header && header.value) {
+                message[key.replace(/\-(.)/g, (o, c) => c.toUpperCase())] = decodeWords(header.value);
+            }
+        }
+
+        let dateHeader = this.root.headers.find(line => line.key === 'date');
+        if (dateHeader) {
+            let date = new Date(dateHeader.value);
+            if (!date || date.toString() === 'Invalid Date') {
+                date = dateHeader.value;
+            } else {
+                // enforce ISO format if seems to be a valid date
+                date = date.toISOString();
+            }
+            message.date = date;
+        }
+
+        if (this.textContent && this.textContent.html) {
+            message.html = this.textContent.html;
+        }
+
+        if (this.textContent && this.textContent.plain) {
+            message.text = this.textContent.plain;
+        }
+
+        message.attachments = this.attachments;
+
+        return message;
+    }
+}