equoter 0.1.0

package/dist/index.mjs

@@ -0,0 +1,913 @@
+import { parseHTML } from "linkedom";
+//#region src/enums.ts
+let Position = /* @__PURE__ */ function(Position) {
+	Position["Begin"] = "begin";
+	Position["End"] = "end";
+	return Position;
+}({});
+//#endregion
+//#region src/patterns.ts
+const REPLY_PATTERNS = [
+	/^On (.*) wrote:$/,
+	/^Am (.*) schrieb (.*):$/,
+	/^Le (.*) a écrit :$/,
+	/El (.*) escribió:$/,
+	/^(.*) написал\(а\):$/,
+	/^Den (.*) skrev (.*):$/,
+	/^Em (.*) escreveu:$/,
+	/^Op (.*) schreef (.*):$/,
+	/^(.*) schreef op (.*):$/,
+	/^Op (.*) heeft (.*) het volgende geschreven:$/,
+	/([0-9]{4}\/[0-9]{1,2}\/[0-9]{1,2}) (.* <.*@.*>)$/
+];
+const REPLY_DATE_SPLIT_REGEX = /^(.*(:[0-9]{2}( [apAP]\.?[mM]\.?)?)), (.*)?$/;
+const FORWARD_MESSAGES = [
+	"Begin forwarded message",
+	"Anfang der weitergeleiteten E-Mail",
+	"Début du message réexpédié",
+	"Inicio del mensaje reenviado",
+	"Forwarded [mM]essage",
+	"Mensaje reenviado",
+	"Vidarebefordrat meddelande",
+	"Original [mM]essage",
+	"Ursprüngliche Nachricht",
+	"Mensaje [oO]riginal",
+	"Message transféré",
+	"Пересылаемое сообщение",
+	"Oorspronkelijk bericht",
+	"Doorgestuurd bericht"
+];
+const FORWARD_LINE = "________________________________";
+const FORWARD_PATTERNS = [
+	new RegExp(`^${FORWARD_LINE}$`),
+	...FORWARD_MESSAGES.map((p) => new RegExp(`^---+ ?${p} ?---+$`)),
+	...FORWARD_MESSAGES.map((p) => new RegExp(`^${p}:$`))
+];
+const FORWARD_STYLES = [/^border:none;border-top:solid #[0-9a-fA-F]{6} 1\.0pt;padding:3\.0pt 0(in|cm) 0(in|cm) 0(in|cm)$/u, /padding-top:\s*5px;\s*border-top-color:\s*rgb\(229,\s*229,\s*229\);\s*border-top-width:\s*1px;\s*border-top-style:\s*solid/u];
+const HEADER_RE = /^\*?([-\p{L}\p{N}_ ]+):\*?(.*)$/u;
+const HEADER_MAP = {
+	from: "from",
+	von: "from",
+	de: "from",
+	"от кого": "from",
+	från: "from",
+	van: "from",
+	to: "to",
+	an: "to",
+	aan: "to",
+	para: "to",
+	à: "to",
+	pour: "to",
+	кому: "to",
+	till: "to",
+	cc: "cc",
+	kopie: "cc",
+	kopia: "cc",
+	bcc: "bcc",
+	cco: "bcc",
+	blindkopie: "bcc",
+	"reply-to": "reply-to",
+	"antwort an": "reply-to",
+	"répondre à": "reply-to",
+	"responder a": "reply-to",
+	date: "date",
+	sent: "date",
+	received: "date",
+	datum: "date",
+	gesendet: "date",
+	"enviado el": "date",
+	enviados: "date",
+	fecha: "date",
+	дата: "date",
+	verzonden: "date",
+	subject: "subject",
+	betreff: "subject",
+	asunto: "subject",
+	objet: "subject",
+	sujet: "subject",
+	тема: "subject",
+	ämne: "subject",
+	onderwerp: "subject"
+};
+const COMPILED_PATTERN_MAP = {
+	reply: REPLY_PATTERNS,
+	forward: FORWARD_PATTERNS
+};
+const MULTIPLE_WHITESPACE_RE = /\s+/g;
+//#endregion
+//#region src/html.ts
+const INLINE_TAGS = new Set([
+	"a",
+	"b",
+	"em",
+	"i",
+	"strong",
+	"span",
+	"font",
+	"q",
+	"object",
+	"bdo",
+	"sub",
+	"sup",
+	"center",
+	"td",
+	"th"
+]);
+function isText(node) {
+	return node.nodeType === 3;
+}
+function removeNode(node) {
+	node.parentNode?.removeChild(node);
+}
+/**
+* Remove the document tree following the given element. If includeElement
+* is true, the given element is kept; otherwise it is removed.
+*
+* Mirrors lxml's approach: at each ancestor level, remove all nodes
+* (elements and text) that come after the reference point.
+*/
+function trimTreeAfter(element, includeElement = true) {
+	let current = element;
+	let isFirst = true;
+	while (true) {
+		const parent = current.parentElement;
+		if (!parent) break;
+		let cutAfter;
+		if (isFirst && !includeElement) {
+			cutAfter = current.previousSibling;
+			removeNode(current);
+		} else cutAfter = current;
+		if (cutAfter) while (cutAfter.nextSibling) removeNode(cutAfter.nextSibling);
+		else while (parent.firstChild) removeNode(parent.firstChild);
+		current = parent;
+		isFirst = false;
+	}
+}
+/**
+* Remove the document tree preceding the given element. If includeElement
+* is true, the given element is kept; otherwise it is removed.
+*/
+function trimTreeBefore(element, includeElement = true, keepHead = true) {
+	let current = element;
+	let isFirst = true;
+	while (true) {
+		const parent = current.parentElement;
+		if (!parent) break;
+		let cutBefore;
+		if (isFirst && !includeElement) {
+			cutBefore = current.nextSibling;
+			removeNode(current);
+		} else cutBefore = current;
+		if (cutBefore) while (cutBefore.previousSibling) {
+			const node = cutBefore.previousSibling;
+			if (!(keepHead && node.nodeType === 1 && node.tagName?.toLowerCase() === "head")) removeNode(node);
+			else break;
+		}
+		else while (parent.firstChild) {
+			const node = parent.firstChild;
+			if (!(keepHead && node.nodeType === 1 && node.tagName?.toLowerCase() === "head")) removeNode(node);
+			else break;
+		}
+		current = parent;
+		isFirst = false;
+	}
+}
+function isIndentationElement(element) {
+	return element.tagName?.toLowerCase() === "blockquote";
+}
+/**
+* Trim a slice tuple so it starts/ends at non-empty lines.
+*/
+function trimSlice(lines, sliceTuple) {
+	const empty = (line) => !line || line.trim() === ">";
+	if (!sliceTuple) return null;
+	let [sliceStart, sliceEnd] = sliceTuple;
+	if (sliceStart === null) sliceStart = 0;
+	if (sliceEnd === null) sliceEnd = lines.length;
+	while (sliceStart < sliceEnd && empty(lines[sliceStart])) sliceStart++;
+	while (sliceEnd > sliceStart && empty(lines[sliceEnd - 1])) sliceEnd--;
+	return [sliceStart, sliceEnd];
+}
+/**
+* Remove the outermost blockquote indentation by replacing it with a div.
+*/
+function unindentTree(element) {
+	const walker = element.ownerDocument.createTreeWalker(element, 1);
+	let node = walker.currentNode;
+	while (node) {
+		if (isIndentationElement(node)) {
+			while (node.attributes.length > 0) node.removeAttribute(node.attributes[0].name);
+			const div = node.ownerDocument.createElement("div");
+			while (node.firstChild) div.appendChild(node.firstChild);
+			node.replaceWith(div);
+			return;
+		}
+		node = walker.nextNode();
+	}
+}
+/**
+* Yield tokens for the given HTML element.
+*/
+function* treeTokenGenerator(el, indentationLevel = 0) {
+	if (!el.tagName) return;
+	const isIndentation = isIndentationElement(el);
+	if (isIndentation) indentationLevel++;
+	yield {
+		type: "element",
+		element: el,
+		position: Position.Begin,
+		indentationLevel
+	};
+	const firstText = getDirectText(el);
+	if (firstText) yield {
+		type: "text",
+		text: firstText
+	};
+	for (const child of Array.from(el.children)) {
+		const prevText = getTextBefore(child);
+		if (prevText) yield {
+			type: "text",
+			text: prevText
+		};
+		yield* treeTokenGenerator(child, indentationLevel);
+	}
+	if (isIndentation) indentationLevel--;
+	yield {
+		type: "element",
+		element: el,
+		position: Position.End,
+		indentationLevel
+	};
+	const tailText = getTailText(el);
+	if (tailText) yield {
+		type: "text",
+		text: tailText
+	};
+}
+/**
+* Get text directly inside an element (before its first child).
+*/
+function getDirectText(el) {
+	let text = "";
+	for (const child of Array.from(el.childNodes)) if (isText(child)) text += child.textContent ?? "";
+	else break;
+	return text || null;
+}
+/**
+* Get text between the previous sibling and this element.
+*/
+function getTextBefore(el) {
+	let prev = el.previousSibling;
+	const textNodes = [];
+	while (prev && isText(prev)) {
+		textNodes.unshift(prev);
+		prev = prev.previousSibling;
+	}
+	if (el.previousElementSibling) return null;
+	return null;
+}
+/**
+* Get text after the closing tag of this element (tail text).
+*/
+function getTailText(el) {
+	let text = "";
+	let next = el.nextSibling;
+	while (next && isText(next)) {
+		text += next.textContent ?? "";
+		next = next.nextSibling;
+	}
+	return text || null;
+}
+/**
+* Iterate through a DOM tree and yield line information.
+* Lines are blocks of text separated by <br> or block elements.
+*/
+function* treeLineGenerator(el, maxLines = null) {
+	const trimSpaces = (text) => text.replace(MULTIPLE_WHITESPACE_RE, " ").trim();
+	let counter = 1;
+	if (maxLines !== null && counter > maxLines) return;
+	let line = "";
+	let startRef = null;
+	let startIndentationLevel = 0;
+	for (const token of treeTokenGenerator(el)) {
+		if (token === null) continue;
+		if (token.type === "element") {
+			const tagName = token.element.tagName.toLowerCase();
+			const lineBreak = tagName === "br" && token.position === Position.Begin;
+			const isBlock = !INLINE_TAGS.has(tagName);
+			const style = token.element.getAttribute("style");
+			const isForward = isBlock && token.position === Position.Begin && style !== null && FORWARD_STYLES.some((re) => re.test(style));
+			if (isBlock || lineBreak) {
+				line = trimSpaces(line);
+				if (line || lineBreak || isForward) {
+					const endRef = [token.element, token.position];
+					yield {
+						startRef,
+						endRef,
+						indentationLevel: startIndentationLevel,
+						text: line
+					};
+					counter++;
+					if (maxLines !== null && counter > maxLines) return;
+					line = "";
+					if (isForward) {
+						yield {
+							startRef: endRef,
+							endRef,
+							indentationLevel: startIndentationLevel,
+							text: FORWARD_LINE
+						};
+						counter++;
+						if (maxLines !== null && counter > maxLines) return;
+					}
+				}
+				if (!line) {
+					startRef = [token.element, token.position];
+					startIndentationLevel = token.indentationLevel;
+				}
+			}
+		} else if (token.type === "text") line += token.text;
+	}
+}
+/**
+* Like treeLineGenerator but yields lines with "> " prepended for indentation.
+*/
+function* indentedTreeLineGenerator(el, maxLines = null) {
+	for (const { startRef, endRef, indentationLevel, text } of treeLineGenerator(el, maxLines)) {
+		const fullLine = text.startsWith(">") ? "\\" + text : text;
+		yield [
+			startRef,
+			endRef,
+			"> ".repeat(indentationLevel) + fullLine
+		];
+	}
+}
+/**
+* Get line info arrays from an element.
+*/
+function getLineInfo(tree, maxLines = null) {
+	const startRefs = [];
+	const endRefs = [];
+	const lines = [];
+	for (const [startRef, endRef, line] of indentedTreeLineGenerator(tree, maxLines)) {
+		startRefs.push(startRef);
+		endRefs.push(endRef);
+		lines.push(line);
+	}
+	return [
+		startRefs,
+		endRefs,
+		lines
+	];
+}
+/**
+* Parse an HTML string into a DOM tree and return the root element.
+*/
+function getHtmlTree(html) {
+	const { document } = parseHTML(`<div>${html}</div>`);
+	return document.querySelector("div");
+}
+/**
+* Render an element tree back to HTML, stripping the wrapper div.
+*/
+function renderHtmlTree(tree) {
+	return tree.innerHTML.trim();
+}
+/**
+* Slice the HTML tree at the given range.
+*/
+function sliceTree(tree, startRefs, endRefs, sliceTuple, htmlCopy) {
+	let startRef = null;
+	let endRef = null;
+	let sliceStart = null;
+	let sliceEnd = null;
+	if (sliceTuple) {
+		[sliceStart, sliceEnd] = sliceTuple;
+		if (sliceStart !== null && sliceStart >= startRefs.length || sliceEnd !== null && sliceEnd <= 0) return getHtmlTree("");
+		if (sliceStart !== null && sliceStart <= 0) sliceStart = null;
+		if (sliceEnd !== null && sliceEnd >= startRefs.length) sliceEnd = null;
+	}
+	if (sliceStart !== null) startRef = startRefs[sliceStart];
+	if (sliceEnd !== null && sliceEnd < endRefs.length) endRef = endRefs[sliceEnd - 1];
+	let newTree;
+	if (htmlCopy !== void 0) {
+		newTree = getHtmlTree(htmlCopy);
+		if (startRef) {
+			const path = getElementPath(tree, startRef[0]);
+			const newEl = resolveElementPath(newTree, path);
+			if (newEl) startRef = [newEl, startRef[1]];
+		}
+		if (endRef) {
+			const path = getElementPath(tree, endRef[0]);
+			const newEl = resolveElementPath(newTree, path);
+			if (newEl) endRef = [newEl, endRef[1]];
+		}
+	} else newTree = tree;
+	const includeStart = startRef ? startRef[1] === Position.Begin : false;
+	const includeEnd = endRef ? endRef[1] === Position.End : false;
+	if (startRef && endRef && startRef[0] === endRef[0] && (!includeStart || !includeEnd)) return getHtmlTree("");
+	if (startRef) trimTreeBefore(startRef[0], includeStart);
+	if (endRef) trimTreeAfter(endRef[0], includeEnd);
+	return newTree;
+}
+/**
+* Compute a path from root to element as an array of child indices.
+*/
+function getElementPath(root, target) {
+	const path = [];
+	let current = target;
+	while (current && current !== root) {
+		const parent = current.parentElement;
+		if (!parent) break;
+		const index = Array.from(parent.children).indexOf(current);
+		path.unshift(index);
+		current = parent;
+	}
+	return path;
+}
+/**
+* Resolve an element path from root.
+*/
+function resolveElementPath(root, path) {
+	let current = root;
+	for (const index of path) {
+		const children = Array.from(current.children);
+		if (index >= children.length) return null;
+		current = children[index];
+	}
+	return current;
+}
+/**
+* Try to find quoted content using client-specific HTML selectors.
+* Returns the element that starts the quoted section, or null if none found.
+*
+* Tries all heuristics and returns whichever match appears earliest
+* in the document. This handles cases where e.g. Outlook wraps a Gmail
+* thread — the Outlook separator comes first in the document even though
+* the Gmail class is also present deeper in.
+*
+* Heuristics:
+* - Outlook Web App: #OLK_SRC_BODY_SECTION
+* - Outlook desktop/mobile: #divRplyFwdMsg
+* - Outlook border styles: div with known forward CSS
+* - Zimbra: hr[data-marker="__DIVIDER__"]
+* - Gmail: div.gmail_quote or div.x_gmail_quote
+* - Last non-nested blockquote (not .gmail_quote)
+*/
+function findClientSpecificQuote(tree) {
+	const candidates = [];
+	const olkSection = tree.querySelector("#OLK_SRC_BODY_SECTION");
+	if (olkSection) candidates.push(olkSection);
+	const divRplyFwd = tree.querySelector("#divRplyFwdMsg");
+	if (divRplyFwd) candidates.push(divRplyFwd);
+	const allDivs = tree.querySelectorAll("div[style]");
+	for (const div of Array.from(allDivs)) {
+		const style = div.getAttribute("style") ?? "";
+		if (FORWARD_STYLES.some((re) => re.test(style))) {
+			candidates.push(div);
+			break;
+		}
+	}
+	const zimbraHr = tree.querySelector("hr[data-marker=\"__DIVIDER__\"]");
+	if (zimbraHr) candidates.push(zimbraHr);
+	const gmailQuote = tree.querySelector("div.gmail_quote, div.x_gmail_quote");
+	if (gmailQuote) candidates.push(gmailQuote);
+	const blockquotes = tree.querySelectorAll("blockquote:not(.gmail_quote):not(blockquote blockquote)");
+	if (blockquotes.length > 0) candidates.push(blockquotes[blockquotes.length - 1]);
+	if (candidates.length === 0) return null;
+	if (candidates.length === 1) return candidates[0];
+	return candidates.reduce((earliest, current) => {
+		return earliest.compareDocumentPosition(current) & 4 ? earliest : current;
+	});
+}
+//#endregion
+//#region src/internal.ts
+/**
+* Find a forward/reply pattern within the given lines on the given
+* line number. Returns [lineNumber, type] or null.
+*/
+function findPatternOnLine(lines, n, maxWrapLines, position) {
+	for (const [typ, regexes] of Object.entries(COMPILED_PATTERN_MAP)) for (const regex of regexes) for (let m = 0; m < maxWrapLines; m++) {
+		let matchLine = joinWrappedLines(lines.slice(n, n + 1 + m));
+		if (matchLine.startsWith(">")) matchLine = matchLine.slice(1).trim();
+		if (!matchLine) break;
+		if (regex.test(matchLine.trim())) switch (position) {
+			case Position.Begin: return [n, typ];
+			case Position.End: return [n + m, typ];
+		}
+	}
+	return null;
+}
+/**
+* Return the beginning or ending line number of a quoting pattern.
+*/
+function findQuotePosition(lines, maxWrapLines, limit = null, position = Position.End) {
+	for (let n = 0; n < lines.length; n++) {
+		const result = findPatternOnLine(lines, n, maxWrapLines, position);
+		if (result) return result[0];
+		if (limit !== null && n >= limit - 1) return n;
+	}
+	return null;
+}
+/**
+* Join one or multiple lines that wrapped.
+*/
+function joinWrappedLines(lines) {
+	if (lines.length === 1) return lines[0];
+	let joined = lines[0];
+	for (let i = 1; i < lines.length; i++) if (joined && "<([{\"'".includes(joined[joined.length - 1])) joined += lines[i];
+	else joined += " " + lines[i];
+	return joined;
+}
+/**
+* Extract email headers from the given lines. Returns [headers, linesProcessed].
+*/
+function extractHeaders(lines, maxWrapLines) {
+	const hdrs = {};
+	let headerName = null;
+	let extendLines = 0;
+	let linesProcessed = 0;
+	for (let n = 0; n < lines.length; n++) {
+		const line = lines[n];
+		if (!line.trim()) {
+			headerName = null;
+			continue;
+		}
+		const match = HEADER_RE.exec(line);
+		HEADER_RE.lastIndex = 0;
+		if (match) {
+			headerName = match[1].trim().toLowerCase();
+			const headerValue = match[2];
+			extendLines = 0;
+			if (headerName in HEADER_MAP) hdrs[HEADER_MAP[headerName]] = headerValue.trim();
+			linesProcessed = n + 1;
+		} else {
+			extendLines++;
+			if (extendLines < maxWrapLines && headerName !== null && headerName in HEADER_MAP) {
+				hdrs[HEADER_MAP[headerName]] = joinWrappedLines([hdrs[HEADER_MAP[headerName]], line.trim()]);
+				linesProcessed = n + 1;
+			} else break;
+		}
+	}
+	return [hdrs, linesProcessed];
+}
+/**
+* Parse a reply line ("On DATE, USER wrote:") and return { date, from } or null.
+*/
+function parseReply(line) {
+	if (line.startsWith(">")) line = line.slice(1).trim();
+	let date;
+	let user;
+	for (const pattern of COMPILED_PATTERN_MAP["reply"]) {
+		const match = pattern.exec(line);
+		if (match) {
+			const groups = match.slice(1);
+			if (groups.length === 2) {
+				date = groups[0];
+				user = groups[1];
+			} else {
+				const splitMatch = REPLY_DATE_SPLIT_REGEX.exec(groups[0]);
+				if (splitMatch) {
+					const splitGroups = splitMatch.slice(1);
+					date = splitGroups[0];
+					user = splitGroups[splitGroups.length - 1];
+				} else {
+					const splitIdx = groups[0].lastIndexOf(",");
+					if (splitIdx !== -1) {
+						date = groups[0].slice(0, splitIdx);
+						user = groups[0].slice(splitIdx + 1);
+					}
+				}
+			}
+		}
+	}
+	if (date) date = date.trim();
+	if (user) user = user.trim();
+	if (date && user) return {
+		date: date.trim(),
+		from: user.trim()
+	};
+	return null;
+}
+/**
+* Find the starting point of a wrapped email.
+* Returns [startLine, endLine, type] or null.
+*/
+function findUnwrapStart(lines, maxWrapLines, minHeaderLines, minQuotedLines) {
+	for (let n = 0; n < lines.length; n++) {
+		const line = lines[n];
+		if (!line.trim()) continue;
+		const result = findPatternOnLine(lines, n, maxWrapLines, Position.End);
+		if (result) {
+			const [end, typ] = result;
+			return [
+				n,
+				end,
+				typ
+			];
+		}
+		if (line.startsWith(">")) {
+			let matchedLines = 1;
+			if (matchedLines >= minQuotedLines) return [
+				n,
+				n,
+				"quoted"
+			];
+			for (let i = n + 1; i < lines.length; i++) {
+				const peekLine = lines[i];
+				if (!peekLine.trim()) continue;
+				if (!peekLine.startsWith(">")) break;
+				matchedLines++;
+				if (matchedLines >= minQuotedLines) return [
+					n,
+					n,
+					"quoted"
+				];
+			}
+		}
+		const headerMatch = HEADER_RE.exec(line);
+		HEADER_RE.lastIndex = 0;
+		if (headerMatch) {
+			const [hdrs] = extractHeaders(lines.slice(n), maxWrapLines);
+			if (Object.keys(hdrs).length >= minHeaderLines) return [
+				n,
+				n,
+				"headers"
+			];
+		}
+	}
+	return null;
+}
+/**
+* Unindent lines by stripping leading "> " or ">".
+*/
+function unindentLines(lines) {
+	const unquoted = [];
+	for (const line of lines) if (line.startsWith("> ")) unquoted.push(line.slice(2));
+	else if (line.startsWith(">")) unquoted.push(line.slice(1));
+	else break;
+	return unquoted;
+}
+/**
+* Core unwrap function. Returns the unwrap result tuple or null.
+*/
+function unwrap$1(lines, maxWrapLines, minHeaderLines, minQuotedLines) {
+	let headers = {};
+	const result = findUnwrapStart(lines, maxWrapLines, minHeaderLines, minQuotedLines);
+	if (!result) return null;
+	const [start, end, typ] = result;
+	if (typ === "forward" || typ === "reply") {
+		const mainType = typ;
+		if (typ === "reply") {
+			const replyHeaders = parseReply(joinWrappedLines(lines.slice(start, end + 1)));
+			if (replyHeaders) Object.assign(headers, replyHeaders);
+		}
+		const result2 = findUnwrapStart(lines.slice(end + 1), maxWrapLines, minHeaderLines, 1);
+		const start2 = result2 ? result2[0] : 0;
+		const typ2 = result2 ? result2[2] : null;
+		if (typ2 === "quoted") {
+			const quotedStart = end + 1 + start2;
+			const unquoted = unindentLines(lines.slice(quotedStart));
+			const restStart = quotedStart + unquoted.length;
+			const result3 = findUnwrapStart(unquoted, maxWrapLines, minHeaderLines, minQuotedLines);
+			const start3 = result3 ? result3[0] : 0;
+			if ((result3 ? result3[2] : null) === "headers") {
+				const [hdrs, hdrsLength] = extractHeaders(unquoted.slice(start3), maxWrapLines);
+				if (Object.keys(hdrs).length > 0) Object.assign(headers, hdrs);
+				const rest2Start = quotedStart + start3 + hdrsLength;
+				return [
+					mainType,
+					[0, start],
+					headers,
+					[rest2Start, restStart],
+					[restStart, null],
+					true
+				];
+			}
+			return [
+				mainType,
+				[0, start],
+				headers,
+				[quotedStart, restStart],
+				[restStart, null],
+				true
+			];
+		}
+		if (typ2 === "headers") {
+			const [hdrs, hdrsLength] = extractHeaders(lines.slice(start + 1), maxWrapLines);
+			if (Object.keys(hdrs).length > 0) Object.assign(headers, hdrs);
+			const restStart = start + 1 + hdrsLength;
+			return [
+				mainType,
+				[0, start],
+				headers,
+				[restStart, null],
+				null,
+				false
+			];
+		}
+		return [
+			mainType,
+			[0, start],
+			headers,
+			[start + (start2 || 0) + 1, null],
+			null,
+			false
+		];
+	}
+	if (typ === "headers") {
+		const mainType = "forward";
+		const [hdrs, hdrsLength] = extractHeaders(lines.slice(start), maxWrapLines);
+		const restStart = start + hdrsLength;
+		return [
+			mainType,
+			[0, start],
+			hdrs,
+			[restStart, null],
+			null,
+			false
+		];
+	}
+	if (typ === "quoted") {
+		const unquoted = unindentLines(lines.slice(start));
+		const restStart = start + unquoted.length;
+		const result2 = findUnwrapStart(unquoted, maxWrapLines, minHeaderLines, minQuotedLines);
+		const start2 = result2 ? result2[0] : 0;
+		if ((result2 ? result2[2] : null) === "headers") {
+			const mainType = "forward";
+			const [hdrs, hdrsLength] = extractHeaders(unquoted.slice(start2), maxWrapLines);
+			const rest2Start = start + hdrsLength;
+			return [
+				mainType,
+				[0, start],
+				hdrs,
+				[rest2Start, restStart],
+				[restStart, null],
+				true
+			];
+		}
+		return [
+			"quote",
+			[null, start],
+			null,
+			[start, restStart],
+			[restStart, null],
+			true
+		];
+	}
+	throw new Error(`invalid type: ${typ}`);
+}
+//#endregion
+//#region src/index.ts
+/**
+* Divide email body into quoted parts.
+*
+* @param text - Plain text message.
+* @param options.limit - If set, the text will automatically be quoted starting at the
+*   line where the limit is reached.
+* @param options.quoteIntroLine - Whether the line introducing the quoted text ("On ...
+*   wrote:" / "Begin forwarded message:") should be part of the quoted text.
+* @returns List of tuples [shouldExpand, textSegment].
+*/
+function quote(text, options = {}) {
+	const { limit = 1e3, quoteIntroLine = false } = options;
+	const lines = text.split("\n");
+	const found = findQuotePosition(lines, 2, limit, quoteIntroLine ? Position.Begin : Position.End);
+	if (found === null) return [[true, text]];
+	const splitIdx = quoteIntroLine ? found : found + 1;
+	return [[true, lines.slice(0, splitIdx).join("\n")], [false, lines.slice(splitIdx).join("\n")]];
+}
+/**
+* Like quote(), but takes an HTML message as an argument.
+*
+* Uses a two-phase approach inspired by Mailgun's Talon:
+* 1. Try client-specific CSS selectors (Gmail, Zimbra, OWA, Outlook styles)
+* 2. Fall back to line-based pattern matching
+*/
+function quoteHtml(html, options = {}) {
+	const { limit = 1e3, quoteIntroLine = false } = options;
+	const tree = getHtmlTree(html);
+	const clientQuote = findClientSpecificQuote(tree);
+	if (clientQuote) {
+		const [startRefs, endRefs, lines] = getLineInfo(tree, limit + 1);
+		const quoteLineIdx = findQuoteSplitIndex(clientQuote, startRefs, endRefs);
+		if (quoteLineIdx !== null && quoteLineIdx > 0) {
+			const searchStart = Math.max(0, quoteLineIdx - 3);
+			const searchEnd = quoteLineIdx + 1;
+			const found = findQuotePosition(lines.slice(searchStart, searchEnd), 1, null, quoteIntroLine ? Position.Begin : Position.End);
+			let splitIdx;
+			if (found !== null) {
+				const effectiveFound = found + searchStart;
+				splitIdx = quoteIntroLine ? effectiveFound : effectiveFound + 1;
+			} else splitIdx = quoteLineIdx;
+			if (splitIdx > 0 && splitIdx <= lines.length) {
+				const startTree = sliceTree(tree, startRefs, endRefs, [0, splitIdx], html);
+				const endTree = sliceTree(tree, startRefs, endRefs, [splitIdx, null]);
+				return [[true, renderHtmlTree(startTree)], [false, renderHtmlTree(endTree)]];
+			}
+		}
+	}
+	const tree2 = getHtmlTree(html);
+	const [startRefs, endRefs, lines] = getLineInfo(tree2, limit + 1);
+	const found = findQuotePosition(lines, 1, limit, quoteIntroLine ? Position.Begin : Position.End);
+	if (found === null) return [[true, renderHtmlTree(tree2)]];
+	const splitIdx = quoteIntroLine ? found : found + 1;
+	const startTree = sliceTree(tree2, startRefs, endRefs, [0, splitIdx], html);
+	const endTree = sliceTree(tree2, startRefs, endRefs, [splitIdx, null]);
+	return [[true, renderHtmlTree(startTree)], [false, renderHtmlTree(endTree)]];
+}
+/**
+* Find the line index where the quoted content starts, given a client-detected
+* quote element. Returns the split index (first line of the quote).
+*
+* For container elements (div.gmail_quote, #OLK_SRC_BODY_SECTION): returns
+* the first line whose content is inside the element.
+*
+* For separator elements (hr): returns the first line that follows the
+* separator in document order.
+*/
+function findQuoteSplitIndex(target, startRefs, endRefs) {
+	if (target.tagName?.toLowerCase() === "hr") for (let i = 0; i < startRefs.length; i++) {
+		const startEl = startRefs[i]?.[0];
+		if (!startEl) continue;
+		if (isAfterInDocument(target, startEl)) return i;
+	}
+	else for (let i = 0; i < startRefs.length; i++) {
+		const startEl = startRefs[i]?.[0];
+		const endEl = endRefs[i]?.[0];
+		if (startEl === target || endEl === target || target.contains(startEl) || target.contains(endEl)) return i;
+	}
+	return null;
+}
+/**
+* Check if `after` comes after `before` in document order,
+* and `after` is not contained within `before`.
+*/
+function isAfterInDocument(before, after) {
+	if (before === after || before.contains(after)) return false;
+	let current = before;
+	while (current) {
+		let next = current.nextElementSibling;
+		while (next) {
+			if (next === after || next.contains(after)) return true;
+			next = next.nextElementSibling;
+		}
+		current = current.parentElement;
+	}
+	return false;
+}
+/**
+* If the passed text is the text body of a forwarded message, a reply, or
+* contains quoted text, returns a structured result. Otherwise returns null.
+*/
+function unwrap(text) {
+	const lines = text.split("\n");
+	const unwrapResult = unwrap$1(lines, 2, 2, 3);
+	if (!unwrapResult) return null;
+	const [typ, topRange, hdrs, mainRange, bottomRange, needsUnindent] = unwrapResult;
+	const textTopLines = topRange ? lines.slice(topRange[0] ?? 0, topRange[1] ?? void 0) : [];
+	let textLines = mainRange ? lines.slice(mainRange[0] ?? 0, mainRange[1] ?? void 0) : [];
+	const textBottomLines = bottomRange ? lines.slice(bottomRange[0] ?? 0, bottomRange[1] ?? void 0) : [];
+	if (needsUnindent) textLines = unindentLines(textLines);
+	const result = { type: typ };
+	const textContent = textLines.join("\n").trim();
+	const textTop = textTopLines.join("\n").trim();
+	const textBottom = textBottomLines.join("\n").trim();
+	if (textContent) result.text = textContent;
+	if (textTop) result.text_top = textTop;
+	if (textBottom) result.text_bottom = textBottom;
+	if (hdrs) Object.assign(result, hdrs);
+	return result;
+}
+/**
+* Like unwrap(), but for HTML email bodies.
+*/
+function unwrapHtml(html) {
+	const tree = getHtmlTree(html);
+	const [startRefs, endRefs, lines] = getLineInfo(tree);
+	const unwrapResult = unwrap$1(lines, 1, 2, 1);
+	if (!unwrapResult) return null;
+	const [typ, topRange, hdrs, mainRange, bottomRange, needsUnindent] = unwrapResult;
+	const result = { type: typ };
+	const topRangeSlice = trimSlice(lines, topRange);
+	const mainRangeSlice = trimSlice(lines, mainRange);
+	const bottomRangeSlice = trimSlice(lines, bottomRange);
+	if (topRangeSlice) {
+		const htmlTop = renderHtmlTree(sliceTree(tree, startRefs, endRefs, topRangeSlice, html));
+		if (htmlTop) result.html_top = htmlTop;
+	}
+	if (bottomRangeSlice) {
+		const htmlBottom = renderHtmlTree(sliceTree(tree, startRefs, endRefs, bottomRangeSlice, html));
+		if (htmlBottom) result.html_bottom = htmlBottom;
+	}
+	if (mainRangeSlice) {
+		const mainTree = sliceTree(tree, startRefs, endRefs, mainRangeSlice);
+		if (needsUnindent) unindentTree(mainTree);
+		const htmlContent = renderHtmlTree(mainTree);
+		if (htmlContent) result.html = htmlContent;
+	}
+	if (hdrs) Object.assign(result, hdrs);
+	return result;
+}
+//#endregion
+export { Position, quote, quoteHtml, unwrap, unwrapHtml };