@zone-eu/mailsplit 5.4.8 → 5.4.10

package/lib/message-splitter.js

@@ -3,6 +3,13 @@
 const Transform = require('stream').Transform;
 const MimeNode = require('./mime-node');
 
+/** @typedef {import('..').MimeNode} MimeNodeType */
+/** @typedef {import('..').MessageChunk} MessageChunk */
+/** @typedef {import('..').SplitterChunk} SplitterChunk */
+/** @typedef {import('..').SplitterGroup} SplitterGroup */
+/** @typedef {import('..').SplitterOptions} SplitterOptions */
+/** @typedef {(err?: (Error & {code?: string}) | null, data?: SplitterChunk | MessageChunk | false, flush?: boolean) => void} ProcessLineCallback */
+
 const MAX_HEAD_SIZE = 1 * 1024 * 1024;
 const MAX_CHILD_NODES = 1000;
 
@@ -10,6 +17,9 @@ const HEAD = 0x01;
 const BODY = 0x02;
 
 class MessageSplitter extends Transform {
+    /**
+     * @param {SplitterOptions} [config]
+     */
     constructor(config) {
         let options = {
             readableObjectMode: true,
@@ -20,25 +30,36 @@ 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));
         this.newNode();
         this.tree.push(this.node);
+        /** @type {Buffer | false} */
         this.line = false;
         this.hasFailed = false;
     }
 
