@zone-eu/mailsplit 5.4.8 → 5.4.10

package/index.d.ts

@@ -0,0 +1,44 @@
+/// <reference types="node" />
+
+import Splitter = require('./lib/message-splitter');
+import Joiner = require('./lib/message-joiner');
+import Rewriter = require('./lib/node-rewriter');
+import Streamer = require('./lib/node-streamer');
+import ChunkedPassthrough = require('./lib/chunked-passthrough');
+import Headers = require('./lib/headers');
+import MimeNode = require('./lib/mime-node');
+
+export {
+    Splitter,
+    Joiner,
+    Rewriter,
+    Streamer,
+    ChunkedPassthrough,
+    Headers,
+    MimeNode
+};
+
+export type {
+    Maybe,
+    PartNumberItem,
+    PartNumber,
+    LibmimeOptions,
+    SplitterOptions,
+    ChunkedPassthroughOptions,
+    FlowedDecoderOptions,
+    HeaderLine,
+    DecodedHeader,
+    MimeNode,
+    MessageChunk,
+    EmptyChunk,
+    SplitterChunk,
+    RewriterInput,
+    FilterFunc,
+    ErrorWithCode,
+    ContinueCallback,
+    ContentStream,
+    DecoderStream,
+    SplitterGroup,
+    RewriterNode,
+    StreamerNode
+} from './lib/types';

package/index.js

@@ -6,12 +6,15 @@ const NodeRewriter = require('./lib/node-rewriter');
 const NodeStreamer = require('./lib/node-streamer');
 const Headers = require('./lib/headers');
 const ChunkedPassthrough = require('./lib/chunked-passthrough');
+const MimeNode = require('./lib/mime-node');
 
+/** @type {typeof import('.')} */
 module.exports = {
     Splitter: MessageSplitter,
     Joiner: MessageJoiner,
     Rewriter: NodeRewriter,
     Streamer: NodeStreamer,
     ChunkedPassthrough,
-    Headers
+    Headers,
+    MimeNode
 };

package/lib/chunked-passthrough.d.ts

@@ -0,0 +1,13 @@
+import { Transform } from 'node:stream';
+import type { ChunkedPassthroughOptions } from './types';
+
+declare class ChunkedPassthrough extends Transform {
+    constructor(options?: ChunkedPassthroughOptions);
+    on(event: 'data', listener: (data: Buffer) => void): this;
+    once(event: 'data', listener: (data: Buffer) => void): this;
+    addListener(event: 'data', listener: (data: Buffer) => void): this;
+    prependListener(event: 'data', listener: (data: Buffer) => void): this;
+    emit(event: 'data', data: Buffer): boolean;
+}
+
+export = ChunkedPassthrough;

package/lib/chunked-passthrough.js

