@zone-eu/mailsplit 5.4.17 → 5.4.18

package/lib/flowed-decoder.js

@@ -56,12 +56,8 @@ class FlowedDecoder extends Transform {
      */
     _flush(callback) {
         if (this.chunklen) {
+            // transfer decoding is done upstream by MimeNode.getDecoder()
             let currentBody = Buffer.concat(this.chunks, this.chunklen);
-
-            if (this.config.encoding === 'base64') {
-                currentBody = Buffer.from(currentBody.toString('binary'), 'base64');
-            }
-
             let content = this.libmime.decodeFlowed(currentBody.toString('binary'), this.config.delSp);
             this.push(Buffer.from(content, 'binary'));
         }

package/lib/headers.js

@@ -365,39 +365,49 @@ class Headers {
             return;
         }
 
-        /** @type {Array<string | HeaderLine>} */
-        let lines = this.headers
+        let rawLines = this.headers
             .toString('binary')
             .replace(/[\r\n]+$/, '')
             .split(/\r?\n/);
 
-        for (let i = lines.length - 1; i >= 0; i--) {
-            let currentLine = /** @type {string} */ (lines[i]);
-            if (i && this._isFoldingChar(currentLine.charAt(0))) {
-                lines[i - 1] = /** @type {string} */ (lines[i - 1]) + '\r\n' + currentLine;
-                lines.splice(i, 1);
-            } else {
-                let line = currentLine;
-                if (!i && /^From /i.test(line)) {
-                    // mbox file
-                    this.mbox = line;
-                    lines.splice(i, 1);
-                    continue;
-                } else if (!i && /^POST /i.test(line)) {
-                    // HTTP POST request
-                    this.http = line;
-                    lines.splice(i, 1);
-                    continue;
+        // Single forward pass. Splicing folded lines out of the source array in place was
+        // quadratic on a header block with many continuation lines.
+        let i = 1;
+
+        // The first logical line may be an mbox or HTTP POST preamble instead of a header
+        let first = rawLines[0];
+        while (i < rawLines.length && this._isFoldingChar(rawLines[i].charAt(0))) {
+            first += '\r\n' + rawLines[i++];
+        }
+
+        /** @type {HeaderLine[]} */
+        let lines = [];
+        if (/^From /i.test(first)) {
+            // mbox file
+            this.mbox = first;
+        } else if (/^POST /i.test(first)) {
+            // HTTP POST request
+            this.http = first;
+        } else {
+            lines.push({ key: this._normalizeHeader(first.substr(0, first.indexOf(':'))), line: first });
+        }
+
+        for (; i < rawLines.length; i++) {
+            let currentLine = rawLines[i];
+            if (this._isFoldingChar(currentLine.charAt(0))) {
+                // the loop starts on a non-folded line, so there is always a last entry here
+                let entry = lines[lines.length - 1];
+                entry.line += '\r\n' + currentLine;
+                if (!entry.key) {
+                    // the key comes from the first colon, which may only appear in a continuation
+                    entry.key = this._normalizeHeader(entry.line.substr(0, entry.line.indexOf(':')));
                 }
-                let key = this._normalizeHeader(line.substr(0, line.indexOf(':')));
-                lines[i] = {
-                    key,
-                    line
-                };
+            } else {
+                lines.push({ key: this._normalizeHeader(currentLine.substr(0, currentLine.indexOf(':'))), line: currentLine });
             }
         }
 
-        this.lines = /** @type {HeaderLine[]} */ (lines);
+        this.lines = lines;
         this.parsed = true;
     }
 

package/lib/message-splitter.js

@@ -28,6 +28,10 @@ const BOUNDARY_LINE_SUFFIX = 2 /* "--" prefix */ + 2 /* "--" suffix */ + 2; /* t
 // the longest a delimiter line can ever be once the boundary value is subtracted
 const BOUNDARY_LINE_OVERHEAD = BOUNDARY_LINE_SUFFIX + 2; /* leading <CR><LF> */
 
+// Bytes of input split in one go before yielding to the event loop. Bytes rather than lines
+// bound the work per batch whatever the line length: 16 KiB is at most 16k (empty) lines.
+const YIELD_BYTES = 16 * 1024;
+
 const HEAD = 0x01;
 const BODY = 0x02;
 
@@ -153,6 +157,12 @@ class MessageSplitter extends Transform {
         };
         let groupstart = this.lineLength ? -this.lineLength : 0;
         let groupend = 0;
+        // input position where the current batch started
+        let yieldPos = 0;
+        // true while processLine() runs synchronously for the current line
+        let inLine = false;
+        // set when the current line finished synchronously and the batch may continue in place
+        let resumeInLine = false;
 
         /**
          * Removes a pending line break from body data that belongs to a following boundary.
@@ -187,96 +197,133 @@ class MessageSplitter extends Transform {
             }
         };
 
+        // assigned below, the line handlers and the batch loop call each other
+        /** @type {() => void} */
+        let iterateData;
+
         /**
-         * Iterates the current input chunk line by line and emits parsed groups.
+         * Continues with the next line. Lines are processed in place and the event loop is
+         * only yielded to every YIELD_BYTES of input, a setImmediate per line made line-dense
+         * input very slow to split. A line that completed asynchronously always reschedules.
          *
          * @returns {void}
          */
-        let iterateData = () => {
-            for (let len = chunk.length; i < len; i++) {
-                // find next <LF>
-                if (chunk[i] === 0x0a) {
-                    // line end
+        let nextLine = () => {
+            if (inLine && i - yieldPos < YIELD_BYTES) {
+                resumeInLine = true;
+                return;
+            }
+            setImmediate(iterateData);
+        };
 
-                    let start = Math.max(pos, 0);
-                    pos = ++i;
+        /**
+         * Handles the result of processLine() for the line that ends at `i`. Defined once per
+         * write rather than once per line.
+         *
+         * @type {ProcessLineCallback}
+         */
+        let onLine = (err, data, flush) => {
+            if (err) {
+                this.hasFailed = true;
+                return setImmediate(() => callback(err));
+            }
 
-                    return this.processLine(chunk.slice(start, i), false, (err, data, flush) => {
-                        if (err) {
-                            this.hasFailed = true;
-                            return setImmediate(() => callback(err));
-                        }
+            if (!data) {
+                return nextLine();
+            }
 
-                        if (!data) {
-                            return setImmediate(iterateData);
+            if (flush) {
+                if (group && group.type !== 'none') {
+                    // do not include the last line ending for body
+                    groupend = trimBodyLineEnd(group, chunk, groupstart, groupend);
+                    if (groupstart < groupend) {
+                        // re-slice, the value the line was emitted with may
+                        // still include the line ending we just trimmed
+                        group.value = chunk.slice(groupstart, groupend);
+                        if (groupend < i && 'value' in data) {
+                            // the trimmed line ending belongs to the boundary line
+                            data.value = chunk.slice(groupend, i);
                         }
+                    }
+                    // the group is pushed even when nothing is left of it, so that a
+                    // part whose whole body is a line ending still reports a body
+                    this.push(group);
+                    group = {
+                        type: 'none'
+                    };
+                    groupstart = groupend = i;
+                }
+                this.push(data);
+                groupend = i;
+                return nextLine();
+            }
 
-                        if (flush) {
-                            if (group && group.type !== 'none') {
-                                // do not include the last line ending for body
-                                groupend = trimBodyLineEnd(group, chunk, groupstart, groupend);
-                                if (groupstart < groupend) {
-                                    // re-slice, the value the line was emitted with may
-                                    // still include the line ending we just trimmed
-                                    group.value = chunk.slice(groupstart, groupend);
-                                    if (groupend < i && 'value' in data) {
-                                        // the trimmed line ending belongs to the boundary line
-                                        data.value = chunk.slice(groupend, i);
-                                    }
-                                }
-                                // the group is pushed even when nothing is left of it, so that a
-                                // part whose whole body is a line ending still reports a body
-                                this.push(group);
-                                group = {
-                                    type: 'none'
-                                };
-                                groupstart = groupend = i;
-                            }
-                            this.push(data);
-                            groupend = i;
-                            return setImmediate(iterateData);
+            if (data.type === group.type) {
+                // shift slice end position forward
+                groupend = i;
+            } else {
+                // do not include the last line ending for body
+                groupend = trimBodyLineEnd(group, chunk, groupstart, groupend);
+
+                if (group.type !== 'none' && group.type !== 'node') {
+                    // we have a previous data/body chunk to output
+                    if (groupstart !== groupend) {
+                        group.value = chunk.slice(groupstart, groupend);
+                        if (group.value && group.value.length) {
+                            this.push(group);
+                            group = {
+                                type: 'none'
+                            };
                         }
+                    }
+                }
 
-                        if (data.type === group.type) {
-                            // shift slice end position forward
-                            groupend = i;
-                        } else {
-                            // do not include the last line ending for body
-                            groupend = trimBodyLineEnd(group, chunk, groupstart, groupend);
-
-                            if (group.type !== 'none' && group.type !== 'node') {
-                                // we have a previous data/body chunk to output
-                                if (groupstart !== groupend) {
-                                    group.value = chunk.slice(groupstart, groupend);
-                                    if (group.value && group.value.length) {
-                                        this.push(group);
-                                        group = {
-                                            type: 'none'
-                                        };
-                                    }
-                                }
-                            }
-
-                            if (data.type === 'node') {
-                                this.push(data);
-                                groupstart = i;
-                                groupend = i;
-                            } else if (groupstart < 0) {
-                                groupstart = i;
-                                groupend = i;
-                                checkTrailingLinebreak(data);
-                                if (data.value && data.value.length) {
-                                    this.push(data);
-                                }
-                            } else {
-                                // start new body/data chunk
-                                group = data;
-                                groupstart = groupend;
-                                groupend = i;
-                            }
-                        }
-                        return setImmediate(iterateData);
-                    });
+                if (data.type === 'node') {
+                    this.push(data);
+                    groupstart = i;
+                    groupend = i;
+                } else if (groupstart < 0) {
+                    groupstart = i;
+                    groupend = i;
+                    checkTrailingLinebreak(data);
+                    if (data.value && data.value.length) {
+                        this.push(data);
+                    }
+                } else {
+                    // start new body/data chunk
+                    group = data;
+                    groupstart = groupend;
+                    groupend = i;
+                }
+            }
+            return nextLine();
+        };
+
+        /**
+         * Iterates the current input chunk line by line and emits parsed groups.
+         *
+         * @returns {void}
+         */
+        iterateData = () => {
+            yieldPos = i;
+            while (i < chunk.length) {
+                // find next <LF>
+                if (chunk[i] !== 0x0a) {
+                    i++;
+                    continue;
+                }
+
+                // line end
+                let start = Math.max(pos, 0);
+                pos = ++i;
+
+                inLine = true;
+                resumeInLine = false;
+                this.processLine(chunk.slice(start, i), false, onLine);
+                inLine = false;
+                if (!resumeInLine) {
+                    // an error or a scheduled continuation takes over from here
+                    return;
                 }
             }
 

package/lib/mime-node.js

@@ -18,6 +18,32 @@ const pathlib = require('path');
 
 const Libmime = /** @type {any} */ (libmime.Libmime);
 
+/**
+ * Removes everything from the first `(` to the last `)` of each line, the same result as
+ * `value.replace(/\(.*\)/g, '')`, but in linear time. The regex backtracks quadratically
+ * on a value with many `(` characters and no closing `)`.
+ *
+ * @param {string} value
+ * @returns {string}
+ */
+function stripComments(value) {
+    if (value.indexOf('(') < 0) {
+        // the common case, nothing to strip
+        return value;
+    }
+    return value
+        .split(/([\n\r\u2028\u2029])/)
+        .map(part => {
+            let start = part.indexOf('(');
+            if (start < 0) {
+                return part;
+            }
+            let end = part.lastIndexOf(')');
+            return end > start ? part.slice(0, start) + part.slice(end + 1) : part;
+        })
+        .join('');
+}
+
 /**
  * Parsed MIME node with mutable headers and transfer-encoding helpers.
  */
@@ -142,11 +168,7 @@ class MimeNode {
         this._parsedContentType = this.libmime.parseHeaderValue(contentHeader);
         let parsedContentType = /** @type {StructuredHeader} */ (this._parsedContentType);
 
-        this.encoding = headers
-            .getFirst('Content-Transfer-Encoding')
-            .replace(/\(.*\)/g, '')
-            .toLowerCase()
-            .trim();
+        this.encoding = stripComments(headers.getFirst('Content-Transfer-Encoding')).toLowerCase().trim();
         this.contentType = (parsedContentType.value || '').toLowerCase().trim() || false;
         this.charset = parsedContentType.params.charset || false;
         this.disposition = (parsedContentDisposition.value || '').toLowerCase().trim() || false;

package/lib/node-rewriter.js

@@ -203,9 +203,10 @@ class NodeRewriter extends Transform {
         if (/^text\//.test(node.contentType || '') && node.flowed) {
             // text/plain; format=flowed is a special case
             let flowDecoder = decoder;
+            // the transfer encoding is already removed by node.getDecoder(), so the flowed
+            // decoder must not decode base64 a second time
             decoder = new FlowedDecoder({
-                delSp: node.delSp,
-                encoding: node.encoding || false
+                delSp: node.delSp
             });
             flowDecoder.on(
                 'error',

package/lib/types.d.ts

@@ -41,9 +41,6 @@ export interface ChunkedPassthroughOptions {
 export interface FlowedDecoderOptions extends LibmimeOptions {
     /** Whether format=flowed uses RFC 3676 `DelSp=yes` space deletion semantics. */
     delSp?: boolean;
-
-    /** Source Content-Transfer-Encoding hint used during format=flowed handling. */
-    encoding?: string | false;
 }
 
 /** Parsed raw header line with a normalized lookup key. */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@zone-eu/mailsplit",
-    "version": "5.4.17",
+    "version": "5.4.18",
     "description": "Split email messages into an object stream",
     "main": "index.js",
     "types": "index.d.ts",
@@ -16,7 +16,7 @@
     "license": "(MIT OR EUPL-1.1+)",
     "dependencies": {
         "libbase64": "1.3.0",
-        "libmime": "5.4.4",
+        "libmime": "5.4.5",
         "libqp": "2.1.1"
     },
     "devDependencies": {
@@ -25,7 +25,7 @@
         "@types/grunt": "0.4.32",
         "@types/libmime": "5.3.0",
         "@types/libqp": "1.1.3",
-        "@types/node": "26.5.1",
+        "@types/node": "26.6.3",
         "eslint": "8.29.0",
         "eslint-config-nodemailer": "1.2.0",
         "eslint-config-prettier": "9.1.0",