+    /**
+     * @param {Buffer} chunk
+     * @param {BufferEncoding} encoding
+     * @param {import('stream').TransformCallback} callback
+     * @returns {void}
+     */
     _transform(chunk, encoding, callback) {
         // process line by line
         // find next line ending
         let pos = 0;
         let i = 0;
+        /** @type {SplitterGroup} */
         let group = {
             type: 'none'
         };
         let groupstart = this.line ? -this.line.length : 0;
         let groupend = 0;
 
+        /** @param {MessageChunk} data */
         let checkTrailingLinebreak = data => {
             if (data.type === 'body' && data.node.parentNode && data.value && data.value.length) {
                 if (data.value[data.value.length - 1] === 0x0a) {
@@ -88,7 +109,7 @@ class MessageSplitter extends Transform {
 
                         if (flush) {
                             if (group && group.type !== 'none') {
-                                if (group.type === 'body' && groupend >= groupstart && group.node.parentNode) {
+                                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--;
@@ -99,7 +120,7 @@ class MessageSplitter extends Transform {
                                 }
                                 if (groupstart !== groupend) {
                                     group.value = chunk.slice(groupstart, groupend);
-                                    if (groupend < i) {
+                                    if (groupend < i && 'value' in data) {
                                         data.value = chunk.slice(groupend, i);
                                     }
                                 }
@@ -118,7 +139,7 @@ class MessageSplitter extends Transform {
                             // shift slice end position forward
                             groupend = i;
                         } else {
-                            if (group.type === 'body' && groupend >= groupstart && group.node.parentNode) {
+                            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--;
@@ -165,7 +186,7 @@ class MessageSplitter extends Transform {
             }
 
             // skip last linebreak for body
-            if (pos >= groupstart + 1 && group.type === 'body' && group.node.parentNode) {
+            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--;
@@ -200,6 +221,10 @@ class MessageSplitter extends Transform {
         setImmediate(iterateData);
     }
 
+    /**
+     * @param {import('stream').TransformCallback} callback
+     * @returns {void}
+     */
     _flush(callback) {
         if (this.hasFailed) {
             return callback();
@@ -215,6 +240,12 @@ class MessageSplitter extends Transform {
         });
     }
 
+    /**
+     * @param {Buffer} line
+     * @param {number} startpos
+     * @param {Buffer} boundary
+     * @returns {1 | 2 | false}
+     */
     compareBoundary(line, startpos, boundary) {
         // --{boundary}\r\n or --{boundary}--\r\n
         if (line.length < boundary.length + 3 + startpos || line.length > boundary.length + 6 + startpos) {
@@ -256,6 +287,10 @@ class MessageSplitter extends Transform {
         return 2;
     }
 
+    /**
+     * @param {Buffer} line
+     * @returns {1 | 2 | 3 | 4 | false}
+     */
     checkBoundary(line) {
         let startpos = 0;
         if (line.length >= 1 && (line[0] === 0x0d || line[0] === 0x0a)) {
@@ -269,6 +304,7 @@ class MessageSplitter extends Transform {
             return false;
         }
 
+        /** @type {1 | 2 | false} */
         let boundary;
         if (this.node._boundary && (boundary = this.compareBoundary(line, startpos, this.node._boundary))) {
             // 1: next child
@@ -279,12 +315,18 @@ class MessageSplitter extends Transform {
         if (this.node._parentBoundary && (boundary = this.compareBoundary(line, startpos, this.node._parentBoundary))) {
             // 3: next sibling
             // 4: parent end
-            return boundary + 2;
+            return /** @type {3 | 4} */ (boundary + 2);
         }
 
         return false;
     }
 
+    /**
+     * @param {Buffer | false} line
+     * @param {boolean} final
+     * @param {ProcessLineCallback} next
+     * @returns {void}
+     */
     processLine(line, final, next) {
         let flush = false;
 
@@ -301,7 +343,7 @@ class MessageSplitter extends Transform {
         }
 
         if (this.nodeCounter > this.maxChildNodes) {
-            let err = new Error('Max allowed child nodes exceeded');
+            let err = /** @type {Error & {code?: string}} */ (new Error('Max allowed child nodes exceeded'));
             err.code = 'EMAXLEN';
             return next(err);
         }
@@ -339,7 +381,7 @@ class MessageSplitter extends Transform {
                     }
                     // move up
                     if (this.tree.length) {
-                        this.node = this.tree.pop();
+                        this.node = /** @type {MimeNodeType} */ (this.tree.pop());
                     }
                     this.state = BODY;
                     break;
@@ -360,7 +402,7 @@ class MessageSplitter extends Transform {
             case HEAD: {
                 this.node.addHeaderChunk(line);
                 if (this.node._headerlen > this.maxHeadSize) {
-                    let err = new Error('Max header size for a MIME node exceeded');
+                    let err = /** @type {Error & {code?: string}} */ (new Error('Max header size for a MIME node exceeded'));
                     err.code = 'EMAXLEN';
                     return next(err);
                 }
@@ -412,8 +454,12 @@ class MessageSplitter extends Transform {
         next(null, false);
     }
 
+    /**
+     * @param {MimeNodeType | false} [parent]
+     * @returns {void}
+     */
     newNode(parent) {
-        this.node = new MimeNode(parent || false, this.config);
+        this.node = /** @type {MimeNodeType} */ (new MimeNode(parent || false, this.config));
         this.state = HEAD;
         this.nodeCounter++;
     }

package/lib/mime-node.d.ts

@@ -0,0 +1,38 @@
+import type { ContentStream, MimeNode as MimeNodeShape, PartNumber, PartNumberItem, SplitterOptions } from './types';
+import type Headers = require('./headers');
+
+declare class MimeNode implements MimeNodeShape {
+    type: 'node';
+    root: boolean;
+    parentNode: MimeNodeShape | false;
+    _boundary: Buffer | false;
+    _parentBoundary: Buffer | false;
+    _headerlen: number;
+    multipart: string | false;
+    encoding: string | false;
+    headers: Headers | false;
+    contentType: string | false;
+    charset: string | false;
+    disposition: string | false;
+    filename: string | false;
+    flowed: boolean;
+    delSp: boolean;
+    config: SplitterOptions;
+    partNr: PartNumber | false;
+    childPartNumbers: number;
+    rfc822: boolean;
+    messageNode?: boolean;
+
+    constructor(parentNode?: MimeNodeShape | false, config?: SplitterOptions);
+    getPartNr(provided?: PartNumberItem): PartNumber;
+    addHeaderChunk(line?: Buffer | false): void;
+    parseHeaders(): void;
+    getHeaders(): Buffer;
+    setContentType(contentType?: string | false): void;
+    setCharset(charset?: string | false): void;
+    setFilename(filename?: string | false): void;
+    getDecoder(): ContentStream;
+    getEncoder(encoding?: string | false): ContentStream;
+}
+
+export = MimeNode;

package/lib/mime-node.js

@@ -3,52 +3,94 @@
 const Headers = require('./headers');
 const libmime = require('libmime');
 const libqp = require('libqp');
+// @ts-ignore
 const libbase64 = require('libbase64');
 const PassThrough = require('stream').PassThrough;
 const pathlib = require('path');
 
+/** @typedef {import('..').Headers} HeadersType */
+/** @typedef {import('..').PartNumberItem} PartNumberItem */
+/** @typedef {import('..').PartNumber} PartNumber */
+/** @typedef {import('..').SplitterOptions} SplitterOptions */
+/** @typedef {import('libmime').StructuredHeader} StructuredHeader */
+/** @typedef {import('stream').Transform | import('stream').PassThrough} ContentStream */
+/** @typedef {import('..').MimeNode} MimeNodeType */
+
+const Libmime = /** @type {any} */ (libmime.Libmime);
+
 class MimeNode {
+    /**
+     * @param {MimeNodeType | false} parentNode
+     * @param {SplitterOptions} [config]
+     */
     constructor(parentNode, config) {
+        /** @type {'node'} */
         this.type = 'node';
         this.root = !parentNode;
+        /** @type {MimeNodeType | false} */
         this.parentNode = parentNode;
 
+        /** @type {Buffer | false} */
         this._parentBoundary = this.parentNode && this.parentNode._boundary;
+        /** @type {Buffer[]} */
         this._headersLines = [];
         this._headerlen = 0;
 
+        /** @type {StructuredHeader | false} */
         this._parsedContentType = false;
+        /** @type {StructuredHeader | false} */
+        this._parsedContentDisposition = false;
+        /** @type {Buffer | false} */
         this._boundary = false;
 
+        /** @type {string | false} */
         this.multipart = false;
+        /** @type {string | false} */
         this.encoding = false;
+        /** @type {HeadersType | false} */
         this.headers = false;
+        /** @type {string | false} */
         this.contentType = false;
+        /** @type {string | false} */
+        this.charset = false;
+        /** @type {string | false} */
+        this.disposition = false;
+        /** @type {string | false} */
+        this.filename = false;
         this.flowed = false;
         this.delSp = false;
 
         this.config = config || {};
-        this.libmime = new libmime.Libmime({ Iconv: this.config.Iconv });
+        this.libmime = new Libmime({ Iconv: this.config.Iconv });
 
-        this.parentPartNumber = (parentNode && this.partNr) || [];
+        /** @type {PartNumber} */
+        this.parentPartNumber = [];
+        /** @type {PartNumber | false} */
         this.partNr = false; // resolved later
         this.childPartNumbers = 0;
+        this.rfc822 = false;
+        /** @type {boolean | undefined} */
+        this.messageNode = undefined;
     }
 
+    /**
+     * @param {PartNumberItem} [provided]
+     * @returns {PartNumber}
+     */
     getPartNr(provided) {
+        /** @type {PartNumber} */
+        let partNr = this.partNr || [];
         if (provided) {
-            return []
-                .concat(this.partNr || [])
-                .filter(nr => !isNaN(nr))
-                .concat(provided);
+            return partNr.filter(nr => !isNaN(Number(nr))).concat(provided);
         }
         let childPartNr = ++this.childPartNumbers;
-        return []
-            .concat(this.partNr || [])
-            .filter(nr => !isNaN(nr))
-            .concat(childPartNr);
+        return partNr.filter(nr => !isNaN(Number(nr))).concat(childPartNr);
     }
 
+    /**
+     * @param {Buffer | false} [line]
+     * @returns {void}
+     */
     addHeaderChunk(line) {
         if (!line) {
             return;
@@ -57,27 +99,32 @@ class MimeNode {
         this._headerlen += line.length;
     }
 
+    /**
+     * @returns {void}
+     */
     parseHeaders() {
         if (this.headers) {
             return;
         }
         this.headers = new Headers(Buffer.concat(this._headersLines, this._headerlen), this.config);
+        let headers = this.headers;
 
-        this._parsedContentDisposition = this.libmime.parseHeaderValue(this.headers.getFirst('Content-Disposition'));
+        this._parsedContentDisposition = this.libmime.parseHeaderValue(headers.getFirst('Content-Disposition'));
+        let parsedContentDisposition = /** @type {StructuredHeader} */ (this._parsedContentDisposition);
 
         // if content-type is missing default to plaintext
         let contentHeader;
-        if (this.headers.get('Content-Type').length) {
-            contentHeader = this.headers.getFirst('Content-Type');
+        if (headers.get('Content-Type').length) {
+            contentHeader = headers.getFirst('Content-Type');
         } else {
-            if (this._parsedContentDisposition.params.filename) {
-                let extension = pathlib.parse(this._parsedContentDisposition.params.filename).ext.replace(/^\./, '');
+            if (parsedContentDisposition.params.filename) {
+                let extension = pathlib.parse(parsedContentDisposition.params.filename).ext.replace(/^\./, '');
                 if (extension) {
                     contentHeader = libmime.detectMimeType(extension);
                 }
             }
             if (!contentHeader) {
-                if (/^attachment$/i.test(this._parsedContentDisposition.value)) {
+                if (/^attachment$/i.test(parsedContentDisposition.value)) {
                     contentHeader = 'application/octet-stream';
                 } else {
                     contentHeader = 'text/plain';
@@ -86,15 +133,16 @@ class MimeNode {
         }
 
         this._parsedContentType = this.libmime.parseHeaderValue(contentHeader);
+        let parsedContentType = /** @type {StructuredHeader} */ (this._parsedContentType);
 
-        this.encoding = this.headers
+        this.encoding = headers
             .getFirst('Content-Transfer-Encoding')
             .replace(/\(.*\)/g, '')
             .toLowerCase()
             .trim();
-        this.contentType = (this._parsedContentType.value || '').toLowerCase().trim() || false;
-        this.charset = this._parsedContentType.params.charset || false;
-        this.disposition = (this._parsedContentDisposition.value || '').toLowerCase().trim() || false;
+        this.contentType = (parsedContentType.value || '').toLowerCase().trim() || false;
+        this.charset = parsedContentType.params.charset || false;
+        this.disposition = (parsedContentDisposition.value || '').toLowerCase().trim() || false;
 
         // fix invalidly encoded disposition values
         if (this.disposition) {
@@ -105,11 +153,11 @@ class MimeNode {
             }
         }
 
-        this.filename = this._parsedContentDisposition.params.filename || this._parsedContentType.params.name || false;
+        this.filename = parsedContentDisposition.params.filename || parsedContentType.params.name || false;
 
-        if (this._parsedContentType.params.format && this._parsedContentType.params.format.toLowerCase().trim() === 'flowed') {
+        if (parsedContentType.params.format && parsedContentType.params.format.toLowerCase().trim() === 'flowed') {
             this.flowed = true;
-            if (this._parsedContentType.params.delsp && this._parsedContentType.params.delsp.toLowerCase().trim() === 'yes') {
+            if (parsedContentType.params.delsp && parsedContentType.params.delsp.toLowerCase().trim() === 'yes') {
                 this.delSp = true;
             }
         }
@@ -127,7 +175,7 @@ class MimeNode {
                 this.contentType.substr(0, this.contentType.indexOf('/')) === 'multipart' &&
                 this.contentType.substr(this.contentType.indexOf('/') + 1)) ||
             false;
-        this._boundary = (this._parsedContentType.params.boundary && Buffer.from(this._parsedContentType.params.boundary)) || false;
+        this._boundary = (parsedContentType.params.boundary && Buffer.from(parsedContentType.params.boundary)) || false;
 
         this.rfc822 = this.contentType === 'message/rfc822';
 
@@ -138,38 +186,54 @@ class MimeNode {
         }
     }
 
+    /**
+     * @returns {Buffer}
+     */
     getHeaders() {
         if (!this.headers) {
             this.parseHeaders();
         }
-        return this.headers.build();
+        let headers = /** @type {HeadersType} */ (this.headers);
+        return headers.build();
     }
 
+    /**
+     * @param {string | false} [contentType]
+     * @returns {void}
+     */
     setContentType(contentType) {
         if (!this.headers) {
             this.parseHeaders();
         }
+        let headers = /** @type {HeadersType} */ (this.headers);
+        let parsedContentType = /** @type {StructuredHeader} */ (this._parsedContentType);
 
         contentType = (contentType || '').toLowerCase().trim();
         if (contentType) {
-            this._parsedContentType.value = contentType;
+            parsedContentType.value = contentType;
         }
 
-        if (!this.flowed && this._parsedContentType.params.format) {
-            delete this._parsedContentType.params.format;
+        if (!this.flowed && parsedContentType.params.format) {
+            delete parsedContentType.params.format;
         }
 
-        if (!this.delSp && this._parsedContentType.params.delsp) {
-            delete this._parsedContentType.params.delsp;
+        if (!this.delSp && parsedContentType.params.delsp) {
+            delete parsedContentType.params.delsp;
         }
 
-        this.headers.update('Content-Type', this.libmime.buildHeaderValue(this._parsedContentType));
+        headers.update('Content-Type', this.libmime.buildHeaderValue(parsedContentType));
     }
 
+    /**
+     * @param {string | false} [charset]
+     * @returns {void}
+     */
     setCharset(charset) {
         if (!this.headers) {
             this.parseHeaders();
         }
+        let headers = /** @type {HeadersType} */ (this.headers);
+        let parsedContentType = /** @type {StructuredHeader} */ (this._parsedContentType);
 
         charset = (charset || '').toLowerCase().trim();
 
@@ -178,51 +242,61 @@ class MimeNode {
         }
 
         if (!charset) {
-            if (!this._parsedContentType.value) {
+            if (!parsedContentType.value) {
                 // nothing to set or update
                 return;
             }
-            delete this._parsedContentType.params.charset;
+            delete parsedContentType.params.charset;
         } else {
-            this._parsedContentType.params.charset = charset;
+            parsedContentType.params.charset = charset;
         }
 
-        if (!this._parsedContentType.value) {
-            this._parsedContentType.value = 'text/plain';
+        if (!parsedContentType.value) {
+            parsedContentType.value = 'text/plain';
         }
 
-        this.headers.update('Content-Type', this.libmime.buildHeaderValue(this._parsedContentType));
+        headers.update('Content-Type', this.libmime.buildHeaderValue(parsedContentType));
     }
 
+    /**
+     * @param {string | false} [filename]
+     * @returns {void}
+     */
     setFilename(filename) {
         if (!this.headers) {
             this.parseHeaders();
         }
+        let headers = /** @type {HeadersType} */ (this.headers);
+        let parsedContentType = /** @type {StructuredHeader} */ (this._parsedContentType);
+        let parsedContentDisposition = /** @type {StructuredHeader} */ (this._parsedContentDisposition);
 
         this.filename = (filename || '').toLowerCase().trim();
 
-        if (this._parsedContentType.params.name) {
-            delete this._parsedContentType.params.name;
-            this.headers.update('Content-Type', this.libmime.buildHeaderValue(this._parsedContentType));
+        if (parsedContentType.params.name) {
+            delete parsedContentType.params.name;
+            headers.update('Content-Type', this.libmime.buildHeaderValue(parsedContentType));
         }
 
         if (!this.filename) {
-            if (!this._parsedContentDisposition.value) {
+            if (!parsedContentDisposition.value) {
                 // nothing to set or update
                 return;
             }
-            delete this._parsedContentDisposition.params.filename;
+            delete parsedContentDisposition.params.filename;
         } else {
-            this._parsedContentDisposition.params.filename = this.filename;
+            parsedContentDisposition.params.filename = this.filename;
         }
 
-        if (!this._parsedContentDisposition.value) {
-            this._parsedContentDisposition.value = 'attachment';
+        if (!parsedContentDisposition.value) {
+            parsedContentDisposition.value = 'attachment';
         }
 
-        this.headers.update('Content-Disposition', this.libmime.buildHeaderValue(this._parsedContentDisposition));
+        headers.update('Content-Disposition', this.libmime.buildHeaderValue(parsedContentDisposition));
     }
 
+    /**
+     * @returns {import('stream').Transform | import('stream').PassThrough}
+     */
     getDecoder() {
         if (!this.headers) {
             this.parseHeaders();
@@ -238,15 +312,20 @@ class MimeNode {
         }
     }
 
+    /**
+     * @param {string | false} [encoding]
+     * @returns {import('stream').Transform | import('stream').PassThrough}
+     */
     getEncoder(encoding) {
         if (!this.headers) {
             this.parseHeaders();
         }
+        let headers = /** @type {HeadersType} */ (this.headers);
 
         encoding = (encoding || '').toString().toLowerCase().trim();
 
         if (encoding && encoding !== this.encoding) {
-            this.headers.update('Content-Transfer-Encoding', encoding);
+            headers.update('Content-Transfer-Encoding', encoding);
         } else {
             encoding = this.encoding;
         }

package/lib/node-rewriter.d.ts

@@ -0,0 +1,18 @@
+import { Transform } from 'node:stream';
+import type { FilterFunc, RewriterNode, SplitterChunk } from './types';
+
+declare class NodeRewriter extends Transform {
+    constructor(filterFunc: FilterFunc, rewriteAction?: Function);
+    on(event: 'data', listener: (data: SplitterChunk) => void): this;
+    on(event: 'node', listener: (data: RewriterNode) => void): this;
+    once(event: 'data', listener: (data: SplitterChunk) => void): this;
+    once(event: 'node', listener: (data: RewriterNode) => void): this;
+    addListener(event: 'data', listener: (data: SplitterChunk) => void): this;
+    addListener(event: 'node', listener: (data: RewriterNode) => void): this;
+    prependListener(event: 'data', listener: (data: SplitterChunk) => void): this;
+    prependListener(event: 'node', listener: (data: RewriterNode) => void): this;
+    emit(event: 'data', data: SplitterChunk): boolean;
+    emit(event: 'node', data: RewriterNode): boolean;
+}
+
+export = NodeRewriter;