arn-rawmime 0.0.5 → 0.0.7

package/package.json

@@ -1,9 +1,12 @@
 {
 	"name": "arn-rawmime",
-	"version": "0.0.5",
+	"version": "0.0.7",
 	"description": "A lightweight, dependency-free raw MIME email builder with DKIM support.",
 	"author": "ARNDESK",
 	"type": "module",
+	"engines": {
+		"node": ">=16.0.0"
+	},
 	"main": "src/index.js",
 	"types": "src/index.d.ts",
 	"files": [
@@ -13,22 +16,11 @@
 		"test": "test"
 	},
 	"dependencies": {
-		"deepmerge": "^4.3.1",
-		"dom-serializer": "^2.0.0",
-		"domelementtype": "^2.3.0",
-		"domhandler": "^5.0.3",
-		"domutils": "^3.2.2",
-		"entities": "^4.5.0",
 		"he": "^1.2.0",
-		"html-to-text": "^9.0.5",
-		"htmlparser2": "^8.0.2",
-		"leac": "^0.6.0",
+		"html-to-text": "^10.0.0",
 		"mailparser": "^3.9.0",
-		"marked": "^17.0.1",
+		"marked": "^18.0.3",
 		"mime-types": "^3.0.2",
-		"parseley": "^0.12.1",
-		"peberminta": "^0.9.0",
-		"selderee": "^0.11.0",
 		"turndown": "^7.2.2"
 	},
 	"scripts": {

package/src/dkim-signer.js

@@ -68,12 +68,12 @@ function DKIMSign(email, options) {
 	options = options || {};
 	email = (email || "").toString("utf-8");
 
-	var match = email.match(/^\r?\n|(?:\r?\n){2}/),
+	let match = email.match(/^\r?\n|(?:\r?\n){2}/),
 		headers = (match && email.substring(0, match.index)) || "",
 		body = (match && email.substring(match.index + match[0].length)) || email;
 
 	// All listed fields from RFC4871 #5.5
-	var defaultFieldNames =
+	const defaultFieldNames =
 		"From:Sender:Reply-To:Subject:To:" +
 		"Cc:MIME-Version:Content-Type:Content-Transfer-Encoding:Content-ID:" +
 		"Content-Description:Resent-Date:Resent-From:Resent-Sender:" +
@@ -82,7 +82,7 @@ function DKIMSign(email, options) {
 		"List-Owner:List-Archive:" +
 		"List-Unsubscribe-Post:Date:Message-ID:Feedback-ID:DKIM-Signature:";
 
-	var dkim = generateDKIMHeader(
+	let dkim = generateDKIMHeader(
 		options.domainName,
 		options.keySelector,
 		options.headerFieldNames || defaultFieldNames,
@@ -117,7 +117,7 @@ function DKIMSign(email, options) {
  * @return {String} Mime folded DKIM-Signature string
  */
 function generateDKIMHeader(domainName, keySelector, headerFieldNames, headers, body) {
-	var canonicalizedBody = DKIMCanonicalizer.relaxedBody(body),
+	let canonicalizedBody = DKIMCanonicalizer.relaxedBody(body),
 		canonicalizedBodyHash = sha256(canonicalizedBody, "base64"),
 		canonicalizedHeaderData = DKIMCanonicalizer.relaxedHeaders(headers, headerFieldNames),
 		dkim;
@@ -176,7 +176,7 @@ const DKIMCanonicalizer = {
 	 * @return {Object} Canonicalized headers and field names
 	 */
 	relaxedHeaders: function (headers, fieldNames) {
-		var includedFields = (fieldNames || "").split(":").map(function (field) {
+		let includedFields = (fieldNames || "").split(":").map(function (field) {
 			return field.trim();
 		}),
 			includedFieldsLower = includedFields.map(function (field) {
@@ -197,7 +197,7 @@ const DKIMCanonicalizer = {
 		// Process header lines
 		for (i = 0; i < headerLines.length; i++) {
 			line = DKIMCanonicalizer.relaxedHeaderLine(headerLines[i]);
-			var keyLower = line.key.toLowerCase();
+			let keyLower = line.key.toLowerCase();
 
 			if (includedFieldsLower.indexOf(keyLower) >= 0 && !(keyLower in headerFields)) {
 				headerFields[keyLower] = {
@@ -207,20 +207,20 @@ const DKIMCanonicalizer = {
 			}
 		}
 
-		var headers = [];
-		var usedFields = [];
+		let resultHeaders = [];
+		let usedFields = [];
 		for (i = includedFields.length - 1; i >= 0; i--) {
-			var keyLower = includedFields[i].toLowerCase();
+			let keyLower = includedFields[i].toLowerCase();
 			if (!headerFields[keyLower]) {
 				includedFields.splice(i, 1);
 			} else {
-				headers.unshift(headerFields[keyLower].key.toLowerCase() + ":" + headerFields[keyLower].value);
+				resultHeaders.unshift(headerFields[keyLower].key.toLowerCase() + ":" + headerFields[keyLower].value);
 				usedFields.unshift(headerFields[keyLower].key);
 			}
 		}
 
 		return {
-			headers: headers.join("\r\n") + "\r\n",
+			headers: resultHeaders.join("\r\n") + "\r\n",
 			fieldNames: usedFields.join(":"),
 		};
 	},
@@ -231,7 +231,7 @@ const DKIMCanonicalizer = {
 	 * @return {Object} Parsed header line with key and value
 	 */
 	relaxedHeaderLine: function (line) {
-		var parts = line.split(":"),
+		let parts = line.split(":"),
 			key = (parts.shift() || "").trim(),
 			value = parts.join(":").replace(/\s+/g, " ").trim();
 
@@ -250,7 +250,7 @@ const DKIMCanonicalizer = {
  * @return {String} SHA-256 hash in the selected output encoding
  */
 function sha256(str, encoding) {
-	var shasum = crypto.createHash("sha256");
+	const shasum = crypto.createHash("sha256");
 	shasum.update(str);
 	return shasum.digest(encoding || "hex");
 }
@@ -262,7 +262,7 @@ function sha256(str, encoding) {
  * @return {Boolean} true if the string contains non-ASCII symbols
  */
 function hasUTFChars(str) {
-	var rforeign = /[^\u0000-\u007f]/;
+	const rforeign = /[^\u0000-\u007f]/;
 	return !!rforeign.test(str);
 }
 

package/src/rawmimeBuilder.js

@@ -4,7 +4,7 @@ import path from "path";
 import { randomBytes } from "crypto";
 import { convert } from "html-to-text";
 import { DKIMSign } from "./dkim-signer.js";
-import { processMarkDown } from "./processMarkDown.js"; // <--- IMPORT ADDED
+import { processMarkDown } from "./processMarkDown.js";
 
 const desiredOrder = [
 	"List-Unsubscribe-Post",
@@ -27,7 +27,7 @@ class MimeMessage {
 		this.bodyParts = [];
 		this.attachments = [];
 		this.attachmentPromises = [];
-		this.processingPromises = []; // <--- NEW: Track async ops
+		this.processingPromises = [];
 		this.removedHeaders = new Set();
 	}
 
@@ -38,7 +38,7 @@ class MimeMessage {
 			wordwrap: 130,
 			selectors: [
 				{ selector: "img", format: "skip" },
-				{ selector: "a", options: { hideLinkHrefIfSameAsText: true } },
+				{ selector: "a", options: { hideLinkHrefIfSameAsText: true, linkBrackets: ["<", ">"] } },
 			],
 		});
 	}
@@ -78,7 +78,12 @@ class MimeMessage {
 					if (isSafe) {
 						tempStr += String.fromCharCode(byte);
 					} else if (isSpaceOrTab) {
-						tempStr += String.fromCharCode(byte);
+						// RFC 2045 §6.7 Rule 3: trailing whitespace MUST be encoded
+						if (i === buffer.length - 1) {
+							tempStr += "=" + byte.toString(16).toUpperCase().padStart(2, "0");
+						} else {
+							tempStr += String.fromCharCode(byte);
+						}
 					} else {
 						tempStr += "=" + byte.toString(16).toUpperCase().padStart(2, "0");
 					}
@@ -123,6 +128,39 @@ class MimeMessage {
 			.join("\r\n");
 	}
 
+	// ─── HELPER: RFC 2047 Encoded-Word Chunking ──────────────────────
+	_encodeRFC2047(str) {
+		const MAX_ENCODED_LENGTH = 75;
+		const prefix = "=?UTF-8?B?";
+		const suffix = "?=";
+		const maxB64Len = MAX_ENCODED_LENGTH - prefix.length - suffix.length; // 63
+		const maxBytes = Math.floor(maxB64Len * 3 / 4); // 47 bytes
+
+		let result = [];
+		let currentChunk = "";
+		let currentChunkBytes = 0;
+
+		for (const char of str) {
+			const charBytes = Buffer.byteLength(char, "utf8");
+			if (currentChunkBytes + charBytes > maxBytes) {
+				const b64 = Buffer.from(currentChunk, "utf8").toString("base64");
+				result.push(`${prefix}${b64}${suffix}`);
+				currentChunk = char;
+				currentChunkBytes = charBytes;
+			} else {
+				currentChunk += char;
+				currentChunkBytes += charBytes;
+			}
+		}
+		if (currentChunk.length > 0) {
+			const b64 = Buffer.from(currentChunk, "utf8").toString("base64");
+			result.push(`${prefix}${b64}${suffix}`);
+		}
+
+		// Separate encoded words by space. Standard ASCII folding will wrap them if needed.
+		return result.join(" ");
+	}
+
 	// ─── HELPER: Header Folding (RFC 5322) ──────────────────────────
 	_foldHeader(name, value) {
 		const hasNonAscii = /[^\x00-\x7F]/.test(value);
@@ -130,45 +168,47 @@ class MimeMessage {
 		// 1. Unstructured headers (Subject, etc) -> Full Encode
 		const unstructured = ["subject", "x-report-abuse", "thread-topic"];
 		if (hasNonAscii && unstructured.includes(name.toLowerCase())) {
-			const encodedValue = Buffer.from(value, "utf8").toString("base64");
-			return `${name}: =?UTF-8?B?${encodedValue}?=`;
+			value = this._encodeRFC2047(value);
 		}
 
 		// 2. Structured headers (From, To) -> Smart Replace
-		// Finds quoted strings with special chars, e.g. "René", and encodes JUST that part.
-		if (hasNonAscii) {
-			const encodedStruct = value.replace(/"([^"]*)"/g, (match, content) => {
-				if (/[^\x00-\x7F]/.test(content)) {
-					const b64 = Buffer.from(content, "utf8").toString("base64");
-					return `=?UTF-8?B?${b64}?=`;
+		// Encodes quoted non-ASCII strings AND unquoted non-ASCII words
+		if (hasNonAscii && !unstructured.includes(name.toLowerCase())) {
+			value = value.replace(/"([^"]*)"|([^\s<>]*[^\x00-\x7F][^\s<>]*)/g, (match, quoted, unquoted) => {
+				if (quoted !== undefined && /[^\x00-\x7F]/.test(quoted)) {
+					return this._encodeRFC2047(quoted);
+				}
+				if (unquoted !== undefined && /[^\x00-\x7F]/.test(unquoted)) {
+					return this._encodeRFC2047(unquoted);
 				}
 				return match;
 			});
-			// If we changed anything, return it. If not (e.g. unquoted special chars), fallback to old folding
-			if (encodedStruct !== value) {
-				return `${name}: ${encodedStruct}`;
-			}
 		}
 
 		// 3. Standard folding for ASCII-only (or unhandled) headers
 		const line = `${name}: ${value}`;
 		if (line.length <= 76) return line;
 
-		const headerKey = `${name}: `;
-		let remaining = value;
-		let result = headerKey;
-		let available = 76 - headerKey.length;
-
-		if (remaining.length < available) return result + remaining;
+		let result = `${name}: `;
+		const tokens = value.split(/(?=[ \t])/);
+		let currentLineLength = result.length;
+		const prefixLength = result.length;
 
-		result += remaining.substring(0, available) + "\r\n ";
-		remaining = remaining.substring(available);
+		tokens.forEach((token) => {
+			if (currentLineLength + token.length > 76 && currentLineLength > prefixLength) {
+				if (/^[ \t]/.test(token)) {
+					result += "\r\n" + token;
+					currentLineLength = token.length;
+				} else {
+					result += token;
+					currentLineLength += token.length;
+				}
+			} else {
+				result += token;
+				currentLineLength += token.length;
+			}
+		});
 
-		while (remaining.length > 75) {
-			result += remaining.substring(0, 75) + "\r\n ";
-			remaining = remaining.substring(75);
-		}
-		result += remaining;
 		return result;
 	}
 
@@ -212,7 +252,10 @@ class MimeMessage {
 	formatMailboxes(mailboxes) {
 		if (!mailboxes) return "";
 		const mbs = Array.isArray(mailboxes) ? mailboxes : [mailboxes];
-		return mbs.map((mb) => (mb.name ? `"${mb.name}" <${mb.email}>` : mb.email)).join(", ");
+		return mbs.map((mb) => {
+			if (typeof mb === "string") return mb;
+			return mb.name ? `"${mb.name}" <${mb.email}>` : mb.email;
+		}).join(", ");
 	}
 
 	setFrom(sender) {
@@ -376,7 +419,7 @@ class MimeMessage {
 		encoding = "quoted-printable",
 		autoTextPart = false,
 		autoMinify = true,
-		markdownToHtml = false, // <--- NEW OPTION
+		markdownToHtml = false,
 	}) {
 		if (markdownToHtml) {
 			// Push the async operation to the queue
@@ -604,15 +647,20 @@ class MimeMessage {
 				// UPDATE THIS ARRAY BELOW
 				// Add "list-unsubscribe" and "list-unsubscribe-post" to this list
 				const doNotFold = [
+					"subject",
 					"message-id",
 					"references",
 					"in-reply-to",
 					"content-id",
-					"list-unsubscribe", // <--- Added
-					"list-unsubscribe-post", // <--- Added
+					"list-unsubscribe",
+					"list-unsubscribe-post",
 				];
 
 				if (doNotFold.includes(lowerName)) {
+					// Still encode non-ASCII, just skip line folding
+					if (/[^\x00-\x7F]/.test(h.value)) {
+						return `${h.name}: ${this._encodeRFC2047(h.value)}`;
+					}
 					return `${h.name}: ${h.value}`;
 				}
 				return this._foldHeader(h.name, h.value);

package/src/utility/mailParser.d.ts

@@ -1,5 +1,5 @@
 // src/utility/mailParser.d.ts
-import type { ProcessMarkDownResult } from "../processMarkDown";
+import type { MarkdownResult } from "../processMarkDown";
 
 /**
  * Generates a random numeric ID string for Doublelist posts.
@@ -50,7 +50,7 @@ export interface ParsedMailData {
     /** HTML body with tracking images removed */
     html: string;
     /** Processed markdown result from processMarkDown */
-    markdownResult: ProcessMarkDownResult;
+    markdownResult: MarkdownResult;
     /** Plain text body */
     text: string;
     /** Number of attachments */

package/src/utility/mailParser.js

@@ -11,8 +11,8 @@ export const randomizeDoublelistPostID = (length = 11) => {
     // 1. Pick the first digit (1-9)
     let result = firstDigit.charAt(Math.floor(Math.random() * firstDigit.length));
     // 2. Generate the rest, stopping 1 digit early
-    // If length is 11, this loop generates 9 more digits (Total: 10)
-    for (let i = 1; i < length - 1; i++) {
+    // If length is 11, this loop generates 10 more digits (Total: 11)
+    for (let i = 1; i < length; i++) {
         result += restDigits.charAt(Math.floor(Math.random() * restDigits.length));
     }
     return result;