@depup/zone-eu__mailsplit 5.4.16-depup.0

package/lib/mime-node.d.ts

@@ -0,0 +1,147 @@
+import type { ContentStream, MimeNode as MimeNodeShape, PartNumber, PartNumberItem, SplitterOptions } from './types';
+import type Headers = require('./headers');
+
+/** Parsed MIME node with mutable headers and content encoding helpers. */
+declare class MimeNode implements MimeNodeShape {
+    /** Discriminator identifying this chunk as a MIME node. */
+    type: 'node';
+
+    /** Whether this node is the root message node. */
+    root: boolean;
+
+    /** Parent MIME node, or `false` for the root node. */
+    parentNode: MimeNodeShape | false;
+
+    /** Boundary used by this multipart node, or `false` when not multipart. */
+    _boundary: Buffer | false;
+
+    /** 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;
+
+    /** Multipart subtype such as `mixed` or `alternative`, or `false` for leaf nodes. */
+    multipart: string | false;
+
+    /** Content-Transfer-Encoding value, normalized to lower case, or `false` when absent. */
+    encoding: string | false;
+
+    /** Parsed and mutable header collection, available after headers are parsed. */
+    headers: Headers | false;
+
+    /** MIME content type such as `text/plain`, or `false` when unavailable. */
+    contentType: string | false;
+
+    /** Charset parameter from Content-Type, or `false` when absent. */
+    charset: string | false;
+
+    /** Content-Disposition value such as `inline` or `attachment`, or `false` when absent. */
+    disposition: string | false;
+
+    /** Decoded filename from Content-Disposition or Content-Type parameters, or `false` when absent. */
+    filename: string | false;
+
+    /** Whether this node is `text/*` with `format=flowed`. */
+    flowed: boolean;
+
+    /** Whether flowed text uses `delsp=yes`. */
+    delSp: boolean;
+
+    /** Splitter configuration used when parsing this node. */
+    config: SplitterOptions;
+
+    /** Resolved IMAP-style part number for this node, or `false` before resolution. */
+    partNr: PartNumber | false;
+
+    /** Number of child part numbers allocated by this node. */
+    childPartNumbers: number;
+
+    /** Whether this node's content type is `message/rfc822`. */
+    rfc822: boolean;
+
+    /** Whether an embedded `message/rfc822` node was parsed as a nested message. */
+    messageNode?: boolean;
+
+    /**
+     * Creates a MIME node with empty header state.
+     *
+     * @param parentNode Parent node, or `false`/omitted for the root node.
+     * @param config Optional splitter and libmime configuration.
+     */
+    constructor(parentNode?: MimeNodeShape | false, config?: SplitterOptions);
+
+    /**
+     * Builds the next child part number for this node.
+     *
+     * @param provided Optional explicit part number item to append.
+     * @returns Resolved MIME part number.
+     */
+    getPartNr(provided?: PartNumberItem): PartNumber;
+
+    /**
+     * Appends one raw header line to this node while parsing.
+     *
+     * @param line Raw header line bytes; falsy values are ignored.
+     * @returns Nothing.
+     */
+    addHeaderChunk(line?: Buffer | false): void;
+
+    /**
+     * Parses collected header bytes and populates MIME metadata fields.
+     *
+     * @returns Nothing.
+     */
+    parseHeaders(): void;
+
+    /**
+     * Builds this node's header block.
+     *
+     * @returns Header bytes ending with an empty header/body separator line.
+     */
+    getHeaders(): Buffer;
+
+    /**
+     * Sets or updates the Content-Type header value.
+     *
+     * @param contentType MIME content type to set; falsy keeps the current type.
+     * @returns Nothing.
+     */
+    setContentType(contentType?: string | false): void;
+
+    /**
+     * Sets, updates, or removes the Content-Type charset parameter.
+     *
+     * @param charset Charset to set; falsy removes it when possible.
+     * @returns Nothing.
+     */
+    setCharset(charset?: string | false): void;
+
+    /**
+     * Sets, updates, or removes the filename parameter.
+     *
+     * @param filename Filename to set; falsy removes it when possible.
+     * @returns Nothing.
+     */
+    setFilename(filename?: string | false): void;
+
+    /**
+     * Creates a decoder stream for this node's transfer encoding.
+     *
+     * @returns Transform stream that outputs decoded content bytes.
+     */
+    getDecoder(): ContentStream;
+
+    /**
+     * Creates an encoder stream and updates the Content-Transfer-Encoding header when needed.
+     *
+     * @param encoding Target transfer encoding; defaults to the node's current encoding.
+     * @returns Transform stream that outputs encoded content bytes.
+     */
+    getEncoder(encoding?: string | false): ContentStream;
+}
+
+export = MimeNode;

package/lib/mime-node.js

