@yozz.app/imap 0.1.0

package/dist/index.mjs

@@ -0,0 +1,2221 @@
+//#region src/bytes.ts
+const concatByteArrays = (arrays) => {
+	let totalLength = 0;
+	for (const arr of arrays) totalLength += arr.length;
+	const result = new Uint8Array(totalLength);
+	let offset = 0;
+	for (const arr of arrays) {
+		result.set(arr, offset);
+		offset += arr.length;
+	}
+	return result;
+};
+const asciiDecoder = new TextDecoder("ascii");
+const textEncoder = new TextEncoder();
+const asciiToString = (bytes) => asciiDecoder.decode(bytes);
+const stringToBytes = (str) => textEncoder.encode(str);
+const isDigit = (byte) => byte >= 48 && byte <= 57;
+const B64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const bytesToBase64 = (bytes) => {
+	let result = "";
+	const len = bytes.length;
+	let i = 0;
+	while (i < len) {
+		const b0 = bytes[i] ?? 0;
+		const b1 = i + 1 < len ? bytes[i + 1] ?? 0 : null;
+		const b2 = i + 2 < len ? bytes[i + 2] ?? 0 : null;
+		const idx0 = b0 >> 2;
+		result += B64_CHARS[idx0] ?? "";
+		if (b1 !== null) {
+			const idx1 = (b0 & 3) << 4 | b1 >> 4;
+			result += B64_CHARS[idx1] ?? "";
+			if (b2 !== null) {
+				const idx2 = (b1 & 15) << 2 | b2 >> 6;
+				const idx3 = b2 & 63;
+				result += (B64_CHARS[idx2] ?? "") + (B64_CHARS[idx3] ?? "");
+				i += 3;
+			} else {
+				const idx2 = (b1 & 15) << 2;
+				result += (B64_CHARS[idx2] ?? "") + "=";
+				i += 2;
+			}
+		} else {
+			const idx1 = (b0 & 3) << 4;
+			result += (B64_CHARS[idx1] ?? "") + "==";
+			i += 1;
+		}
+	}
+	return result;
+};
+//#endregion
+//#region src/utf7.ts
+/**
+* RFC 3501 §5.1.3 Modified UTF-7 encoding and decoding for IMAP mailbox names.
+*
+* Printable ASCII (0x20..0x7E) except '&' are direct.
+* '&' is encoded as '&-'.
+* Non-ASCII characters are encoded as UTF-16BE in modified Base64 (',' instead of '/', no '=' padding),
+* enclosed between '&' and '-'.
+*/
+const b64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+,";
+const encodeModifiedBase64 = (codeUnits) => {
+	const bytes = [];
+	for (const cu of codeUnits) {
+		bytes.push(cu >> 8 & 255);
+		bytes.push(cu & 255);
+	}
+	let result = "";
+	let i = 0;
+	while (i < bytes.length) {
+		const b0 = bytes[i] ?? 0;
+		const b1 = i + 1 < bytes.length ? bytes[i + 1] ?? 0 : null;
+		const b2 = i + 2 < bytes.length ? bytes[i + 2] ?? 0 : null;
+		const idx0 = b0 >> 2;
+		result += b64Chars[idx0] ?? "";
+		if (b1 !== null) {
+			const idx1 = (b0 & 3) << 4 | b1 >> 4;
+			result += b64Chars[idx1] ?? "";
+			if (b2 !== null) {
+				const idx2 = (b1 & 15) << 2 | b2 >> 6;
+				const idx3 = b2 & 63;
+				result += (b64Chars[idx2] ?? "") + (b64Chars[idx3] ?? "");
+				i += 3;
+			} else {
+				const idx2 = (b1 & 15) << 2;
+				result += b64Chars[idx2] ?? "";
+				i += 2;
+			}
+		} else {
+			const idx1 = (b0 & 3) << 4;
+			result += b64Chars[idx1] ?? "";
+			i += 1;
+		}
+	}
+	return result;
+};
+const decodeModifiedBase64 = (str) => {
+	const standardB64 = str.replace(/,/g, "/");
+	const remainder = standardB64.length % 4;
+	const padded = remainder === 0 ? standardB64 : standardB64 + "=".repeat(4 - remainder);
+	try {
+		const binary = atob(padded);
+		let decoded = "";
+		for (let i = 0; i + 1 < binary.length; i += 2) {
+			const high = binary.charCodeAt(i);
+			const low = binary.charCodeAt(i + 1);
+			decoded += String.fromCharCode(high << 8 | low);
+		}
+		return decoded;
+	} catch {
+		return `&${str}-`;
+	}
+};
+const encodeModifiedUtf7 = (str) => {
+	let result = "";
+	let nonAsciiBuffer = [];
+	const flushNonAscii = () => {
+		if (nonAsciiBuffer.length === 0) return;
+		result += `&${encodeModifiedBase64(nonAsciiBuffer)}-`;
+		nonAsciiBuffer = [];
+	};
+	for (let i = 0; i < str.length; i++) {
+		const code = str.charCodeAt(i);
+		if (code === 38) {
+			flushNonAscii();
+			result += "&-";
+		} else if (code >= 32 && code <= 126) {
+			flushNonAscii();
+			result += str[i] ?? "";
+		} else nonAsciiBuffer.push(code);
+	}
+	flushNonAscii();
+	return result;
+};
+const decodeModifiedUtf7 = (str) => {
+	let result = "";
+	let i = 0;
+	while (i < str.length) if (str[i] === "&") {
+		if (i + 1 < str.length && str[i + 1] === "-") {
+			result += "&";
+			i += 2;
+			continue;
+		}
+		const dashIndex = str.indexOf("-", i + 1);
+		if (dashIndex === -1) {
+			result += str.slice(i);
+			break;
+		}
+		const b64Part = str.slice(i + 1, dashIndex);
+		result += decodeModifiedBase64(b64Part);
+		i = dashIndex + 1;
+	} else {
+		result += str[i] ?? "";
+		i++;
+	}
+	return result;
+};
+//#endregion
+//#region src/commands.ts
+/**
+* Pure builders for IMAP commands. Each builder returns exact bytes to send.
+* No I/O is performed here.
+*/
+const quoteString = (str) => {
+	return `"${str.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+};
+const isSafeQuotedString = (str) => {
+	for (let i = 0; i < str.length; i++) {
+		const code = str.charCodeAt(i);
+		if (code < 32 || code > 126 || code === 0) return false;
+	}
+	return true;
+};
+const buildSaslPlainBytes = (user, pass) => {
+	const userBytes = stringToBytes(user);
+	const passBytes = stringToBytes(pass);
+	const result = new Uint8Array(1 + userBytes.length + 1 + passBytes.length);
+	result[0] = 0;
+	result.set(userBytes, 1);
+	result[1 + userBytes.length] = 0;
+	result.set(passBytes, 2 + userBytes.length);
+	return result;
+};
+const buildCapabilityCommand = (tag) => ({ lines: [{ text: stringToBytes(`${tag} CAPABILITY\r\n`) }] });
+const buildAuthenticatePlainSaslIrCommand = (tag, user, pass) => {
+	return { lines: [{ text: stringToBytes(`${tag} AUTHENTICATE PLAIN ${bytesToBase64(buildSaslPlainBytes(user, pass))}\r\n`) }] };
+};
+const buildAuthenticatePlainInitialCommand = (tag) => ({ lines: [{ text: stringToBytes(`${tag} AUTHENTICATE PLAIN\r\n`) }] });
+const buildAuthenticatePlainResponse = (user, pass) => {
+	return { lines: [{ text: stringToBytes(`${bytesToBase64(buildSaslPlainBytes(user, pass))}\r\n`) }] };
+};
+const buildLoginCommand = (tag, user, pass) => {
+	const userSafe = isSafeQuotedString(user);
+	const passSafe = isSafeQuotedString(pass);
+	if (userSafe && passSafe) return { lines: [{ text: stringToBytes(`${tag} LOGIN ${quoteString(user)} ${quoteString(pass)}\r\n`) }] };
+	if (!userSafe && passSafe) return { lines: [{
+		text: stringToBytes(`${tag} LOGIN `),
+		literal: stringToBytes(user)
+	}, { text: stringToBytes(` ${quoteString(pass)}\r\n`) }] };
+	if (userSafe && !passSafe) return { lines: [{
+		text: stringToBytes(`${tag} LOGIN ${quoteString(user)} `),
+		literal: stringToBytes(pass)
+	}, { text: stringToBytes("\r\n") }] };
+	return { lines: [
+		{
+			text: stringToBytes(`${tag} LOGIN `),
+			literal: stringToBytes(user)
+		},
+		{
+			text: stringToBytes(" "),
+			literal: stringToBytes(pass)
+		},
+		{ text: stringToBytes("\r\n") }
+	] };
+};
+const buildListCommand = (tag, reference, pattern) => {
+	const refUtf7 = encodeModifiedUtf7(reference);
+	const patUtf7 = encodeModifiedUtf7(pattern);
+	return { lines: [{ text: stringToBytes(`${tag} LIST ${quoteString(refUtf7)} ${quoteString(patUtf7)}\r\n`) }] };
+};
+const buildSelectCommand = (tag, mailbox, readOnly = false) => {
+	return { lines: [{ text: stringToBytes(`${tag} ${readOnly ? "EXAMINE" : "SELECT"} ${quoteString(encodeModifiedUtf7(mailbox))}\r\n`) }] };
+};
+/**
+* Everything a list row and client-side threading need, in one round trip. `References` is the
+* one header ENVELOPE does not carry; `X-GM-THRID` is Gmail's own threading answer and is only
+* asked for when the server advertised `X-GM-EXT-1`, since an unknown item is a BAD.
+*
+* `bySeq` drops the `UID` prefix, so `set` is read as message sequence numbers instead. `UID`
+* stays in the items either way: a summary is worthless without the id its folder is keyed by.
+*/
+const buildFetchSummariesCommand = (tag, set, { gmail, bySeq = false }) => ({ lines: [{ text: stringToBytes(`${tag} ${bySeq ? "FETCH" : "UID FETCH"} ${set} (FLAGS ENVELOPE INTERNALDATE RFC822.SIZE UID BODY.PEEK[HEADER.FIELDS (REFERENCES)]${gmail ? " X-GM-THRID" : ""})\r\n`) }] });
+const buildFetchFlagsCommand = (tag, uidSet) => ({ lines: [{ text: stringToBytes(`${tag} UID FETCH ${uidSet} (FLAGS UID)\r\n`) }] });
+const buildFetchRawCommand = (tag, uid) => ({ lines: [{ text: stringToBytes(`${tag} UID FETCH ${uid} (BODY.PEEK[])\r\n`) }] });
+const buildStoreFlagsCommand = (tag, uidSet, mode, flags) => {
+	return { lines: [{ text: stringToBytes(`${tag} UID STORE ${uidSet} ${mode === "add" ? "+FLAGS" : mode === "remove" ? "-FLAGS" : "FLAGS"} (${flags.join(" ")})\r\n`) }] };
+};
+/** APPEND with the message as a literal; flags are IMAP atoms such as `\\Seen`, sent unquoted. */
+const buildAppendCommand = (tag, mailbox, flags, message) => {
+	return { lines: [{
+		text: stringToBytes(`${tag} APPEND ${quoteString(encodeModifiedUtf7(mailbox))} (${flags.join(" ")}) `),
+		literal: message
+	}, { text: stringToBytes("\r\n") }] };
+};
+/** RFC 6851 UID MOVE — relocates messages into another mailbox in one round trip. */
+const buildMoveCommand = (tag, uidSet, mailbox) => ({ lines: [{ text: stringToBytes(`${tag} UID MOVE ${uidSet} ${quoteString(encodeModifiedUtf7(mailbox))}\r\n`) }] });
+/** CREATE a mailbox (e.g. Archive the first time the client needs one). */
+const buildCreateCommand = (tag, mailbox) => ({ lines: [{ text: stringToBytes(`${tag} CREATE ${quoteString(encodeModifiedUtf7(mailbox))}\r\n`) }] });
+const buildNoopCommand = (tag) => ({ lines: [{ text: stringToBytes(`${tag} NOOP\r\n`) }] });
+const buildIdleCommand = (tag) => ({ lines: [{ text: stringToBytes(`${tag} IDLE\r\n`) }] });
+/** RFC 2177: the client ends IDLE with a bare DONE line (no tag). */
+const buildIdleDoneLine = () => stringToBytes("DONE\r\n");
+const buildLogoutCommand = (tag) => ({ lines: [{ text: stringToBytes(`${tag} LOGOUT\r\n`) }] });
+//#endregion
+//#region src/rfc2047.ts
+/**
+* RFC 2047 MIME Part Three: Message Header Extensions for Non-ASCII Text.
+*
+* Decodes encoded-words in header fields (Q and B encodings).
+* Crucial invariants:
+* 1. Adjacent encoded-words separated only by linear-white-space (LWS) are joined by their
+*    raw decoded bytes before charset decoding.
+* 2. The output is NEVER re-scanned.
+* 3. Unknown charsets leave the raw word intact.
+*/
+const ENCODED_WORD_REGEX = /=\?([^?]+)\?([bBqQ])\?([^?]*)\?=/g;
+const decodeQToBytes = (text) => {
+	const bytes = [];
+	let i = 0;
+	while (i < text.length) {
+		const ch = text[i];
+		if (ch === "_") {
+			bytes.push(32);
+			i++;
+		} else if (ch === "=" && i + 2 < text.length && /^[0-9a-fA-F]{2}$/.test(text.slice(i + 1, i + 3))) {
+			bytes.push(Number.parseInt(text.slice(i + 1, i + 3), 16));
+			i += 3;
+		} else {
+			bytes.push((text.charCodeAt(i) ?? 0) & 255);
+			i++;
+		}
+	}
+	return new Uint8Array(bytes);
+};
+const decodeBToBytes = (text) => {
+	try {
+		const binary = atob(text.trim());
+		const bytes = new Uint8Array(binary.length);
+		for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+		return bytes;
+	} catch {
+		return null;
+	}
+};
+const decodeBytesWithCharset = (bytes, charset) => {
+	try {
+		return new TextDecoder(charset).decode(bytes);
+	} catch {
+		return null;
+	}
+};
+const decodeRfc2047 = (header) => {
+	const matches = [];
+	let match = null;
+	ENCODED_WORD_REGEX.lastIndex = 0;
+	while (true) {
+		match = ENCODED_WORD_REGEX.exec(header);
+		if (match === null) break;
+		const raw = match[0];
+		const charset = match[1] ?? "";
+		const encodingLetter = (match[2] ?? "").toUpperCase();
+		const encodedText = match[3] ?? "";
+		const start = match.index;
+		const end = start + raw.length;
+		if (encodingLetter === "B" || encodingLetter === "Q") matches.push({
+			start,
+			end,
+			raw,
+			charset,
+			encoding: encodingLetter,
+			encodedText
+		});
+	}
+	if (matches.length === 0) return header;
+	let result = "";
+	let cursor = 0;
+	let i = 0;
+	while (i < matches.length) {
+		const current = matches[i];
+		if (current === void 0) break;
+		if (current.start > cursor) result += header.slice(cursor, current.start);
+		const adjacentWords = [current];
+		let nextIndex = i + 1;
+		while (nextIndex < matches.length) {
+			const prev = adjacentWords[adjacentWords.length - 1];
+			const next = matches[nextIndex];
+			if (prev === void 0 || next === void 0) break;
+			const between = header.slice(prev.end, next.start);
+			if (/^[ \t\r\n]+$/.test(between)) {
+				adjacentWords.push(next);
+				nextIndex++;
+			} else break;
+		}
+		let j = 0;
+		while (j < adjacentWords.length) {
+			const firstInCharset = adjacentWords[j];
+			if (firstInCharset === void 0) break;
+			const sameCharsetWords = [firstInCharset];
+			let k = j + 1;
+			while (k < adjacentWords.length) {
+				const candidate = adjacentWords[k];
+				if (candidate !== void 0 && candidate.charset.toLowerCase() === firstInCharset.charset.toLowerCase()) {
+					sameCharsetWords.push(candidate);
+					k++;
+				} else break;
+			}
+			let isCharsetSupported = true;
+			try {
+				new TextDecoder(firstInCharset.charset);
+			} catch {
+				isCharsetSupported = false;
+			}
+			if (!isCharsetSupported) for (const w of sameCharsetWords) result += w.raw;
+			else {
+				const byteChunks = [];
+				let hasDecodeError = false;
+				for (const w of sameCharsetWords) {
+					const chunk = w.encoding === "B" ? decodeBToBytes(w.encodedText) : decodeQToBytes(w.encodedText);
+					if (chunk === null) {
+						hasDecodeError = true;
+						break;
+					}
+					byteChunks.push(chunk);
+				}
+				if (hasDecodeError) for (const w of sameCharsetWords) result += w.raw;
+				else {
+					const decodedText = decodeBytesWithCharset(concatByteArrays(byteChunks), firstInCharset.charset);
+					if (decodedText !== null) result += decodedText;
+					else for (const w of sameCharsetWords) result += w.raw;
+				}
+			}
+			j = k;
+		}
+		const lastWord = adjacentWords[adjacentWords.length - 1];
+		cursor = lastWord !== void 0 ? lastWord.end : current.end;
+		i = nextIndex;
+	}
+	if (cursor < header.length) result += header.slice(cursor);
+	return result;
+};
+//#endregion
+//#region src/envelope.ts
+/**
+* Parsers for IMAP FETCH items: ENVELOPE, FLAGS, INTERNALDATE, RFC822.SIZE, BODYSTRUCTURE.
+*/
+const tokenToString$1 = (token) => {
+	if (token === void 0 || token.kind === "nil") return null;
+	if (token.kind === "quoted" || token.kind === "atom") return token.value;
+	if (token.kind === "number") return String(token.value);
+	if (token.kind === "literal") return asciiToString(token.value);
+	return null;
+};
+/**
+* Parses a single address tuple `(name adl mailbox host)` and advances index past `)`.
+*/
+const parseAddressTuple = (tokens, start) => {
+	let idx = start;
+	if (tokens[idx]?.kind !== "lparen") return null;
+	idx++;
+	const rawName = tokenToString$1(tokens[idx]);
+	idx++;
+	idx++;
+	const rawMailbox = tokenToString$1(tokens[idx]);
+	idx++;
+	const rawHost = tokenToString$1(tokens[idx]);
+	idx++;
+	while (idx < tokens.length && tokens[idx]?.kind !== "rparen") idx++;
+	if (tokens[idx]?.kind === "rparen") idx++;
+	const name = rawName !== null ? decodeRfc2047(rawName) : null;
+	const mailbox = rawMailbox;
+	const host = rawHost;
+	if (host === null) {
+		if (mailbox !== null) return {
+			address: "group-start",
+			nextIndex: idx
+		};
+		return {
+			address: "group-end",
+			nextIndex: idx
+		};
+	}
+	return {
+		address: {
+			name,
+			mailbox,
+			host
+		},
+		nextIndex: idx
+	};
+};
+/**
+* Parses an address list `( (addr1) (addr2) ... )` or `NIL`.
+* Flattening groups to their member addresses.
+*/
+const parseAddressList = (tokens, start) => {
+	const first = tokens[start];
+	if (first === void 0 || first.kind === "nil") return {
+		addresses: [],
+		nextIndex: start + 1
+	};
+	if (first.kind !== "lparen") return {
+		addresses: [],
+		nextIndex: start + 1
+	};
+	let idx = start + 1;
+	const addresses = [];
+	while (idx < tokens.length) {
+		const tok = tokens[idx];
+		if (tok === void 0 || tok.kind === "rparen") {
+			idx++;
+			break;
+		}
+		if (tok.kind === "lparen") {
+			const parsed = parseAddressTuple(tokens, idx);
+			if (parsed === null) idx++;
+			else {
+				if (parsed.address !== "group-start" && parsed.address !== "group-end") addresses.push(parsed.address);
+				idx = parsed.nextIndex;
+			}
+		} else idx++;
+	}
+	return {
+		addresses,
+		nextIndex: idx
+	};
+};
+/**
+* Parses an ENVELOPE structure:
+* `(date subject from sender reply-to to cc bcc in-reply-to message-id)`
+*/
+const parseEnvelope = (tokens, start) => {
+	if (tokens[start]?.kind !== "lparen") return null;
+	let idx = start + 1;
+	const date = tokenToString$1(tokens[idx]);
+	idx++;
+	const subjectRaw = tokenToString$1(tokens[idx]);
+	const subject = subjectRaw !== null ? decodeRfc2047(subjectRaw) : null;
+	idx++;
+	const fromResult = parseAddressList(tokens, idx);
+	const from = fromResult.addresses;
+	idx = fromResult.nextIndex;
+	const senderResult = parseAddressList(tokens, idx);
+	const sender = senderResult.addresses;
+	idx = senderResult.nextIndex;
+	const replyToResult = parseAddressList(tokens, idx);
+	const replyTo = replyToResult.addresses;
+	idx = replyToResult.nextIndex;
+	const toResult = parseAddressList(tokens, idx);
+	const to = toResult.addresses;
+	idx = toResult.nextIndex;
+	const ccResult = parseAddressList(tokens, idx);
+	const cc = ccResult.addresses;
+	idx = ccResult.nextIndex;
+	const bccResult = parseAddressList(tokens, idx);
+	const bcc = bccResult.addresses;
+	idx = bccResult.nextIndex;
+	const inReplyTo = tokenToString$1(tokens[idx]);
+	idx++;
+	const messageId = tokenToString$1(tokens[idx]);
+	idx++;
+	while (idx < tokens.length && tokens[idx]?.kind !== "rparen") idx++;
+	if (tokens[idx]?.kind === "rparen") idx++;
+	return {
+		envelope: {
+			date,
+			subject,
+			subjectRaw,
+			from,
+			sender,
+			replyTo,
+			to,
+			cc,
+			bcc,
+			inReplyTo,
+			messageId
+		},
+		nextIndex: idx
+	};
+};
+/**
+* Parses BODYSTRUCTURE, extracting only the list of MIME parts (e.g. ['TEXT/PLAIN', 'TEXT/HTML']).
+*/
+const parseBodyStructureParts = (tokens, start) => {
+	if (tokens[start]?.kind !== "lparen") return {
+		parts: [],
+		nextIndex: start + 1
+	};
+	let idx = start + 1;
+	const parts = [];
+	if (tokens[idx]?.kind === "lparen") {
+		while (idx < tokens.length && tokens[idx]?.kind === "lparen") {
+			const child = parseBodyStructureParts(tokens, idx);
+			parts.push(...child.parts);
+			idx = child.nextIndex;
+		}
+		let depth = 1;
+		while (idx < tokens.length && depth > 0) {
+			if (tokens[idx]?.kind === "lparen") depth++;
+			else if (tokens[idx]?.kind === "rparen") depth--;
+			idx++;
+		}
+		return {
+			parts,
+			nextIndex: idx
+		};
+	}
+	const mediaType = tokenToString$1(tokens[idx]) ?? "APPLICATION";
+	idx++;
+	const subType = tokenToString$1(tokens[idx]) ?? "OCTET-STREAM";
+	idx++;
+	parts.push(`${mediaType.toUpperCase()}/${subType.toUpperCase()}`);
+	let depth = 1;
+	while (idx < tokens.length && depth > 0) {
+		if (tokens[idx]?.kind === "lparen") depth++;
+		else if (tokens[idx]?.kind === "rparen") depth--;
+		idx++;
+	}
+	return {
+		parts,
+		nextIndex: idx
+	};
+};
+/**
+* Parses items inside a FETCH response `(...)`.
+*/
+const parseFetchItems = (tokens, start) => {
+	if (tokens[start]?.kind !== "lparen") return {
+		items: [],
+		nextIndex: start + 1
+	};
+	let idx = start + 1;
+	const items = [];
+	while (idx < tokens.length) {
+		const tok = tokens[idx];
+		if (tok === void 0 || tok.kind === "rparen") {
+			idx++;
+			break;
+		}
+		if (tok.kind === "atom") {
+			const itemName = tok.value.toUpperCase();
+			idx++;
+			if (itemName === "UID") {
+				const uidTok = tokens[idx];
+				const uid = uidTok?.kind === "number" ? uidTok.value : 0;
+				idx++;
+				items.push({
+					kind: "uid",
+					uid
+				});
+			} else if (itemName === "RFC822.SIZE") {
+				const sizeTok = tokens[idx];
+				const size = sizeTok?.kind === "number" ? sizeTok.value : 0;
+				idx++;
+				items.push({
+					kind: "size",
+					size
+				});
+			} else if (itemName === "INTERNALDATE") {
+				const dateStr = tokenToString$1(tokens[idx]) ?? "";
+				idx++;
+				items.push({
+					kind: "internalDate",
+					date: dateStr
+				});
+			} else if (itemName === "FLAGS") if (tokens[idx]?.kind === "lparen") {
+				idx++;
+				const flags = [];
+				while (idx < tokens.length && tokens[idx]?.kind !== "rparen") {
+					const flagTok = tokens[idx];
+					if (flagTok?.kind === "atom") flags.push(flagTok.value);
+					idx++;
+				}
+				if (tokens[idx]?.kind === "rparen") idx++;
+				items.push({
+					kind: "flags",
+					flags
+				});
+			} else idx++;
+			else if (itemName === "ENVELOPE") {
+				const envResult = parseEnvelope(tokens, idx);
+				if (envResult !== null) {
+					items.push({
+						kind: "envelope",
+						envelope: envResult.envelope
+					});
+					idx = envResult.nextIndex;
+				} else idx++;
+			} else if (itemName === "BODYSTRUCTURE" || itemName === "BODY" || itemName === "BODY.PEEK") if (tokens[idx]?.kind === "lparen") {
+				const bsResult = parseBodyStructureParts(tokens, idx);
+				items.push({
+					kind: "bodyStructure",
+					parts: bsResult.parts
+				});
+				idx = bsResult.nextIndex;
+			} else if (tokens[idx]?.kind === "lbracket") {
+				idx++;
+				const sectionParts = [];
+				while (idx < tokens.length && tokens[idx]?.kind !== "rbracket") {
+					const secTok = tokens[idx];
+					if (secTok !== void 0) {
+						if (secTok.kind === "atom" || secTok.kind === "quoted") sectionParts.push(secTok.value);
+						else if (secTok.kind === "number") sectionParts.push(String(secTok.value));
+						else if (secTok.kind === "lparen") sectionParts.push("(");
+						else if (secTok.kind === "rparen") sectionParts.push(")");
+						else if (secTok.kind === "nil") sectionParts.push("NIL");
+						else if (secTok.kind === "literal") sectionParts.push(asciiToString(secTok.value));
+					}
+					idx++;
+				}
+				if (tokens[idx]?.kind === "rbracket") idx++;
+				const section = sectionParts.join(" ");
+				const originTok = tokens[idx];
+				if (originTok?.kind === "atom" && /^<\d+(\.\d+)?>$/.test(originTok.value)) idx++;
+				const bodyTok = tokens[idx];
+				idx++;
+				let bytes = null;
+				if (bodyTok?.kind === "literal") bytes = bodyTok.value;
+				else if (bodyTok?.kind === "quoted" || bodyTok?.kind === "atom") bytes = stringToBytes(bodyTok.value);
+				else if (bodyTok?.kind === "nil") bytes = null;
+				items.push({
+					kind: "body",
+					section,
+					bytes
+				});
+			} else idx++;
+			else if (itemName === "X-GM-THRID") {
+				const id = tokenToString$1(tokens[idx]);
+				idx++;
+				if (id !== null && /^\d+$/.test(id)) items.push({
+					kind: "gmailThreadId",
+					id
+				});
+			} else {
+				items.push({
+					kind: "other",
+					name: itemName
+				});
+				idx++;
+			}
+		} else idx++;
+	}
+	return {
+		items,
+		nextIndex: idx
+	};
+};
+//#endregion
+//#region src/response.ts
+/**
+* IMAP response parser: converts token stream into typed tagged, untagged, and continuation responses.
+*/
+const tokenToString = (token) => {
+	if (token === void 0 || token.kind === "nil") return null;
+	if (token.kind === "quoted" || token.kind === "atom") return token.value;
+	if (token.kind === "number") return String(token.value);
+	if (token.kind === "literal") return asciiToString(token.value);
+	return null;
+};
+const tokensToText = (tokens, start) => {
+	const parts = [];
+	for (let i = start; i < tokens.length; i++) {
+		const tok = tokens[i];
+		if (tok === void 0) continue;
+		if (tok.kind === "atom" || tok.kind === "quoted") parts.push(tok.value);
+		else if (tok.kind === "number") parts.push(String(tok.value));
+		else if (tok.kind === "literal") parts.push(asciiToString(tok.value));
+		else if (tok.kind === "plus") parts.push("+");
+		else if (tok.kind === "nil") parts.push("NIL");
+		else if (tok.kind === "lparen") parts.push("(");
+		else if (tok.kind === "rparen") parts.push(")");
+		else if (tok.kind === "lbracket") parts.push("[");
+		else if (tok.kind === "rbracket") parts.push("]");
+	}
+	return parts.join(" ");
+};
+const parseResponseCode = (tokens, start) => {
+	if (tokens[start]?.kind !== "lbracket") return null;
+	let idx = start + 1;
+	const codeTok = tokens[idx];
+	if (codeTok?.kind !== "atom") return null;
+	const codeName = codeTok.value.toUpperCase();
+	idx++;
+	if (codeName === "CAPABILITY") {
+		const capabilities = [];
+		while (idx < tokens.length && tokens[idx]?.kind !== "rbracket") {
+			const capTok = tokens[idx];
+			if (capTok?.kind === "atom") capabilities.push(capTok.value);
+			idx++;
+		}
+		if (tokens[idx]?.kind === "rbracket") idx++;
+		return {
+			code: {
+				kind: "capability",
+				capabilities
+			},
+			nextIndex: idx
+		};
+	}
+	if (codeName === "PERMANENTFLAGS") {
+		const flags = [];
+		if (tokens[idx]?.kind === "lparen") {
+			idx++;
+			while (idx < tokens.length && tokens[idx]?.kind !== "rparen") {
+				const flagTok = tokens[idx];
+				if (flagTok?.kind === "atom") flags.push(flagTok.value);
+				idx++;
+			}
+			if (tokens[idx]?.kind === "rparen") idx++;
+		}
+		while (idx < tokens.length && tokens[idx]?.kind !== "rbracket") idx++;
+		if (tokens[idx]?.kind === "rbracket") idx++;
+		return {
+			code: {
+				kind: "permanentFlags",
+				flags
+			},
+			nextIndex: idx
+		};
+	}
+	if (codeName === "UIDVALIDITY") {
+		const valTok = tokens[idx];
+		const value = valTok?.kind === "number" ? valTok.value : 0;
+		idx++;
+		while (idx < tokens.length && tokens[idx]?.kind !== "rbracket") idx++;
+		if (tokens[idx]?.kind === "rbracket") idx++;
+		return {
+			code: {
+				kind: "uidValidity",
+				value
+			},
+			nextIndex: idx
+		};
+	}
+	if (codeName === "UIDNEXT") {
+		const valTok = tokens[idx];
+		const value = valTok?.kind === "number" ? valTok.value : 0;
+		idx++;
+		while (idx < tokens.length && tokens[idx]?.kind !== "rbracket") idx++;
+		if (tokens[idx]?.kind === "rbracket") idx++;
+		return {
+			code: {
+				kind: "uidNext",
+				value
+			},
+			nextIndex: idx
+		};
+	}
+	if (codeName === "READ-ONLY") {
+		while (idx < tokens.length && tokens[idx]?.kind !== "rbracket") idx++;
+		if (tokens[idx]?.kind === "rbracket") idx++;
+		return {
+			code: { kind: "readOnly" },
+			nextIndex: idx
+		};
+	}
+	if (codeName === "READ-WRITE") {
+		while (idx < tokens.length && tokens[idx]?.kind !== "rbracket") idx++;
+		if (tokens[idx]?.kind === "rbracket") idx++;
+		return {
+			code: { kind: "readWrite" },
+			nextIndex: idx
+		};
+	}
+	if (codeName === "ALERT") {
+		while (idx < tokens.length && tokens[idx]?.kind !== "rbracket") idx++;
+		if (tokens[idx]?.kind === "rbracket") idx++;
+		return {
+			code: { kind: "alert" },
+			nextIndex: idx
+		};
+	}
+	const args = [];
+	while (idx < tokens.length && tokens[idx]?.kind !== "rbracket") {
+		const str = tokenToString(tokens[idx]);
+		if (str !== null) args.push(str);
+		idx++;
+	}
+	if (tokens[idx]?.kind === "rbracket") idx++;
+	return {
+		code: {
+			kind: "other",
+			code: codeName,
+			args
+		},
+		nextIndex: idx
+	};
+};
+const parseResponse = (tokens) => {
+	if (tokens.length === 0) return {
+		ok: false,
+		reason: {
+			kind: "protocol",
+			detail: "Empty response line"
+		}
+	};
+	const first = tokens[0];
+	if (first === void 0) return {
+		ok: false,
+		reason: {
+			kind: "protocol",
+			detail: "Empty token stream"
+		}
+	};
+	if (first.kind === "plus") return {
+		ok: true,
+		value: {
+			kind: "continuation",
+			text: tokensToText(tokens, 1)
+		}
+	};
+	if (first.kind === "atom" && first.value === "*") {
+		const second = tokens[1];
+		if (second === void 0) return {
+			ok: false,
+			reason: {
+				kind: "protocol",
+				detail: "Bare * untagged marker"
+			}
+		};
+		if (second.kind === "atom") {
+			const upper = second.value.toUpperCase();
+			if (upper === "OK" || upper === "NO" || upper === "BAD" || upper === "BYE" || upper === "PREAUTH") {
+				let idx = 2;
+				let code = null;
+				if (tokens[idx]?.kind === "lbracket") {
+					const codeResult = parseResponseCode(tokens, idx);
+					if (codeResult !== null) {
+						code = codeResult.code;
+						idx = codeResult.nextIndex;
+					}
+				}
+				const text = tokensToText(tokens, idx);
+				return {
+					ok: true,
+					value: {
+						kind: "untagged",
+						untagged: {
+							kind: "status",
+							status: upper,
+							code,
+							text
+						}
+					}
+				};
+			}
+			if (upper === "CAPABILITY") {
+				const capabilities = [];
+				for (let i = 2; i < tokens.length; i++) {
+					const tok = tokens[i];
+					if (tok?.kind === "atom") capabilities.push(tok.value);
+				}
+				return {
+					ok: true,
+					value: {
+						kind: "untagged",
+						untagged: {
+							kind: "capability",
+							capabilities
+						}
+					}
+				};
+			}
+			if (upper === "FLAGS") {
+				const flags = [];
+				let idx = 2;
+				if (tokens[idx]?.kind === "lparen") {
+					idx++;
+					while (idx < tokens.length && tokens[idx]?.kind !== "rparen") {
+						const tok = tokens[idx];
+						if (tok?.kind === "atom") flags.push(tok.value);
+						idx++;
+					}
+				}
+				return {
+					ok: true,
+					value: {
+						kind: "untagged",
+						untagged: {
+							kind: "flags",
+							flags
+						}
+					}
+				};
+			}
+			if (upper === "LIST") {
+				let idx = 2;
+				const attributes = [];
+				if (tokens[idx]?.kind === "lparen") {
+					idx++;
+					while (idx < tokens.length && tokens[idx]?.kind !== "rparen") {
+						const tok = tokens[idx];
+						if (tok?.kind === "atom") attributes.push(tok.value);
+						idx++;
+					}
+					if (tokens[idx]?.kind === "rparen") idx++;
+				}
+				const delimiter = tokenToString(tokens[idx]);
+				idx++;
+				return {
+					ok: true,
+					value: {
+						kind: "untagged",
+						untagged: {
+							kind: "list",
+							mailbox: {
+								name: decodeModifiedUtf7(tokenToString(tokens[idx]) ?? ""),
+								delimiter,
+								attributes
+							}
+						}
+					}
+				};
+			}
+			if (upper === "SEARCH") {
+				const uids = [];
+				for (let i = 2; i < tokens.length; i++) {
+					const tok = tokens[i];
+					if (tok?.kind === "number") uids.push(tok.value);
+				}
+				return {
+					ok: true,
+					value: {
+						kind: "untagged",
+						untagged: {
+							kind: "search",
+							uids
+						}
+					}
+				};
+			}
+		}
+		if (second.kind === "number") {
+			const num = second.value;
+			const third = tokens[2];
+			if (third?.kind === "atom") {
+				const verb = third.value.toUpperCase();
+				if (verb === "EXISTS") return {
+					ok: true,
+					value: {
+						kind: "untagged",
+						untagged: {
+							kind: "exists",
+							count: num
+						}
+					}
+				};
+				if (verb === "RECENT") return {
+					ok: true,
+					value: {
+						kind: "untagged",
+						untagged: {
+							kind: "recent",
+							count: num
+						}
+					}
+				};
+				if (verb === "EXPUNGE") return {
+					ok: true,
+					value: {
+						kind: "untagged",
+						untagged: {
+							kind: "expunge",
+							seq: num
+						}
+					}
+				};
+				if (verb === "FETCH") return {
+					ok: true,
+					value: {
+						kind: "untagged",
+						untagged: {
+							kind: "fetch",
+							seq: num,
+							items: parseFetchItems(tokens, 3).items
+						}
+					}
+				};
+			}
+		}
+		const name = second.kind === "atom" ? second.value : String(tokenToString(second));
+		const rest = [];
+		for (let i = 2; i < tokens.length; i++) {
+			const str = tokenToString(tokens[i]);
+			if (str !== null) rest.push(str);
+		}
+		return {
+			ok: true,
+			value: {
+				kind: "untagged",
+				untagged: {
+					kind: "unknown",
+					name,
+					rest
+				}
+			}
+		};
+	}
+	if (first.kind === "atom") {
+		const tag = first.value;
+		const second = tokens[1];
+		if (second?.kind === "atom") {
+			const statusUpper = second.value.toUpperCase();
+			if (statusUpper === "OK" || statusUpper === "NO" || statusUpper === "BAD") {
+				let idx = 2;
+				let code = null;
+				if (tokens[idx]?.kind === "lbracket") {
+					const codeResult = parseResponseCode(tokens, idx);
+					if (codeResult !== null) {
+						code = codeResult.code;
+						idx = codeResult.nextIndex;
+					}
+				}
+				const text = tokensToText(tokens, idx);
+				return {
+					ok: true,
+					value: {
+						kind: "tagged",
+						tag,
+						status: statusUpper,
+						code,
+						text
+					}
+				};
+			}
+		}
+	}
+	return {
+		ok: false,
+		reason: {
+			kind: "protocol",
+			detail: `Unrecognised IMAP response line starting with ${first.kind}`
+		}
+	};
+};
+//#endregion
+//#region src/tokenizer.ts
+/**
+* Hand-written tokenizer over byte offsets for IMAP4rev2/rev1 stream.
+*
+* Implements total parsing over attacker-controlled bytes:
+* - Line ends at CRLF; bare LF is a protocol failure.
+* - Logical line frames `{n}` literals (and `{n+}` LITERAL+).
+* - Enforces maxLiteralBytes (default 32 MiB).
+* - A number above 2^32 - 1 is an atom of digits, not a failure: RFC 9051's `number` is
+*   32-bit, but Gmail's X-GM-THRID is 64-bit and arrives as a bare number.
+* - Never throws on malformed input; returns typed ImapResult.
+*/
+const DEFAULT_MAX_LITERAL_BYTES = 32 * 1024 * 1024;
+const MAX_UINT32 = 4294967295;
+/**
+* Checks for bare LF in a slice of bytes.
+*/
+const checkBareLf = (bytes, start, end) => {
+	for (let i = start; i < end; i++) if (bytes[i] === 10 && (i === 0 || bytes[i - 1] !== 13)) return {
+		kind: "protocol",
+		detail: `Bare LF at index ${i}`
+	};
+	return null;
+};
+/**
+* Parses literal length from `{<digits>}` or `{<digits>+}` before CRLF.
+* Returns valid length, invalid failure, or none if not a literal header.
+*/
+const parseLiteralHeader = (bytes, textStart, crlfIndex, maxLiteralBytes) => {
+	if (crlfIndex === 0) return { kind: "none" };
+	let i = crlfIndex - 1;
+	if (bytes[i] !== 125) return { kind: "none" };
+	i--;
+	if (i >= textStart && bytes[i] === 43) i--;
+	const digitsEnd = i + 1;
+	while (i >= textStart && isDigit(bytes[i] ?? 0)) i--;
+	if (i < textStart || bytes[i] !== 123) {
+		for (let j = crlfIndex - 2; j >= textStart; j--) if (bytes[j] === 123) return {
+			kind: "invalid",
+			detail: "Invalid literal header syntax"
+		};
+		return { kind: "none" };
+	}
+	const braceIndex = i;
+	const digitsStart = i + 1;
+	if (digitsStart >= digitsEnd) return {
+		kind: "invalid",
+		detail: "Empty literal length in literal header"
+	};
+	const digitsStr = asciiToString(bytes.slice(digitsStart, digitsEnd));
+	const num = Number.parseInt(digitsStr, 10);
+	if (!Number.isSafeInteger(num) || num > MAX_UINT32) return {
+		kind: "invalid",
+		detail: `Literal length ${digitsStr} is not a valid 32-bit unsigned integer`
+	};
+	if (num > maxLiteralBytes) return {
+		kind: "invalid",
+		detail: `Literal of ${num} bytes exceeds maxLiteralBytes (${maxLiteralBytes})`
+	};
+	return {
+		kind: "valid",
+		length: num,
+		braceIndex
+	};
+};
+/**
+* Scans `buffer` for a complete logical line (including any literals).
+*/
+const readLogicalLine = (buffer, maxLiteralBytes = DEFAULT_MAX_LITERAL_BYTES, resume) => {
+	const segments = resume?.segments ? [...resume.segments] : [];
+	let scanOffset = resume?.resumeAt ?? 0;
+	let textStart = resume?.textStart ?? resume?.resumeAt ?? 0;
+	if (resume?.pendingLiteral !== void 0) {
+		const { start, end } = resume.pendingLiteral;
+		if (buffer.length < end) return {
+			status: "incomplete",
+			resumeAt: scanOffset,
+			needBytes: end,
+			segments,
+			textStart,
+			pendingLiteral: resume.pendingLiteral
+		};
+		segments.push({
+			kind: "literal",
+			bytes: buffer.slice(start, end)
+		});
+		scanOffset = end;
+		textStart = end;
+	}
+	while (scanOffset < buffer.length) {
+		let crlfIndex = -1;
+		for (let i = scanOffset; i < buffer.length - 1; i++) if (buffer[i] === 13 && buffer[i + 1] === 10) {
+			crlfIndex = i;
+			break;
+		}
+		if (crlfIndex === -1) {
+			const lfFailure = checkBareLf(buffer, scanOffset, buffer.length);
+			if (lfFailure !== null) return {
+				status: "failure",
+				failure: lfFailure
+			};
+			return {
+				status: "incomplete",
+				resumeAt: Math.max(textStart, buffer.length - 1),
+				needBytes: buffer.length + 1,
+				segments,
+				textStart
+			};
+		}
+		const lfFailure = checkBareLf(buffer, scanOffset, crlfIndex);
+		if (lfFailure !== null) return {
+			status: "failure",
+			failure: lfFailure
+		};
+		const headerResult = parseLiteralHeader(buffer, textStart, crlfIndex, maxLiteralBytes);
+		if (headerResult.kind === "invalid") return {
+			status: "failure",
+			failure: {
+				kind: "protocol",
+				detail: headerResult.detail
+			}
+		};
+		if (headerResult.kind === "valid") {
+			const braceIndex = headerResult.braceIndex;
+			const literalLength = headerResult.length;
+			if (braceIndex > textStart) segments.push({
+				kind: "text",
+				bytes: buffer.slice(textStart, braceIndex)
+			});
+			const literalDataStart = crlfIndex + 2;
+			const literalDataEnd = literalDataStart + literalLength;
+			if (buffer.length < literalDataEnd) return {
+				status: "incomplete",
+				resumeAt: crlfIndex,
+				needBytes: literalDataEnd,
+				segments,
+				textStart: literalDataEnd,
+				pendingLiteral: {
+					start: literalDataStart,
+					end: literalDataEnd
+				}
+			};
+			segments.push({
+				kind: "literal",
+				bytes: buffer.slice(literalDataStart, literalDataEnd)
+			});
+			scanOffset = literalDataEnd;
+			textStart = literalDataEnd;
+		} else {
+			if (crlfIndex >= textStart) segments.push({
+				kind: "text",
+				bytes: buffer.slice(textStart, crlfIndex)
+			});
+			const consumedBytes = crlfIndex + 2;
+			let rawText = "";
+			for (const seg of segments) if (seg.kind === "text") rawText += asciiToString(seg.bytes);
+			else rawText += `<literal:${seg.bytes.length}B>`;
+			return {
+				status: "complete",
+				line: {
+					segments,
+					rawText
+				},
+				consumedBytes
+			};
+		}
+	}
+	return {
+		status: "incomplete",
+		resumeAt: Math.max(textStart, buffer.length - 1),
+		needBytes: buffer.length + 1,
+		segments,
+		textStart
+	};
+};
+/**
+* Tokenizes a text segment into IMAP tokens.
+*/
+const tokenizeTextSegment = (bytes, tokens) => {
+	let i = 0;
+	const len = bytes.length;
+	while (i < len) {
+		const byte = bytes[i] ?? 0;
+		if (byte === 32 || byte === 9 || byte === 13 || byte === 10) {
+			i++;
+			continue;
+		}
+		if (byte === 40) {
+			tokens.push({ kind: "lparen" });
+			i++;
+			continue;
+		}
+		if (byte === 41) {
+			tokens.push({ kind: "rparen" });
+			i++;
+			continue;
+		}
+		if (byte === 91) {
+			tokens.push({ kind: "lbracket" });
+			i++;
+			continue;
+		}
+		if (byte === 93) {
+			tokens.push({ kind: "rbracket" });
+			i++;
+			continue;
+		}
+		if (byte === 34) {
+			i++;
+			let quotedStr = "";
+			let isTerminated = false;
+			while (i < len) {
+				const qb = bytes[i] ?? 0;
+				if (qb === 10 && (i === 0 || bytes[i - 1] !== 13)) return {
+					ok: false,
+					reason: {
+						kind: "protocol",
+						detail: "Bare LF in quoted string"
+					}
+				};
+				if (qb === 92) {
+					i++;
+					if (i >= len) return {
+						ok: false,
+						reason: {
+							kind: "protocol",
+							detail: "Unterminated escape in quoted string"
+						}
+					};
+					quotedStr += String.fromCharCode(bytes[i] ?? 0);
+					i++;
+				} else if (qb === 34) {
+					isTerminated = true;
+					i++;
+					break;
+				} else {
+					quotedStr += String.fromCharCode(qb);
+					i++;
+				}
+			}
+			if (!isTerminated) return {
+				ok: false,
+				reason: {
+					kind: "protocol",
+					detail: "Unterminated quoted string"
+				}
+			};
+			tokens.push({
+				kind: "quoted",
+				value: quotedStr
+			});
+			continue;
+		}
+		if (byte === 43) {
+			const next = i + 1 < len ? bytes[i + 1] ?? 0 : 0;
+			if (!(next !== 0 && next !== 32 && next !== 9 && next !== 40 && next !== 41 && next !== 91 && next !== 93 && next !== 13 && next !== 10)) {
+				tokens.push({ kind: "plus" });
+				i++;
+				continue;
+			}
+		}
+		const atomStart = i;
+		while (i < len) {
+			const b = bytes[i] ?? 0;
+			if (b === 32 || b === 9 || b === 13 || b === 10 || b === 40 || b === 41 || b === 91 || b === 93 || b === 34) break;
+			i++;
+		}
+		const atomStr = asciiToString(bytes.slice(atomStart, i));
+		if (atomStr.toUpperCase() === "NIL") tokens.push({ kind: "nil" });
+		else if (/^\d+$/.test(atomStr)) {
+			const num = Number.parseInt(atomStr, 10);
+			if (num > MAX_UINT32) tokens.push({
+				kind: "atom",
+				value: atomStr
+			});
+			else tokens.push({
+				kind: "number",
+				value: num
+			});
+		} else tokens.push({
+			kind: "atom",
+			value: atomStr
+		});
+	}
+	return {
+		ok: true,
+		value: void 0
+	};
+};
+/**
+* Tokenizes a complete LogicalLine into ImapTokens.
+*/
+const tokenizeLogicalLine = (line) => {
+	const tokens = [];
+	for (const seg of line.segments) if (seg.kind === "literal") tokens.push({
+		kind: "literal",
+		value: seg.bytes
+	});
+	else {
+		const result = tokenizeTextSegment(seg.bytes, tokens);
+		if (!result.ok) return result;
+	}
+	return {
+		ok: true,
+		value: tokens
+	};
+};
+//#endregion
+//#region src/client.ts
+/**
+* The msg-ids out of a `HEADER.FIELDS (REFERENCES)` section: the header unfolded, then every
+* `<...>` in order. A truncated or absent header is simply fewer ids.
+*/
+const parseReferencesHeader = (bytes) => {
+	if (bytes === null) return [];
+	const line = asciiToString(bytes).replace(/\r?\n[ \t]+/g, " ").split(/\r?\n/).find((l) => /^references:/i.test(l));
+	if (line === void 0) return [];
+	return line.slice(line.indexOf(":") + 1).match(/<[^<>\s]+>/g) ?? [];
+};
+/**
+* The summaries in a FETCH response's untagged lines, whether the command asked by uid or by
+* sequence number: `* <seq> FETCH (UID n …)` carries both either way.
+*/
+const summariesFrom = (untagged) => untagged.flatMap((item) => {
+	if (item.kind !== "fetch") return [];
+	let uid = 0;
+	let flags = [];
+	let internalDate = null;
+	let size = null;
+	let envelope = null;
+	let references = [];
+	let gmailThreadId = null;
+	for (const fItem of item.items) if (fItem.kind === "uid") uid = fItem.uid;
+	else if (fItem.kind === "flags") flags = fItem.flags;
+	else if (fItem.kind === "internalDate") internalDate = fItem.date;
+	else if (fItem.kind === "size") size = fItem.size;
+	else if (fItem.kind === "envelope") envelope = fItem.envelope;
+	else if (fItem.kind === "gmailThreadId") gmailThreadId = fItem.id;
+	else if (fItem.kind === "body" && fItem.section.toUpperCase().startsWith("HEADER.FIELDS")) references = parseReferencesHeader(fItem.bytes);
+	return [{
+		seq: item.seq,
+		uid,
+		flags,
+		internalDate,
+		size,
+		envelope,
+		references,
+		gmailThreadId
+	}];
+});
+const createImapClient = (transport, options) => {
+	const maxLiteralBytes = options?.maxLiteralBytes ?? 33554432;
+	const onUntagged = options?.onUntagged;
+	let chunks = [];
+	let totalBufferedBytes = 0;
+	let resumeState;
+	let isClosed = false;
+	let failureReason = null;
+	let knownCapabilities = [];
+	let tagCounter = 1;
+	const nextTag = () => `A${String(tagCounter++).padStart(4, "0")}`;
+	/**
+	* Reads and parses the next complete IMAP response from the transport.
+	*/
+	const readNextResponse = async () => {
+		if (failureReason !== null) return {
+			ok: false,
+			reason: failureReason
+		};
+		if (isClosed) return {
+			ok: false,
+			reason: { kind: "closed" }
+		};
+		while (true) {
+			if (resumeState === void 0 || totalBufferedBytes >= resumeState.needBytes) {
+				const buffer = chunks.length === 1 && chunks[0] !== void 0 ? chunks[0] : concatByteArrays(chunks);
+				const lineResult = readLogicalLine(buffer, maxLiteralBytes, resumeState);
+				if (lineResult.status === "failure") {
+					isClosed = true;
+					failureReason = lineResult.failure;
+					return {
+						ok: false,
+						reason: lineResult.failure
+					};
+				}
+				if (lineResult.status === "complete") {
+					const remainingBytes = buffer.length - lineResult.consumedBytes;
+					if (remainingBytes > 0) {
+						chunks = [buffer.slice(lineResult.consumedBytes)];
+						totalBufferedBytes = remainingBytes;
+					} else {
+						chunks = [];
+						totalBufferedBytes = 0;
+					}
+					resumeState = void 0;
+					const tokenResult = tokenizeLogicalLine(lineResult.line);
+					if (!tokenResult.ok) {
+						isClosed = true;
+						failureReason = tokenResult.reason;
+						return {
+							ok: false,
+							reason: tokenResult.reason
+						};
+					}
+					const parseResult = parseResponse(tokenResult.value);
+					if (!parseResult.ok) {
+						isClosed = true;
+						failureReason = parseResult.reason;
+						return {
+							ok: false,
+							reason: parseResult.reason
+						};
+					}
+					return parseResult;
+				}
+				resumeState = lineResult;
+			}
+			const chunk = await transport.read().catch(() => null);
+			if (chunk === null) {
+				isClosed = true;
+				failureReason = { kind: "closed" };
+				return {
+					ok: false,
+					reason: { kind: "closed" }
+				};
+			}
+			chunks.push(chunk);
+			totalBufferedBytes += chunk.length;
+		}
+	};
+	/**
+	* Greeting is captured immediately as soon as client is created.
+	*/
+	const greetingPromise = (async () => {
+		const res = await readNextResponse();
+		if (!res.ok) return res;
+		if (res.value.kind === "untagged" && res.value.untagged.kind === "status") {
+			const status = res.value.untagged.status;
+			if (status === "OK" || status === "PREAUTH") {
+				const code = res.value.untagged.code;
+				const caps = code !== null && code.kind === "capability" ? code.capabilities : null;
+				if (caps !== null) knownCapabilities = [...caps];
+				return {
+					ok: true,
+					value: {
+						text: res.value.untagged.text,
+						capabilities: caps
+					}
+				};
+			}
+			if (status === "BYE") {
+				const reason = {
+					kind: "bye",
+					text: res.value.untagged.text
+				};
+				isClosed = true;
+				failureReason = reason;
+				return {
+					ok: false,
+					reason
+				};
+			}
+		}
+		return {
+			ok: false,
+			reason: {
+				kind: "protocol",
+				detail: "Invalid IMAP greeting received from server"
+			}
+		};
+	})();
+	let commandQueue = Promise.resolve();
+	const enqueueCommand = (task) => {
+		const result = commandQueue.then(task);
+		commandQueue = result.then(() => void 0, () => void 0);
+		return result.catch(() => ({
+			ok: false,
+			reason: { kind: "closed" }
+		}));
+	};
+	/**
+	* Sends a command and collects untagged responses until matching tagged response.
+	*/
+	const executeCommand = async (build, options) => {
+		if (isClosed) return {
+			ok: false,
+			reason: { kind: "closed" }
+		};
+		if (failureReason !== null) return {
+			ok: false,
+			reason: failureReason.kind === "protocol" ? { kind: "closed" } : failureReason
+		};
+		const greetRes = await greetingPromise;
+		if (!greetRes.ok) return greetRes;
+		const tag = nextTag();
+		const command = build(tag);
+		const hasLiteralPlus = knownCapabilities.some((c) => c.toUpperCase() === "LITERAL+");
+		const hasLiteralMinus = knownCapabilities.some((c) => c.toUpperCase() === "LITERAL-");
+		const untaggedList = [];
+		let seenCapability = false;
+		let allowedByeReason = null;
+		for (const line of command.lines) {
+			try {
+				await transport.write(line.text);
+			} catch {
+				isClosed = true;
+				failureReason = { kind: "closed" };
+				return {
+					ok: false,
+					reason: { kind: "closed" }
+				};
+			}
+			if (line.literal !== void 0) {
+				const len = line.literal.length;
+				if (hasLiteralPlus || hasLiteralMinus && len <= 4096) try {
+					await transport.write(stringToBytes(`{${len}+}\r\n`));
+					await transport.write(line.literal);
+				} catch {
+					isClosed = true;
+					failureReason = { kind: "closed" };
+					return {
+						ok: false,
+						reason: { kind: "closed" }
+					};
+				}
+				else {
+					try {
+						await transport.write(stringToBytes(`{${len}}\r\n`));
+					} catch {
+						isClosed = true;
+						failureReason = { kind: "closed" };
+						return {
+							ok: false,
+							reason: { kind: "closed" }
+						};
+					}
+					let continuationReceived = false;
+					while (!continuationReceived) {
+						const respResult = await readNextResponse();
+						if (!respResult.ok) {
+							if (respResult.reason.kind === "closed" && allowedByeReason !== null) return {
+								ok: false,
+								reason: allowedByeReason
+							};
+							return respResult;
+						}
+						const resp = respResult.value;
+						if (resp.kind === "untagged") {
+							untaggedList.push(resp.untagged);
+							onUntagged?.(resp.untagged);
+							if (resp.untagged.kind === "capability") {
+								knownCapabilities = [...resp.untagged.capabilities];
+								seenCapability = true;
+							}
+							if (resp.untagged.kind === "status" && resp.untagged.status === "BYE") {
+								if (options?.allowBye !== true) {
+									const reason = {
+										kind: "bye",
+										text: resp.untagged.text
+									};
+									isClosed = true;
+									failureReason = reason;
+									return {
+										ok: false,
+										reason
+									};
+								}
+								allowedByeReason = {
+									kind: "bye",
+									text: resp.untagged.text
+								};
+							}
+						} else if (resp.kind === "continuation") {
+							continuationReceived = true;
+							try {
+								await transport.write(line.literal);
+							} catch {
+								isClosed = true;
+								failureReason = { kind: "closed" };
+								return {
+									ok: false,
+									reason: { kind: "closed" }
+								};
+							}
+						} else if (resp.kind === "tagged") {
+							if (resp.tag !== tag) {
+								isClosed = true;
+								failureReason = {
+									kind: "protocol",
+									detail: `Received unexpected tag ${resp.tag}, expected ${tag}`
+								};
+								return {
+									ok: false,
+									reason: failureReason
+								};
+							}
+							if (resp.status === "NO") return {
+								ok: false,
+								reason: {
+									kind: "no",
+									text: resp.text
+								}
+							};
+							if (resp.status === "BAD") return {
+								ok: false,
+								reason: {
+									kind: "bad",
+									text: resp.text
+								}
+							};
+						}
+					}
+				}
+			}
+		}
+		while (true) {
+			const respResult = await readNextResponse();
+			if (!respResult.ok) {
+				if (respResult.reason.kind === "closed" && allowedByeReason !== null) return {
+					ok: false,
+					reason: allowedByeReason
+				};
+				return respResult;
+			}
+			const resp = respResult.value;
+			if (resp.kind === "untagged") {
+				untaggedList.push(resp.untagged);
+				onUntagged?.(resp.untagged);
+				if (resp.untagged.kind === "capability") {
+					knownCapabilities = [...resp.untagged.capabilities];
+					seenCapability = true;
+				}
+				if (resp.untagged.kind === "status" && resp.untagged.status === "BYE") {
+					if (options?.allowBye !== true) {
+						const reason = {
+							kind: "bye",
+							text: resp.untagged.text
+						};
+						isClosed = true;
+						failureReason = reason;
+						return {
+							ok: false,
+							reason
+						};
+					}
+					allowedByeReason = {
+						kind: "bye",
+						text: resp.untagged.text
+					};
+				}
+			} else if (resp.kind === "continuation") if (options?.onContinuation !== void 0) {
+				const contRes = await options.onContinuation();
+				if (!contRes.ok) return contRes;
+			} else {
+				isClosed = true;
+				failureReason = {
+					kind: "protocol",
+					detail: "Unexpected continuation response from server"
+				};
+				return {
+					ok: false,
+					reason: failureReason
+				};
+			}
+			else if (resp.kind === "tagged") {
+				if (resp.tag !== tag) {
+					isClosed = true;
+					failureReason = {
+						kind: "protocol",
+						detail: `Received unexpected tag ${resp.tag}, expected ${tag}`
+					};
+					return {
+						ok: false,
+						reason: failureReason
+					};
+				}
+				if (resp.code !== null && resp.code.kind === "capability") {
+					knownCapabilities = [...resp.code.capabilities];
+					seenCapability = true;
+				}
+				if (resp.status === "OK") return {
+					ok: true,
+					value: {
+						tagged: resp,
+						untagged: untaggedList,
+						seenCapability
+					}
+				};
+				if (resp.status === "NO") return {
+					ok: false,
+					reason: {
+						kind: "no",
+						text: resp.text
+					}
+				};
+				if (resp.status === "BAD") return {
+					ok: false,
+					reason: {
+						kind: "bad",
+						text: resp.text
+					}
+				};
+			}
+		}
+	};
+	return {
+		greeting: () => greetingPromise,
+		capability: () => enqueueCommand(async () => {
+			const res = await executeCommand(buildCapabilityCommand);
+			if (!res.ok) return res;
+			return {
+				ok: true,
+				value: [...knownCapabilities]
+			};
+		}),
+		capabilities: () => [...knownCapabilities],
+		hasCapability: (name) => knownCapabilities.some((c) => c.toUpperCase() === name.toUpperCase()),
+		authenticate: (username, password) => enqueueCommand(async () => {
+			const greetRes = await greetingPromise;
+			if (!greetRes.ok) return greetRes;
+			if (knownCapabilities.length === 0) {
+				const capRes = await executeCommand(buildCapabilityCommand);
+				if (!capRes.ok) return capRes;
+			}
+			const hasAuthPlain = knownCapabilities.some((c) => c.toUpperCase() === "AUTH=PLAIN" || c.toUpperCase() === "AUTHENTICATE=PLAIN");
+			const hasSaslIr = knownCapabilities.some((c) => c.toUpperCase() === "SASL-IR");
+			const hasLoginDisabled = knownCapabilities.some((c) => c.toUpperCase() === "LOGINDISABLED");
+			let authCmdRes;
+			if (hasAuthPlain) if (hasSaslIr) authCmdRes = await executeCommand((tag) => buildAuthenticatePlainSaslIrCommand(tag, username, password));
+			else authCmdRes = await executeCommand((tag) => buildAuthenticatePlainInitialCommand(tag), { onContinuation: async () => {
+				try {
+					const respCmd = buildAuthenticatePlainResponse(username, password);
+					for (const line of respCmd.lines) await transport.write(line.text);
+					return {
+						ok: true,
+						value: void 0
+					};
+				} catch {
+					isClosed = true;
+					failureReason = { kind: "closed" };
+					return {
+						ok: false,
+						reason: { kind: "closed" }
+					};
+				}
+			} });
+			else if (!hasLoginDisabled) authCmdRes = await executeCommand((tag) => buildLoginCommand(tag, username, password));
+			else return {
+				ok: false,
+				reason: {
+					kind: "unsupported",
+					detail: "Server does not support AUTH=PLAIN and LOGIN is disabled"
+				}
+			};
+			if (!authCmdRes.ok) return authCmdRes;
+			if (!authCmdRes.value.seenCapability) {
+				const postAuthCapRes = await executeCommand(buildCapabilityCommand);
+				if (!postAuthCapRes.ok) return postAuthCapRes;
+			}
+			return {
+				ok: true,
+				value: void 0
+			};
+		}),
+		list: (reference, pattern) => enqueueCommand(async () => {
+			const res = await executeCommand((tag) => buildListCommand(tag, reference, pattern));
+			if (!res.ok) return res;
+			const mailboxes = [];
+			for (const item of res.value.untagged) if (item.kind === "list") mailboxes.push(item.mailbox);
+			return {
+				ok: true,
+				value: mailboxes
+			};
+		}),
+		select: (mailbox, options) => enqueueCommand(async () => {
+			const isReadOnlyRequested = options?.readOnly ?? false;
+			const res = await executeCommand((tag) => buildSelectCommand(tag, mailbox, isReadOnlyRequested));
+			if (!res.ok) return res;
+			let exists = 0;
+			let flags = [];
+			let permanentFlags = [];
+			let uidValidity = null;
+			let uidNext = null;
+			let isReadOnly = isReadOnlyRequested;
+			const applyCode = (code) => {
+				if (code === null) return;
+				if (code.kind === "uidValidity") uidValidity = code.value;
+				else if (code.kind === "uidNext") uidNext = code.value;
+				else if (code.kind === "permanentFlags") permanentFlags = [...code.flags];
+				else if (code.kind === "readOnly") isReadOnly = true;
+				else if (code.kind === "readWrite") isReadOnly = false;
+			};
+			for (const item of res.value.untagged) if (item.kind === "exists") exists = item.count;
+			else if (item.kind === "flags") flags = [...item.flags];
+			else if (item.kind === "status") applyCode(item.code);
+			applyCode(res.value.tagged.code);
+			return {
+				ok: true,
+				value: {
+					name: mailbox,
+					exists,
+					uidValidity,
+					uidNext,
+					flags,
+					permanentFlags,
+					readOnly: isReadOnly
+				}
+			};
+		}),
+		fetchSummaries: (uidSet) => enqueueCommand(async () => {
+			const gmail = knownCapabilities.some((c) => c.toUpperCase() === "X-GM-EXT-1");
+			const res = await executeCommand((tag) => buildFetchSummariesCommand(tag, uidSet, { gmail }));
+			if (!res.ok) return res;
+			return {
+				ok: true,
+				value: summariesFrom(res.value.untagged)
+			};
+		}),
+		fetchSummariesBySeq: (seqSet) => enqueueCommand(async () => {
+			const gmail = knownCapabilities.some((c) => c.toUpperCase() === "X-GM-EXT-1");
+			const res = await executeCommand((tag) => buildFetchSummariesCommand(tag, seqSet, {
+				gmail,
+				bySeq: true
+			}));
+			if (!res.ok) return res;
+			return {
+				ok: true,
+				value: summariesFrom(res.value.untagged)
+			};
+		}),
+		fetchFlags: (uidSet) => enqueueCommand(async () => {
+			const res = await executeCommand((tag) => buildFetchFlagsCommand(tag, uidSet));
+			if (!res.ok) return res;
+			const result = [];
+			for (const item of res.value.untagged) {
+				if (item.kind !== "fetch") continue;
+				let uid = 0;
+				let flags = [];
+				for (const fItem of item.items) if (fItem.kind === "uid") uid = fItem.uid;
+				else if (fItem.kind === "flags") flags = fItem.flags;
+				if (uid !== 0) result.push({
+					uid,
+					flags
+				});
+			}
+			return {
+				ok: true,
+				value: result
+			};
+		}),
+		fetchRaw: (uid) => enqueueCommand(async () => {
+			const res = await executeCommand((tag) => buildFetchRawCommand(tag, uid));
+			if (!res.ok) return res;
+			for (const item of res.value.untagged) if (item.kind === "fetch") {
+				for (const fItem of item.items) if (fItem.kind === "body" && fItem.bytes !== null) return {
+					ok: true,
+					value: fItem.bytes
+				};
+			}
+			return {
+				ok: false,
+				reason: {
+					kind: "no",
+					text: "Raw message body not found"
+				}
+			};
+		}),
+		storeFlags: (uidSet, mode, flags) => enqueueCommand(async () => {
+			const res = await executeCommand((tag) => buildStoreFlagsCommand(tag, uidSet, mode, flags));
+			if (!res.ok) return res;
+			return {
+				ok: true,
+				value: void 0
+			};
+		}),
+		append: (mailbox, message, flags) => enqueueCommand(async () => {
+			const res = await executeCommand((tag) => buildAppendCommand(tag, mailbox, flags, message));
+			if (!res.ok) return res;
+			return {
+				ok: true,
+				value: void 0
+			};
+		}),
+		move: (uidSet, mailbox) => enqueueCommand(async () => {
+			const greetRes = await greetingPromise;
+			if (!greetRes.ok) return greetRes;
+			if (!knownCapabilities.some((c) => {
+				const name = c.toUpperCase();
+				return name === "MOVE" || name === "IMAP4REV2";
+			})) return {
+				ok: false,
+				reason: {
+					kind: "no",
+					text: "MOVE is not supported by this server"
+				}
+			};
+			const res = await executeCommand((tag) => buildMoveCommand(tag, uidSet, mailbox));
+			if (!res.ok) return res;
+			return {
+				ok: true,
+				value: void 0
+			};
+		}),
+		create: (mailbox) => enqueueCommand(async () => {
+			const res = await executeCommand((tag) => buildCreateCommand(tag, mailbox));
+			if (!res.ok) return res;
+			return {
+				ok: true,
+				value: void 0
+			};
+		}),
+		noop: () => enqueueCommand(async () => {
+			const res = await executeCommand(buildNoopCommand);
+			if (!res.ok) return res;
+			return {
+				ok: true,
+				value: void 0
+			};
+		}),
+		idle: () => {
+			if (isClosed || failureReason !== null) {
+				const ended = Promise.resolve({
+					ok: false,
+					reason: { kind: "closed" }
+				});
+				return {
+					done: async () => ended,
+					ended
+				};
+			}
+			let doneRequested = false;
+			let doneSent = false;
+			/** True once '+' arrived; DONE may be written (including from `done()` while a read waits). */
+			let isIdling = false;
+			/** True once the IDLE has settled either way; a `done()` after that has nothing to end. */
+			let isEnded = false;
+			const sendDone = async () => {
+				if (doneSent || !isIdling || isEnded) return null;
+				doneSent = true;
+				try {
+					await transport.write(buildIdleDoneLine());
+					return null;
+				} catch {
+					isClosed = true;
+					failureReason = { kind: "closed" };
+					return {
+						ok: false,
+						reason: { kind: "closed" }
+					};
+				}
+			};
+			const ended = enqueueCommand(async () => {
+				if (failureReason !== null) return {
+					ok: false,
+					reason: failureReason.kind === "protocol" ? { kind: "closed" } : failureReason
+				};
+				if (isClosed) return {
+					ok: false,
+					reason: { kind: "closed" }
+				};
+				const greetRes = await greetingPromise;
+				if (!greetRes.ok) return greetRes;
+				const tag = nextTag();
+				const command = buildIdleCommand(tag);
+				for (const line of command.lines) try {
+					await transport.write(line.text);
+				} catch {
+					isClosed = true;
+					failureReason = { kind: "closed" };
+					return {
+						ok: false,
+						reason: { kind: "closed" }
+					};
+				}
+				while (true) {
+					const respResult = await readNextResponse();
+					if (!respResult.ok) return respResult;
+					const resp = respResult.value;
+					if (resp.kind === "untagged") {
+						onUntagged?.(resp.untagged);
+						if (resp.untagged.kind === "status" && resp.untagged.status === "BYE") {
+							const reason = {
+								kind: "bye",
+								text: resp.untagged.text
+							};
+							isClosed = true;
+							failureReason = reason;
+							return {
+								ok: false,
+								reason
+							};
+						}
+						continue;
+					}
+					if (resp.kind === "continuation") break;
+					if (resp.kind === "tagged") {
+						if (resp.tag !== tag) {
+							isClosed = true;
+							failureReason = {
+								kind: "protocol",
+								detail: `Received unexpected tag ${resp.tag}, expected ${tag}`
+							};
+							return {
+								ok: false,
+								reason: failureReason
+							};
+						}
+						if (resp.status === "NO") return {
+							ok: false,
+							reason: {
+								kind: "no",
+								text: resp.text
+							}
+						};
+						if (resp.status === "BAD") return {
+							ok: false,
+							reason: {
+								kind: "bad",
+								text: resp.text
+							}
+						};
+						isClosed = true;
+						failureReason = {
+							kind: "protocol",
+							detail: "IDLE completed without a continuation"
+						};
+						return {
+							ok: false,
+							reason: failureReason
+						};
+					}
+				}
+				isIdling = true;
+				if (doneRequested) {
+					const sendFail = await sendDone();
+					if (sendFail !== null) return sendFail;
+				}
+				while (true) {
+					const respResult = await readNextResponse();
+					if (!respResult.ok) return respResult;
+					const resp = respResult.value;
+					if (resp.kind === "untagged") {
+						onUntagged?.(resp.untagged);
+						if (resp.untagged.kind === "status" && resp.untagged.status === "BYE") {
+							const reason = {
+								kind: "bye",
+								text: resp.untagged.text
+							};
+							isClosed = true;
+							failureReason = reason;
+							return {
+								ok: false,
+								reason
+							};
+						}
+						continue;
+					}
+					if (resp.kind === "continuation") {
+						isClosed = true;
+						failureReason = {
+							kind: "protocol",
+							detail: "Unexpected continuation while IDLE"
+						};
+						return {
+							ok: false,
+							reason: failureReason
+						};
+					}
+					if (resp.kind === "tagged") {
+						if (resp.tag !== tag) {
+							isClosed = true;
+							failureReason = {
+								kind: "protocol",
+								detail: `Received unexpected tag ${resp.tag}, expected ${tag}`
+							};
+							return {
+								ok: false,
+								reason: failureReason
+							};
+						}
+						if (!doneSent) {
+							isClosed = true;
+							failureReason = {
+								kind: "protocol",
+								detail: "Tagged response while IDLE before DONE"
+							};
+							return {
+								ok: false,
+								reason: failureReason
+							};
+						}
+						if (resp.status === "OK") return {
+							ok: true,
+							value: void 0
+						};
+						if (resp.status === "NO") return {
+							ok: false,
+							reason: {
+								kind: "no",
+								text: resp.text
+							}
+						};
+						if (resp.status === "BAD") return {
+							ok: false,
+							reason: {
+								kind: "bad",
+								text: resp.text
+							}
+						};
+					}
+				}
+			});
+			ended.finally(() => {
+				isEnded = true;
+			});
+			return {
+				done: async () => {
+					doneRequested = true;
+					await sendDone();
+					return ended;
+				},
+				ended
+			};
+		},
+		logout: () => enqueueCommand(async () => {
+			const res = await executeCommand(buildLogoutCommand, { allowBye: true });
+			isClosed = true;
+			if (!res.ok) return res;
+			return {
+				ok: true,
+				value: void 0
+			};
+		})
+	};
+};
+//#endregion
+export { DEFAULT_MAX_LITERAL_BYTES, createImapClient, decodeRfc2047, parseResponse };