primcli 1.52.0 → 1.54.0

package/dist/{repeats-D2xtLium-B8Wq41vG.js → repeats-D2xtLium-DmtVD6ol.js}

@@ -1,368 +1,556 @@
 import { r as __toESM, t as __commonJSMin } from "./rolldown-runtime-CNZpIYwj.js";
-//#region ../node_modules/.pnpm/nodemailer@9.1.1/node_modules/nodemailer/lib/addressparser/index.js
-var require_addressparser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	/**
-	* Restores the quoting of a local part that was read out of a quoted string.
-	*
-	* RFC 5321 allows '@' inside a quoted local part, so handing '"user@evil.com"@good.com'
-	* on as the bare 'user@evil.com@good.com' leaves it to the consumer which '@' splits the
-	* domain off. Getting that wrong is a misrouting vector, so the quotes go back on. The
-	* same holds for the other specials: a ',' or a ';' that loses its quotes reads as a
-	* recipient separator once the consumer puts the address back into a header.
-	*
-	* This module has no dependencies so that it can ship on its own, which is why the two
-	* grammar tests below are spelled out here instead of shared with lib/mime-node. Keeping
-	* only what is ambiguous quoted is deliberate, mime-node applies the stricter RFC 5321
-	* dot-atom rule on top of this when it emits an address.
-	*
-	* @param {String} address Address with an unquoted local part
-	* @return {String} Address with the local part as a quoted-string
-	*/
-	function _quoteLocalPart(address) {
-		const lastAt = address.lastIndexOf("@");
-		if (lastAt < 0) return address;
-		const user = address.substr(0, lastAt);
-		if (/^[^\s"(),:;<>@[\\\]]+$/.test(user) || /^"(?:[^"\\]|\\[\s\S])*"$/.test(user)) return address;
-		return "\"" + user.replace(/["\\]/g, "\\$&") + "\"@" + address.substr(lastAt + 1);
-	}
-	/**
-	* Reached for every parsed address, so it is built once rather than per call.
-	*/
-	const HAS_WHITESPACE = /\s/;
-	/**
-	* An addr-spec that carries its whitespace legally, inside a quoted local part. The
-	* optional tail is the malformed shape: a real mailbox with wreckage trailing it.
-	*/
-	const QUOTED_LOCAL_ADDR = /^("(?:[^"\\]|\\[\s\S])*"@\S+)(?:\s+([\s\S]+))?$/;
-	/**
-	* One run holding a single '@' and no whitespace, the shape an addr-spec has to have.
-	*/
-	const ADDR_SPEC = /^[^@\s]+@[^@\s]+$/;
-	/**
-	* The looser reading applied once the strict one finds nothing, which tolerates the
-	* further '@' that a domain should not have but malformed headers carry anyway.
-	*/
-	const LOOSE_ADDR_SPEC = /^[^@\s]+@\S+$/;
-	/**
-	* Recovers the addr-spec from an angle-addr that came back holding unquoted whitespace.
-	*
-	* A malformed header can put more than a mailbox between the angle brackets, most often
-	* because the generator wrote the recipient twice: '<user@example.com user@example.com>'
-	* or '<example.com user@example.com>'. Whitespace is not addr-spec, so the whole run can
-	* never be a mailbox anyone could deliver to, and passing it on as the address loses the
-	* recipient that is sitting right there in the header.
-	*
-	* The run that still reads as an addr-spec is kept and whatever is left over becomes
-	* display text rather than being dropped. Candidates are read strictly first and then
-	* under the looser grammar, the same two tiers the unquoted-text branch below applies to
-	* the same problem, so that '<a@b@c.com junk>' and a bare 'a@b@c.com junk' agree on the
-	* recipient. When several runs qualify the first wins, which is what that branch's looser
-	* tier does within a token.
-	*
-	* A quoted local part is left alone: RFC 5321 allows whitespace inside it, so
-	* '<"user name"@example.com>' is well formed and means exactly what it says.
-	*
-	* @param {Object} data Collected address parts, mutated in place
-	*/
-	function _recoverAddrSpec(data) {
-		if (!HAS_WHITESPACE.test(data.address)) return;
-		let address;
-		let rest;
-		const quoted = data.address.match(QUOTED_LOCAL_ADDR);
-		if (quoted) {
-			if (!quoted[2]) return;
-			address = quoted[1];
-			rest = [quoted[2]];
-		} else {
-			if (data.address.indexOf("\"") >= 0) return;
-			const parts = data.address.split(/\s+/);
-			let addrIndex = parts.findIndex((part) => ADDR_SPEC.test(part));
-			if (addrIndex < 0) addrIndex = parts.findIndex((part) => LOOSE_ADDR_SPEC.test(part));
-			if (addrIndex < 0) return;
-			address = parts.splice(addrIndex, 1)[0];
-			rest = parts;
-		}
-		data.address = address;
-		data.text = [data.text].concat(rest).filter((part) => part).join(" ");
-	}
-	/**
-	* Converts tokens for a single address into an address object
-	*
-	* @param {Array} tokens Tokens object
-	* @param {Number} depth Current recursion depth for nested group protection
-	* @return {Object} Address object
-	*/
-	function _handleAddress(tokens, depth) {
-		let isGroup = false;
-		let state = "text";
-		const addresses = [];
-		const data = {
-			address: [],
-			comment: [],
-			group: [],
-			text: [],
-			textWasQuoted: []
-		};
-		let insideQuotes = false;
-		for (let i = 0, len = tokens.length; i < len; i++) {
-			const token = tokens[i];
-			const prevToken = i ? tokens[i - 1] : null;
-			if (token.type === "operator") switch (token.value) {
-				case "<":
-					state = "address";
-					insideQuotes = false;
-					break;
-				case "(":
-					state = "comment";
-					insideQuotes = false;
-					break;
-				case ":":
-					state = "group";
-					isGroup = true;
-					insideQuotes = false;
-					break;
-				case "\"":
-					insideQuotes = !insideQuotes;
-					state = "text";
-					break;
-				default:
-					state = "text";
-					insideQuotes = false;
-					break;
-			}
-			else if (token.value) {
-				if (state === "address") token.value = token.value.replace(/^[^<]*<\s*/, "");
-				const parts = data[state];
-				if (prevToken && prevToken.noBreak && parts.length && (prevToken.value !== ")" || parts[parts.length - 1].slice(-1) === "@" || token.value.charAt(0) === "@")) {
-					data[state][data[state].length - 1] += token.value;
-					if (state === "text" && insideQuotes) data.textWasQuoted[data.textWasQuoted.length - 1] = true;
-				} else {
-					data[state].push(token.value);
-					if (state === "text") data.textWasQuoted.push(insideQuotes);
+//#region ../node_modules/.pnpm/nodemailer@10.0.15/node_modules/nodemailer/dist/esm/addressparser/index.js
+/**
+* Restores the quoting of a local part that was read out of a quoted string.
+*
+* RFC 5321 allows '@' inside a quoted local part, so handing '"user@evil.com"@good.com'
+* on as the bare 'user@evil.com@good.com' leaves it to the consumer which '@' splits the
+* domain off. Getting that wrong is a misrouting vector, so the quotes go back on. The
+* same holds for the other specials: a ',' or a ';' that loses its quotes reads as a
+* recipient separator once the consumer puts the address back into a header.
+*
+* This module has no dependencies so that it can ship on its own, which is why the two
+* grammar tests below are spelled out here instead of shared with src/mime-node. Keeping
+* only what is ambiguous quoted is deliberate, mime-node applies the stricter RFC 5321
+* dot-atom rule on top of this when it emits an address.
+*
+* @param address Address with an unquoted local part
+* @return Address with the local part as a quoted-string
+*/
+function _quoteLocalPart(address) {
+	const lastAt = address.lastIndexOf("@");
+	if (lastAt < 0) return address;
+	const user = address.substr(0, lastAt);
+	if (/^[^\s"(),:;<>@[\\\]]+$/.test(user) || /^"(?:[^"\\]|\\[\s\S])*"$/.test(user)) return address;
+	return "\"" + user.replace(/["\\]/g, "\\$&") + "\"@" + address.substr(lastAt + 1);
+}
+/**
+* Reached for every parsed address, so it is built once rather than per call.
+*/
+const HAS_WHITESPACE = /\s/;
+/**
+* An addr-spec that carries its whitespace legally, inside a quoted local part. The
+* optional tail is the malformed shape: a real mailbox with wreckage trailing it.
+*/
+const QUOTED_LOCAL_ADDR = /^("(?:[^"\\]|\\[\s\S])*"@\S+)(?:\s+([\s\S]+))?$/;
+/**
+* One run holding a single '@' and no whitespace, the shape an addr-spec has to have.
+*/
+const ADDR_SPEC = /^[^@\s]+@[^@\s]+$/;
+/**
+* The looser reading applied once the strict one finds nothing, which tolerates the
+* further '@' that a domain should not have but malformed headers carry anyway.
+*/
+const LOOSE_ADDR_SPEC = /^[^@\s]+@\S+$/;
+/**
+* An addr-spec sitting inside free text, together with the whitespace around it. Sticky
+* on purpose: it is run at the one offset _looseAddressStart picks rather than being let
+* loose to search, see there.
+*/
+const LOOSE_TEXT_ADDR = /\s*\b[^@\s]+@[^\s]+\b\s*/y;
+/**
+* The characters JS `\s` matches, which the scan below has to agree with to land on the
+* same match the pattern would.
+*/
+function _isSpaceCode(code) {
+	return code === 32 || code >= 9 && code <= 13 || code === 160 || code === 5760 || code >= 8192 && code <= 8202 || code === 8232 || code === 8233 || code === 8239 || code === 8287 || code === 12288 || code === 65279;
+}
+/**
+* The characters JS `\w` matches without the unicode flag, the set the `\b` in
+* LOOSE_TEXT_ADDR is read against. charCodeAt off either end of the string gives NaN,
+* which compares false throughout, so out of range reads as the non-word the pattern
+* treats them as.
+*/
+function _isWordCode(code) {
+	return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 95;
+}
+/**
+* Whether `\b` holds at an offset
+*/
+function _isBoundary(text, at) {
+	return _isWordCode(text.charCodeAt(at - 1)) !== _isWordCode(text.charCodeAt(at));
+}
+/**
+* Offset of the first '@' in `text` between `from` and `to`, or -1 when the range holds none.
+*
+* indexOf would scan on to the end of the value, and the value here is a whole header. The
+* walk below steps one whitespace delimited run at a time and only ever uses a '@' that sits
+* inside the run it is on, so an unbounded probe rescans everything behind that run once per
+* run and grows with the square of the header: 400KB of free text carrying no '@' took a
+* quarter of a second. GHSA-v53p-9fqp-m79j took the pattern search out of this walk and left
+* the probe unbounded behind it.
+*
+* @param text Text to look in
+* @param from Offset to start at
+* @param to Offset to stop before
+* @return Offset of the '@', or -1
+*/
+function _indexOfAt(text, from, to) {
+	for (let i = from; i < to; i++) if (text.charCodeAt(i) === 64) return i;
+	return -1;
+}
+/**
+* Finds the offset LOOSE_TEXT_ADDR matches at, or -1 when it does not match at all.
+*
+* Letting the pattern search for itself is quadratic: '[^@\s]+' is retried from every
+* offset and rescans the run to the next '@' each time, so 140KB of header holding no
+* usable '@' blocks the event loop for about ten seconds (GHSA-v53p-9fqp-m79j). The search is also unnecessary.
+* '[^@\s]+' crosses neither whitespace nor a '@', so a match can only begin at the head of
+* a whitespace delimited run or just past a '@' inside one, and '[^\s]+\b' gives characters
+* back until it lands on a boundary, so the only end it can take in that run is the last
+* boundary in it. Both are found in one pass, and the pattern is then run at that single
+* offset.
+*
+* @param text Free text to look in
+* @return Offset to match at, or -1
+*/
+function _looseAddressStart(text) {
+	const len = text.length;
+	let pos = 0;
+	while (pos < len) {
+		while (pos < len && _isSpaceCode(text.charCodeAt(pos))) pos++;
+		if (pos >= len) break;
+		const runStart = pos;
+		let runEnd = pos;
+		while (runEnd < len && !_isSpaceCode(text.charCodeAt(runEnd))) runEnd++;
+		let at = _indexOfAt(text, runStart, runEnd);
+		if (at >= 0) {
+			let lastBoundary = -1;
+			for (let k = runEnd; k > runStart; k--) if (_isBoundary(text, k)) {
+				lastBoundary = k;
+				break;
+			}
+			let atomStart = runStart;
+			while (lastBoundary >= 0 && at >= 0) {
+				if (at > atomStart && runEnd > at + 1 && lastBoundary > at + 1) {
+					for (let start = atomStart; start < at; start++) if (_isBoundary(text, start)) {
+						if (start > runStart) return start;
+						let padded = runStart;
+						while (padded > 0 && _isSpaceCode(text.charCodeAt(padded - 1))) padded--;
+						return padded;
+					}
 				}
+				atomStart = at + 1;
+				at = _indexOfAt(text, atomStart, runEnd);
 			}
 		}
-		if (!data.text.length && data.comment.length) {
-			data.text = data.comment;
-			data.comment = [];
+		pos = runEnd;
+	}
+	return -1;
+}
+/**
+* Recovers the addr-spec from an angle-addr that came back holding unquoted whitespace.
+*
+* A malformed header can put more than a mailbox between the angle brackets, most often
+* because the generator wrote the recipient twice: '<user@example.com user@example.com>'
+* or '<example.com user@example.com>'. Whitespace is not addr-spec, so the whole run can
+* never be a mailbox anyone could deliver to, and passing it on as the address loses the
+* recipient that is sitting right there in the header.
+*
+* The run that still reads as an addr-spec is kept and whatever is left over becomes
+* display text rather than being dropped. Candidates are read strictly first and then
+* under the looser grammar, the same two tiers the unquoted-text branch below applies to
+* the same problem, so that '<a@b@c.com junk>' and a bare 'a@b@c.com junk' agree on the
+* recipient. When several runs qualify the first wins, which is what that branch's looser
+* tier does within a token.
+*
+* A quoted local part is left alone: RFC 5321 allows whitespace inside it, so
+* '<"user name"@example.com>' is well formed and means exactly what it says.
+*
+* @param data Collected address parts, mutated in place
+*/
+function _recoverAddrSpec(data) {
+	if (!HAS_WHITESPACE.test(data.address)) return;
+	let address;
+	let rest;
+	const quoted = data.address.match(QUOTED_LOCAL_ADDR);
+	if (quoted) {
+		if (!quoted[2]) return;
+		address = quoted[1];
+		rest = [quoted[2]];
+	} else {
+		if (data.address.indexOf("\"") >= 0) return;
+		const parts = data.address.split(/\s+/);
+		let addrIndex = parts.findIndex((part) => ADDR_SPEC.test(part));
+		if (addrIndex < 0) addrIndex = parts.findIndex((part) => LOOSE_ADDR_SPEC.test(part));
+		if (addrIndex < 0) return;
+		address = parts.splice(addrIndex, 1)[0];
+		rest = parts;
+	}
+	data.address = address;
+	data.text = [data.text].concat(rest).filter((part) => part).join(" ");
+}
+/**
+* Takes the RFC 5322 comments out of the contents of an angle-addr.
+*
+* The tokenizer tracks a single open operator, so once '<' is open a '(' is plain text and
+* a comment inside the brackets reached the address verbatim: 'Name <user@example.com(x)evil.com>'
+* put 'user@example.com(x)evil.com' into the envelope, a value that is no mailbox and that a
+* receiver stripping the comment reads as 'user@example.comevil.com' (GHSA-g73g-hqqh-jr95).
+* A comment is folding whitespace, so it is read as a space that splits two atoms and as
+* nothing next to an '@', the same rule the token walk applies outside the brackets. Quoted
+* strings and domain literals are copied through untouched, a '(' in there is not a comment.
+*
+* @param address Contents of the angle brackets
+* @return The address with the comments removed, and the text of the comments
+*/
+function _stripAddressComments(address) {
+	const comments = [];
+	let result = "";
+	let comment = "";
+	let depth = 0;
+	let closer = "";
+	let lastChar = "";
+	for (let i = 0, len = address.length; i < len; i++) {
+		const chr = address.charAt(i);
+		if (depth) {
+			if (chr === "\\" && i < len - 1) comment += address.charAt(++i);
+			else if (chr === "(") {
+				depth++;
+				comment += chr;
+			} else if (chr === ")" && !--depth) {
+				comments.push(comment.trim());
+				comment = "";
+				if (lastChar !== "@" && address.charAt(i + 1) !== "@") {
+					result += " ";
+					lastChar = " ";
+				}
+			} else comment += chr;
+			continue;
 		}
-		if (isGroup) {
-			data.text = data.text.join(" ");
-			let groupMembers = [];
-			if (data.group.length) addressparser(data.group.join(","), { _depth: depth + 1 }).forEach((member) => {
-				if (member.group) groupMembers = groupMembers.concat(member.group);
-				else groupMembers.push(member);
-			});
-			addresses.push({
-				name: data.text || "",
-				group: groupMembers
-			});
-		} else {
-			if (!data.address.length && data.text.length) {
-				for (let i = data.text.length - 1; i >= 0; i--) if (!data.textWasQuoted[i] && ADDR_SPEC.test(data.text[i])) {
-					data.address = data.text.splice(i, 1);
-					data.textWasQuoted.splice(i, 1);
-					break;
-				}
-				if (!data.address.length) {
-					let extracted = false;
-					for (let i = data.text.length - 1; i >= 0; i--) if (!data.textWasQuoted[i]) {
-						data.text[i] = data.text[i].replace(/\s*\b[^@\s]+@[^\s]+\b\s*/, (match) => {
-							if (!extracted) {
-								data.address = [match.trim()];
-								extracted = true;
-								return " ";
-							}
-							return match;
-						}).trim();
-						if (extracted) break;
-					}
-				}
+		if (closer) {
+			if (chr === "\\" && closer === "\"" && i < len - 1) {
+				result += chr + address.charAt(++i);
+				lastChar = address.charAt(i);
+				continue;
 			}
-			if (!data.text.length && data.comment.length) {
-				data.text = data.comment;
-				data.comment = [];
+			if (chr === closer) closer = "";
+		} else if (chr === "\"") closer = "\"";
+		else if (chr === "[") closer = "]";
+		else if (chr === "(") {
+			depth = 1;
+			continue;
+		}
+		result += chr;
+		lastChar = chr;
+	}
+	if (depth) comments.push(comment.trim());
+	return {
+		address: result.trim(),
+		comments: comments.filter((text) => text)
+	};
+}
+/**
+* Converts tokens for a single address into an address object
+*
+* @param tokens Tokens object
+* @param depth Current recursion depth for nested group protection
+* @return Address object
+*/
+function _handleAddress(tokens, depth) {
+	let isGroup = false;
+	let state = "text";
+	const addresses = [];
+	const data = {
+		address: [],
+		comment: [],
+		group: [],
+		text: [],
+		textWasQuoted: []
+	};
+	let insideQuotes = false;
+	const lastChars = {
+		address: "",
+		comment: "",
+		group: "",
+		text: ""
+	};
+	for (let i = 0, len = tokens.length; i < len; i++) {
+		const token = tokens[i];
+		const prevToken = i ? tokens[i - 1] : null;
+		if (token.type === "operator") switch (token.value) {
+			case "<":
+				state = "address";
+				insideQuotes = false;
+				break;
+			case "(":
+				state = "comment";
+				insideQuotes = false;
+				break;
+			case ":":
+				state = "group";
+				isGroup = true;
+				insideQuotes = false;
+				break;
+			case "\"":
+				insideQuotes = !insideQuotes;
+				state = "text";
+				break;
+			default:
+				state = "text";
+				insideQuotes = false;
+				break;
+		}
+		else if (token.value) {
+			const prevPrevToken = i > 1 ? tokens[i - 2] : null;
+			const opensAfterEmptyQuotedString = prevToken?.type === "operator" && prevToken.value === "\"" && !!prevToken.noBreak && prevPrevToken?.type === "operator" && prevPrevToken.value === "\"";
+			if (state === "address") token.value = token.value.replace(/^[^<]*<\s*/, "");
+			const parts = data[state];
+			if (prevToken && prevToken.noBreak && parts.length && (prevToken.value !== ")" || lastChars[state] === "@" || token.value.charAt(0) === "@")) {
+				data[state][data[state].length - 1] += token.value;
+				if (token.value) lastChars[state] = token.value.charAt(token.value.length - 1);
+				if (state === "text" && insideQuotes) data.textWasQuoted[data.textWasQuoted.length - 1] = true;
+			} else {
+				data[state].push(token.value);
+				lastChars[state] = token.value.charAt(token.value.length - 1);
+				if (state === "text") data.textWasQuoted.push(insideQuotes || opensAfterEmptyQuotedString);
 			}
-			if (data.address.length > 1) data.text = data.text.concat(data.address.splice(1));
-			const addressFromQuotedText = !data.address.length && data.textWasQuoted.some((wasQuoted) => wasQuoted);
-			data.text = data.text.join(" ");
-			data.address = data.address.join(" ");
-			_recoverAddrSpec(data);
-			const address = {
-				address: data.address || data.text || "",
-				name: data.text || data.address || ""
-			};
-			if (address.address === address.name) if (/@/.test(address.address || "")) address.name = "";
-			else address.address = "";
-			if (addressFromQuotedText && address.address) address.address = _quoteLocalPart(address.address);
-			addresses.push(address);
 		}
-		return addresses;
 	}
-	/**
-	* Creates a Tokenizer object for tokenizing address field strings
-	*
-	* @constructor
-	* @param {String} str Address field string
-	*/
-	var Tokenizer = class {
-		constructor(str) {
-			this.str = (str || "").toString();
-			this.operatorCurrent = "";
-			this.operatorExpecting = "";
-			this.node = null;
-			this.escaped = false;
-			this.inDomainLiteral = false;
-			this.list = [];
-			/**
-			* Operator tokens and which tokens are expected to end the sequence
-			*/
-			this.operators = {
-				"\"": "\"",
-				"(": ")",
-				"<": ">",
-				",": "",
-				":": ";",
-				";": ""
-			};
+	if (!data.text.length && data.comment.length) {
+		data.text = data.comment;
+		data.comment = [];
+	}
+	if (isGroup) {
+		data.text = data.text.join(" ");
+		let groupMembers = [];
+		if (data.group.length) _parseAddressList(data.group.join(","), depth + 1).forEach((member) => {
+			if (member.group) groupMembers = groupMembers.concat(member.group);
+			else groupMembers.push(member);
+		});
+		addresses.push({
+			name: data.text || "",
+			group: groupMembers
+		});
+	} else {
+		const addressComments = [];
+		const addressParts = [];
+		for (const part of data.address) {
+			if (part.indexOf("(") < 0) {
+				addressParts.push(part);
+				continue;
+			}
+			const stripped = _stripAddressComments(part);
+			for (const comment of stripped.comments) addressComments.push(comment);
+			if (stripped.address) addressParts.push(stripped.address);
+		}
+		data.address = addressParts;
+		if (!data.address.length && data.text.length) {
+			for (let i = data.text.length - 1; i >= 0; i--) if (!data.textWasQuoted[i] && ADDR_SPEC.test(data.text[i])) {
+				data.address = data.text.splice(i, 1);
+				data.textWasQuoted.splice(i, 1);
+				break;
+			}
+			if (!data.address.length) {
+				let extracted = false;
+				for (let i = data.text.length - 1; i >= 0; i--) if (!data.textWasQuoted[i]) {
+					const part = data.text[i];
+					let remainder = part;
+					const at = _looseAddressStart(part);
+					if (at >= 0) {
+						LOOSE_TEXT_ADDR.lastIndex = at;
+						const match = LOOSE_TEXT_ADDR.exec(part);
+						if (match) {
+							data.address = [match[0].trim()];
+							extracted = true;
+							remainder = part.slice(0, at) + " " + part.slice(at + match[0].length);
+						}
+					}
+					data.text[i] = remainder.trim();
+					if (extracted) break;
+				}
+			}
 		}
-		/**
-		* Tokenizes the original input string
-		*
-		* @return {Array} An array of operator|text tokens
-		*/
-		tokenize() {
-			const list = [];
-			for (let i = 0, len = this.str.length; i < len; i++) {
-				const chr = this.str.charAt(i);
-				const nextChr = i < len - 1 ? this.str.charAt(i + 1) : null;
-				this.checkChar(chr, nextChr);
-			}
-			this.list.forEach((node) => {
-				node.value = (node.value || "").toString().trim();
-				if (node.value) list.push(node);
-			});
-			return list;
+		if (!data.text.length && data.comment.length) {
+			data.text = data.comment;
+			data.comment = [];
 		}
+		if (data.address.length > 1) data.text = data.text.concat(data.address.splice(1));
+		const addressFromQuotedText = !data.address.length && data.textWasQuoted.some((wasQuoted) => wasQuoted);
+		data.text = data.text.join(" ");
+		data.address = data.address.join(" ");
+		if (addressFromQuotedText && data.text.indexOf("@") >= 0) {
+			data.address = _quoteLocalPart(data.text);
+			data.text = "";
+		}
+		_recoverAddrSpec(data);
+		if (!data.text && addressComments.length) data.text = addressComments.join(" ");
+		const address = {
+			address: data.address || data.text || "",
+			name: data.text || data.address || ""
+		};
+		if (address.address === address.name) if (/@/.test(address.address || "")) address.name = "";
+		else address.address = "";
+		addresses.push(address);
+	}
+	return addresses;
+}
+/**
+* Creates a Tokenizer object for tokenizing address field strings
+*
+* @constructor
+* @param str Address field string
+*/
+var Tokenizer = class {
+	constructor(str) {
+		this.str = (str || "").toString();
+		this.operatorCurrent = "";
+		this.operatorExpecting = "";
+		this.node = null;
+		this.escaped = false;
+		this.inDomainLiteral = false;
+		this.afterAt = false;
+		this.list = [];
 		/**
-		* Checks if a character is an operator or text and acts accordingly
-		*
-		* @param {String} chr Character from the address field
+		* Operator tokens and which tokens are expected to end the sequence
 		*/
-		checkChar(chr, nextChr) {
-			if (!this.escaped && !this.operatorExpecting) {
-				if (!this.inDomainLiteral && chr === "[") this.inDomainLiteral = true;
-				else if (this.inDomainLiteral && (chr === "]" || chr === "," || chr === ";")) this.inDomainLiteral = false;
-			}
-			if (this.escaped) {} else if (chr === this.operatorExpecting) {
-				this.node = {
-					type: "operator",
-					value: chr
-				};
-				if (nextChr && ![
-					" ",
-					"	",
-					"\r",
-					"\n",
-					",",
-					";"
-				].includes(nextChr)) this.node.noBreak = true;
-				this.list.push(this.node);
-				this.node = null;
-				this.operatorExpecting = "";
-				this.escaped = false;
-				return;
-			} else if (!this.operatorExpecting && !this.inDomainLiteral && chr in this.operators) {
-				this.node = {
-					type: "operator",
-					value: chr
-				};
-				this.list.push(this.node);
-				this.node = null;
-				this.operatorExpecting = this.operators[chr];
-				this.escaped = false;
-				return;
-			} else if (["\"", "'"].includes(this.operatorExpecting) && chr === "\\") {
-				this.escaped = true;
-				return;
-			}
-			if (!this.node) {
-				this.node = {
-					type: "text",
-					value: ""
-				};
-				this.list.push(this.node);
-			}
-			if (chr === "\n") chr = " ";
-			if (chr.charCodeAt(0) >= 33 || [" ", "	"].includes(chr)) this.node.value += chr;
-			this.escaped = false;
-		}
-	};
+		this.operators = {
+			"\"": "\"",
+			"(": ")",
+			"<": ">",
+			",": "",
+			":": ";",
+			";": ""
+		};
+	}
 	/**
-	* Maximum recursion depth for parsing nested groups.
-	* RFC 5322 doesn't allow nested groups, so this is a safeguard against
-	* malicious input that could cause stack overflow.
+	* Tokenizes the original input string
+	*
+	* @return An array of operator|text tokens
 	*/
-	const MAX_NESTED_GROUP_DEPTH = 50;
+	tokenize() {
+		const list = [];
+		for (let i = 0, len = this.str.length; i < len; i++) {
+			const chr = this.str.charAt(i);
+			const nextChr = i < len - 1 ? this.str.charAt(i + 1) : null;
+			this.checkChar(chr, nextChr);
+		}
+		this.list.forEach((node) => {
+			node.value = (node.value || "").toString().trim();
+			if (node.value) list.push(node);
+		});
+		return list;
+	}
 	/**
-	* Parses structured e-mail addresses from an address field
-	*
-	* Example:
-	*
-	*    'Name <address@domain>'
+	* Checks if a character is an operator or text and acts accordingly
 	*
-	* will be converted to
-	*
-	*     [{name: 'Name', address: 'address@domain'}]
-	*
-	* @param {String} str Address field
-	* @param {Object} options Optional options object
-	* @param {Number} options._depth Internal recursion depth counter (do not set manually)
-	* @return {Array} An array of address objects
+	* @param chr Character from the address field
+	* @param nextChr Character following chr, null at the end of the field
 	*/
-	function addressparser(str, options) {
-		options = options || {};
-		const depth = options._depth || 0;
-		if (depth > MAX_NESTED_GROUP_DEPTH) return [];
-		const tokens = new Tokenizer(str).tokenize();
-		const addresses = [];
-		let address = [];
-		let parsedAddresses = [];
-		tokens.forEach((token) => {
-			if (token.type === "operator" && (token.value === "," || token.value === ";")) {
-				if (address.length) addresses.push(address);
-				address = [];
-			} else address.push(token);
-		});
-		if (address.length) addresses.push(address);
-		addresses.forEach((addr) => {
-			const handled = _handleAddress(addr, depth);
-			for (let i = 0; i < handled.length; i++) parsedAddresses.push(handled[i]);
-		});
-		const mergedAddresses = [];
-		for (let i = parsedAddresses.length - 1; i >= 0; i--) {
-			const current = parsedAddresses[i];
-			const next = mergedAddresses.length ? mergedAddresses[mergedAddresses.length - 1] : null;
-			if (next && current.address === "" && current.name && !current.group && next.address && next.name) next.name = current.name + ", " + next.name;
-			else mergedAddresses.push(current);
-		}
-		mergedAddresses.reverse();
-		parsedAddresses = mergedAddresses;
-		if (options.flatten) {
-			const flatAddresses = [];
-			const walkAddressList = (list) => {
-				list.forEach((entry) => {
-					if (entry.group) return walkAddressList(entry.group);
-					flatAddresses.push(entry);
-				});
+	checkChar(chr, nextChr) {
+		if (!this.escaped && !this.operatorExpecting) {
+			if (!this.inDomainLiteral && chr === "[" && this.afterAt) this.inDomainLiteral = true;
+			else if (this.inDomainLiteral && (chr === "]" || chr === "," || chr === ";")) this.inDomainLiteral = false;
+		}
+		if (this.escaped) {} else if (chr === this.operatorExpecting) {
+			this.node = {
+				type: "operator",
+				value: chr
 			};
-			walkAddressList(parsedAddresses);
-			return flatAddresses;
+			if (nextChr && ![
+				" ",
+				"	",
+				"\r",
+				"\n",
+				",",
+				";"
+			].includes(nextChr)) this.node.noBreak = true;
+			this.list.push(this.node);
+			this.node = null;
+			if (chr !== ")") this.afterAt = false;
+			this.operatorExpecting = "";
+			this.escaped = false;
+			return;
+		} else if (!this.operatorExpecting && !(this.inDomainLiteral && chr === ":") && chr in this.operators) {
+			this.node = {
+				type: "operator",
+				value: chr
+			};
+			this.list.push(this.node);
+			this.node = null;
+			if (chr !== "(") this.afterAt = false;
+			this.operatorExpecting = this.operators[chr];
+			this.escaped = false;
+			return;
+		} else if (["\"", "'"].includes(this.operatorExpecting) && chr === "\\") {
+			this.escaped = true;
+			return;
+		}
+		if (!this.node) {
+			this.node = {
+				type: "text",
+				value: ""
+			};
+			this.list.push(this.node);
+		}
+		if (chr === "\n") chr = " ";
+		if (chr.charCodeAt(0) >= 33 || [" ", "	"].includes(chr)) {
+			this.node.value += chr;
+			if (!this.operatorExpecting && chr !== " " && chr !== "	") this.afterAt = chr === "@";
 		}
-		return parsedAddresses;
+		this.escaped = false;
 	}
-	module.exports = addressparser;
-}));
+};
+/**
+* Maximum recursion depth for parsing nested groups.
+* RFC 5322 doesn't allow nested groups, so this is a safeguard against
+* malicious input that could cause stack overflow.
+*/
+const MAX_NESTED_GROUP_DEPTH = 50;
+/**
+* Parses an address list, recursing into the groups it holds.
+*
+* The depth is threaded through the calls rather than carried in an options object, so a
+* caller supplied one can not seed it and lift the recursion limit: `{ _depth: -1e9 }`
+* bought a billion levels of nesting and turned the guard below into the stack overflow it
+* is there to prevent.
+*
+* @param str Address field
+* @param depth Current recursion depth for nested group protection
+* @return An array of address objects
+*/
+function _parseAddressList(str, depth) {
+	if (depth > MAX_NESTED_GROUP_DEPTH) return [];
+	const tokens = new Tokenizer(str).tokenize();
+	const addresses = [];
+	let address = [];
+	const parsedAddresses = [];
+	tokens.forEach((token) => {
+		if (token.type === "operator" && (token.value === "," || token.value === ";")) {
+			if (address.length) addresses.push(address);
+			address = [];
+		} else address.push(token);
+	});
+	if (address.length) addresses.push(address);
+	addresses.forEach((addr) => {
+		const handled = _handleAddress(addr, depth);
+		for (let i = 0; i < handled.length; i++) parsedAddresses.push(handled[i]);
+	});
+	const mergedAddresses = [];
+	for (let i = parsedAddresses.length - 1; i >= 0; i--) {
+		const current = parsedAddresses[i];
+		const next = mergedAddresses.length ? mergedAddresses[mergedAddresses.length - 1] : null;
+		if (next && current.address === "" && current.name && !current.group && next.address && next.name) next.name = current.name + ", " + next.name;
+		else mergedAddresses.push(current);
+	}
+	mergedAddresses.reverse();
+	return mergedAddresses;
+}
+function addressparser(str, options) {
+	const parsedAddresses = _parseAddressList(str, 0);
+	if (options?.flatten) {
+		const flatAddresses = [];
+		const walkAddressList = (list) => {
+			list.forEach((entry) => {
+				if (entry.group) return walkAddressList(entry.group);
+				flatAddresses.push(entry);
+			});
+		};
+		walkAddressList(parsedAddresses);
+		return flatAddresses;
+	}
+	return parsedAddresses;
+}
 //#endregion
 //#region ../node_modules/.pnpm/validator@13.15.35/node_modules/validator/lib/util/assertString.js
 var require_assertString = /* @__PURE__ */ __commonJSMin(((exports, module) => {
@@ -557,8 +745,8 @@ var require_isIP = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports.default = exports.default;
 }));
 //#endregion
-//#region ../node_modules/.pnpm/validator@13.15.35/node_modules/validator/lib/isEmail.js
-var require_isEmail = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+//#region ../sdk-node/dist/address-parser-kzXOIiuh.js
+var import_isEmail = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.default = isEmail;
 	var _assertString = _interopRequireDefault(require_assertString());
@@ -657,11 +845,7 @@ var require_isEmail = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	}
 	module.exports = exports.default;
 	module.exports.default = exports.default;
-}));
-//#endregion
-//#region ../sdk-node/dist/address-parser-kzXOIiuh.js
-var import_addressparser = /* @__PURE__ */ __toESM(require_addressparser(), 1);
-var import_isEmail = /* @__PURE__ */ __toESM(require_isEmail(), 1);
+})))(), 1);
 const MAX_HEADER_LENGTH = 998;
 const IS_EMAIL_OPTIONS = {
 	allow_ip_domain: true,
@@ -711,7 +895,7 @@ function parseFromHeader(header) {
 		ok: false,
 		reason: "too_long"
 	};
-	const parsed = (0, import_addressparser.default)(trimmed);
+	const parsed = addressparser(trimmed);
 	if (parsed.length > 1) return {
 		ok: false,
 		reason: "multiple_addresses"