@@ -0,0 +1,351 @@
+'use strict';
+
+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);
+
+/**
+ * Parsed MIME node with mutable headers and transfer-encoding helpers.
+ */
+class MimeNode {
+    /**
+     * @param {MimeNodeType | false} parentNode Parent node, or false for the root node.
+     * @param {SplitterOptions} [config] Splitter and libmime configuration.
+     */
+    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;
+        // 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;
+
+        /** @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({ Iconv: this.config.Iconv });
+
+        /** @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 partNr.filter(nr => !isNaN(Number(nr))).concat(provided);
+        }
+        let childPartNr = ++this.childPartNumbers;
+        return partNr.filter(nr => !isNaN(Number(nr))).concat(childPartNr);
+    }
+
+    /**
+     * @param {Buffer | false} [line]
+     * @returns {void}
+     */
+    addHeaderChunk(line) {
+        if (!line) {
+            return;
+        }
+        this._headersLines.push(line);
+        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(headers.getFirst('Content-Disposition'));
+        let parsedContentDisposition = /** @type {StructuredHeader} */ (this._parsedContentDisposition);
+
+        // if content-type is missing default to plaintext
+        let contentHeader;
+        if (headers.get('Content-Type').length) {
+            contentHeader = headers.getFirst('Content-Type');
+        } else {
+            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(parsedContentDisposition.value)) {
+                    contentHeader = 'application/octet-stream';
+                } else {
+                    contentHeader = 'text/plain';
+                }
+            }
+        }
+
+        this._parsedContentType = this.libmime.parseHeaderValue(contentHeader);
+        let parsedContentType = /** @type {StructuredHeader} */ (this._parsedContentType);
+
+        this.encoding = headers
+            .getFirst('Content-Transfer-Encoding')
+            .replace(/\(.*\)/g, '')
+            .toLowerCase()
+            .trim();
+        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) {
+            try {
+                this.disposition = this.libmime.decodeWords(this.disposition);
+            } catch (E) {
+                // failed to parse disposition, keep as is (most probably an unknown charset is used)
+            }
+        }
+
+        this.filename = parsedContentDisposition.params.filename || parsedContentType.params.name || false;
+
+        if (parsedContentType.params.format && parsedContentType.params.format.toLowerCase().trim() === 'flowed') {
+            this.flowed = true;
+            if (parsedContentType.params.delsp && parsedContentType.params.delsp.toLowerCase().trim() === 'yes') {
+                this.delSp = true;
+            }
+        }
+
+        if (this.filename) {
+            try {
+                this.filename = this.libmime.decodeWords(this.filename);
+            } catch (E) {
+                // failed to parse filename, keep as is (most probably an unknown charset is used)
+            }
+        }
+
+        this.multipart =
+            (this.contentType &&
+                this.contentType.substr(0, this.contentType.indexOf('/')) === 'multipart' &&
+                this.contentType.substr(this.contentType.indexOf('/') + 1)) ||
+            false;
+        this._boundary = (parsedContentType.params.boundary && Buffer.from(parsedContentType.params.boundary)) || false;
+
+        this.rfc822 = this.contentType === 'message/rfc822';
+
+        if (!this.parentNode || this.parentNode.rfc822) {
+            this.partNr = this.parentNode ? this.parentNode.getPartNr('TEXT') : ['TEXT'];
+        } else {
+            this.partNr = this.parentNode ? this.parentNode.getPartNr() : [];
+        }
+    }
+
+    /**
+     * @returns {Buffer}
+     */
+    getHeaders() {
+        if (!this.headers) {
+            this.parseHeaders();
+        }
+        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) {
+            parsedContentType.value = contentType;
+        }
+
+        if (!this.flowed && parsedContentType.params.format) {
+            delete parsedContentType.params.format;
+        }
+
+        if (!this.delSp && parsedContentType.params.delsp) {
+            delete parsedContentType.params.delsp;
+        }
+
+        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();
+
+        if (charset === 'ascii') {
+            charset = '';
+        }
+
+        if (!charset) {
+            if (!parsedContentType.value) {
+                // nothing to set or update
+                return;
+            }
+            delete parsedContentType.params.charset;
+        } else {
+            parsedContentType.params.charset = charset;
+        }
+
+        if (!parsedContentType.value) {
+            parsedContentType.value = 'text/plain';
+        }
+
+        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 (parsedContentType.params.name) {
+            delete parsedContentType.params.name;
+            headers.update('Content-Type', this.libmime.buildHeaderValue(parsedContentType));
+        }
+
+        if (!this.filename) {
+            if (!parsedContentDisposition.value) {
+                // nothing to set or update
+                return;
+            }
+            delete parsedContentDisposition.params.filename;
+        } else {
+            parsedContentDisposition.params.filename = this.filename;
+        }
+
+        if (!parsedContentDisposition.value) {
+            parsedContentDisposition.value = 'attachment';
+        }
+
+        headers.update('Content-Disposition', this.libmime.buildHeaderValue(parsedContentDisposition));
+    }
+
+    /**
+     * @returns {import('stream').Transform | import('stream').PassThrough}
+     */
+    getDecoder() {
+        if (!this.headers) {
+            this.parseHeaders();
+        }
+
+        switch (this.encoding) {
+            case 'base64':
+                return new libbase64.Decoder();
+            case 'quoted-printable':
+                return new libqp.Decoder();
+            default:
+                return new PassThrough();
+        }
+    }
+
+    /**
+     * @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) {
+            headers.update('Content-Transfer-Encoding', encoding);
+        } else {
+            encoding = this.encoding;
+        }
+
+        switch (encoding) {
+            case 'base64':
+                return new libbase64.Encoder();
+            case 'quoted-printable':
+                return new libqp.Encoder();
+            default:
+                return new PassThrough();
+        }
+    }
+}
+
+module.exports = MimeNode;

package/lib/node-rewriter.d.ts

@@ -0,0 +1,105 @@
+import { Transform } from 'node:stream';
+import type { FilterFunc, RewriterNode, SplitterChunk } from './types';
+
+/** Transform stream that replaces the body content of selected MIME nodes. */
+declare class NodeRewriter extends Transform {
+    /**
+     * Creates a node rewriter that accepts splitter chunks and emits rewritten splitter chunks.
+     *
+     * @param filterFunc Predicate that selects MIME nodes to rewrite.
+     * @param rewriteAction Optional compatibility hook stored on the instance; consumers usually handle the `node` event.
+     */
+    constructor(filterFunc: FilterFunc, rewriteAction?: Function);
+
+    /**
+     * Registers a listener for rewritten splitter chunks.
+     *
+     * @param event Event name.
+     * @param listener Receives each outgoing MIME node, data chunk, or body chunk.
+     * @returns This rewriter instance.
+     */
+    on(event: 'data', listener: (data: SplitterChunk) => void): this;
+
+    /**
+     * Registers a listener for selected nodes.
+     *
+     * @param event Event name.
+     * @param listener Receives decoder and encoder streams for a selected node.
+     * @returns This rewriter instance.
+     */
+    on(event: 'node', listener: (data: RewriterNode) => void): this;
+
+    /**
+     * Registers a one-time listener for the next rewritten splitter chunk.
+     *
+     * @param event Event name.
+     * @param listener Receives the next outgoing MIME node, data chunk, or body chunk.
+     * @returns This rewriter instance.
+     */
+    once(event: 'data', listener: (data: SplitterChunk) => void): this;
+
+    /**
+     * Registers a one-time listener for the next selected node.
+     *
+     * @param event Event name.
+     * @param listener Receives decoder and encoder streams for the next selected node.
+     * @returns This rewriter instance.
+     */
+    once(event: 'node', listener: (data: RewriterNode) => void): this;
+
+    /**
+     * Adds a listener for rewritten splitter chunks.
+     *
+     * @param event Event name.
+     * @param listener Receives each outgoing MIME node, data chunk, or body chunk.
+     * @returns This rewriter instance.
+     */
+    addListener(event: 'data', listener: (data: SplitterChunk) => void): this;
+
+    /**
+     * Adds a listener for selected nodes.
+     *
+     * @param event Event name.
+     * @param listener Receives decoder and encoder streams for a selected node.
+     * @returns This rewriter instance.
+     */
+    addListener(event: 'node', listener: (data: RewriterNode) => void): this;
+
+    /**
+     * Prepends a listener for rewritten splitter chunks.
+     *
+     * @param event Event name.
+     * @param listener Receives each outgoing MIME node, data chunk, or body chunk.
+     * @returns This rewriter instance.
+     */
+    prependListener(event: 'data', listener: (data: SplitterChunk) => void): this;
+
+    /**
+     * Prepends a listener for selected nodes.
+     *
+     * @param event Event name.
+     * @param listener Receives decoder and encoder streams for a selected node.
+     * @returns This rewriter instance.
+     */
+    prependListener(event: 'node', listener: (data: RewriterNode) => void): this;
+
+    /**
+     * Emits a rewritten splitter chunk.
+     *
+     * @param event Event name.
+     * @param data MIME node, data chunk, or body chunk to emit.
+     * @returns `true` when the event had listeners.
+     */
+    emit(event: 'data', data: SplitterChunk): boolean;
+
+    /**
+     * Emits a selected-node payload.
+     *
+     * @param event Event name.
+     * @param data Selected node payload containing decoder and encoder streams.
+     * @returns `true` when the event had listeners.
+     */
+    emit(event: 'node', data: RewriterNode): boolean;
+}
+
+export = NodeRewriter;