@mavogel/awscdk-rootmail 0.1.2 → 0.1.4

package/node_modules/@zone-eu/mailsplit/lib/headers.js

@@ -130,7 +130,8 @@ class Headers {
         }
 
         value = value.toString('binary');
-        this.addFormatted(key, this.libmime.foldLines(key + ': ' + value.replace(/\r?\n/g, ''), 76, false), index);
+        // a header value may not contain line breaks of its own, folding is added by foldLines
+        this.addFormatted(key, this.libmime.foldLines(key + ': ' + value.replace(/[\r\n]/g, ''), 76, false), index);
     }
 
     /**
@@ -155,6 +156,13 @@ class Headers {
             line = line.toString('binary');
         }
 
+        // every header insertion runs through here, so this is where a value or a key
+        // built from untrusted input is stopped from injecting an extra header line
+        line = this._normalizeInsertedLine(line);
+        if (!line) {
+            return;
+        }
+
         let header = {
             key: this._normalizeHeader(key),
             line
@@ -227,7 +235,10 @@ class Headers {
     }
 
     /**
-     * @param {string | false} [lineEnd]
+     * Serializes the headers. Unmodified headers are returned byte for byte as they
+     * were received, otherwise every line is rebuilt with `lineEnd` line endings.
+     *
+     * @param {string | false} [lineEnd] Line ending to use, defaults to CRLF.
      * @returns {Buffer}
      */
     build(lineEnd) {
@@ -240,26 +251,30 @@ class Headers {
         }
         let lines = this._getLines();
 
-        lineEnd = lineEnd || '\r\n';
+        const ending = lineEnd || '\r\n';
 
         let headers = lines
-            .map(line => this._buildHeaderLine(line.line.replace(/\r?\n/g, lineEnd)))
+            .map(line => this._normalizeLineBreaks(line.line, ending))
+            // an empty line would close the header block and demote every later header
+            // into the body, so a line left with nothing in it is dropped instead
+            .filter(line => line !== '')
+            .map(line => this._buildHeaderLine(line))
             .reduce((joined, line, idx) => {
                 if (idx) {
-                    joined.push(Buffer.from(lineEnd, 'binary'));
+                    joined.push(Buffer.from(ending, 'binary'));
                 }
                 joined.push(line);
                 return joined;
             }, /** @type {Buffer[]} */ ([]));
 
-        headers.push(Buffer.from(lineEnd + lineEnd, 'binary'));
+        headers.push(Buffer.from(ending + ending, 'binary'));
 
         if (this.mbox) {
-            headers.unshift(Buffer.from(this.mbox + lineEnd, 'binary'));
+            headers.unshift(Buffer.from(this.mbox + ending, 'binary'));
         }
 
         if (this.http) {
-            headers.unshift(Buffer.from(this.http + lineEnd, 'binary'));
+            headers.unshift(Buffer.from(this.http + ending, 'binary'));
         }
 
         return Buffer.concat(headers);
@@ -273,6 +288,63 @@ class Headers {
         return (key || '').toLowerCase().trim();
     }
 
+    /**
+     * Rewrites the line breaks of a header line so that the line can only ever parse
+     * back as the single header it was reported as. A line break followed by whitespace
+     * is folding and becomes `lineEnd`, every other line break would start a new header
+     * line and is dropped.
+     *
+     * A bare <CR> is never a line break for _parseHeaders, so promoting one here would
+     * emit a header line that was never reported as parsed.
+     *
+     * @param {string} line Header line to normalize.
+     * @param {string} lineEnd Line ending to fold with.
+     * @returns {string} Line with only folding line breaks left.
+     */
+    _normalizeLineBreaks(line, lineEnd) {
+        return (
+            line
+                // lines are joined with lineEnd, so a line that opens with a break of its own
+                // would close the header block. Dropping only the break leaves any whitespace
+                // behind it folding into the line before, which adds no header of its own.
+                .replace(/^[\r\n]+/, '')
+                .replace(/\r\n|\r|\n/g, (match, offset, source) => (match !== '\r' && this._isFoldingChar(source.charAt(offset + match.length)) ? lineEnd : ''))
+        );
+    }
+
+    /**
+     * Prepares a caller supplied line for insertion. On top of the line break rules an
+     * inserted line has to stand on its own: a leading fold or indent would attach it to
+     * whichever header happens to precede it, and a leading line break would close the
+     * header block outright.
+     *
+     * Lines that were parsed out of a message keep their leading whitespace instead, so
+     * that rebuilding can never turn an indented continuation into a header of its own.
+     *
+     * An inserted line is normalized twice, here with CRLF and again in build() with the
+     * line ending the caller asked for. That is only sound because _normalizeLineBreaks is
+     * idempotent over its own output: the folds this pass emits are still recognized as
+     * folds by the next one. Any change to how a fold is represented has to keep that true.
+     *
+     * @param {string} line Formatted header line supplied by the caller.
+     * @returns {string} Line that inserts as exactly one header, or an empty string.
+     */
+    _normalizeInsertedLine(line) {
+        return this._normalizeLineBreaks(line.replace(/^[\r\n \t]+/, ''), '\r\n');
+    }
+
+    /**
+     * Tells whether a character continues the previous header line rather than
+     * starting a new one. Used by both the parser and the builder so that the two
+     * can not disagree on what folding is.
+     *
+     * @param {string} chr Character that follows a line break.
+     * @returns {boolean} True if the line break is folding.
+     */
+    _isFoldingChar(chr) {
+        return chr === ' ' || chr === '\t';
+    }
+
     /**
      * @returns {HeaderLine[]}
      */
@@ -301,8 +373,7 @@ class Headers {
 
         for (let i = lines.length - 1; i >= 0; i--) {
             let currentLine = /** @type {string} */ (lines[i]);
-            let chr = currentLine.charAt(0);
-            if (i && (chr === ' ' || chr === '\t')) {
+            if (i && this._isFoldingChar(currentLine.charAt(0))) {
                 lines[i - 1] = /** @type {string} */ (lines[i - 1]) + '\r\n' + currentLine;
                 lines.splice(i, 1);
             } else {

package/node_modules/@zone-eu/mailsplit/lib/message-splitter.js

@@ -13,9 +13,61 @@ const MimeNode = require('./mime-node');
 const MAX_HEAD_SIZE = 1 * 1024 * 1024;
 const MAX_CHILD_NODES = 1000;
 
+// how much of a body line without a line break is buffered before it is flushed
+// out as regular content instead of being kept in memory
+const MAX_PENDING_LINE_SIZE = 64 * 1024;
+
+// how many separate writes the pending line may be kept in before it is compacted
+const MAX_PENDING_LINE_CHUNKS = 1024;
+
+// what a delimiter line may carry after the boundary value: the "--" prefix, an optional
+// "--" suffix and the line terminator. This is the bound compareBoundary() accepts.
+const BOUNDARY_LINE_SUFFIX = 2 /* "--" prefix */ + 2 /* "--" suffix */ + 2; /* trailing <CR><LF> */
+
+// checkBoundary() additionally allows a line ending in front of the delimiter, so this is
+// 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> */
+
 const HEAD = 0x01;
 const BODY = 0x02;
 
+/**
+ * Creates the error used for all size limit violations.
+ *
+ * @param {string} message Human readable error message.
+ * @returns {Error & {code: string}} Error tagged with the EMAXLEN code.
+ */
+function maxLenError(message) {
+    let err = /** @type {Error & {code: string}} */ (new Error(message));
+    err.code = 'EMAXLEN';
+    return err;
+}
+
+/**
+ * Moves an end offset back over the line ending that closes a body line, because the line
+ * ending in front of a boundary belongs to the delimiter and not to the part content. Only
+ * a group holding the body of a child node carries such a line ending, anything else is
+ * returned untouched.
+ *
+ * @param {SplitterGroup} group Group the offsets describe.
+ * @param {Buffer} chunk Chunk the offsets point into.
+ * @param {number} start Start offset of the body slice.
+ * @param {number} end End offset of the body slice.
+ * @returns {number} End offset with a trailing <CR><LF>, <LF> or nothing removed.
+ */
+function trimBodyLineEnd(group, chunk, start, end) {
+    if (group.type !== 'body' || !group.node || !group.node.parentNode) {
+        return end;
+    }
+    if (end > start && chunk[end - 1] === 0x0a) {
+        end--;
+        if (end > start && chunk[end - 1] === 0x0d) {
+            end--;
+        }
+    }
+    return end;
+}
+
 /**
  * Transform stream that splits raw email bytes into MIME node and content chunks.
  */
@@ -33,15 +85,55 @@ class MessageSplitter extends Transform {
         this.config = config || {};
         this.maxHeadSize = this.config.maxHeadSize || MAX_HEAD_SIZE;
         this.maxChildNodes = this.config.maxChildNodes || MAX_CHILD_NODES;
-        /** @type {MimeNodeType[]} */
-        this.tree = [];
         this.nodeCounter = 0;
         this.node = /** @type {MimeNodeType} */ (/** @type {unknown} */ (null));
+        // set once the closing delimiter of the current node's multipart has been seen, so
+        // that any later boundary line of that node counts as epilogue. Reset per node.
+        this.inEpilogue = false;
         this.newNode();
-        this.tree.push(this.node);
-        /** @type {Buffer | false} */
-        this.line = false;
+        // incomplete trailing line of the previous chunk, kept as a list of chunks so
+        // that a long line without a line break is not copied over for every write
+        /** @type {Buffer[]} */
+        this.lineChunks = [];
+        this.lineLength = 0;
         this.hasFailed = false;
+        // set when the pending line was flushed as overlong content, the remainder
+        // of that same line can not be a boundary either
+        this.pendingLineTruncated = false;
+    }
+
+    /**
+     * Appends unterminated trailing data to the pending line.
+     *
+     * @param {Buffer} chunk Data that follows the last line break of a write.
+     * @returns {void}
+     */
+    appendPendingLine(chunk) {
+        if (!chunk.length) {
+            return;
+        }
+        this.lineChunks.push(chunk);
+        this.lineLength += chunk.length;
+        if (this.lineChunks.length >= MAX_PENDING_LINE_CHUNKS) {
+            // a line written one byte at a time would otherwise cost an array slot and a
+            // Buffer view per byte, which is far more memory than the data itself
+            this.lineChunks = [Buffer.concat(this.lineChunks, this.lineLength)];
+        }
+    }
+
+    /**
+     * Returns the pending line as a single buffer and clears the pending state.
+     *
+     * @returns {Buffer | false} Pending line contents or false if there was none.
+     */
+    takePendingLine() {
+        if (!this.lineLength) {
+            return false;
+        }
+        let line = this.lineChunks.length === 1 ? this.lineChunks[0] : Buffer.concat(this.lineChunks, this.lineLength);
+        this.lineChunks = [];
+        this.lineLength = 0;
+        return line;
     }
 
     /**
@@ -59,7 +151,7 @@ class MessageSplitter extends Transform {
         let group = {
             type: 'none'
         };
-        let groupstart = this.line ? -this.line.length : 0;
+        let groupstart = this.lineLength ? -this.lineLength : 0;
         let groupend = 0;
 
         /**
@@ -78,10 +170,9 @@ class MessageSplitter extends Transform {
                         groupstart--;
                         groupend--;
                         pos--;
-                        if (groupstart < 0 && !this.line) {
+                        if (groupstart < 0 && !this.lineLength) {
                             // store only <CR> as <LF> should be on the positive side
-                            this.line = Buffer.allocUnsafe(1);
-                            this.line[0] = 0x0d;
+                            this.appendPendingLine(Buffer.from([0x0d]));
                         }
                         data.value = data.value.slice(0, data.value.length - 2);
                     } else {
@@ -122,21 +213,19 @@ class MessageSplitter extends Transform {
 
                         if (flush) {
                             if (group && group.type !== 'none') {
-                                if (group.type === 'body' && groupend >= groupstart && group.node && group.node.parentNode) {
-                                    // do not include the last line ending for body
-                                    if (chunk[groupend - 1] === 0x0a) {
-                                        groupend--;
-                                        if (groupend >= groupstart && chunk[groupend - 1] === 0x0d) {
-                                            groupend--;
-                                        }
-                                    }
-                                }
-                                if (groupstart !== groupend) {
+                                // 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'
@@ -152,15 +241,8 @@ class MessageSplitter extends Transform {
                             // shift slice end position forward
                             groupend = i;
                         } else {
-                            if (group.type === 'body' && groupend >= groupstart && group.node && group.node.parentNode) {
-                                // do not include the last line ending for body
-                                if (chunk[groupend - 1] === 0x0a) {
-                                    groupend--;
-                                    if (groupend >= groupstart && chunk[groupend - 1] === 0x0d) {
-                                        groupend--;
-                                    }
-                                }
-                            }
+                            // 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
@@ -199,15 +281,7 @@ class MessageSplitter extends Transform {
             }
 
             // skip last linebreak for body
-            if (pos >= groupstart + 1 && group.type === 'body' && group.node && group.node.parentNode) {
-                // do not include the last line ending for body
-                if (chunk[pos - 1] === 0x0a) {
-                    pos--;
-                    if (pos >= groupstart && chunk[pos - 1] === 0x0d) {
-                        pos--;
-                    }
-                }
-            }
+            pos = trimBodyLineEnd(group, chunk, groupstart, pos);
 
             if (group.type !== 'none' && group.type !== 'node' && pos > groupstart) {
                 // we have a leftover data/body chunk to push out
@@ -222,11 +296,16 @@ class MessageSplitter extends Transform {
             }
 
             if (pos < chunk.length) {
-                if (this.line) {
-                    this.line = Buffer.concat([this.line, chunk.slice(pos)]);
-                } else {
-                    this.line = chunk.slice(pos);
-                }
+                // checkTrailingLinebreak can push pos before the start of this write when a
+                // line ending straddles it. A negative start would make slice() count from
+                // the END of the buffer and hand over the wrong bytes entirely.
+                this.appendPendingLine(chunk.slice(Math.max(pos, 0)));
+            }
+
+            let pendingLineError = this.enforcePendingLineLimit();
+            if (pendingLineError) {
+                this.hasFailed = true;
+                return callback(pendingLineError);
             }
             callback();
         };
@@ -261,7 +340,7 @@ class MessageSplitter extends Transform {
      */
     compareBoundary(line, startpos, boundary) {
         // --{boundary}\r\n or --{boundary}--\r\n
-        if (line.length < boundary.length + 3 + startpos || line.length > boundary.length + 6 + startpos) {
+        if (line.length < boundary.length + 3 + startpos || line.length > boundary.length + BOUNDARY_LINE_SUFFIX + startpos) {
             return false;
         }
         for (let i = 0; i < boundary.length; i++) {
@@ -308,7 +387,8 @@ class MessageSplitter extends Transform {
         let startpos = 0;
         if (line.length >= 1 && (line[0] === 0x0d || line[0] === 0x0a)) {
             startpos++;
-            if (line.length >= 2 && (line[0] === 0x0d || line[1] === 0x0a)) {
+            if (line.length >= 2 && line[0] === 0x0d && line[1] === 0x0a) {
+                // only <CR><LF> is two bytes, a lone <CR> in front of a delimiter is one
                 startpos++;
             }
         }
@@ -319,7 +399,7 @@ class MessageSplitter extends Transform {
 
         /** @type {1 | 2 | false} */
         let boundary;
-        if (this.node._boundary && (boundary = this.compareBoundary(line, startpos, this.node._boundary))) {
+        if (!this.inEpilogue && this.node._boundary && (boundary = this.compareBoundary(line, startpos, this.node._boundary))) {
             // 1: next child
             // 2: multipart end
             return boundary;
@@ -334,6 +414,75 @@ class MessageSplitter extends Transform {
         return false;
     }
 
+    /**
+     * Checks the header bytes collected for the current node against maxHeadSize.
+     *
+     * @param {number} [extra] Bytes that belong to the header block but are not stored yet.
+     * @returns {(Error & {code?: string}) | null} Error object if the limit was exceeded.
+     */
+    checkHeadSize(extra) {
+        if (this.node._headerlen + (extra || 0) > this.maxHeadSize) {
+            return maxLenError('Max header size for a MIME node exceeded');
+        }
+        return null;
+    }
+
+    /**
+     * Enforces the limits on the pending line so that it can not grow without bound.
+     * A line that is still short enough to become a boundary delimiter is always kept.
+     * Past that length it is a header line and counts against maxHeadSize, or it is
+     * body content, in which case it is pushed out rather than held in memory. Flushing
+     * marks the pending line truncated, so the tail of it is not tested as a delimiter.
+     *
+     * @returns {(Error & {code?: string}) | null} Error object if a limit was exceeded.
+     */
+    enforcePendingLineLimit() {
+        if (!this.lineLength) {
+            return null;
+        }
+
+        let maxBoundaryLength = Math.max(
+            this.node._boundary ? this.node._boundary.length : 0,
+            this.node._parentBoundary ? this.node._parentBoundary.length : 0
+        );
+
+        if (this.lineLength <= maxBoundaryLength + BOUNDARY_LINE_OVERHEAD) {
+            // might still turn out to be a boundary delimiter line
+            return null;
+        }
+
+        if (this.state === HEAD) {
+            // not a boundary line, so it is a header line and counts against the
+            // header size limit even though it has not been stored on the node yet
+            return this.checkHeadSize(this.lineLength);
+        }
+
+        if (this.lineLength < MAX_PENDING_LINE_SIZE) {
+            return null;
+        }
+
+        let value = /** @type {Buffer} */ (this.takePendingLine());
+        if (value[value.length - 1] === 0x0d) {
+            // a trailing <CR> may still turn out to be the first half of the line ending
+            // that closes this line, and a line ending in front of a boundary belongs to
+            // the delimiter. Keep it pending so the normal trimming can decide. Copy it
+            // rather than slicing, a view would pin the whole flushed buffer.
+            this.appendPendingLine(Buffer.from([0x0d]));
+            value = value.slice(0, value.length - 1);
+        }
+
+        this.push({
+            node: this.node,
+            type: this.node.multipart ? 'data' : 'body',
+            value
+        });
+        // whatever follows continues an overlong line, so the tail of it
+        // can not be a boundary line either
+        this.pendingLineTruncated = true;
+
+        return null;
+    }
+
     /**
      * @param {Buffer | false} line
      * @param {boolean} final
@@ -343,12 +492,13 @@ class MessageSplitter extends Transform {
     processLine(line, final, next) {
         let flush = false;
 
-        if (this.line && line) {
-            line = Buffer.concat([this.line, line]);
-            this.line = false;
-        } else if (this.line && !line) {
-            line = this.line;
-            this.line = false;
+        // consumed here so that no later branch can leak it into the next line
+        let truncatedLine = this.pendingLineTruncated;
+        this.pendingLineTruncated = false;
+
+        let pending = this.takePendingLine();
+        if (pending) {
+            line = line ? Buffer.concat([pending, line]) : pending;
         }
 
         if (!line) {
@@ -356,13 +506,12 @@ class MessageSplitter extends Transform {
         }
 
         if (this.nodeCounter > this.maxChildNodes) {
-            let err = /** @type {Error & {code?: string}} */ (new Error('Max allowed child nodes exceeded'));
-            err.code = 'EMAXLEN';
-            return next(err);
+            return next(maxLenError('Max allowed child nodes exceeded'));
         }
 
         // we check boundary outside the HEAD/BODY scope as it may appear anywhere
-        let boundary = this.checkBoundary(line);
+        // unless the line is the remainder of an already flushed overlong line
+        let boundary = truncatedLine ? false : this.checkBoundary(line);
         if (boundary) {
             // reached boundary, switch context
             switch (boundary) {
@@ -376,28 +525,28 @@ class MessageSplitter extends Transform {
                     break;
                 case 3: {
                     // next sibling
-                    let parentNode = this.node.parentNode;
-                    if (parentNode && parentNode.contentType === 'message/rfc822') {
-                        // special case where immediate parent is an inline message block
-                        // move up another step
-                        parentNode = parentNode.parentNode;
-                    }
-                    this.newNode(parentNode);
+                    this.newNode(this.parentMultipartNode());
                     flush = true;
                     break;
                 }
-                case 4:
+                case 4: {
                     // special case when boundary close a node with only header.
                     if (this.node && this.node._headerlen && !this.node.headers) {
                         this.node.parseHeaders();
                         this.push(this.node);
                     }
-                    // move up
-                    if (this.tree.length) {
-                        this.node = /** @type {MimeNodeType} */ (this.tree.pop());
+                    // move up to the multipart node this closing delimiter belongs to
+                    let parentNode = this.parentMultipartNode();
+                    if (parentNode) {
+                        this.node = parentNode;
+                        // the closing delimiter of this multipart was just processed, so any
+                        // later boundary line of this node belongs to the epilogue. A closing
+                        // delimiter seen in the preamble (case 2) deliberately does not count.
+                        this.inEpilogue = true;
                     }
                     this.state = BODY;
                     break;
+                }
             }
 
             return next(
@@ -414,10 +563,9 @@ class MessageSplitter extends Transform {
         switch (this.state) {
             case HEAD: {
                 this.node.addHeaderChunk(line);
-                if (this.node._headerlen > this.maxHeadSize) {
-                    let err = /** @type {Error & {code?: string}} */ (new Error('Max header size for a MIME node exceeded'));
-                    err.code = 'EMAXLEN';
-                    return next(err);
+                let headSizeError = this.checkHeadSize();
+                if (headSizeError) {
+                    return next(headSizeError);
                 }
                 if (final || (line.length === 1 && line[0] === 0x0a) || (line.length === 2 && line[0] === 0x0d && line[1] === 0x0a)) {
                     let currentNode = this.node;
@@ -434,16 +582,16 @@ class MessageSplitter extends Transform {
                         currentNode.messageNode = true;
                         this.newNode(currentNode);
                         if (currentNode.parentNode) {
+                            // the embedded message continues inside its container, so a
+                            // delimiter of the container's own parent still applies here
                             this.node._parentBoundary = currentNode.parentNode._boundary;
+                            this.node._parentBoundaryOwner = currentNode.parentNode;
                         }
                     } else {
                         if (currentNode.contentType === 'message/rfc822') {
                             currentNode.messageNode = false;
                         }
                         this.state = BODY;
-                        if (currentNode.multipart && currentNode._boundary) {
-                            this.tree.push(currentNode);
-                        }
                     }
 
                     return next(null, currentNode, flush);
@@ -467,6 +615,16 @@ class MessageSplitter extends Transform {
         next(null, false);
     }
 
+    /**
+     * Resolves the multipart node that owns the boundary of the current node, ie. the
+     * node a sibling delimiter or a closing delimiter of _parentBoundary refers to.
+     *
+     * @returns {MimeNodeType | false} Owner of _parentBoundary or false for the root node.
+     */
+    parentMultipartNode() {
+        return this.node._parentBoundaryOwner || false;
+    }
+
     /**
      * @param {MimeNodeType | false} [parent]
      * @returns {void}
@@ -475,6 +633,8 @@ class MessageSplitter extends Transform {
         this.node = /** @type {MimeNodeType} */ (new MimeNode(parent || false, this.config));
         this.state = HEAD;
         this.nodeCounter++;
+        // a fresh node starts before its own content, never in an epilogue
+        this.inEpilogue = false;
     }
 }
 

package/node_modules/@zone-eu/mailsplit/lib/mime-node.d.ts

@@ -18,6 +18,9 @@ declare class MimeNode implements MimeNodeShape {
     /** Boundary inherited from the parent multipart node, or `false` when absent. */
     _parentBoundary: Buffer | false;
 
+    /** Node whose boundary `_parentBoundary` was copied from. */
+    _parentBoundaryOwner: MimeNode | false;
+
     /** Length, in bytes, of the raw header block collected for this node. */
     _headerlen: number;
 

package/node_modules/@zone-eu/mailsplit/lib/mime-node.js

@@ -35,6 +35,10 @@ class MimeNode {
 
         /** @type {Buffer | false} */
         this._parentBoundary = this.parentNode && this.parentNode._boundary;
+        // the node whose boundary _parentBoundary was copied from, recorded here so that
+        // a delimiter for it never has to be matched back to an owner by walking the tree
+        /** @type {MimeNodeType | false} */
+        this._parentBoundaryOwner = this.parentNode || false;
         /** @type {Buffer[]} */
         this._headersLines = [];
         this._headerlen = 0;

package/node_modules/@zone-eu/mailsplit/lib/types.d.ts

@@ -81,6 +81,9 @@ export interface MimeNode {
     /** Boundary inherited from the parent multipart node, or `false` when absent. */
     _parentBoundary: Buffer | false;
 
+    /** Node whose boundary `_parentBoundary` was copied from. */
+    _parentBoundaryOwner: MimeNode | false;
+
     /** Length, in bytes, of the raw header block collected for this node. */
     _headerlen: number;