arn-rawmime 0.0.6 → 0.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "arn-rawmime",
-	"version": "0.0.6",
+	"version": "0.0.7",
 	"description": "A lightweight, dependency-free raw MIME email builder with DKIM support.",
 	"author": "ARNDESK",
 	"type": "module",

package/src/rawmimeBuilder.js

@@ -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;
 	}
 
@@ -607,6 +647,7 @@ 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",
@@ -616,6 +657,10 @@ class MimeMessage {
 				];
 
 				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);