@@ -3,6 +3,9 @@
 const { Transform } = require('stream');
 
 class ChunkedPassthrough extends Transform {
+    /**
+     * @param {import('..').ChunkedPassthroughOptions} [options]
+     */
     constructor(options = {}) {
         let config = {
             readableObjectMode: true,
@@ -13,6 +16,12 @@ class ChunkedPassthrough extends Transform {
         this.buffer = Buffer.alloc(0);
     }
 
+    /**
+     * @param {Buffer} chunk
+     * @param {BufferEncoding} encoding
+     * @param {import('stream').TransformCallback} callback
+     * @returns {void}
+     */
     _transform(chunk, encoding, callback) {
         this.buffer = Buffer.concat([this.buffer, chunk]);
 
@@ -24,6 +33,10 @@ class ChunkedPassthrough extends Transform {
         callback();
     }
 
+    /**
+     * @param {import('stream').TransformCallback} callback
+     * @returns {void}
+     */
     _flush(callback) {
         // Send remaining data
         if (this.buffer.length > 0) {

package/lib/flowed-decoder.d.ts

@@ -0,0 +1,13 @@
+import { Transform } from 'node:stream';
+import type { FlowedDecoderOptions } from './types';
+
+declare class FlowedDecoder extends Transform {
+    constructor(config?: FlowedDecoderOptions);
+    on(event: 'data', listener: (data: Buffer) => void): this;
+    once(event: 'data', listener: (data: Buffer) => void): this;
+    addListener(event: 'data', listener: (data: Buffer) => void): this;
+    prependListener(event: 'data', listener: (data: Buffer) => void): this;
+    emit(event: 'data', data: Buffer): boolean;
+}
+
+export = FlowedDecoder;

package/lib/flowed-decoder.js

@@ -5,29 +5,43 @@
 const Transform = require('stream').Transform;
 const libmime = require('libmime');
 
+/** @typedef {import('..').FlowedDecoderOptions} FlowedDecoderOptions */
+
+const Libmime = /** @type {any} */ (libmime.Libmime);
+
 /**
  * Really bad "stream" transform to parse format=flowed content
  *
  * @constructor
- * @param {String} delSp True if delsp option was used
+ * @param {FlowedDecoderOptions} [config]
  */
 class FlowedDecoder extends Transform {
+    /**
+     * @param {FlowedDecoderOptions} [config]
+     */
     constructor(config) {
         super();
         this.config = config || {};
 
+        /** @type {Buffer[]} */
         this.chunks = [];
         this.chunklen = 0;
 
-        this.libmime = new libmime.Libmime({ Iconv: config.Iconv });
+        this.libmime = new Libmime({ Iconv: this.config.Iconv });
     }
 
+    /**
+     * @param {Buffer | string} chunk
+     * @param {BufferEncoding} encoding
+     * @param {import('stream').TransformCallback} callback
+     * @returns {void}
+     */
     _transform(chunk, encoding, callback) {
         if (!chunk || !chunk.length) {
             return callback();
         }
 
-        if (!encoding !== 'buffer') {
+        if (typeof chunk === 'string') {
             chunk = Buffer.from(chunk, encoding);
         }
 
@@ -37,6 +51,10 @@ class FlowedDecoder extends Transform {
         callback();
     }
 
+    /**
+     * @param {import('stream').TransformCallback} callback
+     * @returns {void}
+     */
     _flush(callback) {
         if (this.chunklen) {
             let currentBody = Buffer.concat(this.chunks, this.chunklen);

package/lib/headers.d.ts

@@ -0,0 +1,24 @@
+import type { DecodedHeader, HeaderLine, LibmimeOptions } from './types';
+
+declare class Headers {
+    changed: boolean;
+    headers: string | Buffer | false;
+    parsed: boolean;
+    lines: HeaderLine[] | false;
+    mbox: string | false;
+    http: string | false;
+
+    constructor(headers?: string | Buffer | HeaderLine[] | false, config?: LibmimeOptions);
+    hasHeader(key: string): boolean;
+    get(key: string): string[];
+    getDecoded(key: string): DecodedHeader[];
+    getFirst(key: string): string;
+    getList(): HeaderLine[];
+    add(key: string, value?: string | number | Buffer, index?: number): void;
+    addFormatted(key: string, line?: string | Buffer | false, index?: number): void;
+    remove(key: string): void;
+    update(key: string, value?: string | number | Buffer, relativeIndex?: number): void;
+    build(lineEnd?: string | false): Buffer;
+}
+
+export = Headers;

package/lib/headers.js

@@ -2,76 +2,120 @@
 
 const libmime = require('libmime');
 
+/** @typedef {import('..').HeaderLine} HeaderLine */
+/** @typedef {import('..').LibmimeOptions} LibmimeOptions */
+/** @typedef {import('..').DecodedHeader} DecodedHeader */
+
+const Libmime = /** @type {any} */ (libmime.Libmime);
+
 /**
  * Class Headers to parse and handle message headers. Headers instance allows to
  * check existing, delete or add new headers
  */
 class Headers {
+    /**
+     * @param {string | Buffer | HeaderLine[] | false} [headers]
+     * @param {LibmimeOptions} [config]
+     */
     constructor(headers, config) {
         config = config || {};
 
         if (Array.isArray(headers)) {
             // already using parsed headers
             this.changed = true;
+            /** @type {string | Buffer | false} */
             this.headers = false;
             this.parsed = true;
+            /** @type {HeaderLine[] | false} */
             this.lines = headers;
         } else {
             // using original string/buffer headers
             this.changed = false;
-            this.headers = headers;
+            /** @type {string | Buffer | false} */
+            this.headers = headers || false;
             this.parsed = false;
+            /** @type {HeaderLine[] | false} */
             this.lines = false;
         }
+        /** @type {string | false} */
         this.mbox = false;
+        /** @type {string | false} */
         this.http = false;
 
-        this.libmime = new libmime.Libmime({ Iconv: config.Iconv });
+        this.libmime = new Libmime({ Iconv: config.Iconv });
     }
 
+    /**
+     * @param {string} key
+     * @returns {boolean}
+     */
     hasHeader(key) {
         if (!this.parsed) {
             this._parseHeaders();
         }
+        let lines = this._getLines();
         key = this._normalizeHeader(key);
-        return typeof this.lines.find(line => line.key === key) === 'object';
+        return typeof lines.find(line => line.key === key) === 'object';
     }
 
+    /**
+     * @param {string} key
+     * @returns {string[]}
+     */
     get(key) {
         if (!this.parsed) {
             this._parseHeaders();
         }
+        let headerLines = this._getLines();
         key = this._normalizeHeader(key);
-        let lines = this.lines.filter(line => line.key === key).map(line => line.line);
+        let lines = headerLines.filter(line => line.key === key).map(line => this._decodeHeaderValue(line.line));
 
         return lines;
     }
 
+    /**
+     * @param {string} key
+     * @returns {DecodedHeader[]}
+     */
     getDecoded(key) {
         return this.get(key)
             .map(line => this.libmime.decodeHeader(line))
             .filter(line => line && line.value);
     }
 
+    /**
+     * @param {string} key
+     * @returns {string}
+     */
     getFirst(key) {
         if (!this.parsed) {
             this._parseHeaders();
         }
+        let lines = this._getLines();
         key = this._normalizeHeader(key);
-        let header = this.lines.find(line => line.key === key);
+        let header = lines.find(line => line.key === key);
         if (!header) {
             return '';
         }
-        return ((this.libmime.decodeHeader(header.line) || {}).value || '').toString().trim();
+        return ((this.libmime.decodeHeader(this._decodeHeaderValue(header.line)) || {}).value || '').toString().trim();
     }
 
+    /**
+     * @returns {HeaderLine[]}
+     */
     getList() {
         if (!this.parsed) {
             this._parseHeaders();
         }
-        return this.lines;
+        return this._getLines();
     }
 
+    /**
+     * @param {string} key
+     * @param {string | number | Buffer} [value]
+     * @param {number} [index]
+     * @returns {void}
+     */
     add(key, value, index) {
         if (typeof value === 'undefined') {
             return;
@@ -89,10 +133,17 @@ class Headers {
         this.addFormatted(key, this.libmime.foldLines(key + ': ' + value.replace(/\r?\n/g, ''), 76, false), index);
     }
 
+    /**
+     * @param {string} key
+     * @param {string | Buffer | false} [line]
+     * @param {number} [index]
+     * @returns {void}
+     */
     addFormatted(key, line, index) {
         if (!this.parsed) {
             this._parseHeaders();
         }
+        let lines = this._getLines();
         index = index || 0;
         this.changed = true;
 
@@ -110,45 +161,57 @@ class Headers {
         };
 
         if (index < 1) {
-            this.lines.unshift(header);
-        } else if (index >= this.lines.length) {
-            this.lines.push(header);
+            lines.unshift(header);
+        } else if (index >= lines.length) {
+            lines.push(header);
         } else {
-            this.lines.splice(index, 0, header);
+            lines.splice(index, 0, header);
         }
     }
 
+    /**
+     * @param {string} key
+     * @returns {void}
+     */
     remove(key) {
         if (!this.parsed) {
             this._parseHeaders();
         }
+        let lines = this._getLines();
         key = this._normalizeHeader(key);
-        for (let i = this.lines.length - 1; i >= 0; i--) {
-            if (this.lines[i].key === key) {
+        for (let i = lines.length - 1; i >= 0; i--) {
+            if (lines[i].key === key) {
                 this.changed = true;
-                this.lines.splice(i, 1);
+                lines.splice(i, 1);
             }
         }
     }
 
+    /**
+     * @param {string} key
+     * @param {string | number | Buffer} [value]
+     * @param {number} [relativeIndex]
+     * @returns {void}
+     */
     update(key, value, relativeIndex) {
         if (!this.parsed) {
             this._parseHeaders();
         }
+        let lines = this._getLines();
         let keyName = key;
         let index = 0;
         key = this._normalizeHeader(key);
         let relativeIndexCount = 0;
         let relativeMatchFound = false;
-        for (let i = this.lines.length - 1; i >= 0; i--) {
-            if (this.lines[i].key === key) {
+        for (let i = lines.length - 1; i >= 0; i--) {
+            if (lines[i].key === key) {
                 if (relativeIndex && relativeIndex !== relativeIndexCount) {
                     relativeIndexCount++;
                     continue;
                 }
                 index = i;
                 this.changed = true;
-                this.lines.splice(i, 1);
+                lines.splice(i, 1);
                 if (relativeIndex) {
                     relativeMatchFound = true;
                     break;
@@ -163,34 +226,66 @@ class Headers {
         this.add(keyName, value, index);
     }
 
+    /**
+     * @param {string | false} [lineEnd]
+     * @returns {Buffer}
+     */
     build(lineEnd) {
         if (!this.changed && !lineEnd) {
-            return typeof this.headers === 'string' ? Buffer.from(this.headers, 'binary') : this.headers;
+            return typeof this.headers === 'string' ? Buffer.from(this.headers, 'binary') : this.headers || Buffer.alloc(0);
         }
 
         if (!this.parsed) {
             this._parseHeaders();
         }
+        let lines = this._getLines();
 
         lineEnd = lineEnd || '\r\n';
 
-        let headers = this.lines.map(line => line.line.replace(/\r?\n/g, lineEnd)).join(lineEnd) + `${lineEnd}${lineEnd}`;
+        let headers = lines
+            .map(line => this._buildHeaderLine(line.line.replace(/\r?\n/g, lineEnd)))
+            .reduce((joined, line, idx) => {
+                if (idx) {
+                    joined.push(Buffer.from(lineEnd, 'binary'));
+                }
+                joined.push(line);
+                return joined;
+            }, /** @type {Buffer[]} */ ([]));
+
+        headers.push(Buffer.from(lineEnd + lineEnd, 'binary'));
 
         if (this.mbox) {
-            headers = this.mbox + lineEnd + headers;
+            headers.unshift(Buffer.from(this.mbox + lineEnd, 'binary'));
         }
 
         if (this.http) {
-            headers = this.http + lineEnd + headers;
+            headers.unshift(Buffer.from(this.http + lineEnd, 'binary'));
         }
 
-        return Buffer.from(headers, 'binary');
+        return Buffer.concat(headers);
     }
 
+    /**
+     * @param {string} key
+     * @returns {string}
+     */
     _normalizeHeader(key) {
         return (key || '').toLowerCase().trim();
     }
 
+    /**
+     * @returns {HeaderLine[]}
+     */
+    _getLines() {
+        if (!this.lines) {
+            this.lines = [];
+        }
+        return this.lines;
+    }
+
+    /**
+     * @returns {void}
+     */
     _parseHeaders() {
         if (!this.headers) {
             this.lines = [];
@@ -198,18 +293,20 @@ class Headers {
             return;
         }
 
+        /** @type {Array<string | HeaderLine>} */
         let lines = this.headers
             .toString('binary')
             .replace(/[\r\n]+$/, '')
             .split(/\r?\n/);
 
         for (let i = lines.length - 1; i >= 0; i--) {
-            let chr = lines[i].charAt(0);
+            let currentLine = /** @type {string} */ (lines[i]);
+            let chr = currentLine.charAt(0);
             if (i && (chr === ' ' || chr === '\t')) {
-                lines[i - 1] += '\r\n' + lines[i];
+                lines[i - 1] = /** @type {string} */ (lines[i - 1]) + '\r\n' + currentLine;
                 lines.splice(i, 1);
             } else {
-                let line = lines[i];
+                let line = currentLine;
                 if (!i && /^From /i.test(line)) {
                     // mbox file
                     this.mbox = line;
@@ -229,9 +326,31 @@ class Headers {
             }
         }
 
-        this.lines = lines;
+        this.lines = /** @type {HeaderLine[]} */ (lines);
         this.parsed = true;
     }
+
+    /**
+     * @param {string} line
+     * @returns {Buffer}
+     */
+    _buildHeaderLine(line) {
+        let value = this._decodeHeaderValue(line);
+        return Buffer.from(value, value === line ? 'binary' : 'utf8');
+    }
+
+    /**
+     * @param {string} str
+     * @returns {string}
+     */
+    _decodeHeaderValue(str) {
+        if (!str) {
+            return str;
+        }
+
+        let utf8 = Buffer.from(str, 'binary').toString('utf8');
+        return utf8.includes('\uFFFD') ? str : utf8;
+    }
 }
 
 // expose to the world

package/lib/message-joiner.d.ts

@@ -0,0 +1,12 @@
+import { Transform } from 'node:stream';
+
+declare class MessageJoiner extends Transform {
+    constructor();
+    on(event: 'data', listener: (data: Buffer) => void): this;
+    once(event: 'data', listener: (data: Buffer) => void): this;
+    addListener(event: 'data', listener: (data: Buffer) => void): this;
+    prependListener(event: 'data', listener: (data: Buffer) => void): this;
+    emit(event: 'data', data: Buffer): boolean;
+}
+
+export = MessageJoiner;

package/lib/message-joiner.js

@@ -2,6 +2,8 @@
 
 const Transform = require('stream').Transform;
 
+/** @typedef {import('..').SplitterChunk} SplitterChunk */
+
 class MessageJoiner extends Transform {
     constructor() {
         let options = {
@@ -11,6 +13,12 @@ class MessageJoiner extends Transform {
         super(options);
     }
 
+    /**
+     * @param {SplitterChunk | Buffer} obj
+     * @param {BufferEncoding} encoding
+     * @param {import('stream').TransformCallback} callback
+     * @returns {void}
+     */
     _transform(obj, encoding, callback) {
         if (Buffer.isBuffer(obj)) {
             this.push(obj);
@@ -22,6 +30,10 @@ class MessageJoiner extends Transform {
         return callback();
     }
 
+    /**
+     * @param {import('stream').TransformCallback} callback
+     * @returns {void}
+     */
     _flush(callback) {
         return callback();
     }

package/lib/message-splitter.d.ts

@@ -0,0 +1,13 @@
+import { Transform } from 'node:stream';
+import type { SplitterChunk, SplitterOptions } from './types';
+
+declare class MessageSplitter extends Transform {
+    constructor(config?: SplitterOptions);
+    on(event: 'data', listener: (data: SplitterChunk) => void): this;
+    once(event: 'data', listener: (data: SplitterChunk) => void): this;
+    addListener(event: 'data', listener: (data: SplitterChunk) => void): this;
+    prependListener(event: 'data', listener: (data: SplitterChunk) => void): this;
+    emit(event: 'data', data: SplitterChunk): boolean;
+}
+
+export = MessageSplitter;