@orkestrel/msg 0.0.1

package/dist/src/core/index.js

@@ -0,0 +1,2445 @@
+//#region src/core/constants.ts
+/**
+* CFB magic header bytes (0xD0CF11E0A1B11AE1).
+*/
+var MSG_FILE_HEADER = new Uint8Array([
+	208,
+	207,
+	17,
+	224,
+	161,
+	177,
+	26,
+	225
+]);
+/**
+* Sentinel for unused blocks in the FAT.
+*/
+var MSG_UNUSED_BLOCK = -1;
+/**
+* Sentinel for end-of-chain in the FAT.
+*/
+var MSG_END_OF_CHAIN = -2;
+/**
+* Small sector size (512 bytes).
+*/
+var MSG_S_BIG_BLOCK_SIZE = 512;
+/**
+* Small sector size mark in the header (byte at offset 30).
+*/
+var MSG_S_BIG_BLOCK_MARK = 9;
+/**
+* Large sector size (4096 bytes).
+*/
+var MSG_L_BIG_BLOCK_SIZE = 4096;
+/**
+* Large sector size mark in the header (byte at offset 30).
+*/
+var MSG_L_BIG_BLOCK_MARK = 12;
+/**
+* Mini-stream sector size (64 bytes).
+*/
+var MSG_SMALL_BLOCK_SIZE = 64;
+/**
+* Threshold below which data is stored in the mini-stream.
+*/
+var MSG_BIG_BLOCK_MIN_DOC_SIZE = 4096;
+/**
+* Header offset: property (directory) start sector.
+*/
+var MSG_HEADER_PROPERTY_START_OFFSET = 48;
+/**
+* Header offset: BAT sector array start.
+*/
+var MSG_HEADER_BAT_START_OFFSET = 76;
+/**
+* Header offset: BAT sector count.
+*/
+var MSG_HEADER_BAT_COUNT_OFFSET = 44;
+/**
+* Header offset: SBAT start sector.
+*/
+var MSG_HEADER_SBAT_START_OFFSET = 60;
+/**
+* Header offset: SBAT sector count.
+*/
+var MSG_HEADER_SBAT_COUNT_OFFSET = 64;
+/**
+* Header offset: XBAT (DIFAT) start sector.
+*/
+var MSG_HEADER_XBAT_START_OFFSET = 68;
+/**
+* Header offset: XBAT (DIFAT) sector count.
+*/
+var MSG_HEADER_XBAT_COUNT_OFFSET = 72;
+/**
+* No child/sibling index sentinel.
+*/
+var MSG_PROP_NO_INDEX = -1;
+/**
+* Maximum recursion depth accepted by the directory hierarchy builder
+* (`MSGReader#buildHierarchy`). Defense-in-depth against a pathological
+* or hostile directory tree — the sibling-chain and visited-set guards
+* already bound each level, this caps the recursion depth itself.
+*/
+var MSG_MAX_HIERARCHY_DEPTH = 64;
+/**
+* Directory entry size in bytes.
+*/
+var MSG_PROPERTY_SIZE = 128;
+/**
+* Offset within a directory entry: name byte length.
+*/
+var MSG_PROP_NAME_SIZE_OFFSET = 64;
+/**
+* Offset within a directory entry: object type byte.
+*/
+var MSG_PROP_TYPE_OFFSET = 66;
+/**
+* Offset within a directory entry: left sibling index.
+*/
+var MSG_PROP_PREVIOUS_PROPERTY_OFFSET = 68;
+/**
+* Offset within a directory entry: right sibling index.
+*/
+var MSG_PROP_NEXT_PROPERTY_OFFSET = 72;
+/**
+* Offset within a directory entry: child index.
+*/
+var MSG_PROP_CHILD_PROPERTY_OFFSET = 76;
+/**
+* Offset within a directory entry: start sector of stream data.
+*/
+var MSG_PROP_START_BLOCK_OFFSET = 116;
+/**
+* Offset within a directory entry: stream byte length.
+*/
+var MSG_PROP_SIZE_OFFSET = 120;
+/**
+* Directory entry type: unallocated.
+*/
+var MSG_TYPE_UNALLOCATED = 0;
+/**
+* Directory entry type: storage (folder).
+*/
+var MSG_TYPE_DIRECTORY = 1;
+/**
+* Directory entry type: stream (document).
+*/
+var MSG_TYPE_DOCUMENT = 2;
+/**
+* Directory entry type: root storage.
+*/
+var MSG_TYPE_ROOT = 5;
+/**
+* Name prefix for attachment storage entries.
+*/
+var MSG_PREFIX_ATTACHMENT = "__attach_version1.0";
+/**
+* Name prefix for recipient storage entries.
+*/
+var MSG_PREFIX_RECIPIENT = "__recip_version1.0";
+/**
+* Name prefix for document (substg) stream entries.
+*/
+var MSG_PREFIX_DOCUMENT = "__substg1.";
+/**
+* Name prefix for named property mapping storage.
+*/
+var MSG_PREFIX_NAMEID = "__nameid_version1.0";
+/**
+* MAPI property tag to field name mapping.
+*/
+var MSG_FIELD_NAME_MAPPING = {
+	"001a": "messageClass",
+	"0037": "subject",
+	"0039": "clientSubmitTime",
+	"0070": "conversationTopic",
+	"007d": "headers",
+	"0c15": "recipientRole",
+	"0c1a": "senderName",
+	"0c1e": "senderAddressType",
+	"0c1f": "senderEmail",
+	"0e06": "messageDeliveryTime",
+	"0e07": "messageFlags",
+	"0e1d": "normalizedSubject",
+	"1000": "body",
+	"1009": "compressedRTF",
+	"1035": "messageId",
+	"3001": "name",
+	"3002": "addressType",
+	"3003": "email",
+	"3007": "creationTime",
+	"3008": "lastModificationTime",
+	"3703": "extension",
+	"3704": "fileNameShort",
+	"3707": "fileName",
+	"3712": "contentId",
+	"370e": "mimeType",
+	"39fe": "smtpAddress",
+	"3fd9": "preview",
+	"3fde": "internetCodepage",
+	"3ff1": "messageLocaleId",
+	"3ffa": "lastModifierName",
+	"3ffd": "messageCodepage",
+	"5d01": "senderSMTPAddress",
+	"5d02": "sentRepresentingSMTPAddress",
+	"5d0a": "creatorSMTPAddress",
+	"5d0b": "lastModifierSMTPAddress",
+	"7ffe": "attachmentHidden",
+	"3a05": "generation",
+	"3a06": "givenName",
+	"3a08": "businessPhone",
+	"3a09": "homePhone",
+	"3a0d": "location",
+	"3a11": "surname",
+	"3a15": "postalAddress",
+	"3a16": "companyName",
+	"3a17": "jobTitle",
+	"3a18": "departmentName",
+	"3a1c": "mobilePhone",
+	"3a24": "businessFax",
+	"3a26": "country",
+	"3a27": "homeAddressCity",
+	"3a28": "stateOrProvince",
+	"3a29": "streetAddress",
+	"3a2a": "postalCode",
+	"3a44": "middleName",
+	"3a45": "namePrefix",
+	"3a51": "businessHomePage"
+};
+/**
+* Full 8-char property tag to field name mapping (for compound tags).
+*/
+var MSG_FIELD_FULL_NAME_MAPPING = {
+	"1013001f": "bodyHTML",
+	"10130102": "html"
+};
+/**
+* MAPI property type tag to decode type mapping.
+*/
+var MSG_FIELD_TYPE_MAPPING = {
+	"001e": "string",
+	"001f": "unicode",
+	"0040": "time",
+	"0102": "binary",
+	"0003": "integer",
+	"000b": "boolean"
+};
+/**
+* Attachment data class identifier.
+*/
+var MSG_FIELD_CLASS_ATTACHMENT_DATA = "3701";
+/**
+* Directory field type indicating an embedded MSG.
+*/
+var MSG_FIELD_DIR_TYPE_INNER_MSG = "000d";
+/**
+* MAPI recipient type: TO.
+*/
+var MSG_MAPI_RECIPIENT_TO = 1;
+/**
+* MAPI recipient type: CC.
+*/
+var MSG_MAPI_RECIPIENT_CC = 2;
+/**
+* MAPI recipient type: BCC.
+*/
+var MSG_MAPI_RECIPIENT_BCC = 3;
+/**
+* PidLid property set GUID to LID-to-field-name mapping.
+* Maps well-known MAPI named property sets to their property
+* long IDs and corresponding field names on MSGFieldData.
+*/
+var MSG_PIDLID_MAPPING = {
+	"00062008-0000-0000-c000-000000000046": {
+		34084: "votingResponse",
+		34176: "internetAccountName"
+	},
+	"00062002-0000-0000-c000-000000000046": {
+		33293: "appointmentStart",
+		33294: "appointmentEnd",
+		33288: "appointmentLocation",
+		33332: "timeZoneDescription",
+		33333: "clipStart",
+		33334: "clipEnd"
+	},
+	"00062004-0000-0000-c000-000000000046": {
+		32773: "fileUnder",
+		32784: "departmentName",
+		32795: "workAddress",
+		32811: "contactWebPage",
+		32812: "yomiFirstName",
+		32813: "yomiLastName",
+		32814: "yomiCompanyName",
+		32837: "workAddressStreet",
+		32838: "workAddressCity",
+		32839: "workAddressState",
+		32840: "workAddressPostalCode",
+		32841: "workAddressCountry",
+		32866: "instantMessagingAddress",
+		32896: "primaryEmailDisplayName",
+		32899: "primaryEmailAddress",
+		32900: "primaryEmailOriginalDisplayName",
+		32946: "fax1AddressType",
+		32947: "fax1EmailAddress",
+		32948: "fax1OriginalDisplayName",
+		32962: "fax2AddressType",
+		32963: "fax2EmailAddress",
+		32964: "fax2OriginalDisplayName",
+		32978: "fax3AddressType",
+		32979: "fax3EmailAddress",
+		32980: "fax3OriginalDisplayName",
+		32987: "workAddressCountryCode",
+		32989: "addressCountryCode"
+	},
+	"6ed8da90-450b-101b-98da-00aa003f1305": {
+		3: "globalAppointmentId",
+		40: "appointmentOldLocation"
+	}
+};
+/**
+* Standard CFB sector size in bytes (512).
+*/
+var MSG_BURNER_SECTOR_SIZE = 512;
+/**
+* CFB mini-stream sector size in bytes (64).
+*/
+var MSG_BURNER_MINI_SECTOR_SIZE = 64;
+/**
+* Threshold below which streams are stored in the mini-stream (4096).
+*/
+var MSG_BURNER_MINI_STREAM_CUTOFF = 4096;
+/**
+* Number of 32-bit integers per standard sector (128).
+*/
+var MSG_BURNER_INTS_PER_SECTOR = 512 / 4;
+/**
+* Maximum DIFAT entries stored in the CFB header (109).
+*/
+var MSG_BURNER_DIFAT_HEADER_SLOTS = 109;
+/**
+* CFB directory entry size in bytes (128).
+*/
+var MSG_BURNER_DIR_ENTRY_SIZE = 128;
+/**
+* FAT sector marker: this sector holds FAT data (-3).
+*/
+var MSG_BURNER_FAT_SECTOR_MARKER = -3;
+/**
+* DIFAT sector marker: this sector holds DIFAT data (-4).
+*/
+var MSG_BURNER_DIFAT_SECTOR_MARKER = -4;
+/**
+* Maximum UTF-16 code units allowed in a CFB directory entry name (31).
+* The fixed 64-byte name field holds 32 UTF-16 units including the
+* NUL terminator, so the name itself is capped at 31 units.
+*/
+var MSG_BURNER_NAME_MAX = 31;
+/**
+* Root entry CLSID for MSG compound files.
+*/
+var MSG_BURNER_ROOT_CLSID = new Uint8Array([
+	11,
+	13,
+	2,
+	0,
+	0,
+	0,
+	0,
+	0,
+	192,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	70
+]);
+/**
+* File extensions recognized as RFC 2822 / MIME email files.
+*/
+var EML_EXTENSIONS = [".eml"];
+/**
+* File extensions recognized as Outlook binary email files.
+*/
+var MSG_EXTENSIONS = [".msg"];
+/**
+* MIME types recognized as RFC 2822 / MIME email files.
+*/
+var EML_MIME_TYPES = ["message/rfc822"];
+/**
+* MIME types recognized as Outlook binary email files.
+*/
+var MSG_MIME_TYPES = ["application/vnd.ms-outlook"];
+/**
+* Default charset for decoding MIME part bodies.
+*/
+var FALLBACK_CHARSET = "utf-8";
+/**
+* Default file name for attachments without an explicit name.
+*/
+var FALLBACK_ATTACHMENT_NAME = "attachment";
+/**
+* Common MIME types to file extensions mapping.
+* Used for inferring the correct extension during file extraction.
+*/
+var MIME_EXTENSIONS = /* @__PURE__ */ new Map([
+	["image/jpeg", ".jpg"],
+	["image/jpg", ".jpg"],
+	["image/png", ".png"],
+	["image/gif", ".gif"],
+	["image/webp", ".webp"],
+	["application/pdf", ".pdf"],
+	["text/plain", ".txt"],
+	["text/csv", ".csv"],
+	["text/html", ".html"],
+	["application/json", ".json"],
+	["application/zip", ".zip"],
+	["application/vnd.ms-excel", ".xls"],
+	["application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", ".xlsx"],
+	["application/msword", ".doc"],
+	["application/vnd.openxmlformats-officedocument.wordprocessingml.document", ".docx"],
+	["application/vnd.ms-powerpoint", ".ppt"],
+	["application/vnd.openxmlformats-officedocument.presentationml.presentation", ".pptx"],
+	["message/rfc822", ".eml"],
+	["application/vnd.ms-outlook", ".msg"]
+]);
+/**
+* Maximum multipart nesting depth accepted by `parseMIMEPart`.
+* Guards against pathological or hostile MIME trees causing
+* unbounded recursion.
+*/
+var MIME_MAX_DEPTH = 50;
+/**
+* Minimum valid code point for each UTF-8 sequence length, keyed by the
+* number of continuation bytes (1, 2, or 3). Enforces the WHATWG
+* requirement that a sequence encode the shortest possible form — an
+* overlong encoding (a code point below its sequence's minimum) is
+* rejected rather than accepted by `decodeUTF8`.
+*/
+var UTF8_SEQUENCE_MINIMUM = {
+	1: 128,
+	2: 2048,
+	3: 65536
+};
+/**
+* Windows-1252 high-byte (0x80-0x9F) to Unicode code point lookup.
+* Index `n` maps byte `0x80 + n` to its Unicode code point; entries
+* that Windows-1252 leaves undefined map to the byte's own value
+* (C1 control code passthrough) per the WHATWG encoding standard.
+*/
+var WINDOWS_1252_HIGH = [
+	8364,
+	129,
+	8218,
+	402,
+	8222,
+	8230,
+	8224,
+	8225,
+	710,
+	8240,
+	352,
+	8249,
+	338,
+	141,
+	381,
+	143,
+	144,
+	8216,
+	8217,
+	8220,
+	8221,
+	8226,
+	8211,
+	8212,
+	732,
+	8482,
+	353,
+	8250,
+	339,
+	157,
+	382,
+	376
+];
+//#endregion
+//#region src/core/errors.ts
+/**
+* An error thrown or returned by the MSG/EML parsing and burning surfaces.
+*
+* @remarks
+* Carries a machine-readable {@link MSGErrorCode} so a `catch` (or a
+* `Failure.error` branch) can dispatch on `error.code` instead of parsing
+* the message text. `context` carries whatever structured detail the
+* throwing site has on hand (e.g. `{ offset, expected }`).
+*/
+var MSGError = class extends Error {
+	code;
+	context;
+	constructor(code, message, context) {
+		super(message);
+		this.name = "MSGError";
+		this.code = code;
+		this.context = context;
+	}
+};
+/**
+* Narrow an unknown caught (or `Failure.error`) value to an {@link MSGError}.
+*
+* @param value - The value to test (typically a `catch` binding or a `Result.error`)
+* @returns `true` when `value` is an {@link MSGError}
+*
+* @example
+* ```ts
+* import { isMSGError } from '@src/core'
+*
+* try {
+* 	reader.parse()
+* } catch (error) {
+* 	if (isMSGError(error) && error.code === 'MALFORMED') return
+* }
+* ```
+*/
+function isMSGError(value) {
+	return value instanceof MSGError;
+}
+//#endregion
+//#region src/core/helpers.ts
+/**
+* Construct a {@link Success} wrapping a value.
+*
+* @param value - The value to wrap
+* @returns A `Success<T>` result
+*
+* @example
+* ```ts
+* const result = success(42) // { success: true, value: 42 }
+* ```
+*/
+function success(value) {
+	return {
+		success: true,
+		value
+	};
+}
+/**
+* Construct a {@link Failure} wrapping an error.
+*
+* @param error - The error to wrap
+* @returns A `Failure<E>` result
+*
+* @example
+* ```ts
+* const result = failure(new MSGError('MALFORMED', 'bad input'))
+* ```
+*/
+function failure(error) {
+	return {
+		success: false,
+		error
+	};
+}
+/**
+* Narrow a Result to Success.
+*
+* @param result - Result to check
+* @returns True when result is Success
+*/
+function isSuccess(result) {
+	return result.success;
+}
+/**
+* Narrow a Result to Failure.
+*
+* @param result - Result to check
+* @returns True when result is Failure
+*/
+function isFailure(result) {
+	return !result.success;
+}
+/**
+* Narrow an unknown value to a plain record.
+*
+* @param value - Value to check
+* @returns True when value is a non-null, non-array object
+*/
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Validate that a DataView starts with the CFB magic header.
+*
+* @param view - DataView to check
+* @returns True when the first 8 bytes match the CFB signature
+*/
+function isMSGFile(view) {
+	const header = [
+		208,
+		207,
+		17,
+		224,
+		161,
+		177,
+		26,
+		225
+	];
+	if (view.byteLength < header.length) return false;
+	for (let i = 0; i < header.length; i++) if (view.getUint8(i) !== header[i]) return false;
+	return true;
+}
+/**
+* Remove trailing null characters from a string.
+*
+* @param text - Input string
+* @returns String with trailing nulls removed
+*/
+function removeTrailingNull(text) {
+	const index = text.indexOf("\0");
+	if (index !== -1) return text.substring(0, index);
+	return text;
+}
+/**
+* Read a UTF-16LE string from a DataView.
+*
+* @param view - DataView to read from
+* @param offset - Byte offset to start reading
+* @param charCount - Number of UTF-16 code units to read
+* @returns Decoded string
+* @throws {@link MSGError} with code `MALFORMED` when the requested range
+* exceeds the view's bounds
+*/
+function readUTF16String(view, offset, charCount) {
+	const end = offset + charCount * 2;
+	if (offset < 0 || charCount < 0 || end > view.byteLength) throw new MSGError("MALFORMED", "UTF-16 string range exceeds view bounds", {
+		offset,
+		charCount,
+		byteLength: view.byteLength
+	});
+	let result = "";
+	for (let i = 0; i < charCount; i++) {
+		const code = view.getUint16(offset + i * 2, true);
+		result += String.fromCharCode(code);
+	}
+	return result;
+}
+/**
+* Read a non-Unicode (PT_STRING8) string from a byte array using a
+* pure-ES decoder — no `TextDecoder` dependency, so this stays usable
+* in the core's DOM/Node-free environment.
+*
+* @param data - Binary data
+* @param encoding - Encoding to decode with (default `'windows-1252'`)
+* @returns Decoded string
+*
+* @example
+* ```ts
+* readANSIString(new Uint8Array([0x93, 0x41, 0x94])) // '“A”'
+* ```
+*/
+function readANSIString(data, encoding) {
+	const resolved = encoding ?? "windows-1252";
+	if (resolved === "utf-16le") return readUTF16String(new DataView(data.buffer, data.byteOffset, data.byteLength), 0, Math.floor(data.length / 2));
+	if (resolved === "utf-8") return decodeUTF8(data);
+	if (resolved === "latin1") return decodeLatin1(data);
+	return decodeWindows1252(data);
+}
+/**
+* Convert a Windows FILETIME (100-ns intervals since 1601-01-01) to a UTC date string.
+* Combines the low/high 32-bit halves with `BigInt` so the 64-bit interval
+* count never loses precision to float64 rounding.
+*
+* @param low - Low 32 bits of FILETIME
+* @param high - High 32 bits of FILETIME
+* @returns UTC date string
+*/
+function fileTimeToUTCString(low, high) {
+	const unixMs = (BigInt(low >>> 0) + (BigInt(high >>> 0) << 32n) - 116444736000000000n) / 10000n;
+	return new Date(Number(unixMs)).toUTCString();
+}
+/**
+* Convert a number to a lowercase hex string with specified padding.
+*
+* @param value - Number to convert
+* @param length - Minimum hex string length (zero-padded)
+* @returns Lowercase hex string
+*/
+function toHexLower(value, length) {
+	const hex = "0123456789abcdef";
+	let result = "";
+	let remaining = value >>> 0;
+	for (let i = 0; i < length; i++) {
+		result = hex[remaining & 15] + result;
+		remaining = remaining >>> 4;
+	}
+	return result;
+}
+/**
+* Stringify a mixed-endian Microsoft UUID from a byte array.
+*
+* @param data - Byte array containing the UUID
+* @param offset - Byte offset to start reading
+* @returns UUID string in lowercase
+*/
+function msftUUIDStringify(data, offset) {
+	const hex = "0123456789abcdef";
+	const b = (i) => hex[data[offset + i] >> 4 & 15] + hex[data[offset + i] & 15];
+	return b(3) + b(2) + b(1) + b(0) + "-" + b(5) + b(4) + "-" + b(7) + b(6) + "-" + b(8) + b(9) + "-" + b(10) + b(11) + b(12) + b(13) + b(14) + b(15);
+}
+/**
+* Round a value up to the nearest multiple of a boundary.
+*
+* @param value - Number to round
+* @param boundary - Must be a power of 2
+* @returns Rounded value
+*/
+function roundUpToMultiple(value, boundary) {
+	return value + boundary - 1 & ~(boundary - 1);
+}
+/**
+* Compute how many sectors are needed to hold a given byte count.
+*
+* @param bytes - Total byte count
+* @param sectorSize - Sector size in bytes
+* @returns Number of sectors (0 when bytes ≤ 0)
+*/
+function sectorsNeeded(bytes, sectorSize) {
+	if (bytes <= 0) return 0;
+	return roundUpToMultiple(bytes, sectorSize) / sectorSize;
+}
+/**
+* CFB-compliant directory name comparator.
+* Compares by UTF-16 length first, then by uppercased code points.
+*
+* @param a - First name
+* @param b - Second name
+* @returns Negative, zero, or positive
+*/
+function compareCFBName(a, b) {
+	const diff = a.length - b.length;
+	if (diff !== 0) return diff;
+	const x = a.toUpperCase();
+	const y = b.toUpperCase();
+	if (x > y) return 1;
+	if (x < y) return -1;
+	return 0;
+}
+/**
+* Decode a Base64 string into raw bytes without relying on `atob`.
+* Ignores ASCII whitespace and tolerates missing padding.
+*
+* @param text - Base64-encoded string
+* @returns Decoded byte array
+* @throws {@link MSGError} with code `MALFORMED` when the string contains
+* a character outside the Base64 alphabet
+*
+* @example
+* ```ts
+* decodeBase64('SGVsbG8=') // Uint8Array [72, 101, 108, 108, 111]
+* ```
+*/
+function decodeBase64(text) {
+	const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+	const cleaned = text.replace(/[ \t\n\r\f\v]+/g, "").replace(/=+$/, "");
+	const bytes = [];
+	let buffer = 0;
+	let bits = 0;
+	for (const char of cleaned) {
+		const index = alphabet.indexOf(char);
+		if (index === -1) throw new MSGError("MALFORMED", `Invalid Base64 character: ${char}`, { char });
+		buffer = buffer << 6 | index;
+		bits += 6;
+		if (bits >= 8) {
+			bits -= 8;
+			bytes.push(buffer >> bits & 255);
+		}
+	}
+	return new Uint8Array(bytes);
+}
+/**
+* Encode a string into UTF-8 bytes, handling surrogate pairs.
+* A lone (unpaired) surrogate encodes as U+FFFD.
+*
+* @param text - String to encode
+* @returns UTF-8 byte array
+*
+* @example
+* ```ts
+* encodeUTF8('A') // Uint8Array [65]
+* ```
+*/
+function encodeUTF8(text) {
+	const bytes = [];
+	for (let i = 0; i < text.length; i++) {
+		let code = text.charCodeAt(i);
+		if (code >= 55296 && code <= 56319) {
+			const next = text.charCodeAt(i + 1);
+			if (next >= 56320 && next <= 57343) {
+				code = (code - 55296) * 1024 + (next - 56320) + 65536;
+				i++;
+			} else code = 65533;
+		} else if (code >= 56320 && code <= 57343) code = 65533;
+		if (code < 128) bytes.push(code);
+		else if (code < 2048) bytes.push(192 | code >> 6, 128 | code & 63);
+		else if (code < 65536) bytes.push(224 | code >> 12, 128 | code >> 6 & 63, 128 | code & 63);
+		else bytes.push(240 | code >> 18, 128 | code >> 12 & 63, 128 | code >> 6 & 63, 128 | code & 63);
+	}
+	return new Uint8Array(bytes);
+}
+/**
+* Decode UTF-8 bytes into a string, WHATWG-style: an invalid byte
+* sequence decodes as U+FFFD rather than throwing. Rejects overlong
+* encodings, surrogate code points (0xD800-0xDFFF), and code points
+* beyond 0x10FFFF — each invalid sequence yields exactly one U+FFFD
+* and decoding resumes at the next lead byte.
+*
+* @param bytes - UTF-8 byte array
+* @returns Decoded string
+*
+* @example
+* ```ts
+* decodeUTF8(new Uint8Array([65])) // 'A'
+* decodeUTF8(new Uint8Array([0xff])) // '�'
+* ```
+*/
+function decodeUTF8(bytes) {
+	let result = "";
+	let i = 0;
+	while (i < bytes.length) {
+		const byte0 = bytes[i];
+		if (byte0 < 128) {
+			result += String.fromCharCode(byte0);
+			i++;
+			continue;
+		}
+		let length = 0;
+		let codePoint = 0;
+		if ((byte0 & 224) === 192) {
+			length = 1;
+			codePoint = byte0 & 31;
+		} else if ((byte0 & 240) === 224) {
+			length = 2;
+			codePoint = byte0 & 15;
+		} else if ((byte0 & 248) === 240) {
+			length = 3;
+			codePoint = byte0 & 7;
+		} else {
+			result += "�";
+			i++;
+			continue;
+		}
+		if (i + length >= bytes.length) {
+			result += "�";
+			i++;
+			continue;
+		}
+		let valid = true;
+		let value = codePoint;
+		for (let j = 1; j <= length; j++) {
+			const next = bytes[i + j];
+			if ((next & 192) !== 128) {
+				valid = false;
+				break;
+			}
+			value = value << 6 | next & 63;
+		}
+		if (!valid) {
+			result += "�";
+			i++;
+			continue;
+		}
+		const minimum = UTF8_SEQUENCE_MINIMUM[length];
+		if (minimum !== void 0 && value < minimum || value >= 55296 && value <= 57343 || value > 1114111) {
+			result += "�";
+			i += length + 1;
+			continue;
+		}
+		i += length + 1;
+		if (value >= 65536) {
+			value -= 65536;
+			result += String.fromCharCode(55296 + (value >> 10), 56320 + (value & 1023));
+		} else result += String.fromCharCode(value);
+	}
+	return result;
+}
+/**
+* Decode Latin-1 (ISO-8859-1) bytes into a string, byte-for-code-point.
+*
+* @param bytes - Latin-1 byte array
+* @returns Decoded string
+*
+* @example
+* ```ts
+* decodeLatin1(new Uint8Array([0xe9])) // 'é'
+* ```
+*/
+function decodeLatin1(bytes) {
+	let result = "";
+	for (let i = 0; i < bytes.length; i++) result += String.fromCharCode(bytes[i]);
+	return result;
+}
+/**
+* Decode Windows-1252 bytes into a string. Identical to {@link decodeLatin1}
+* except for the 0x80-0x9F range, which maps through {@link WINDOWS_1252_HIGH}.
+*
+* @param bytes - Windows-1252 byte array
+* @returns Decoded string
+*
+* @example
+* ```ts
+* decodeWindows1252(new Uint8Array([0x93])) // '“'
+* ```
+*/
+function decodeWindows1252(bytes) {
+	let result = "";
+	for (let i = 0; i < bytes.length; i++) {
+		const byte = bytes[i];
+		if (byte >= 128 && byte <= 159) result += String.fromCodePoint(WINDOWS_1252_HIGH[byte - 128]);
+		else result += String.fromCharCode(byte);
+	}
+	return result;
+}
+/**
+* Resolve a free-form charset label (as seen in a MIME `charset` parameter)
+* to a supported {@link MSGEncoding}. Unknown or absent labels fall back
+* to `'utf-8'`.
+*
+* @param label - Charset label to resolve (case-insensitive)
+* @returns Resolved encoding
+*
+* @example
+* ```ts
+* resolveEncoding('ISO-8859-1') // 'latin1'
+* resolveEncoding(undefined) // 'utf-8'
+* ```
+*/
+function resolveEncoding(label) {
+	const lower = label?.trim().toLowerCase();
+	if (lower === "utf-8" || lower === "utf8") return "utf-8";
+	if (lower === "utf-16le" || lower === "utf-16") return "utf-16le";
+	if (lower === "windows-1252" || lower === "cp1252") return "windows-1252";
+	if (lower === "us-ascii" || lower === "ascii" || lower === "iso-8859-1" || lower === "iso8859-1" || lower === "latin1") return "latin1";
+	return "utf-8";
+}
+/**
+* Narrow an unknown value to a valid EmailFormat.
+*
+* @param value - Value to check
+* @returns True when value is 'eml' or 'msg'
+*/
+function isEmailFormat(value) {
+	return value === "eml" || value === "msg";
+}
+/**
+* Derive the EmailFormat from a file name and/or MIME type.
+* Returns undefined when the format cannot be determined.
+*
+* @param name - File name to inspect
+* @param mime - MIME type to inspect
+* @returns Detected format or undefined
+*
+* @example
+* ```ts
+* detectFormat('message.eml', undefined) // 'eml'
+* detectFormat(undefined, 'application/vnd.ms-outlook') // 'msg'
+* ```
+*/
+function detectFormat(name, mime) {
+	const lower = name?.toLowerCase();
+	if (lower?.endsWith(".eml") === true) return "eml";
+	if (lower?.endsWith(".msg") === true) return "msg";
+	if (mime === "message/rfc822") return "eml";
+	if (mime === "application/vnd.ms-outlook") return "msg";
+}
+/**
+* Parse headers from a raw RFC 2822 / MIME header text block.
+*
+* @param text - Raw header text
+* @returns Map of parsed header objects
+*/
+function parseMIMEHeaders(text) {
+	const raw = [];
+	for (const line of text.split("\n")) {
+		if (line === "") continue;
+		if ((line.startsWith(" ") || line.startsWith("	")) && raw.length > 0) {
+			const last = raw[raw.length - 1];
+			if (last !== void 0) raw[raw.length - 1] = {
+				name: last.name,
+				value: last.value + " " + line.trim()
+			};
+			continue;
+		}
+		const colon = line.indexOf(":");
+		if (colon === -1) continue;
+		raw.push({
+			name: line.slice(0, colon).trim().toLowerCase(),
+			value: line.slice(colon + 1).trim()
+		});
+	}
+	const map = /* @__PURE__ */ new Map();
+	for (const { name, value } of raw) if (!map.has(name)) {
+		const segments = value.split(";");
+		const val = (segments[0] ?? "").trim();
+		const params = /* @__PURE__ */ new Map();
+		for (let i = 1; i < segments.length; i++) {
+			const segment = (segments[i] ?? "").trim();
+			const eq = segment.indexOf("=");
+			if (eq === -1) continue;
+			const k = segment.slice(0, eq).trim().toLowerCase();
+			let v = segment.slice(eq + 1).trim();
+			if (v.startsWith("\"") && v.endsWith("\"")) v = v.slice(1, -1);
+			params.set(k, v);
+		}
+		map.set(name, {
+			value: val,
+			params
+		});
+	}
+	return map;
+}
+/**
+* Parse a raw RFC 2822 / MIME text string into a MIMEPart tree.
+* Line endings are normalised to \n before processing. Recursion is
+* capped at {@link MIME_MAX_DEPTH} to guard against a hostile or
+* pathological multipart nesting cycle.
+*
+* @param raw - Raw MIME text
+* @param depth - Current recursion depth (internal; callers omit this)
+* @returns Parsed MIMEPart tree
+* @throws {@link MSGError} with code `CYCLE` when nesting exceeds {@link MIME_MAX_DEPTH}
+*/
+function parseMIMEPart(raw, depth = 0) {
+	if (depth > 50) throw new MSGError("CYCLE", "MIME multipart nesting exceeds maximum depth", {
+		depth,
+		max: 50
+	});
+	const normalised = raw.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+	const split = normalised.indexOf("\n\n");
+	const headerText = split === -1 ? normalised : normalised.slice(0, split);
+	const body = split === -1 ? "" : normalised.slice(split + 2);
+	const headers = parseMIMEHeaders(headerText);
+	const contentType = headers.get("content-type");
+	const primaryType = (contentType?.value ?? "").split(";")[0].trim().toLowerCase();
+	const boundary = contentType?.params.get("boundary") ?? "";
+	const parts = [];
+	if (primaryType.startsWith("multipart/") && boundary !== "") {
+		const delimiter = "--" + boundary;
+		const lines = body.split("\n");
+		let current = [];
+		let inside = false;
+		for (const line of lines) {
+			const trimmed = line.trimEnd();
+			if (trimmed === delimiter + "--") {
+				if (inside && current.length > 0) parts.push(parseMIMEPart(current.join("\n"), depth + 1));
+				inside = false;
+				break;
+			}
+			if (trimmed === delimiter) {
+				if (inside && current.length > 0) parts.push(parseMIMEPart(current.join("\n"), depth + 1));
+				current = [];
+				inside = true;
+				continue;
+			}
+			if (inside) current.push(line);
+		}
+		if (inside && current.length > 0) parts.push(parseMIMEPart(current.join("\n"), depth + 1));
+	}
+	return {
+		headers,
+		body,
+		parts
+	};
+}
+/**
+* Decode a MIME-encoded body string into a raw byte array.
+*
+* @param body - Raw encoded string
+* @param encoding - Encoding type (e.g., 'base64', 'quoted-printable')
+* @returns Decoded byte array
+* @throws {@link MSGError} with code `MALFORMED` when `encoding` is `'base64'`
+* and `body` contains an invalid Base64 character
+*/
+function decodeMIMEEncoding(body, encoding) {
+	const enc = encoding.toLowerCase();
+	if (enc === "base64") return decodeBase64(body);
+	if (enc === "quoted-printable") {
+		const unwrapped = body.replace(/=\r?\n/g, "");
+		const result = [];
+		let i = 0;
+		while (i < unwrapped.length) {
+			if (unwrapped[i] === "=" && i + 2 < unwrapped.length) {
+				const hex = unwrapped.slice(i + 1, i + 3);
+				if (/^[0-9A-Fa-f]{2}$/.test(hex)) {
+					result.push(parseInt(hex, 16));
+					i += 3;
+					continue;
+				}
+			}
+			result.push(unwrapped.charCodeAt(i));
+			i++;
+		}
+		return new Uint8Array(result);
+	}
+	return encodeUTF8(body);
+}
+/**
+* Decode a MIME-encoded body into a text string based on an arbitrary
+* charset label, resolved via {@link resolveEncoding}.
+*
+* @param body - Raw encoded string
+* @param encoding - Transfer encoding type
+* @param charset - Character set label (e.g., 'utf-8')
+* @returns Decoded string
+*/
+function decodeMIMEText(body, encoding, charset) {
+	const enc = encoding.toLowerCase();
+	if (enc !== "base64" && enc !== "quoted-printable") return body;
+	return readANSIString(decodeMIMEEncoding(body, encoding), resolveEncoding(charset));
+}
+/**
+* Decode RFC 2047 encoded words in header values.
+* Handles both Base64 (B) and Quoted-Printable (Q) forms.
+*
+* @param text - Header value string potentially containing encoded words
+* @returns Decoded string
+*
+* @example
+* ```ts
+* decodeMIMEWords('=?UTF-8?B?SGVsbG8=?=') // 'Hello'
+* ```
+*/
+function decodeMIMEWords(text) {
+	return text.replace(/(=\?[^?]+\?[BbQq]\?[^?]*\?=)[ \t\r\n]+(?==\?[^?]+\?[BbQq]\?[^?]*\?=)/g, "$1").replace(/=\?([^?]+)\?([BbQq])\?([^?]*)\?=/g, (_match, charset, enc, encoded) => {
+		try {
+			return readANSIString(enc.toUpperCase() === "B" ? decodeMIMEEncoding(encoded, "base64") : decodeMIMEEncoding(encoded.replace(/_/g, " "), "quoted-printable"), resolveEncoding(charset));
+		} catch {
+			return encoded;
+		}
+	});
+}
+/**
+* Format a name and email into a standard composite address.
+*
+* @param name - Display name
+* @param email - Email address
+* @returns Formatted address string
+*/
+function formatEmailAddress(name, email) {
+	const n = name?.trim() ?? "";
+	const e = email?.trim() ?? "";
+	if (n.length > 0 && e.length > 0) return `${n} <${e}>`;
+	if (n.length > 0) return n;
+	return e;
+}
+/**
+* Extract a single EmailMessage from a parsed MSGReader.
+* Reads field data and attachments from the reader interface.
+*
+* Each attachment is read independently: a corrupt attachment throws
+* from `reader.attachment(i)` is caught and that attachment is skipped
+* so the rest of the message still parses. This containment keeps one
+* damaged attachment stream from failing the entire message extraction.
+*
+* @param reader - A parsed MSGReaderInterface instance
+* @returns Structured EmailMessage
+*/
+function extractMessageFromMSG(reader) {
+	const data = reader.parse();
+	const from = formatEmailAddress(data.senderName, data.senderSMTPAddress ?? data.senderEmail);
+	const recipients = data.recipients ?? [];
+	const to = recipients.filter((r) => r.recipientRole === "to").map((r) => formatEmailAddress(r.name, r.smtpAddress ?? r.email)).filter((s) => s.length > 0);
+	const cc = recipients.filter((r) => r.recipientRole === "cc").map((r) => formatEmailAddress(r.name, r.smtpAddress ?? r.email)).filter((s) => s.length > 0);
+	const rawDate = data.messageDeliveryTime ?? data.clientSubmitTime;
+	let date;
+	if (rawDate !== void 0) {
+		const parsed = new Date(rawDate);
+		date = isNaN(parsed.getTime()) ? void 0 : parsed;
+	}
+	const attachments = [];
+	const attachmentFields = data.attachments ?? [];
+	for (let i = 0; i < attachmentFields.length; i++) {
+		const attachment = attachmentFields[i];
+		if (attachment === void 0) continue;
+		if (attachment.attachmentHidden === true) continue;
+		if (attachment.innerMSGContent === true) continue;
+		try {
+			const extracted = reader.attachment(i);
+			attachments.push({
+				name: extracted.fileName,
+				mimeType: attachment.mimeType ?? "application/octet-stream",
+				size: extracted.content.length,
+				bytes: extracted.content
+			});
+		} catch {
+			continue;
+		}
+	}
+	return {
+		from,
+		to,
+		cc,
+		subject: data.subject ?? "",
+		date,
+		text: data.body ?? "",
+		html: data.bodyHTML ?? "",
+		attachments
+	};
+}
+/**
+* Extract a single EmailMessage from a top-level MIMEPart.
+* Walks the full MIME tree to collect text, HTML, and attachments.
+*
+* @param part - Root MIMEPart from parseMIMEPart
+* @returns Structured EmailMessage
+*/
+function extractMessage(part) {
+	const headerValue = (name) => decodeMIMEWords(part.headers.get(name)?.value ?? "");
+	const splitAddresses = (raw) => raw.length === 0 ? [] : raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+	const rawDate = part.headers.get("date")?.value;
+	let date;
+	if (rawDate !== void 0) {
+		const parsed = new Date(rawDate);
+		date = isNaN(parsed.getTime()) ? void 0 : parsed;
+	}
+	const collectedText = [];
+	const collectedHTML = [];
+	const attachments = [];
+	const walk = (p) => {
+		const contentType = p.headers.get("content-type");
+		const disposition = p.headers.get("content-disposition");
+		const transferEncoding = p.headers.get("content-transfer-encoding");
+		const primaryType = (contentType?.value ?? "text/plain").split(";")[0].trim().toLowerCase();
+		const encoding = (transferEncoding?.value ?? "7bit").trim();
+		const charset = contentType?.params.get("charset") ?? "utf-8";
+		const dispositionKind = (disposition?.value ?? "").trim().toLowerCase();
+		if (primaryType.startsWith("multipart/")) {
+			for (const child of p.parts) walk(child);
+			return;
+		}
+		if (dispositionKind === "attachment") {
+			const name = disposition?.params.get("filename") ?? contentType?.params.get("name") ?? "attachment";
+			const bytes = decodeMIMEEncoding(p.body, encoding);
+			attachments.push({
+				name: decodeMIMEWords(name),
+				mimeType: primaryType,
+				size: bytes.length,
+				bytes
+			});
+			return;
+		}
+		if (primaryType === "text/plain") {
+			collectedText.push(decodeMIMEText(p.body, encoding, charset));
+			return;
+		}
+		if (primaryType === "text/html") {
+			collectedHTML.push(decodeMIMEText(p.body, encoding, charset));
+			return;
+		}
+		const inlineName = contentType?.params.get("name") ?? disposition?.params.get("filename");
+		if (inlineName !== void 0) {
+			const bytes = decodeMIMEEncoding(p.body, encoding);
+			attachments.push({
+				name: decodeMIMEWords(inlineName),
+				mimeType: primaryType,
+				size: bytes.length,
+				bytes
+			});
+		}
+	};
+	walk(part);
+	return {
+		from: headerValue("from"),
+		to: splitAddresses(headerValue("to")),
+		cc: splitAddresses(headerValue("cc")),
+		subject: headerValue("subject"),
+		date,
+		text: collectedText.join(""),
+		html: collectedHTML.join(""),
+		attachments
+	};
+}
+/**
+* Infers the file extension for an attachment based on its filename or MIME type.
+* Returns the extension including the dot (e.g., '.jpg').
+*
+* @param mimeType - MIME type to infer from
+* @param fileName - File name to infer from
+* @returns Inferred extension, or `.bin` when neither hint resolves
+*/
+function inferExtension(mimeType, fileName) {
+	if (fileName !== void 0) {
+		const lastDotIndex = fileName.lastIndexOf(".");
+		if (lastDotIndex !== -1 && lastDotIndex < fileName.length - 1) {
+			const ext = fileName.slice(lastDotIndex).toLowerCase();
+			if (/^\.[a-z0-9]{1,10}$/.test(ext)) return ext;
+		}
+	}
+	if (mimeType !== void 0) {
+		const normalized = mimeType.split(";")[0]?.trim().toLowerCase();
+		if (normalized !== void 0) {
+			const ext = MIME_EXTENSIONS.get(normalized);
+			if (ext !== void 0) return ext;
+		}
+	}
+	return ".bin";
+}
+//#endregion
+//#region src/core/MSGBurner.ts
+/**
+* Reconstitutes a valid CFB (Compound Binary File) from a flat list of
+* {@link MSGBurnerEntry} descriptors — root storage at index 0, its
+* children reachable through `children` indices.
+*
+* @remarks
+* Builds a red-black directory tree, allocates FAT/mini-FAT/DIFAT
+* sectors, then writes the header, directory entries, and stream data
+* into a single binary. Used to extract embedded `.msg` attachments as
+* standalone CFB files.
+*/
+var MSGBurner = class {
+	#liteEntries = [];
+	#fat = [];
+	#miniFat = [];
+	/**
+	* Burn a flat list of CFB entries into a valid compound binary file.
+	*
+	* @param entries - Flat entry list starting with Root Entry at index 0
+	* @returns Complete CFB binary as Uint8Array
+	* @throws {@link MSGError} with code `BURN` when an entry name exceeds
+	* the {@link MSG_BURNER_NAME_MAX} UTF-16 code unit limit the CFB directory entry format allows
+	*/
+	burn(entries) {
+		this.#liteEntries = entries.map((entry) => ({
+			entry,
+			left: -1,
+			right: -1,
+			child: -1,
+			firstSector: 0,
+			mini: entry.type === 2 && entry.length < 4096,
+			red: false
+		}));
+		this.#fat = [];
+		this.#miniFat = [];
+		this.#buildTree(0);
+		const dirSectorCount = sectorsNeeded(128 * this.#liteEntries.length, 512);
+		const entriesFirstSector = this.#allocateFat(dirSectorCount);
+		for (let i = 0; i < this.#liteEntries.length; i++) {
+			const le = this.#liteEntries[i];
+			if (le.entry.type === 2 && !le.mini) le.firstSector = le.entry.length === 0 ? -2 : this.#allocateFat(sectorsNeeded(le.entry.length, 512));
+		}
+		for (let i = 0; i < this.#liteEntries.length; i++) {
+			const le = this.#liteEntries[i];
+			if (le.entry.type === 2 && le.mini) le.firstSector = le.entry.length === 0 ? -2 : this.#allocateMiniFat(sectorsNeeded(le.entry.length, 64));
+		}
+		const numMiniFatSectors = sectorsNeeded(4 * this.#miniFat.length, 512);
+		const firstMiniFatSector = numMiniFatSectors !== 0 ? this.#allocateFat(numMiniFatSectors) : -2;
+		const bytesMiniFat = 64 * this.#miniFat.length;
+		const firstMiniDataSector = bytesMiniFat > 0 ? this.#allocateFat(sectorsNeeded(bytesMiniFat, 512)) : -2;
+		this.#liteEntries[0].firstSector = firstMiniDataSector === -2 ? -2 : firstMiniDataSector;
+		const estimatedFatSectors = Math.max(1, sectorsNeeded(4 * (this.#fat.length + Math.ceil(this.#fat.length / 128) + 1), 512));
+		const firstFatSector = this.#allocateFatAs(estimatedFatSectors, -3);
+		const numFatSectors = this.#fat.length - firstFatSector;
+		const numDifatSectors = numFatSectors > 109 ? sectorsNeeded(4 * Math.ceil((numFatSectors - 109) / 127 * 128), 512) : 0;
+		const firstDifatSector = numDifatSectors !== 0 ? this.#allocateFatAs(numDifatSectors, -4) : -2;
+		const totalSize = 512 * (1 + this.#fat.length);
+		const buffer = new ArrayBuffer(totalSize);
+		const view = new DataView(buffer);
+		const bytes = new Uint8Array(buffer);
+		while (this.#miniFat.length % 128 !== 0) this.#miniFat.push(-1);
+		const difat1 = [];
+		const difat2 = [];
+		this.#buildDifat(difat1, difat2, numFatSectors, firstFatSector, firstDifatSector);
+		this.#writeHeader(view, bytes, numFatSectors, entriesFirstSector, firstMiniFatSector, numMiniFatSectors, firstDifatSector, numDifatSectors, difat1);
+		this.#writeDirectoryEntries(view, bytes, entriesFirstSector, bytesMiniFat);
+		this.#writeLargeStreams(bytes);
+		this.#writeMiniStreams(bytes, firstMiniDataSector);
+		this.#writeMiniFat(view, firstMiniFatSector);
+		this.#writeFat(view, firstFatSector);
+		this.#writeDifat(view, difat2, firstDifatSector, numDifatSectors);
+		return new Uint8Array(buffer);
+	}
+	#allocateFat(count) {
+		const first = this.#fat.length;
+		for (let i = 0; i < count; i++) {
+			const next = i + 1 === count ? -2 : first + i + 1;
+			this.#fat.push(next);
+		}
+		return first;
+	}
+	#allocateFatAs(count, value) {
+		const first = this.#fat.length;
+		for (let i = 0; i < count; i++) this.#fat.push(value);
+		return first;
+	}
+	#allocateMiniFat(count) {
+		const first = this.#miniFat.length;
+		for (let i = 0; i < count; i++) {
+			const next = i + 1 === count ? -2 : first + i + 1;
+			this.#miniFat.push(next);
+		}
+		return first;
+	}
+	#buildTree(dirIndex) {
+		const liteEntry = this.#liteEntries[dirIndex];
+		const children = liteEntry.entry.children;
+		if (children === void 0 || children.length === 0) return;
+		const sorted = children.slice().sort((a, b) => compareCFBName(this.#liteEntries[a].entry.name, this.#liteEntries[b].entry.name));
+		const mid = Math.floor(sorted.length / 2);
+		const rootIndex = sorted[mid];
+		const rootEntry = this.#liteEntries[rootIndex];
+		rootEntry.red = false;
+		rootEntry.left = this.#splitTree(sorted, 0, mid, true);
+		rootEntry.right = this.#splitTree(sorted, mid + 1, sorted.length, true);
+		liteEntry.child = rootIndex;
+		for (let i = 0; i < sorted.length; i++) {
+			const idx = sorted[i];
+			if (this.#liteEntries[idx].entry.type === 1) this.#buildTree(idx);
+		}
+	}
+	#splitTree(sorted, start, end, red) {
+		if (start >= end) return -1;
+		const mid = Math.floor((start + end) / 2);
+		const entryIndex = sorted[mid];
+		const entry = this.#liteEntries[entryIndex];
+		entry.red = red;
+		entry.left = this.#splitTree(sorted, start, mid, !red);
+		entry.right = this.#splitTree(sorted, mid + 1, end, !red);
+		return entryIndex;
+	}
+	#buildDifat(difat1, difat2, numFatSectors, firstFatSector, firstDifatSector) {
+		let x = 0;
+		for (; x < 109 && x < numFatSectors; x++) difat1.push(firstFatSector + x);
+		let nextDifatSector = firstDifatSector + 1;
+		for (; x < numFatSectors; x++) {
+			difat2.push(firstFatSector + x);
+			if ((difat2.length & 127) === 127) {
+				difat2.push(nextDifatSector);
+				nextDifatSector++;
+			}
+		}
+		while (difat2.length > 0 && (difat2.length & 127) !== 0) {
+			const remain = difat2.length & 127;
+			difat2.push(remain === 127 ? -2 : -1);
+		}
+	}
+	#writeHeader(view, bytes, numFatSectors, entriesFirstSector, firstMiniFatSector, numMiniFatSectors, firstDifatSector, numDifatSectors, difat1) {
+		bytes.set(MSG_FILE_HEADER, 0);
+		view.setUint16(24, 62, true);
+		view.setUint16(26, 3, true);
+		view.setUint16(28, 65534, true);
+		view.setUint16(30, 9, true);
+		view.setUint16(32, 6, true);
+		view.setInt32(44, numFatSectors, true);
+		view.setInt32(48, entriesFirstSector, true);
+		view.setInt32(56, MSG_BURNER_MINI_STREAM_CUTOFF, true);
+		view.setInt32(60, firstMiniFatSector, true);
+		view.setInt32(64, numMiniFatSectors, true);
+		view.setInt32(68, firstDifatSector, true);
+		view.setInt32(72, numDifatSectors, true);
+		let offset = 76;
+		for (let i = 0; i < difat1.length; i++) {
+			view.setInt32(offset, difat1[i], true);
+			offset += 4;
+		}
+		for (let i = difat1.length; i < 109; i++) {
+			view.setInt32(offset, -1, true);
+			offset += 4;
+		}
+	}
+	#writeDirectoryEntries(view, bytes, entriesFirstSector, bytesMiniFat) {
+		for (let x = 0; x < this.#liteEntries.length; x++) {
+			const le = this.#liteEntries[x];
+			const pos = 512 * (1 + entriesFirstSector) + 128 * x;
+			const name = le.entry.name;
+			if (name.length > 31) throw new MSGError("BURN", `directory entry name exceeds 31 characters`, { name });
+			for (let i = 0; i < name.length; i++) view.setUint16(pos + i * 2, name.charCodeAt(i), true);
+			view.setUint16(pos + name.length * 2, 0, true);
+			view.setUint16(pos + 64, (name.length + 1) * 2, true);
+			bytes[pos + 66] = le.entry.type;
+			bytes[pos + 67] = le.red ? 0 : 1;
+			view.setInt32(pos + 68, le.left, true);
+			view.setInt32(pos + 72, le.right, true);
+			view.setInt32(pos + 76, le.child, true);
+			if (x === 0) bytes.set(MSG_BURNER_ROOT_CLSID, pos + 80);
+			const length = x === 0 ? bytesMiniFat : le.entry.length;
+			const firstSector = length !== 0 ? le.firstSector : le.entry.type === 1 ? 0 : -2;
+			view.setInt32(pos + 116, firstSector, true);
+			view.setInt32(pos + 120, length, true);
+		}
+	}
+	#writeLargeStreams(bytes) {
+		for (let i = 0; i < this.#liteEntries.length; i++) {
+			const le = this.#liteEntries[i];
+			if (le.entry.type === 2 && !le.mini && le.entry.binaryProvider !== void 0) {
+				const data = le.entry.binaryProvider();
+				bytes.set(data, 512 * (1 + le.firstSector));
+			}
+		}
+	}
+	#writeMiniStreams(bytes, firstMiniDataSector) {
+		if (firstMiniDataSector === -2) return;
+		for (let i = 0; i < this.#liteEntries.length; i++) {
+			const le = this.#liteEntries[i];
+			if (le.entry.type === 2 && le.mini && le.entry.binaryProvider !== void 0) {
+				const data = le.entry.binaryProvider();
+				bytes.set(data, 512 * (1 + firstMiniDataSector) + 64 * le.firstSector);
+			}
+		}
+	}
+	#writeMiniFat(view, firstMiniFatSector) {
+		if (firstMiniFatSector === -2) return;
+		let offset = 512 * (1 + firstMiniFatSector);
+		for (let i = 0; i < this.#miniFat.length; i++) {
+			view.setInt32(offset, this.#miniFat[i], true);
+			offset += 4;
+		}
+	}
+	#writeFat(view, firstFatSector) {
+		while (this.#fat.length % 128 !== 0) this.#fat.push(-1);
+		let offset = 512 * (1 + firstFatSector);
+		for (let i = 0; i < this.#fat.length; i++) {
+			view.setInt32(offset, this.#fat[i], true);
+			offset += 4;
+		}
+	}
+	#writeDifat(view, difat2, firstDifatSector, numDifatSectors) {
+		if (numDifatSectors < 1) return;
+		let offset = 512 * (1 + firstDifatSector);
+		for (let i = 0; i < difat2.length; i++) {
+			view.setInt32(offset, difat2[i], true);
+			offset += 4;
+		}
+	}
+};
+//#endregion
+//#region src/core/MSGReader.ts
+/**
+* Parses Microsoft Outlook .msg files (CFB/OLE2 compound binary format).
+* Every parsing step treats the input as untrusted: sector and property
+* chains are cycle-guarded and length-capped, every raw byte range is
+* bounds-checked before a view is constructed over it, and every failure
+* surfaces as a typed {@link MSGError} rather than a raw `RangeError` or
+* `TypeError`.
+*/
+var MSGReader = class {
+	#view;
+	#byteLength;
+	#totalSectors;
+	#options;
+	#bigBlockSize = 0;
+	#bigBlockLength = 0;
+	#xBlockLength = 0;
+	#batCount = 0;
+	#propertyStart = 0;
+	#sbatStart = 0;
+	#sbatCount = 0;
+	#xbatStart = 0;
+	#xbatCount = 0;
+	#bat = [];
+	#sbat = [];
+	#properties = [];
+	#bigBlockTable = [];
+	#fields;
+	#privatePidToKeyed = {};
+	#innerMSGBurners = {};
+	/**
+	* Create a reader over a raw MSG file buffer.
+	*
+	* @param input - Raw MSG file bytes, as an `ArrayBuffer` or a `Uint8Array` view
+	* @param options - Reader configuration
+	*/
+	constructor(input, options) {
+		if (input instanceof Uint8Array) {
+			this.#view = new DataView(input.buffer, input.byteOffset, input.byteLength);
+			this.#byteLength = input.byteLength;
+		} else {
+			this.#view = new DataView(input);
+			this.#byteLength = input.byteLength;
+		}
+		this.#options = options ?? {};
+		this.#totalSectors = Math.ceil(this.#byteLength / 512);
+	}
+	/**
+	* Parse the MSG file and return extracted field data.
+	*
+	* @returns Root message field data with nested attachments and recipients
+	* @throws {@link MSGError} with code `UNSUPPORTED`, `MALFORMED`, `CYCLE`,
+	* or `RANGE` when the compound file cannot be parsed
+	*/
+	parse() {
+		if (this.#fields !== void 0) return this.#fields;
+		this.#parseHeader();
+		this.#bat = this.#readBat();
+		if (this.#xbatCount > 0) this.#readXbat();
+		this.#sbat = this.#readSbat();
+		this.#properties = this.#readProperties(this.#propertyStart);
+		this.#bigBlockTable = this.#buildBigBlockTable();
+		this.#privatePidToKeyed = {};
+		this.#innerMSGBurners = {};
+		const fields = this.#extractFields();
+		this.#fields = fields;
+		return fields;
+	}
+	/**
+	* Read attachment binary content by index.
+	*
+	* @param index - Zero-based index into the parsed attachment list
+	* @returns File name and raw binary content
+	* @throws {@link MSGError} with code `RANGE` when the index is out of bounds
+	*/
+	attachment(index) {
+		const attachments = this.parse().attachments;
+		if (attachments === void 0 || index < 0 || index >= attachments.length) throw new MSGError("RANGE", `Attachment index ${index} out of range`, { index });
+		const attach = attachments[index];
+		if (attach.innerMSGContent === true && typeof attach.folderId === "number") {
+			const name = typeof attach.name === "string" ? attach.name : "embedded";
+			const burner = this.#innerMSGBurners[attach.folderId];
+			const content = burner !== void 0 ? burner() : /* @__PURE__ */ new Uint8Array(0);
+			return {
+				fileName: name + ".msg",
+				content
+			};
+		}
+		if (typeof attach.dataId !== "number" || attach.dataId < 0 || attach.dataId >= this.#properties.length) throw new MSGError("RANGE", "Attachment has no valid data reference", { index });
+		const entry = this.#properties[attach.dataId];
+		const content = this.#readEntry(entry);
+		return {
+			fileName: typeof attach.fileName === "string" ? attach.fileName : typeof attach.fileNameShort === "string" ? attach.fileNameShort : typeof attach.name === "string" ? attach.name : "unknown",
+			content
+		};
+	}
+	/**
+	* Rebuild the parsed MSG as a standalone CFB/.msg binary.
+	*
+	* @returns Complete CFB byte stream
+	* @throws {@link MSGError} with code `BURN` when the parsed structure
+	* cannot be reconstituted
+	*/
+	burn() {
+		const parsed = this.parse();
+		if (parsed.kind !== "msg") throw new MSGError("BURN", "Unable to burn a non-message field data structure", { kind: parsed.kind });
+		const root = this.#properties[0];
+		if (root === void 0) throw new MSGError("BURN", "Unable to burn MSG file without a root entry");
+		return this.#burnFolder(root, false, false);
+	}
+	#parseHeader() {
+		if (!isMSGFile(this.#view)) throw new MSGError("UNSUPPORTED", "Input is not a recognized CFB/MSG file");
+		if (this.#byteLength < 512) throw new MSGError("MALFORMED", "File is smaller than the minimum CFB header size", { byteLength: this.#byteLength });
+		const v = this.#view;
+		const sectorMark = v.getUint8(30);
+		this.#bigBlockSize = sectorMark === 12 ? MSG_L_BIG_BLOCK_SIZE : 512;
+		this.#bigBlockLength = this.#bigBlockSize / 4;
+		this.#xBlockLength = this.#bigBlockLength - 1;
+		const batCount = v.getInt32(44, true);
+		const propertyStart = v.getInt32(48, true);
+		const sbatStart = v.getInt32(60, true);
+		const sbatCount = v.getInt32(64, true);
+		const xbatStart = v.getInt32(68, true);
+		const xbatCount = v.getInt32(72, true);
+		this.#validateHeaderField("batCount", batCount);
+		this.#validateHeaderField("sbatCount", sbatCount);
+		this.#validateHeaderField("xbatCount", xbatCount);
+		this.#validateHeaderField("propertyStart", propertyStart);
+		this.#batCount = batCount;
+		this.#propertyStart = propertyStart;
+		this.#sbatStart = sbatStart;
+		this.#sbatCount = sbatCount;
+		this.#xbatStart = xbatStart;
+		this.#xbatCount = xbatCount;
+	}
+	#validateHeaderField(name, value) {
+		if (value < 0 || value > this.#totalSectors) throw new MSGError("MALFORMED", `CFB header field '${name}' is out of range`, {
+			field: name,
+			value
+		});
+	}
+	#assertBounds(start, length) {
+		if (start < 0 || length < 0 || start + length > this.#byteLength) throw new MSGError("MALFORMED", "Computed byte range exceeds file bounds", {
+			start,
+			length,
+			byteLength: this.#byteLength
+		});
+	}
+	#trackSector(visited, sector, label, limit, capacityLabel) {
+		if (visited.has(sector)) throw new MSGError("CYCLE", `${label} chain revisits sector ${sector}`, { sector });
+		if (visited.size >= limit) throw new MSGError("CYCLE", `${label} chain exceeds ${capacityLabel}`, { limit });
+		visited.add(sector);
+	}
+	#batCountInHeader() {
+		return Math.min(this.#batCount, 436 / 4);
+	}
+	#readBat() {
+		const count = this.#batCountInHeader();
+		const result = new Array(count);
+		let offset = 76;
+		for (let i = 0; i < count; i++) {
+			result[i] = this.#view.getInt32(offset, true);
+			offset += 4;
+		}
+		return result;
+	}
+	#blockOffset(sector) {
+		if (sector < 0 || sector >= this.#totalSectors) throw new MSGError("MALFORMED", `Sector index out of range: ${sector}`, {
+			sector,
+			totalSectors: this.#totalSectors
+		});
+		return (sector + 1) * this.#bigBlockSize;
+	}
+	#blockValueAt(sector, index) {
+		const offset = this.#blockOffset(sector) + 4 * index;
+		this.#assertBounds(offset, 4);
+		return this.#view.getInt32(offset, true);
+	}
+	#nextBlockInner(offset, table) {
+		const block = Math.floor(offset / this.#bigBlockLength);
+		const index = offset % this.#bigBlockLength;
+		const sector = table[block];
+		if (sector === void 0) return -2;
+		return this.#blockValueAt(sector, index);
+	}
+	#nextBlock(offset) {
+		return this.#nextBlockInner(offset, this.#bat);
+	}
+	#nextBlockSmall(offset) {
+		return this.#nextBlockInner(offset, this.#sbat);
+	}
+	#readSbat() {
+		const result = [];
+		const visited = /* @__PURE__ */ new Set();
+		let startIndex = this.#sbatStart;
+		for (let i = 0; i < this.#sbatCount && startIndex !== 0 && startIndex !== -2; i++) {
+			this.#trackSector(visited, startIndex, "SBAT", this.#totalSectors, "total sector count");
+			result.push(startIndex);
+			startIndex = this.#nextBlock(startIndex);
+		}
+		return result;
+	}
+	#readXbat() {
+		const headerBatCount = this.#batCountInHeader();
+		let remaining = this.#batCount - headerBatCount;
+		let nextSector = this.#xbatStart;
+		const visited = /* @__PURE__ */ new Set();
+		for (let i = 0; i < this.#xbatCount; i++) {
+			this.#trackSector(visited, nextSector, "XBAT", this.#totalSectors, "total sector count");
+			const blockOffset = this.#blockOffset(nextSector);
+			this.#assertBounds(blockOffset, this.#bigBlockSize);
+			const toProcess = Math.min(remaining, this.#xBlockLength);
+			for (let j = 0; j < toProcess; j++) {
+				const sector = this.#view.getInt32(blockOffset + j * 4, true);
+				if (sector === -1 || sector === -2) break;
+				this.#bat.push(sector);
+			}
+			remaining -= toProcess;
+			nextSector = this.#view.getInt32(blockOffset + this.#xBlockLength * 4, true);
+			if (nextSector === -1 || nextSector === -2) break;
+		}
+	}
+	#readEntryName(offset) {
+		const nameBytes = this.#view.getUint16(offset + 64, true);
+		if (nameBytes < 2) return "";
+		const charCount = Math.min(nameBytes / 2 - 1, 31);
+		return removeTrailingNull(readUTF16String(this.#view, offset, charCount));
+	}
+	#readDirectoryEntry(offset) {
+		const v = this.#view;
+		return {
+			type: v.getUint8(offset + 66),
+			name: this.#readEntryName(offset),
+			previousProperty: v.getInt32(offset + 68, true),
+			nextProperty: v.getInt32(offset + 72, true),
+			childProperty: v.getInt32(offset + 76, true),
+			startBlock: v.getInt32(offset + 116, true),
+			sizeBlock: v.getInt32(offset + 120, true)
+		};
+	}
+	#readProperties(propertyStart) {
+		const props = [];
+		const visited = /* @__PURE__ */ new Set();
+		let currentSector = propertyStart;
+		while (currentSector !== -2) {
+			this.#trackSector(visited, currentSector, "Property", this.#totalSectors, "total sector count");
+			const entryCount = this.#bigBlockSize / 128;
+			let offset = this.#blockOffset(currentSector);
+			for (let i = 0; i < entryCount; i++) {
+				if (offset + 128 > this.#byteLength) break;
+				const entryType = this.#view.getUint8(offset + 66);
+				if (entryType === 5 || entryType === 1 || entryType === 2) props.push(this.#readDirectoryEntry(offset));
+				else props.push({
+					type: entryType,
+					name: "",
+					previousProperty: -1,
+					nextProperty: -1,
+					childProperty: -1,
+					startBlock: 0,
+					sizeBlock: 0
+				});
+				offset += 128;
+			}
+			currentSector = this.#nextBlock(currentSector);
+		}
+		if (props.length > 0) this.#buildHierarchy(props, 0, /* @__PURE__ */ new Set(), 0);
+		return props;
+	}
+	#buildHierarchy(props, nodeIndex, visited, depth) {
+		const node = props[nodeIndex];
+		if (node === void 0 || node.childProperty === -1) return;
+		if (depth > 64) throw new MSGError("CYCLE", "Directory hierarchy nesting exceeds maximum depth", {
+			depth,
+			max: 64
+		});
+		if (visited.has(nodeIndex)) throw new MSGError("CYCLE", `Directory hierarchy revisits property index ${nodeIndex}`, { index: nodeIndex });
+		if (visited.size >= props.length) throw new MSGError("CYCLE", "Directory hierarchy traversal exceeds total property count", { limit: props.length });
+		visited.add(nodeIndex);
+		node.children = [];
+		const siblingVisited = /* @__PURE__ */ new Set([node.childProperty]);
+		const stack = [{
+			mode: "walk",
+			index: node.childProperty
+		}];
+		while (stack.length > 0) {
+			const item = stack.pop();
+			if (item === void 0) break;
+			const current = props[item.index];
+			if (current === void 0) continue;
+			if (item.mode === "push") node.children.push(item.index);
+			else {
+				if (current.type === 1) this.#buildHierarchy(props, item.index, visited, depth + 1);
+				if (current.nextProperty !== -1) {
+					if (siblingVisited.has(current.nextProperty)) throw new MSGError("CYCLE", `Directory sibling chain revisits property index ${current.nextProperty}`, { index: current.nextProperty });
+					siblingVisited.add(current.nextProperty);
+					stack.push({
+						mode: "walk",
+						index: current.nextProperty
+					});
+				}
+				stack.push({
+					mode: "push",
+					index: item.index
+				});
+				if (current.previousProperty !== -1) {
+					if (siblingVisited.has(current.previousProperty)) throw new MSGError("CYCLE", `Directory sibling chain revisits property index ${current.previousProperty}`, { index: current.previousProperty });
+					siblingVisited.add(current.previousProperty);
+					stack.push({
+						mode: "walk",
+						index: current.previousProperty
+					});
+				}
+			}
+		}
+	}
+	#buildBigBlockTable() {
+		const rootProp = this.#properties[0];
+		if (rootProp === void 0) return [];
+		const table = [];
+		const visited = /* @__PURE__ */ new Set();
+		let nextBlock = rootProp.startBlock;
+		while (nextBlock !== -2) {
+			this.#trackSector(visited, nextBlock, "Big block", this.#totalSectors, "total sector count");
+			table.push(nextBlock);
+			nextBlock = this.#nextBlock(nextBlock);
+		}
+		return table;
+	}
+	#readSmallBlockData(startBlock, blockSize, dest, destOffset) {
+		const byteOffset = startBlock * 64;
+		const bigBlockNumber = Math.floor(byteOffset / this.#bigBlockSize);
+		const bigBlockOffset = byteOffset % this.#bigBlockSize;
+		const sector = this.#bigBlockTable[bigBlockNumber];
+		if (sector === void 0) return;
+		const start = this.#blockOffset(sector) + bigBlockOffset;
+		this.#assertBounds(start, blockSize);
+		const src = new Uint8Array(this.#view.buffer, this.#view.byteOffset + start, blockSize);
+		dest.set(src, destOffset);
+	}
+	#readSmallChainData(entry, chain) {
+		const result = new Uint8Array(entry.sizeBlock);
+		let idx = 0;
+		for (let i = 0; i < chain.length; i++) {
+			const readLen = Math.min(result.length - idx, 64);
+			this.#readSmallBlockData(chain[i], readLen, result, idx);
+			idx += readLen;
+		}
+		return result;
+	}
+	#smallBlockChain(entry) {
+		const chain = [];
+		const visited = /* @__PURE__ */ new Set();
+		const capacity = this.#sbat.length * this.#bigBlockLength;
+		let next = entry.startBlock;
+		while (next !== -2) {
+			if (next < 0 || next >= capacity) throw new MSGError("MALFORMED", `Small block index ${next} exceeds mini-FAT capacity`, {
+				sector: next,
+				capacity
+			});
+			this.#trackSector(visited, next, "Small block", capacity, "mini-FAT capacity");
+			chain.push(next);
+			next = this.#nextBlockSmall(next);
+		}
+		return chain;
+	}
+	#readEntry(entry) {
+		if (entry.sizeBlock <= 0) return /* @__PURE__ */ new Uint8Array(0);
+		if (entry.sizeBlock > this.#byteLength) throw new MSGError("MALFORMED", "Directory entry size exceeds file bounds", {
+			sizeBlock: entry.sizeBlock,
+			byteLength: this.#byteLength
+		});
+		if (entry.sizeBlock < 4096) {
+			const chain = this.#smallBlockChain(entry);
+			if (chain.length === 1) {
+				const result = new Uint8Array(entry.sizeBlock);
+				this.#readSmallBlockData(entry.startBlock, entry.sizeBlock, result, 0);
+				return result;
+			} else if (chain.length > 1) return this.#readSmallChainData(entry, chain);
+			return /* @__PURE__ */ new Uint8Array(0);
+		}
+		let nextBlock = entry.startBlock;
+		let remaining = entry.sizeBlock;
+		let position = 0;
+		const result = new Uint8Array(entry.sizeBlock);
+		const visited = /* @__PURE__ */ new Set();
+		while (remaining >= 1) {
+			this.#trackSector(visited, nextBlock, "Entry block", this.#totalSectors, "total sector count");
+			const start = this.#blockOffset(nextBlock);
+			const partSize = Math.min(remaining, this.#bigBlockSize);
+			this.#assertBounds(start, partSize);
+			const src = new Uint8Array(this.#view.buffer, this.#view.byteOffset + start, partSize);
+			result.set(src, position);
+			position += partSize;
+			remaining -= partSize;
+			nextBlock = this.#nextBlock(nextBlock);
+		}
+		return result;
+	}
+	#extractFields() {
+		const root = this.#properties[0];
+		if (root === void 0) throw new MSGError("MALFORMED", "MSG file has no root directory entry");
+		const fields = {
+			kind: "msg",
+			attachments: [],
+			recipients: []
+		};
+		this.#processDirectory(root, fields, "root");
+		return this.#toFieldData(fields);
+	}
+	#str(mutable, key) {
+		const value = mutable[key];
+		return typeof value === "string" ? value : void 0;
+	}
+	#num(mutable, key) {
+		const value = mutable[key];
+		return typeof value === "number" ? value : void 0;
+	}
+	#bool(mutable, key) {
+		const value = mutable[key];
+		return typeof value === "boolean" ? value : void 0;
+	}
+	#bin(mutable, key) {
+		const value = mutable[key];
+		return value instanceof Uint8Array ? value : void 0;
+	}
+	#role(mutable, key) {
+		const value = mutable[key];
+		return value === "to" || value === "cc" || value === "bcc" ? value : void 0;
+	}
+	#toFieldData(mutable) {
+		const attachmentsSource = mutable.attachments;
+		const attachments = attachmentsSource === void 0 ? void 0 : attachmentsSource.map((entry) => this.#toFieldData(entry));
+		const recipientsSource = mutable.recipients;
+		const recipients = recipientsSource === void 0 ? void 0 : recipientsSource.map((entry) => this.#toFieldData(entry));
+		const innerSource = mutable.innerMSGContentFields;
+		const innerMSGContentFields = innerSource === void 0 ? void 0 : this.#toFieldData(innerSource);
+		return {
+			kind: mutable.kind,
+			subject: this.#str(mutable, "subject"),
+			senderName: this.#str(mutable, "senderName"),
+			senderEmail: this.#str(mutable, "senderEmail"),
+			senderAddressType: this.#str(mutable, "senderAddressType"),
+			senderSMTPAddress: this.#str(mutable, "senderSMTPAddress"),
+			sentRepresentingSMTPAddress: this.#str(mutable, "sentRepresentingSMTPAddress"),
+			body: this.#str(mutable, "body"),
+			headers: this.#str(mutable, "headers"),
+			bodyHTML: this.#str(mutable, "bodyHTML"),
+			html: this.#bin(mutable, "html"),
+			compressedRTF: this.#bin(mutable, "compressedRTF"),
+			messageClass: this.#str(mutable, "messageClass"),
+			messageFlags: this.#num(mutable, "messageFlags"),
+			messageId: this.#str(mutable, "messageId"),
+			internetCodepage: this.#num(mutable, "internetCodepage"),
+			messageCodepage: this.#num(mutable, "messageCodepage"),
+			messageLocaleId: this.#num(mutable, "messageLocaleId"),
+			clientSubmitTime: this.#str(mutable, "clientSubmitTime"),
+			messageDeliveryTime: this.#str(mutable, "messageDeliveryTime"),
+			creationTime: this.#str(mutable, "creationTime"),
+			lastModificationTime: this.#str(mutable, "lastModificationTime"),
+			lastModifierName: this.#str(mutable, "lastModifierName"),
+			creatorSMTPAddress: this.#str(mutable, "creatorSMTPAddress"),
+			lastModifierSMTPAddress: this.#str(mutable, "lastModifierSMTPAddress"),
+			preview: this.#str(mutable, "preview"),
+			conversationTopic: this.#str(mutable, "conversationTopic"),
+			normalizedSubject: this.#str(mutable, "normalizedSubject"),
+			name: this.#str(mutable, "name"),
+			email: this.#str(mutable, "email"),
+			addressType: this.#str(mutable, "addressType"),
+			smtpAddress: this.#str(mutable, "smtpAddress"),
+			recipientRole: this.#role(mutable, "recipientRole"),
+			extension: this.#str(mutable, "extension"),
+			fileNameShort: this.#str(mutable, "fileNameShort"),
+			fileName: this.#str(mutable, "fileName"),
+			contentId: this.#str(mutable, "contentId"),
+			attachmentHidden: this.#bool(mutable, "attachmentHidden"),
+			mimeType: this.#str(mutable, "mimeType"),
+			contentLength: mutable.contentLength,
+			dataId: mutable.dataId,
+			folderId: mutable.folderId,
+			innerMSGContent: mutable.innerMSGContent,
+			innerMSGContentFields,
+			attachments,
+			recipients,
+			departmentName: this.#str(mutable, "departmentName"),
+			middleName: this.#str(mutable, "middleName"),
+			generation: this.#str(mutable, "generation"),
+			surname: this.#str(mutable, "surname"),
+			givenName: this.#str(mutable, "givenName"),
+			companyName: this.#str(mutable, "companyName"),
+			jobTitle: this.#str(mutable, "jobTitle"),
+			location: this.#str(mutable, "location"),
+			postalAddress: this.#str(mutable, "postalAddress"),
+			streetAddress: this.#str(mutable, "streetAddress"),
+			postalCode: this.#str(mutable, "postalCode"),
+			country: this.#str(mutable, "country"),
+			stateOrProvince: this.#str(mutable, "stateOrProvince"),
+			homePhone: this.#str(mutable, "homePhone"),
+			mobilePhone: this.#str(mutable, "mobilePhone"),
+			businessPhone: this.#str(mutable, "businessPhone"),
+			businessFax: this.#str(mutable, "businessFax"),
+			businessHomePage: this.#str(mutable, "businessHomePage"),
+			namePrefix: this.#str(mutable, "namePrefix"),
+			homeAddressCity: this.#str(mutable, "homeAddressCity"),
+			appointmentStart: this.#str(mutable, "appointmentStart"),
+			appointmentEnd: this.#str(mutable, "appointmentEnd"),
+			clipStart: this.#str(mutable, "clipStart"),
+			clipEnd: this.#str(mutable, "clipEnd"),
+			timeZoneDescription: this.#str(mutable, "timeZoneDescription"),
+			appointmentLocation: this.#str(mutable, "appointmentLocation"),
+			appointmentOldLocation: this.#str(mutable, "appointmentOldLocation"),
+			globalAppointmentId: this.#str(mutable, "globalAppointmentId"),
+			votingResponse: this.#str(mutable, "votingResponse"),
+			internetAccountName: this.#str(mutable, "internetAccountName"),
+			yomiFirstName: this.#str(mutable, "yomiFirstName"),
+			yomiLastName: this.#str(mutable, "yomiLastName"),
+			yomiCompanyName: this.#str(mutable, "yomiCompanyName"),
+			primaryEmailAddress: this.#str(mutable, "primaryEmailAddress"),
+			primaryEmailDisplayName: this.#str(mutable, "primaryEmailDisplayName"),
+			primaryEmailOriginalDisplayName: this.#str(mutable, "primaryEmailOriginalDisplayName"),
+			fileUnder: this.#str(mutable, "fileUnder"),
+			workAddressCity: this.#str(mutable, "workAddressCity"),
+			workAddressStreet: this.#str(mutable, "workAddressStreet"),
+			workAddressState: this.#str(mutable, "workAddressState"),
+			workAddressPostalCode: this.#str(mutable, "workAddressPostalCode"),
+			workAddressCountry: this.#str(mutable, "workAddressCountry"),
+			workAddressCountryCode: this.#str(mutable, "workAddressCountryCode"),
+			addressCountryCode: this.#str(mutable, "addressCountryCode"),
+			contactWebPage: this.#str(mutable, "contactWebPage"),
+			workAddress: this.#str(mutable, "workAddress"),
+			instantMessagingAddress: this.#str(mutable, "instantMessagingAddress"),
+			fax1AddressType: this.#str(mutable, "fax1AddressType"),
+			fax1EmailAddress: this.#str(mutable, "fax1EmailAddress"),
+			fax1OriginalDisplayName: this.#str(mutable, "fax1OriginalDisplayName"),
+			fax2AddressType: this.#str(mutable, "fax2AddressType"),
+			fax2EmailAddress: this.#str(mutable, "fax2EmailAddress"),
+			fax2OriginalDisplayName: this.#str(mutable, "fax2OriginalDisplayName"),
+			fax3AddressType: this.#str(mutable, "fax3AddressType"),
+			fax3EmailAddress: this.#str(mutable, "fax3EmailAddress"),
+			fax3OriginalDisplayName: this.#str(mutable, "fax3OriginalDisplayName")
+		};
+	}
+	#processDirectory(entry, fields, subClass) {
+		const children = entry.children;
+		if (children === void 0) return;
+		for (let i = 0; i < children.length; i++) {
+			const childIndex = children[i];
+			const child = this.#properties[childIndex];
+			if (child === void 0) continue;
+			if (child.type === 1) this.#processSubDirectory(child, childIndex, fields);
+		}
+		for (let i = 0; i < children.length; i++) {
+			const childIndex = children[i];
+			const child = this.#properties[childIndex];
+			if (child === void 0) continue;
+			if (child.type === 2) {
+				if (child.name.indexOf("__substg1.") === 0) this.#processDocument(child, childIndex, fields);
+				else if (child.name === "__properties_version1.0") {
+					if (subClass === "recip" || subClass === "attachment" || subClass === "sub") this.#processPropertyStream(child, 8, fields);
+					else if (subClass === "root") this.#processPropertyStream(child, 32, fields);
+				}
+			}
+		}
+	}
+	#processSubDirectory(child, childIndex, fields) {
+		if (child.name.indexOf("__attach_version1.0") === 0) {
+			const attachmentField = { kind: "attachment" };
+			if (fields.attachments === void 0) fields.attachments = [];
+			fields.attachments.push(attachmentField);
+			this.#processDirectory(child, attachmentField, "attachment");
+		} else if (child.name.indexOf("__recip_version1.0") === 0) {
+			const recipientField = { kind: "recipient" };
+			if (fields.recipients === void 0) fields.recipients = [];
+			fields.recipients.push(recipientField);
+			this.#processDirectory(child, recipientField, "recip");
+		} else if (child.name.indexOf("__nameid_version1.0") === 0) this.#processNameIdDirectory(child);
+		else if (this.#getDirectoryFieldType(child) === "000d") {
+			const innerFields = {
+				kind: "msg",
+				attachments: [],
+				recipients: []
+			};
+			this.#processDirectory(child, innerFields, "sub");
+			fields.innerMSGContentFields = innerFields;
+			fields.innerMSGContent = true;
+			fields.folderId = childIndex;
+			this.#innerMSGBurners[childIndex] = () => this.#burnFolder(child, true, true);
+		}
+	}
+	#getDirectoryFieldType(entry) {
+		return entry.name.substring(12).toLowerCase().substring(4, 8);
+	}
+	#processDocument(entry, entryIndex, fields) {
+		const value = entry.name.substring(12).toLowerCase();
+		const fieldClass = value.substring(0, 4);
+		const fieldType = value.substring(4, 8);
+		if (fieldClass === "3701") {
+			fields.dataId = entryIndex;
+			fields.contentLength = entry.sizeBlock;
+			return;
+		}
+		const data = this.#readEntry(entry);
+		this.#decodeAndAssign(fieldClass, fieldType, data, fields, false);
+	}
+	#processPropertyStream(entry, headerSize, fields) {
+		const data = this.#readEntry(entry);
+		if (data.length <= headerSize) return;
+		const propView = new DataView(data.buffer, data.byteOffset + headerSize, data.length - headerSize);
+		let offset = 0;
+		while (offset + 16 <= propView.byteLength) {
+			const propertyTag = propView.getUint32(offset, true);
+			if (propertyTag === 0) break;
+			offset += 8;
+			const valueBytes = new Uint8Array(data.buffer, data.byteOffset + headerSize + offset, 8);
+			offset += 8;
+			const fieldClass = toHexLower(propertyTag >>> 16 & 65535, 4);
+			const fieldType = toHexLower(propertyTag & 65535, 4);
+			this.#decodeAndAssign(fieldClass, fieldType, valueBytes, fields, true);
+		}
+	}
+	#decodeAndAssign(fieldClass, fieldType, data, fields, insideProps) {
+		let key = MSG_FIELD_FULL_NAME_MAPPING[`${fieldClass}${fieldType}`] ?? MSG_FIELD_NAME_MAPPING[fieldClass];
+		const classValue = parseInt(fieldClass, 16);
+		if (!Number.isNaN(classValue) && classValue >= 32768) {
+			const keyed = this.#privatePidToKeyed[classValue];
+			if (keyed !== void 0) {
+				if (keyed.useName) key = keyed.name;
+				else if (keyed.propertySet !== void 0 && keyed.propertyLid !== void 0) {
+					const resolved = this.#resolvePidLid(keyed.propertySet, keyed.propertyLid);
+					if (resolved !== void 0) key = resolved;
+				}
+			}
+		}
+		const decodeAs = MSG_FIELD_TYPE_MAPPING[fieldType];
+		let value = data;
+		if (decodeAs === "string") {
+			value = removeTrailingNull(readANSIString(data, this.#options.encoding));
+			if (insideProps) key = void 0;
+		} else if (decodeAs === "unicode") {
+			value = removeTrailingNull(readUTF16String(new DataView(data.buffer, data.byteOffset, data.length), 0, Math.floor(data.length / 2)));
+			if (insideProps) key = void 0;
+		} else if (decodeAs === "binary") {
+			if (insideProps) key = void 0;
+		} else if (decodeAs === "integer") {
+			if (data.length >= 4) value = new DataView(data.buffer, data.byteOffset, data.length).getUint32(0, true);
+		} else if (decodeAs === "boolean") {
+			if (data.length >= 2) value = new DataView(data.buffer, data.byteOffset, data.length).getUint16(0, true) !== 0;
+		} else if (decodeAs === "time") {
+			if (data.length >= 8) {
+				const dv = new DataView(data.buffer, data.byteOffset, data.length);
+				value = fileTimeToUTCString(dv.getUint32(0, true), dv.getUint32(4, true));
+			}
+		}
+		if (key === "recipientRole" && typeof value === "number") {
+			if (value === 1) value = "to";
+			else if (value === 2) value = "cc";
+			else if (value === 3) value = "bcc";
+		}
+		if (key !== void 0) fields[key] = value;
+	}
+	#resolvePidLid(propertySet, propertyLid) {
+		const setMapping = MSG_PIDLID_MAPPING[propertySet];
+		if (setMapping === void 0) return void 0;
+		return setMapping[propertyLid];
+	}
+	#processNameIdDirectory(dirEntry) {
+		const children = dirEntry.children;
+		if (children === void 0) return;
+		let guidTable;
+		let entryTable;
+		let stringTable;
+		for (let i = 0; i < children.length; i++) {
+			const childIndex = children[i];
+			const child = this.#properties[childIndex];
+			if (child === void 0 || child.type !== 2) continue;
+			if (child.name.indexOf("__substg1.") !== 0) continue;
+			const value = child.name.substring(12).toLowerCase();
+			const fieldClass = value.substring(0, 4);
+			const fieldType = value.substring(4, 8);
+			if (fieldClass === "0002" && fieldType === "0102") guidTable = this.#readEntry(child);
+			else if (fieldClass === "0003" && fieldType === "0102") entryTable = this.#readEntry(child);
+			else if (fieldClass === "0004" && fieldType === "0102") stringTable = this.#readEntry(child);
+		}
+		if (guidTable === void 0 || entryTable === void 0 || stringTable === void 0) return;
+		this.#parseEntryStream(entryTable, guidTable, stringTable);
+	}
+	#parseEntryStream(entryTable, guidTable, stringTable) {
+		const view = new DataView(entryTable.buffer, entryTable.byteOffset, entryTable.length);
+		const entryCount = Math.floor(entryTable.length / 8);
+		for (let i = 0; i < entryCount; i++) {
+			const offset = i * 8;
+			const nameIdOrStringOffset = view.getUint32(offset, true);
+			const indexAndKind = view.getUint16(offset + 4, true);
+			const propertyIndex = view.getUint16(offset + 6, true);
+			const guidIndex = indexAndKind >>> 1 & 32767;
+			if ((nameIdOrStringOffset & 1) !== 0) {
+				const strView = new DataView(stringTable.buffer, stringTable.byteOffset, stringTable.length);
+				const strOffset = nameIdOrStringOffset >>> 0;
+				if (strOffset + 4 <= stringTable.length) {
+					const numTextBytes = strView.getUint32(strOffset, true);
+					const charCount = Math.floor(numTextBytes / 2);
+					if (strOffset + 4 + numTextBytes <= stringTable.length) {
+						const name = readUTF16String(strView, strOffset + 4, charCount);
+						this.#privatePidToKeyed[32768 | propertyIndex] = {
+							useName: true,
+							name
+						};
+					}
+				}
+			} else {
+				let propertySet;
+				if (guidIndex === 1) propertySet = "00020328-0000-0000-c000-000000000046";
+				else if (guidIndex === 2) propertySet = "00020329-0000-0000-c000-000000000046";
+				else {
+					const guidOffset = 16 * (guidIndex - 3);
+					if (guidOffset >= 0 && guidOffset + 16 <= guidTable.length) propertySet = msftUUIDStringify(guidTable, guidOffset);
+				}
+				if (propertySet !== void 0) this.#privatePidToKeyed[32768 | propertyIndex] = {
+					useName: false,
+					propertySet,
+					propertyLid: nameIdOrStringOffset
+				};
+			}
+		}
+	}
+	#burnFolder(folder, padTopLevelPropertyStream, includeRootNameId) {
+		const entries = [{
+			name: "Root Entry",
+			type: 5,
+			children: [],
+			length: 0
+		}];
+		this.#registerBurnerFolder(entries, 0, folder, padTopLevelPropertyStream, includeRootNameId);
+		return new MSGBurner().burn(entries);
+	}
+	#registerBurnerFolder(entries, parentIndex, folder, padPropertyStream, includeRootNameId) {
+		const children = folder.children;
+		if (children === void 0) return;
+		const parentChildren = entries[parentIndex].children;
+		if (parentChildren === void 0) return;
+		for (let i = 0; i < children.length; i++) {
+			const childIndex = children[i];
+			const child = this.#properties[childIndex];
+			if (child === void 0 || child.type !== 2) continue;
+			let provider = () => this.#readEntry(child);
+			let length = child.sizeBlock;
+			if (padPropertyStream && child.name === "__properties_version1.0") {
+				const originalProvider = provider;
+				provider = () => {
+					const src = originalProvider();
+					const dst = new Uint8Array(src.length + 8);
+					dst.set(src.subarray(0, 24), 0);
+					dst.set(src.subarray(24), 32);
+					return dst;
+				};
+				length = length + 8;
+			}
+			const subIndex = entries.length;
+			parentChildren.push(subIndex);
+			entries.push({
+				name: child.name,
+				type: 2,
+				binaryProvider: provider,
+				length
+			});
+		}
+		if (includeRootNameId) {
+			const rootProp = this.#properties[0];
+			if (rootProp !== void 0 && rootProp.children !== void 0) for (let i = 0; i < rootProp.children.length; i++) {
+				const rootChildIndex = rootProp.children[i];
+				const rootChild = this.#properties[rootChildIndex];
+				if (rootChild !== void 0 && rootChild.type === 1 && rootChild.name === "__nameid_version1.0") {
+					const subIndex = entries.length;
+					parentChildren.push(subIndex);
+					entries.push({
+						name: rootChild.name,
+						type: 1,
+						children: [],
+						length: 0
+					});
+					this.#registerBurnerFolder(entries, subIndex, rootChild, false, false);
+				}
+			}
+		}
+		for (let i = 0; i < children.length; i++) {
+			const childIndex = children[i];
+			const child = this.#properties[childIndex];
+			if (child === void 0 || child.type !== 1) continue;
+			const subIndex = entries.length;
+			parentChildren.push(subIndex);
+			entries.push({
+				name: child.name,
+				type: 1,
+				children: [],
+				length: 0
+			});
+			this.#registerBurnerFolder(entries, subIndex, child, false, false);
+		}
+	}
+};
+//#endregion
+//#region src/core/EmailParser.ts
+/**
+* Parses raw .eml or .msg file bytes into a structured {@link EmailChain}.
+* Synchronous and dependency-free: format detection falls back to sniffing
+* the CFB magic header when neither `name` nor `mime` resolves it, and every
+* parse failure is contained into a `Result` rather than thrown.
+*
+* @example
+* ```ts
+* import { createEmailParser, isSuccess } from '@src/core'
+*
+* const parser = createEmailParser()
+* const result = parser.parse({ bytes, name: 'message.eml' })
+* if (isSuccess(result)) {
+* 	const { messages } = result.value
+* 	console.log(messages[0].text)
+* 	console.log(messages[0].attachments)
+* }
+* ```
+*/
+var EmailParser = class {
+	#options;
+	constructor(options = {}) {
+		this.#options = { ...options };
+	}
+	/**
+	* Parse raw email bytes into a structured chain.
+	*
+	* @param input - Raw bytes plus optional name/MIME hints
+	* @returns A {@link Success} wrapping the parsed {@link EmailChain}, or a
+	* {@link Failure} wrapping an {@link MSGError} (code `UNSUPPORTED` when
+	* the format cannot be determined, `MALFORMED` when parsing fails)
+	*
+	* @example
+	* ```ts
+	* const result = parser.parse({ bytes, name: 'message.msg' })
+	* ```
+	*/
+	parse(input) {
+		try {
+			const format = detectFormat(input.name, input.mime) ?? (isMSGFile(new DataView(input.bytes.buffer, input.bytes.byteOffset, input.bytes.byteLength)) ? "msg" : void 0);
+			if (format === void 0) return failure(new MSGError("UNSUPPORTED", `"${input.name ?? "input"}" — only .eml and .msg files are supported`, {
+				name: input.name,
+				mime: input.mime
+			}));
+			if (format === "msg") return success({
+				format,
+				messages: [extractMessageFromMSG(new MSGReader(input.bytes, { encoding: this.#options.encoding }))]
+			});
+			return success({
+				format,
+				messages: [extractMessage(parseMIMEPart(decodeUTF8(input.bytes)))]
+			});
+		} catch (cause) {
+			if (isMSGError(cause)) return failure(cause);
+			if (cause instanceof Error) return failure(new MSGError("MALFORMED", cause.message));
+			return failure(new MSGError("MALFORMED", "Failed to parse email input"));
+		}
+	}
+	/**
+	* Current parser configuration.
+	*
+	* @returns A copy of the configured {@link EmailParserOptions} — the
+	* internal reference is never leaked
+	*/
+	get options() {
+		return { ...this.#options };
+	}
+};
+//#endregion
+//#region src/core/factories.ts
+/**
+* Create a new .msg file reader.
+*
+* @param buffer - Raw .msg file bytes
+* @param options - Optional reader configuration
+* @returns A working {@link MSGReaderInterface}
+*
+* @example
+* ```ts
+* import { createMSGReader } from '@src/core'
+*
+* const reader = createMSGReader(buffer)
+* const data = reader.parse()
+* console.log(data.kind)
+* ```
+*/
+function createMSGReader(buffer, options) {
+	return new MSGReader(buffer, options);
+}
+/**
+* Create a new CFB binary writer for reconstituting .msg files.
+*
+* @returns A working {@link MSGBurnerInterface}
+*
+* @example
+* ```ts
+* import { createMSGBurner } from '@src/core'
+*
+* const burner = createMSGBurner()
+* const binary = burner.burn(entries)
+* ```
+*/
+function createMSGBurner() {
+	return new MSGBurner();
+}
+/**
+* Create a new email file parser for .eml and .msg input.
+*
+* @param options - Optional parser configuration
+* @returns A working {@link EmailParserInterface}
+*
+* @example
+* ```ts
+* import { createEmailParser, isSuccess } from '@src/core'
+*
+* const parser = createEmailParser()
+* const result = parser.parse({ bytes, name: 'message.eml' })
+* if (isSuccess(result)) {
+* 	console.log(result.value.messages[0].subject)
+* }
+* ```
+*/
+function createEmailParser(options) {
+	return new EmailParser(options);
+}
+//#endregion
+export { EML_EXTENSIONS, EML_MIME_TYPES, EmailParser, FALLBACK_ATTACHMENT_NAME, FALLBACK_CHARSET, MIME_EXTENSIONS, MIME_MAX_DEPTH, MSGBurner, MSGError, MSGReader, MSG_BIG_BLOCK_MIN_DOC_SIZE, MSG_BURNER_DIFAT_HEADER_SLOTS, MSG_BURNER_DIFAT_SECTOR_MARKER, MSG_BURNER_DIR_ENTRY_SIZE, MSG_BURNER_FAT_SECTOR_MARKER, MSG_BURNER_INTS_PER_SECTOR, MSG_BURNER_MINI_SECTOR_SIZE, MSG_BURNER_MINI_STREAM_CUTOFF, MSG_BURNER_NAME_MAX, MSG_BURNER_ROOT_CLSID, MSG_BURNER_SECTOR_SIZE, MSG_END_OF_CHAIN, MSG_EXTENSIONS, MSG_FIELD_CLASS_ATTACHMENT_DATA, MSG_FIELD_DIR_TYPE_INNER_MSG, MSG_FIELD_FULL_NAME_MAPPING, MSG_FIELD_NAME_MAPPING, MSG_FIELD_TYPE_MAPPING, MSG_FILE_HEADER, MSG_HEADER_BAT_COUNT_OFFSET, MSG_HEADER_BAT_START_OFFSET, MSG_HEADER_PROPERTY_START_OFFSET, MSG_HEADER_SBAT_COUNT_OFFSET, MSG_HEADER_SBAT_START_OFFSET, MSG_HEADER_XBAT_COUNT_OFFSET, MSG_HEADER_XBAT_START_OFFSET, MSG_L_BIG_BLOCK_MARK, MSG_L_BIG_BLOCK_SIZE, MSG_MAPI_RECIPIENT_BCC, MSG_MAPI_RECIPIENT_CC, MSG_MAPI_RECIPIENT_TO, MSG_MAX_HIERARCHY_DEPTH, MSG_MIME_TYPES, MSG_PIDLID_MAPPING, MSG_PREFIX_ATTACHMENT, MSG_PREFIX_DOCUMENT, MSG_PREFIX_NAMEID, MSG_PREFIX_RECIPIENT, MSG_PROPERTY_SIZE, MSG_PROP_CHILD_PROPERTY_OFFSET, MSG_PROP_NAME_SIZE_OFFSET, MSG_PROP_NEXT_PROPERTY_OFFSET, MSG_PROP_NO_INDEX, MSG_PROP_PREVIOUS_PROPERTY_OFFSET, MSG_PROP_SIZE_OFFSET, MSG_PROP_START_BLOCK_OFFSET, MSG_PROP_TYPE_OFFSET, MSG_SMALL_BLOCK_SIZE, MSG_S_BIG_BLOCK_MARK, MSG_S_BIG_BLOCK_SIZE, MSG_TYPE_DIRECTORY, MSG_TYPE_DOCUMENT, MSG_TYPE_ROOT, MSG_TYPE_UNALLOCATED, MSG_UNUSED_BLOCK, UTF8_SEQUENCE_MINIMUM, WINDOWS_1252_HIGH, compareCFBName, createEmailParser, createMSGBurner, createMSGReader, decodeBase64, decodeLatin1, decodeMIMEEncoding, decodeMIMEText, decodeMIMEWords, decodeUTF8, decodeWindows1252, detectFormat, encodeUTF8, extractMessage, extractMessageFromMSG, failure, fileTimeToUTCString, formatEmailAddress, inferExtension, isEmailFormat, isFailure, isMSGError, isMSGFile, isRecord, isSuccess, msftUUIDStringify, parseMIMEHeaders, parseMIMEPart, readANSIString, readUTF16String, removeTrailingNull, resolveEncoding, roundUpToMultiple, sectorsNeeded, success, toHexLower };
+
+//# sourceMappingURL=index.js.map