mailfile 0.1.0

package/dist/mailfile.js

@@ -0,0 +1,2037 @@
+var mailfile = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/index.js
+  var index_exports = {};
+  __export(index_exports, {
+    ErrorCode: () => ErrorCode,
+    Headers: () => Headers,
+    MailfileError: () => MailfileError,
+    Message: () => Message,
+    convert: () => convert,
+    detect: () => detect,
+    version: () => version
+  });
+
+  // src/mime/encodings.js
+  var B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  function bytesToBase64(bytes) {
+    let out = "";
+    let i;
+    const len = bytes.length;
+    for (i = 0; i + 2 < len; i += 3) {
+      const n = bytes[i] << 16 | bytes[i + 1] << 8 | bytes[i + 2];
+      out += B64[n >> 18 & 63] + B64[n >> 12 & 63] + B64[n >> 6 & 63] + B64[n & 63];
+    }
+    const rem = len - i;
+    if (rem === 1) {
+      const a = bytes[i] << 16;
+      out += B64[a >> 18 & 63] + B64[a >> 12 & 63] + "==";
+    } else if (rem === 2) {
+      const b = bytes[i] << 16 | bytes[i + 1] << 8;
+      out += B64[b >> 18 & 63] + B64[b >> 12 & 63] + B64[b >> 6 & 63] + "=";
+    }
+    return out;
+  }
+  function base64ToBytes(str) {
+    let clean = String(str).replace(/[^A-Za-z0-9+/=]/g, "");
+    const pad = clean.indexOf("=");
+    if (pad >= 0) clean = clean.slice(0, pad);
+    const len = clean.length;
+    const out = new Uint8Array(Math.floor(len * 3 / 4));
+    let p = 0;
+    let buf = 0;
+    let bits = 0;
+    for (let i = 0; i < len; i++) {
+      const v = B64.indexOf(clean[i]);
+      if (v < 0) continue;
+      buf = buf << 6 | v;
+      bits += 6;
+      if (bits >= 8) {
+        bits -= 8;
+        out[p++] = buf >> bits & 255;
+      }
+    }
+    return out.subarray(0, p);
+  }
+  function wrap(str, width) {
+    const out = [];
+    for (let i = 0; i < str.length; i += width) out.push(str.slice(i, i + width));
+    return out.join("\r\n");
+  }
+  var encoder = new TextEncoder();
+  function utf8Encode(s) {
+    return encoder.encode(s);
+  }
+  function decodeBytes(bytes, charset) {
+    let cs = (charset || "utf-8").toLowerCase().replace(/^["']|["']$/g, "");
+    if (cs === "us-ascii" || cs === "ascii" || cs === "ansi_x3.4-1968") cs = "utf-8";
+    if (cs === "cp1252" || cs === "win-1252") cs = "windows-1252";
+    if (cs === "utf8") cs = "utf-8";
+    try {
+      return new TextDecoder(cs, { fatal: false }).decode(bytes);
+    } catch {
+      try {
+        return new TextDecoder("windows-1252").decode(bytes);
+      } catch {
+        let s = "";
+        for (let i = 0; i < bytes.length; i++) s += String.fromCharCode(bytes[i]);
+        return s;
+      }
+    }
+  }
+  function utf16Decode(bytes) {
+    try {
+      return new TextDecoder("utf-16le").decode(bytes);
+    } catch {
+      let s = "";
+      for (let i = 0; i + 1 < bytes.length; i += 2) {
+        s += String.fromCharCode(bytes[i] | bytes[i + 1] << 8);
+      }
+      return s;
+    }
+  }
+  function utf16Encode(str) {
+    const out = new Uint8Array(str.length * 2);
+    for (let i = 0; i < str.length; i++) {
+      const c = str.charCodeAt(i);
+      out[i * 2] = c & 255;
+      out[i * 2 + 1] = c >> 8;
+    }
+    return out;
+  }
+  function decodeQP(str, isHeaderWord) {
+    const out = [];
+    let i = 0;
+    while (i < str.length) {
+      const ch = str[i];
+      if (ch === "=") {
+        if (str[i + 1] === "\r" && str[i + 2] === "\n") {
+          i += 3;
+          continue;
+        }
+        if (str[i + 1] === "\n") {
+          i += 2;
+          continue;
+        }
+        const hex = str.substr(i + 1, 2);
+        if (/^[0-9A-Fa-f]{2}$/.test(hex)) {
+          out.push(parseInt(hex, 16));
+          i += 3;
+          continue;
+        }
+        out.push(61);
+        i++;
+      } else if (isHeaderWord && ch === "_") {
+        out.push(32);
+        i++;
+      } else {
+        out.push(str.charCodeAt(i) & 255);
+        i++;
+      }
+    }
+    return new Uint8Array(out);
+  }
+  function encodeQP(bytes) {
+    let out = "";
+    let lineLen = 0;
+    function push(tok) {
+      if (lineLen + tok.length > 75) {
+        out += "=\r\n";
+        lineLen = 0;
+      }
+      out += tok;
+      lineLen += tok.length;
+    }
+    const hex = (b) => "=" + ("0" + b.toString(16).toUpperCase()).slice(-2);
+    for (let i = 0; i < bytes.length; i++) {
+      const b = bytes[i];
+      if (b === 13 && bytes[i + 1] === 10) {
+        out += "\r\n";
+        lineLen = 0;
+        i++;
+        continue;
+      }
+      if (b === 10) {
+        out += "\r\n";
+        lineLen = 0;
+        continue;
+      }
+      if (b === 32 || b === 9) {
+        const next = bytes[i + 1];
+        if (next === 13 || next === 10 || next === void 0) push(hex(b));
+        else push(String.fromCharCode(b));
+        continue;
+      }
+      if (b === 61 || b < 32 || b > 126) push(hex(b));
+      else push(String.fromCharCode(b));
+    }
+    return out;
+  }
+
+  // src/mime/headers.js
+  function decodeWords(str) {
+    if (!str || str.indexOf("=?") < 0) return str || "";
+    const joined = str.replace(/(\?=)(?:\r?\n)?[ \t]+(=\?)/g, "$1$2");
+    return joined.replace(/=\?([^?]+)\?([BbQq])\?([^?]*)\?=/g, (m, cs, enc, text) => {
+      try {
+        const raw = enc.toUpperCase() === "B" ? base64ToBytes(text) : decodeQP(text, true);
+        return decodeBytes(raw, cs);
+      } catch {
+        return m;
+      }
+    });
+  }
+  function needsEncoding(s) {
+    return /[^\x20-\x7E]/.test(s);
+  }
+  function encodeWord(s) {
+    if (!needsEncoding(s)) return s;
+    const parts = [];
+    let cur = "";
+    let curBytes = 0;
+    const chars = Array.from(s);
+    for (const ch of chars) {
+      const n = utf8Encode(ch).length;
+      if (curBytes + n > 36) {
+        parts.push(cur);
+        cur = "";
+        curBytes = 0;
+      }
+      cur += ch;
+      curBytes += n;
+    }
+    if (cur) parts.push(cur);
+    return parts.map((p) => "=?UTF-8?B?" + bytesToBase64(utf8Encode(p)) + "?=").join("\r\n ");
+  }
+  function foldHeader(name, value) {
+    const line = name + ": " + value;
+    if (line.length <= 78 || /\r\n/.test(line)) return line;
+    let out = "";
+    let cur = name + ":";
+    const tokens = value.split(" ");
+    for (const tok of tokens) {
+      if (cur.length + 1 + tok.length > 78 && cur !== name + ":") {
+        out += cur + "\r\n";
+        cur = " " + tok;
+      } else {
+        cur += (cur === " " ? "" : " ") + tok;
+      }
+    }
+    return out + cur;
+  }
+  function formatAddress(name, email) {
+    email = (email || "").trim();
+    name = (name || "").trim();
+    if (!email) return name ? encodeWord(name) : "";
+    if (!name || name.toLowerCase() === email.toLowerCase()) return email;
+    if (needsEncoding(name)) return encodeWord(name) + " <" + email + ">";
+    if (/[()<>@,;:\\".\[\]]/.test(name)) {
+      return '"' + name.replace(/(["\\])/g, "\\$1") + '" <' + email + ">";
+    }
+    return name + " <" + email + ">";
+  }
+  function splitAddressList(str) {
+    const out = [];
+    let cur = "";
+    let inQuote = false;
+    let depth = 0;
+    for (let i = 0; i < str.length; i++) {
+      const c = str[i];
+      if (c === '"' && str[i - 1] !== "\\") inQuote = !inQuote;
+      if (!inQuote && (c === "<" || c === "(")) depth++;
+      if (!inQuote && (c === ">" || c === ")")) depth--;
+      if (c === "," && !inQuote && depth <= 0) {
+        out.push(cur);
+        cur = "";
+        continue;
+      }
+      cur += c;
+    }
+    if (cur.trim()) out.push(cur);
+    return out.map((s) => s.trim()).filter(Boolean);
+  }
+  function parseAddress(str) {
+    const s = decodeWords(String(str).trim());
+    const m = s.match(/^(.*)<([^>]*)>\s*$/);
+    if (m) {
+      const name = m[1].trim().replace(/^"(.*)"$/, "$1").replace(/\\(["\\])/g, "$1");
+      return { name, email: m[2].trim() };
+    }
+    return { name: "", email: s.replace(/^<|>$/g, "").trim() };
+  }
+  function parseAddressList(str) {
+    if (!str) return [];
+    return splitAddressList(String(str)).map(parseAddress).filter((a) => a.email || a.name);
+  }
+  function parseHeaderValue(raw) {
+    let value = "";
+    const params = {};
+    let i = 0;
+    const str = String(raw || "");
+    while (i < str.length && str[i] !== ";") {
+      value += str[i];
+      i++;
+    }
+    const rest = str.slice(i + 1);
+    const re = /\s*([^=\s;]+)\s*=\s*("(?:[^"\\]|\\.)*"|[^;]*)\s*(?:;|$)/g;
+    const raws = {};
+    let m;
+    while (m = re.exec(rest)) {
+      if (!m[1]) break;
+      let v = m[2].trim();
+      if (v[0] === '"') v = v.slice(1, -1).replace(/\\(.)/g, "$1");
+      raws[m[1].toLowerCase()] = v;
+    }
+    const pieces = {};
+    for (const k of Object.keys(raws)) {
+      const mm = k.match(/^([^*]+)(?:\*(\d+))?(\*)?$/);
+      if (!mm) {
+        params[k] = raws[k];
+        continue;
+      }
+      const base = mm[1];
+      const idx = mm[2] === void 0 ? -1 : parseInt(mm[2], 10);
+      const ext = !!mm[3];
+      if (idx < 0 && !ext) {
+        if (!(base in pieces)) params[base] = raws[k];
+        continue;
+      }
+      pieces[base] = pieces[base] || [];
+      pieces[base].push({ idx: idx < 0 ? 0 : idx, ext, v: raws[k] });
+    }
+    for (const base of Object.keys(pieces)) {
+      const list = pieces[base].sort((a, b) => a.idx - b.idx);
+      let charset = null;
+      let acc = "";
+      list.forEach((p, n) => {
+        let v = p.v;
+        if (p.ext) {
+          if (n === 0 && v.indexOf("'") >= 0) {
+            const bits = v.split("'");
+            charset = bits[0];
+            v = bits.slice(2).join("'");
+          }
+          acc += v;
+        } else {
+          acc += v;
+        }
+      });
+      if (charset || /%[0-9A-Fa-f]{2}/.test(acc)) {
+        const bytes = [];
+        for (let j = 0; j < acc.length; j++) {
+          if (acc[j] === "%" && /^[0-9A-Fa-f]{2}$/.test(acc.substr(j + 1, 2))) {
+            bytes.push(parseInt(acc.substr(j + 1, 2), 16));
+            j += 2;
+          } else {
+            bytes.push(acc.charCodeAt(j) & 255);
+          }
+        }
+        params[base] = decodeBytes(new Uint8Array(bytes), charset || "utf-8");
+      } else {
+        params[base] = decodeWords(acc);
+      }
+    }
+    return { value: value.trim(), params };
+  }
+  function encodeParamValue(name, val) {
+    if (!needsEncoding(val) && !/[";\\]/.test(val)) return name + '="' + val + '"';
+    if (!needsEncoding(val)) return name + '="' + val.replace(/(["\\])/g, "\\$1") + '"';
+    const bytes = utf8Encode(val);
+    let enc = "";
+    for (const b of bytes) {
+      if (b >= 48 && b <= 57 || b >= 65 && b <= 90 || b >= 97 && b <= 122 || b === 45 || b === 46 || b === 95) {
+        enc += String.fromCharCode(b);
+      } else {
+        enc += "%" + ("0" + b.toString(16).toUpperCase()).slice(-2);
+      }
+    }
+    const ascii = val.replace(/[^\x20-\x7E]/g, "_").replace(/(["\\])/g, "");
+    return name + '="' + ascii + '"; ' + name + "*=UTF-8''" + enc;
+  }
+  var Headers = class _Headers {
+    /** @param {Array<[string, string]>} [entries] */
+    constructor(entries) {
+      this.entries = entries ? entries.slice() : [];
+    }
+    /**
+     * Parse a raw header block. Continuation lines are unfolded.
+     * @param {string} text
+     * @returns {Headers}
+     */
+    static parse(text) {
+      const unfolded = String(text || "").replace(/\r?\n[ \t]+/g, " ");
+      const entries = [];
+      for (const line of unfolded.split(/\r?\n/)) {
+        if (!line.trim()) continue;
+        const idx = line.indexOf(":");
+        if (idx < 0) continue;
+        entries.push([line.slice(0, idx).trim(), line.slice(idx + 1).trim()]);
+      }
+      return new _Headers(entries);
+    }
+    /** @param {string} name @returns {string|null} First matching value. */
+    get(name) {
+      const lower = name.toLowerCase();
+      for (const [k, v] of this.entries) if (k.toLowerCase() === lower) return v;
+      return null;
+    }
+    /** @param {string} name @returns {string[]} Every matching value, in order. */
+    getAll(name) {
+      const lower = name.toLowerCase();
+      return this.entries.filter(([k]) => k.toLowerCase() === lower).map(([, v]) => v);
+    }
+    /** @param {string} name @returns {boolean} */
+    has(name) {
+      return this.get(name) !== null;
+    }
+    /** Replace all occurrences with a single value. @param {string} name @param {string} value */
+    set(name, value) {
+      this.delete(name);
+      this.entries.push([name, value]);
+      return this;
+    }
+    /** Append without removing existing occurrences. @param {string} name @param {string} value */
+    add(name, value) {
+      this.entries.push([name, value]);
+      return this;
+    }
+    /** @param {string} name */
+    delete(name) {
+      const lower = name.toLowerCase();
+      this.entries = this.entries.filter(([k]) => k.toLowerCase() !== lower);
+      return this;
+    }
+    /** Header block as text, with folding applied. @returns {string} */
+    get raw() {
+      return this.entries.map(([k, v]) => foldHeader(k, v)).join("\r\n");
+    }
+    [Symbol.iterator]() {
+      return this.entries[Symbol.iterator]();
+    }
+  };
+  function formatDate(d) {
+    const days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+    const months = [
+      "Jan",
+      "Feb",
+      "Mar",
+      "Apr",
+      "May",
+      "Jun",
+      "Jul",
+      "Aug",
+      "Sep",
+      "Oct",
+      "Nov",
+      "Dec"
+    ];
+    const p = (n) => (n < 10 ? "0" : "") + n;
+    let tz = -d.getTimezoneOffset();
+    const sign = tz >= 0 ? "+" : "-";
+    tz = Math.abs(tz);
+    return days[d.getDay()] + ", " + d.getDate() + " " + months[d.getMonth()] + " " + d.getFullYear() + " " + p(d.getHours()) + ":" + p(d.getMinutes()) + ":" + p(d.getSeconds()) + " " + sign + p(Math.floor(tz / 60)) + p(tz % 60);
+  }
+  function parseDate(str) {
+    if (!str) return null;
+    const d = new Date(String(str).replace(/\s*\([^)]*\)\s*$/, ""));
+    return isNaN(d.getTime()) ? null : d;
+  }
+
+  // src/mime/build.js
+  function randomBoundary(tag) {
+    let s = "";
+    for (let i = 0; i < 24; i++) s += "0123456789abcdef"[Math.floor(Math.random() * 16)];
+    return "----=_" + tag + "_" + s;
+  }
+  function textPart(mime, content) {
+    return [
+      "Content-Type: " + mime + '; charset="utf-8"',
+      "Content-Transfer-Encoding: quoted-printable",
+      "",
+      encodeQP(utf8Encode(content))
+    ].join("\r\n");
+  }
+  function attachmentPart(att) {
+    const mime = att.mime || "application/octet-stream";
+    const lines = [
+      "Content-Type: " + mime + "; " + encodeParamValue("name", att.filename),
+      "Content-Transfer-Encoding: base64"
+    ];
+    if (att.cid) lines.push("Content-ID: <" + att.cid + ">");
+    lines.push("Content-Disposition: " + (att.inline ? "inline" : "attachment") + "; " + encodeParamValue("filename", att.filename));
+    lines.push("");
+    lines.push(wrap(bytesToBase64(att.data), 76));
+    return lines.join("\r\n");
+  }
+  function multipart(subtype, parts, extraParams) {
+    const b = randomBoundary(subtype.toUpperCase());
+    const head = "Content-Type: multipart/" + subtype + '; boundary="' + b + '"' + (extraParams || "");
+    let body = "";
+    for (const p of parts) body += "--" + b + "\r\n" + p + "\r\n";
+    body += "--" + b + "--\r\n";
+    return { head, body };
+  }
+  function buildEml(msg) {
+    const inline = [];
+    const regular = [];
+    for (const a of msg.attachments || []) {
+      if (a.inline && a.cid) inline.push(a);
+      else regular.push(a);
+    }
+    const bodyParts = [];
+    if (msg.text) bodyParts.push(textPart("text/plain", msg.text));
+    if (msg.html) bodyParts.push(textPart("text/html", msg.html));
+    if (!bodyParts.length) bodyParts.push(textPart("text/plain", ""));
+    let current;
+    if (bodyParts.length > 1) {
+      const alt = multipart("alternative", bodyParts);
+      current = alt.head + "\r\n\r\n" + alt.body;
+    } else {
+      current = bodyParts[0];
+    }
+    if (inline.length) {
+      const rel = multipart(
+        "related",
+        [current].concat(inline.map(attachmentPart)),
+        '; type="text/html"'
+      );
+      current = rel.head + "\r\n\r\n" + rel.body;
+    }
+    if (regular.length) {
+      const mixed = multipart("mixed", [current].concat(regular.map(attachmentPart)));
+      current = mixed.head + "\r\n\r\n" + mixed.body;
+    }
+    const idx = current.indexOf("\r\n\r\n");
+    const partHeaders = current.slice(0, idx);
+    const partBody = current.slice(idx + 4);
+    const headerLines = [];
+    for (const [k, v] of msg.headers || []) headerLines.push(foldHeader(k, v));
+    headerLines.push("MIME-Version: 1.0");
+    for (const l of partHeaders.split("\r\n")) if (l) headerLines.push(l);
+    return utf8Encode(headerLines.join("\r\n") + "\r\n\r\n" + partBody);
+  }
+
+  // src/mime/parse.js
+  function findHeaderEnd(bytes) {
+    for (let i = 0; i + 1 < bytes.length; i++) {
+      if (bytes[i] === 10 && bytes[i + 1] === 10) return { end: i, bodyStart: i + 2 };
+      if (bytes[i] === 13 && bytes[i + 1] === 10 && bytes[i + 2] === 13 && bytes[i + 3] === 10) {
+        return { end: i, bodyStart: i + 4 };
+      }
+    }
+    return { end: bytes.length, bodyStart: bytes.length };
+  }
+  function splitOnBoundary(bytes, boundary) {
+    const marker = utf8Encode("--" + boundary);
+    const parts = [];
+    const starts = [];
+    for (let i = 0; i <= bytes.length - marker.length; i++) {
+      if (bytes[i] !== 45 || bytes[i + 1] !== 45) continue;
+      if (i > 0 && bytes[i - 1] !== 10) continue;
+      let ok = true;
+      for (let j = 0; j < marker.length; j++) {
+        if (bytes[i + j] !== marker[j]) {
+          ok = false;
+          break;
+        }
+      }
+      if (!ok) continue;
+      const after = i + marker.length;
+      const isEnd = bytes[after] === 45 && bytes[after + 1] === 45;
+      let k = after + (isEnd ? 2 : 0);
+      while (bytes[k] === 32 || bytes[k] === 9) k++;
+      if (!(bytes[k] === 13 || bytes[k] === 10 || k >= bytes.length)) continue;
+      let contentStart = k;
+      if (bytes[contentStart] === 13) contentStart++;
+      if (bytes[contentStart] === 10) contentStart++;
+      starts.push({ at: i, contentStart, isEnd });
+      if (isEnd) break;
+    }
+    for (let s = 0; s < starts.length - 1; s++) {
+      const from = starts[s].contentStart;
+      let to = starts[s + 1].at;
+      if (to > from && bytes[to - 1] === 10) to--;
+      if (to > from && bytes[to - 1] === 13) to--;
+      parts.push(bytes.subarray(from, Math.max(from, to)));
+    }
+    return parts;
+  }
+  function decodePart(bytes, encoding) {
+    const enc = (encoding || "7bit").trim().toLowerCase();
+    if (enc === "base64") return base64ToBytes(decodeBytes(bytes, "utf-8"));
+    if (enc === "quoted-printable") {
+      let s = "";
+      for (let i = 0; i < bytes.length; i++) s += String.fromCharCode(bytes[i]);
+      return decodeQP(s, false);
+    }
+    return bytes;
+  }
+  function parseNode(bytes, depth = 0) {
+    const split = findHeaderEnd(bytes);
+    const headers = Headers.parse(decodeBytes(bytes.subarray(0, split.end), "utf-8"));
+    const body = bytes.subarray(split.bodyStart);
+    const ct = parseHeaderValue(headers.get("content-type") || "text/plain");
+    const node = {
+      headers,
+      contentType: (ct.value || "text/plain").toLowerCase(),
+      params: ct.params,
+      children: []
+    };
+    if (node.contentType.startsWith("multipart/") && ct.params.boundary && depth < 20) {
+      for (const kid of splitOnBoundary(body, ct.params.boundary)) {
+        node.children.push(parseNode(kid, depth + 1));
+      }
+    } else {
+      node.content = decodePart(body, headers.get("content-transfer-encoding"));
+    }
+    return node;
+  }
+  var EXT_BY_MIME = {
+    "text/plain": "txt",
+    "text/html": "html",
+    "image/png": "png",
+    "image/jpeg": "jpg",
+    "image/gif": "gif",
+    "application/pdf": "pdf",
+    "message/rfc822": "eml"
+  };
+  function guessName(mime, n) {
+    return "attachment-" + (n + 1) + "." + (EXT_BY_MIME[mime] || "bin");
+  }
+  function collectParts(node, out, parentType) {
+    if (node.children.length) {
+      for (const c of node.children) collectParts(c, out, node.contentType);
+      return;
+    }
+    const disp = parseHeaderValue(node.headers.get("content-disposition") || "");
+    const dispType = (disp.value || "").toLowerCase();
+    const filename = disp.params.filename || node.params.name || "";
+    const cid = (node.headers.get("content-id") || "").replace(/^<|>$/g, "").trim();
+    const isText = node.contentType === "text/plain" || node.contentType === "text/html";
+    const isBody = isText && dispType !== "attachment" && !filename;
+    if (isBody) {
+      const text = decodeBytes(node.content, node.params.charset || "utf-8");
+      if (node.contentType === "text/html") out.html = out.html || text;
+      else out.text = out.text || text;
+      return;
+    }
+    out.attachments.push({
+      filename: decodeWords(filename) || guessName(node.contentType, out.attachments.length),
+      mime: node.contentType,
+      data: node.content || new Uint8Array(0),
+      cid,
+      inline: dispType === "inline" || !!cid && parentType === "multipart/related"
+    });
+  }
+  function parseEml(bytes) {
+    const root = parseNode(bytes, 0);
+    const out = { text: "", html: "", attachments: [], headers: root.headers, root };
+    collectParts(root, out, root.contentType);
+    return out;
+  }
+
+  // src/errors.js
+  var ErrorCode = {
+    /** The bytes are not an OLE2 compound file (wrong magic number). */
+    NOT_COMPOUND_FILE: "NOT_COMPOUND_FILE",
+    /** The compound file's internal structure is inconsistent or damaged. */
+    CORRUPT_CFB: "CORRUPT_CFB",
+    /** A stream ended before the declared length. */
+    TRUNCATED_STREAM: "TRUNCATED_STREAM",
+    /** The compound file is valid but is not an Outlook message. */
+    NOT_A_MESSAGE: "NOT_A_MESSAGE",
+    /** Input was empty. */
+    EMPTY_INPUT: "EMPTY_INPUT",
+    /** A structure is well-formed but uses a feature mailfile cannot represent. */
+    UNSUPPORTED: "UNSUPPORTED",
+    /** Strict mode only: the input deviates from the specification. */
+    MALFORMED: "MALFORMED"
+  };
+  var MailfileError = class extends Error {
+    /**
+     * @param {string} code One of {@link ErrorCode}.
+     * @param {string} message Human-readable description.
+     * @param {{cause?: unknown}} [options]
+     */
+    constructor(code, message, options) {
+      super(message);
+      this.name = "MailfileError";
+      this.code = code;
+      if (options && options.cause !== void 0) this.cause = options.cause;
+    }
+  };
+
+  // src/cfb/read.js
+  var SIG = [208, 207, 17, 224, 161, 177, 26, 225];
+  var FREESECT = 4294967295;
+  var ENDOFCHAIN = 4294967294;
+  var NOSTREAM = 4294967295;
+  var MINI_CUTOFF = 4096;
+  function read(bytes) {
+    if (!bytes || !bytes.length) {
+      throw new MailfileError(ErrorCode.EMPTY_INPUT, "No data to read");
+    }
+    if (bytes.length < 512) {
+      throw new MailfileError(
+        ErrorCode.NOT_COMPOUND_FILE,
+        "File is too small to be a compound file"
+      );
+    }
+    const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    for (let i = 0; i < 8; i++) {
+      if (bytes[i] !== SIG[i]) {
+        throw new MailfileError(
+          ErrorCode.NOT_COMPOUND_FILE,
+          "Not a compound file (bad OLE signature)"
+        );
+      }
+    }
+    const sectorSize = 1 << dv.getUint16(30, true);
+    const miniSectorSize = 1 << dv.getUint16(32, true);
+    const numFatSectors = dv.getUint32(44, true);
+    const firstDirSector = dv.getUint32(48, true);
+    const miniCutoff = dv.getUint32(56, true) || MINI_CUTOFF;
+    const firstMiniFat = dv.getUint32(60, true);
+    const firstDifat = dv.getUint32(68, true);
+    if (sectorSize < 128 || sectorSize > 65536) {
+      throw new MailfileError(ErrorCode.CORRUPT_CFB, "Invalid sector size");
+    }
+    const maxSector = Math.floor((bytes.length - sectorSize) / sectorSize);
+    const sectorOffset = (s) => (s + 1) * sectorSize;
+    function checkSector(s) {
+      if (s > maxSector || s < 0) {
+        throw new MailfileError(
+          ErrorCode.CORRUPT_CFB,
+          "Sector reference outside the file (offset " + s + ")"
+        );
+      }
+    }
+    const fatSectors = [];
+    for (let d = 0; d < 109 && fatSectors.length < numFatSectors; d++) {
+      const v = dv.getUint32(76 + d * 4, true);
+      if (v === FREESECT || v === ENDOFCHAIN) break;
+      fatSectors.push(v);
+    }
+    let difSec = firstDifat;
+    let guard = 0;
+    while (difSec !== ENDOFCHAIN && difSec !== FREESECT && guard++ < 1e5 && fatSectors.length < numFatSectors) {
+      checkSector(difSec);
+      const base = sectorOffset(difSec);
+      for (let k = 0; k < sectorSize / 4 - 1; k++) {
+        const fv = dv.getUint32(base + k * 4, true);
+        if (fv === FREESECT || fv === ENDOFCHAIN) break;
+        fatSectors.push(fv);
+      }
+      difSec = dv.getUint32(base + sectorSize - 4, true);
+    }
+    const perSector = sectorSize / 4;
+    const fat = new Uint32Array(fatSectors.length * perSector);
+    for (let f = 0; f < fatSectors.length; f++) {
+      checkSector(fatSectors[f]);
+      const off = sectorOffset(fatSectors[f]);
+      for (let j = 0; j < perSector; j++) {
+        fat[f * perSector + j] = dv.getUint32(off + j * 4, true);
+      }
+    }
+    function chain(start) {
+      const out = [];
+      let s = start;
+      let n = 0;
+      while (s !== ENDOFCHAIN && s !== FREESECT && s !== void 0) {
+        if (n++ > fat.length + 8) {
+          throw new MailfileError(ErrorCode.CORRUPT_CFB, "Sector chain loops back on itself");
+        }
+        checkSector(s);
+        out.push(s);
+        s = fat[s];
+      }
+      return out;
+    }
+    function readSectors(list, size) {
+      const out = new Uint8Array(list.length * sectorSize);
+      for (let i = 0; i < list.length; i++) {
+        out.set(
+          bytes.subarray(sectorOffset(list[i]), sectorOffset(list[i]) + sectorSize),
+          i * sectorSize
+        );
+      }
+      return size == null ? out : out.subarray(0, size);
+    }
+    const miniFatBytes = readSectors(chain(firstMiniFat));
+    const miniFat = new Uint32Array(miniFatBytes.length >> 2);
+    const mdv = new DataView(miniFatBytes.buffer, miniFatBytes.byteOffset, miniFatBytes.byteLength);
+    for (let m = 0; m < miniFat.length; m++) miniFat[m] = mdv.getUint32(m * 4, true);
+    const dirBytes = readSectors(chain(firstDirSector));
+    const count = Math.floor(dirBytes.length / 128);
+    const ddv = new DataView(dirBytes.buffer, dirBytes.byteOffset, dirBytes.byteLength);
+    const entries = [];
+    for (let e = 0; e < count; e++) {
+      const o = e * 128;
+      const nameLen = ddv.getUint16(o + 64, true);
+      let name = "";
+      for (let c = 0; c + 1 < nameLen - 1; c += 2) {
+        const code = ddv.getUint16(o + c, true);
+        if (code === 0) break;
+        name += String.fromCharCode(code);
+      }
+      entries.push({
+        id: e,
+        name,
+        type: ddv.getUint8(o + 66),
+        left: ddv.getUint32(o + 68, true),
+        right: ddv.getUint32(o + 72, true),
+        child: ddv.getUint32(o + 76, true),
+        start: ddv.getUint32(o + 116, true),
+        size: ddv.getUint32(o + 120, true) + ddv.getUint32(o + 124, true) * 4294967296,
+        children: null
+      });
+    }
+    if (!entries.length) {
+      throw new MailfileError(ErrorCode.CORRUPT_CFB, "Compound file has no directory");
+    }
+    const root = entries[0];
+    const miniStream = readSectors(chain(root.start), root.size);
+    function readStream(entry) {
+      if (!entry || entry.type !== 2 || !entry.size) return new Uint8Array(0);
+      if (entry.size < miniCutoff) {
+        const out = new Uint8Array(entry.size);
+        let s = entry.start;
+        let pos = 0;
+        let n = 0;
+        while (s !== ENDOFCHAIN && s !== FREESECT && pos < entry.size) {
+          if (n++ > miniFat.length + 8) {
+            throw new MailfileError(ErrorCode.CORRUPT_CFB, "Mini sector chain loops back on itself");
+          }
+          const take = Math.min(miniSectorSize, entry.size - pos);
+          out.set(miniStream.subarray(s * miniSectorSize, s * miniSectorSize + take), pos);
+          pos += take;
+          s = miniFat[s];
+        }
+        return out;
+      }
+      return readSectors(chain(entry.start), entry.size);
+    }
+    function collect(nodeId, into, seen) {
+      if (nodeId === NOSTREAM || nodeId >= entries.length || seen[nodeId]) return;
+      seen[nodeId] = 1;
+      const n = entries[nodeId];
+      collect(n.left, into, seen);
+      into.push(n);
+      collect(n.right, into, seen);
+    }
+    function childrenOf(entry) {
+      if (entry.children) return entry.children;
+      const list = [];
+      collect(entry.child, list, {});
+      const map = /* @__PURE__ */ Object.create(null);
+      for (let i = 0; i < list.length; i++) map[list[i].name] = list[i];
+      entry.children = { list, map };
+      return entry.children;
+    }
+    return { root, entries, readStream, childrenOf };
+  }
+
+  // src/cfb/write.js
+  var SIG2 = [208, 207, 17, 224, 161, 177, 26, 225];
+  var FREESECT2 = 4294967295;
+  var ENDOFCHAIN2 = 4294967294;
+  var FATSECT = 4294967293;
+  var DIFSECT = 4294967292;
+  var NOSTREAM2 = 4294967295;
+  var MINI_CUTOFF2 = 4096;
+  function newRoot(clsid) {
+    return { name: "Root Entry", type: 5, clsid: clsid || null, children: [] };
+  }
+  function addStorage(parent, name, clsid) {
+    const n = { name, type: 1, clsid: clsid || null, children: [] };
+    parent.children.push(n);
+    return n;
+  }
+  function addStream(parent, name, data) {
+    const n = { name, type: 2, data: data || new Uint8Array(0) };
+    parent.children.push(n);
+    return n;
+  }
+  function cmpName(a, b) {
+    if (a.length !== b.length) return a.length - b.length;
+    const A = a.toUpperCase();
+    const B = b.toUpperCase();
+    for (let i = 0; i < A.length; i++) {
+      const d = A.charCodeAt(i) - B.charCodeAt(i);
+      if (d) return d;
+    }
+    return 0;
+  }
+  function write(root) {
+    const flat = [];
+    const assign = (node) => {
+      node.id = flat.length;
+      flat.push(node);
+    };
+    assign(root);
+    function buildTree(kids, lo, hi) {
+      if (lo >= hi) return NOSTREAM2;
+      const mid = lo + hi >> 1;
+      const n = kids[mid];
+      n.leftId = buildTree(kids, lo, mid);
+      n.rightId = buildTree(kids, mid + 1, hi);
+      return n.id;
+    }
+    function walk(node) {
+      if (!node.children || !node.children.length) {
+        node.childId = NOSTREAM2;
+        return;
+      }
+      const kids = node.children.slice().sort((a, b) => cmpName(a.name, b.name));
+      for (let i = 0; i < kids.length; i++) assign(kids[i]);
+      node.childId = buildTree(kids, 0, kids.length);
+      for (let j = 0; j < kids.length; j++) walk(kids[j]);
+    }
+    walk(root);
+    const SECTOR = 512;
+    const MINI = 64;
+    const PER = SECTOR / 4;
+    const bigStreams = [];
+    const miniStreams = [];
+    for (let i = 1; i < flat.length; i++) {
+      const n = flat[i];
+      if (n.type !== 2) {
+        n.startSector = ENDOFCHAIN2;
+        n.streamSize = 0;
+        continue;
+      }
+      n.streamSize = n.data.length;
+      if (n.data.length === 0) n.startSector = ENDOFCHAIN2;
+      else if (n.data.length >= MINI_CUTOFF2) bigStreams.push(n);
+      else miniStreams.push(n);
+    }
+    let miniSectorCount = 0;
+    for (const ms of miniStreams) {
+      ms.startSector = miniSectorCount;
+      miniSectorCount += Math.ceil(ms.data.length / MINI);
+    }
+    const miniStreamSize = miniSectorCount * MINI;
+    const miniStreamSectors = Math.ceil(miniStreamSize / SECTOR);
+    const miniStreamData = new Uint8Array(miniStreamSectors * SECTOR);
+    for (const ms of miniStreams) miniStreamData.set(ms.data, ms.startSector * MINI);
+    const bigSectorCounts = bigStreams.map((s) => Math.ceil(s.data.length / SECTOR));
+    const bigTotal = bigSectorCounts.reduce((x, y) => x + y, 0);
+    const miniFatSectors = Math.ceil(miniSectorCount * 4 / SECTOR) || 0;
+    const dirSectors = Math.ceil(flat.length / 4);
+    let fatSectors = 1;
+    let difatSectors = 0;
+    let total = 0;
+    for (let it = 0; it < 64; it++) {
+      total = bigTotal + miniStreamSectors + miniFatSectors + dirSectors + fatSectors + difatSectors;
+      const nf = Math.max(1, Math.ceil(total / PER));
+      const nd = nf <= 109 ? 0 : Math.ceil((nf - 109) / (PER - 1));
+      if (nf === fatSectors && nd === difatSectors) break;
+      fatSectors = nf;
+      difatSectors = nd;
+    }
+    total = bigTotal + miniStreamSectors + miniFatSectors + dirSectors + fatSectors + difatSectors;
+    let cursor = 0;
+    for (let i = 0; i < bigStreams.length; i++) {
+      bigStreams[i].startSector = cursor;
+      cursor += bigSectorCounts[i];
+    }
+    const miniStreamStart = miniStreamSectors ? cursor : ENDOFCHAIN2;
+    cursor += miniStreamSectors;
+    const miniFatStart = miniFatSectors ? cursor : ENDOFCHAIN2;
+    cursor += miniFatSectors;
+    const dirStart = cursor;
+    cursor += dirSectors;
+    const fatStart = cursor;
+    cursor += fatSectors;
+    const difatStart = difatSectors ? cursor : ENDOFCHAIN2;
+    cursor += difatSectors;
+    const fat = new Uint32Array(fatSectors * PER);
+    fat.fill(FREESECT2);
+    function runChain(start, count) {
+      for (let i = 0; i < count; i++) {
+        fat[start + i] = i === count - 1 ? ENDOFCHAIN2 : start + i + 1;
+      }
+    }
+    for (let i = 0; i < bigStreams.length; i++) runChain(bigStreams[i].startSector, bigSectorCounts[i]);
+    if (miniStreamSectors) runChain(miniStreamStart, miniStreamSectors);
+    if (miniFatSectors) runChain(miniFatStart, miniFatSectors);
+    runChain(dirStart, dirSectors);
+    for (let i = 0; i < fatSectors; i++) fat[fatStart + i] = FATSECT;
+    for (let i = 0; i < difatSectors; i++) fat[difatStart + i] = DIFSECT;
+    const miniFat = new Uint32Array(miniFatSectors * SECTOR / 4);
+    miniFat.fill(FREESECT2);
+    for (const ms of miniStreams) {
+      const cnt = Math.ceil(ms.data.length / MINI);
+      for (let q = 0; q < cnt; q++) {
+        miniFat[ms.startSector + q] = q === cnt - 1 ? ENDOFCHAIN2 : ms.startSector + q + 1;
+      }
+    }
+    root.startSector = miniStreamStart;
+    root.streamSize = miniStreamSize;
+    const out = new Uint8Array(SECTOR * (1 + total));
+    const dv = new DataView(out.buffer);
+    for (let i = 0; i < 8; i++) out[i] = SIG2[i];
+    dv.setUint16(24, 62, true);
+    dv.setUint16(26, 3, true);
+    dv.setUint16(28, 65534, true);
+    dv.setUint16(30, 9, true);
+    dv.setUint16(32, 6, true);
+    dv.setUint32(44, fatSectors, true);
+    dv.setUint32(48, dirStart, true);
+    dv.setUint32(56, MINI_CUTOFF2, true);
+    dv.setUint32(60, miniFatStart, true);
+    dv.setUint32(64, miniFatSectors, true);
+    dv.setUint32(68, difatStart, true);
+    dv.setUint32(72, difatSectors, true);
+    for (let h = 0; h < 109; h++) {
+      dv.setUint32(76 + h * 4, h < fatSectors ? fatStart + h : FREESECT2, true);
+    }
+    const off = (sector) => SECTOR * (1 + sector);
+    for (const s of bigStreams) out.set(s.data, off(s.startSector));
+    if (miniStreamSectors) out.set(miniStreamData, off(miniStreamStart));
+    if (miniFatSectors) {
+      for (let i = 0; i < miniFat.length; i++) {
+        dv.setUint32(off(miniFatStart) + i * 4, miniFat[i], true);
+      }
+    }
+    for (let i = 0; i < fat.length; i++) dv.setUint32(off(fatStart) + i * 4, fat[i], true);
+    for (let w = 0; w < difatSectors; w++) {
+      const dbase = off(difatStart + w);
+      for (let k = 0; k < PER - 1; k++) {
+        const idx = 109 + w * (PER - 1) + k;
+        dv.setUint32(dbase + k * 4, idx < fatSectors ? fatStart + idx : FREESECT2, true);
+      }
+      dv.setUint32(
+        dbase + SECTOR - 4,
+        w === difatSectors - 1 ? ENDOFCHAIN2 : difatStart + w + 1,
+        true
+      );
+    }
+    for (let e = 0; e < flat.length; e++) {
+      const node = flat[e];
+      const base = off(dirStart) + e * 128;
+      const nlen = Math.min(node.name.length, 31);
+      for (let p = 0; p < nlen; p++) dv.setUint16(base + p * 2, node.name.charCodeAt(p), true);
+      dv.setUint16(base + 64, nlen * 2 + 2, true);
+      dv.setUint8(base + 66, node.type);
+      dv.setUint8(base + 67, 1);
+      dv.setUint32(base + 68, node.leftId == null ? NOSTREAM2 : node.leftId, true);
+      dv.setUint32(base + 72, node.rightId == null ? NOSTREAM2 : node.rightId, true);
+      dv.setUint32(base + 76, node.childId == null ? NOSTREAM2 : node.childId, true);
+      if (node.clsid) out.set(node.clsid, base + 80);
+      dv.setUint32(base + 116, node.startSector == null ? ENDOFCHAIN2 : node.startSector, true);
+      const sz = node.streamSize || 0;
+      dv.setUint32(base + 120, sz >>> 0, true);
+      dv.setUint32(base + 124, Math.floor(sz / 4294967296), true);
+    }
+    for (let e = flat.length; e < dirSectors * 4; e++) {
+      const base = off(dirStart) + e * 128;
+      dv.setUint32(base + 68, NOSTREAM2, true);
+      dv.setUint32(base + 72, NOSTREAM2, true);
+      dv.setUint32(base + 76, NOSTREAM2, true);
+      dv.setUint32(base + 116, ENDOFCHAIN2, true);
+    }
+    return out;
+  }
+
+  // src/mapi/tags.js
+  var PropId = {
+    SUBJECT: 55,
+    NORMALIZED_SUBJECT: 3613,
+    BODY: 4096,
+    RTF_COMPRESSED: 4105,
+    HTML: 4115,
+    MESSAGE_CLASS: 26,
+    TRANSPORT_HEADERS: 125,
+    CLIENT_SUBMIT_TIME: 57,
+    DELIVERY_TIME: 3590,
+    LAST_MODIFICATION_TIME: 12296,
+    CREATION_TIME: 12295,
+    INTERNET_MESSAGE_ID: 4149,
+    IN_REPLY_TO_ID: 4162,
+    INTERNET_REFERENCES: 4153,
+    DISPLAY_TO: 3588,
+    DISPLAY_CC: 3587,
+    DISPLAY_BCC: 3586,
+    SENDER_NAME: 3098,
+    SENDER_EMAIL: 3103,
+    SENDER_ADDRTYPE: 3102,
+    SENDER_SMTP: 23809,
+    SENT_REP_NAME: 66,
+    SENT_REP_EMAIL: 101,
+    SENT_REP_ADDRTYPE: 100,
+    SENT_REP_SMTP: 23810,
+    MESSAGE_FLAGS: 3591,
+    HASATTACH: 3611,
+    STORE_SUPPORT_MASK: 13325,
+    INTERNET_CPID: 16350,
+    MESSAGE_CODEPAGE: 16381,
+    PRIORITY: 38,
+    IMPORTANCE: 23,
+    OBJECT_TYPE: 4094,
+    DISPLAY_TYPE: 14592,
+    ROWID: 12288,
+    RECIPIENT_TYPE: 3093,
+    DISPLAY_NAME: 12289,
+    EMAIL_ADDRESS: 12291,
+    ADDRTYPE: 12290,
+    SMTP_ADDRESS: 14846,
+    ATTACH_METHOD: 14085,
+    ATTACH_DATA_BIN: 14081,
+    ATTACH_LONG_FILENAME: 14087,
+    ATTACH_FILENAME: 14084,
+    ATTACH_EXTENSION: 14083,
+    ATTACH_MIME_TAG: 14094,
+    ATTACH_CONTENT_ID: 14098,
+    ATTACH_SIZE: 3616,
+    ATTACH_NUM: 3617,
+    ATTACH_FLAGS: 14100,
+    ATTACHMENT_HIDDEN: 32766,
+    RENDERING_POSITION: 14091
+  };
+  var PropType = {
+    SHORT: 2,
+    LONG: 3,
+    FLOAT: 4,
+    DOUBLE: 5,
+    BOOLEAN: 11,
+    I8: 20,
+    STRING8: 30,
+    UNICODE: 31,
+    SYSTIME: 64,
+    BINARY: 258,
+    OBJECT: 13
+  };
+  var RecipientType = { TO: 1, CC: 2, BCC: 3 };
+  var AttachMethod = { NONE: 0, BY_VALUE: 1, BY_REFERENCE: 2, EMBEDDED_MSG: 5 };
+  var HeaderSize = {
+    TOP_LEVEL: 32,
+    EMBEDDED: 24,
+    RECIPIENT: 8,
+    ATTACHMENT: 8
+  };
+  var MSG_CLSID = new Uint8Array([
+    11,
+    13,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    192,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    70
+  ]);
+  var CODEPAGES = {
+    20127: "us-ascii",
+    28591: "iso-8859-1",
+    28592: "iso-8859-2",
+    28595: "iso-8859-5",
+    28597: "iso-8859-7",
+    28598: "iso-8859-8",
+    28599: "iso-8859-9",
+    28605: "iso-8859-15",
+    65e3: "utf-7",
+    65001: "utf-8",
+    1250: "windows-1250",
+    1251: "windows-1251",
+    1252: "windows-1252",
+    1253: "windows-1253",
+    1254: "windows-1254",
+    1255: "windows-1255",
+    1256: "windows-1256",
+    1257: "windows-1257",
+    1258: "windows-1258",
+    932: "shift_jis",
+    936: "gbk",
+    949: "euc-kr",
+    950: "big5",
+    874: "windows-874"
+  };
+  function hex4(n) {
+    return ("000" + n.toString(16).toUpperCase()).slice(-4);
+  }
+  function hex8(n) {
+    return ("0000000" + n.toString(16).toUpperCase()).slice(-8);
+  }
+  function tagName(id, type) {
+    return "__substg1.0_" + hex4(id) + hex4(type);
+  }
+  function filetimeToDate(lo, hi) {
+    if (!lo && !hi) return null;
+    const ft = hi * 4294967296 + lo;
+    const ms = ft / 1e4 - 116444736e5;
+    if (!isFinite(ms) || ms < -22089888e5 || ms > 41024448e5) return null;
+    return new Date(ms);
+  }
+  function dateToFiletime(date) {
+    const ft = Math.round((date.getTime() + 116444736e5) * 1e4);
+    return { lo: ft % 4294967296, hi: Math.floor(ft / 4294967296) };
+  }
+
+  // src/mapi/bag.js
+  var PropertyBag = class {
+    /**
+     * @param {import('../cfb/read.js').CfbFile} cfb
+     * @param {object} storage Directory entry of the storage to read.
+     * @param {number} headerSize One of `HeaderSize.*`.
+     */
+    constructor(cfb, storage, headerSize) {
+      const kids = cfb.childrenOf(storage);
+      this.vars = /* @__PURE__ */ Object.create(null);
+      this.fixed = /* @__PURE__ */ Object.create(null);
+      this.subStorages = [];
+      this.cfb = cfb;
+      this.childMap = kids.map;
+      for (const k of kids.list) {
+        const m = /^__substg1\.0_([0-9A-Fa-f]{8})$/.exec(k.name);
+        if (m) {
+          if (k.type === 2) this.vars[m[1].toUpperCase()] = cfb.readStream(k);
+          else this.subStorages.push(k);
+          continue;
+        }
+        if (k.type === 1) this.subStorages.push(k);
+      }
+      const propsEntry = kids.map["__properties_version1.0"];
+      if (propsEntry) {
+        const buf = cfb.readStream(propsEntry);
+        const dv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+        for (let off = headerSize; off + 16 <= buf.length; off += 16) {
+          this.fixed[dv.getUint16(off + 2, true)] = {
+            type: dv.getUint16(off, true),
+            lo: dv.getUint32(off + 8, true),
+            hi: dv.getUint32(off + 12, true),
+            i32: dv.getInt32(off + 8, true)
+          };
+        }
+      }
+      const cpid = this.fixed[PropId.INTERNET_CPID]?.i32 ?? this.fixed[PropId.MESSAGE_CODEPAGE]?.i32 ?? 0;
+      this.charset = CODEPAGES[cpid] || "windows-1252";
+    }
+    /**
+     * String property, preferring the Unicode variant.
+     * @param {number} id @returns {string}
+     */
+    str(id) {
+      const u = this.vars[hex4(id) + "001F"];
+      if (u) return utf16Decode(u);
+      const a = this.vars[hex4(id) + "001E"];
+      if (a) return decodeBytes(a, this.charset);
+      return "";
+    }
+    /** @param {number} id @returns {Uint8Array|null} */
+    bin(id) {
+      return this.vars[hex4(id) + "0102"] || null;
+    }
+    /** @param {number} id @returns {number|null} */
+    int(id) {
+      return this.fixed[id] ? this.fixed[id].i32 : null;
+    }
+    /** @param {number} id @returns {boolean|null} */
+    bool(id) {
+      return this.fixed[id] ? !!(this.fixed[id].lo & 1) : null;
+    }
+    /** @param {number} id @returns {Date|null} */
+    date(id) {
+      return this.fixed[id] ? filetimeToDate(this.fixed[id].lo, this.fixed[id].hi) : null;
+    }
+    /** @param {number} id @returns {boolean} */
+    has(id) {
+      const h = hex4(id);
+      return !!(this.fixed[id] || this.vars[h + "001F"] || this.vars[h + "001E"] || this.vars[h + "0102"]);
+    }
+    /** Every property id present on this object. @returns {number[]} */
+    ids() {
+      const set = new Set(Object.keys(this.fixed).map(Number));
+      for (const tag of Object.keys(this.vars)) set.add(parseInt(tag.slice(0, 4), 16));
+      return [...set].sort((a, b) => a - b);
+    }
+    /** Nested storages whose names match a prefix, in directory order. */
+    storagesMatching(re) {
+      return this.subStorages.filter((s) => re.test(s.name)).sort((a, b) => a.name.localeCompare(b.name));
+    }
+  };
+  var PropertyWriter = class {
+    /**
+     * @param {import('../cfb/write.js').CfbNode} node Storage to write into.
+     * @param {number} headerSize One of `HeaderSize.*`.
+     */
+    constructor(node, headerSize) {
+      this.node = node;
+      this.headerSize = headerSize;
+      this.entries = [];
+    }
+    _entry(id, type, size, lo, hi) {
+      this.entries.push({ id, type, size, lo: lo || 0, hi: hi || 0 });
+    }
+    /** @param {number} id @param {string} value */
+    str(id, value) {
+      if (value == null || value === "") return this;
+      const bytes = utf16Encode(String(value));
+      addStream(this.node, tagName(id, PropType.UNICODE), bytes);
+      this._entry(id, PropType.UNICODE, bytes.length + 2);
+      return this;
+    }
+    /** @param {number} id @param {Uint8Array} bytes */
+    bin(id, bytes) {
+      if (!bytes) return this;
+      addStream(this.node, tagName(id, PropType.BINARY), bytes);
+      this._entry(id, PropType.BINARY, bytes.length);
+      return this;
+    }
+    /** @param {number} id @param {number} v */
+    int32(id, v) {
+      if (v == null) return this;
+      this._entry(id, PropType.LONG, null, v >>> 0, 0);
+      return this;
+    }
+    /** @param {number} id @param {boolean} v */
+    bool(id, v) {
+      this._entry(id, PropType.BOOLEAN, null, v ? 1 : 0, 0);
+      return this;
+    }
+    /** @param {number} id @param {Date} date */
+    time(id, date) {
+      if (!date) return this;
+      const ft = dateToFiletime(date);
+      this._entry(id, PropType.SYSTIME, null, ft.lo, ft.hi);
+      return this;
+    }
+    /**
+     * Write `__properties_version1.0`.
+     * @param {(dv: DataView) => void} [headerFill] Fills the stream header.
+     */
+    finish(headerFill) {
+      const buf = new Uint8Array(this.headerSize + this.entries.length * 16);
+      const dv = new DataView(buf.buffer);
+      if (headerFill) headerFill(dv);
+      for (let i = 0; i < this.entries.length; i++) {
+        const e = this.entries[i];
+        const off = this.headerSize + i * 16;
+        dv.setUint16(off, e.type, true);
+        dv.setUint16(off + 2, e.id, true);
+        dv.setUint32(off + 4, 6, true);
+        if (e.size != null) {
+          dv.setUint32(off + 8, e.size, true);
+          dv.setUint32(off + 12, 0, true);
+        } else {
+          dv.setUint32(off + 8, e.lo, true);
+          dv.setUint32(off + 12, e.hi, true);
+        }
+      }
+      addStream(this.node, "__properties_version1.0", buf);
+    }
+  };
+
+  // src/rtf/lzfu.js
+  var INIT_DICT = "{\\rtf1\\ansi\\mac\\deff0\\deftab720{\\fonttbl;}{\\f0\\fnil \\froman \\fswiss \\fmodern \\fscript \\fdecor MS Sans SerifSymbolArialTimes New RomanCourier{\\colortbl\\red0\\green0\\blue0\r\n\\par \\pard\\plain\\f0\\fs20\\b\\i\\u\\tab\\tx";
+  var COMPRESSED = 1967544908;
+  var UNCOMPRESSED = 1095517517;
+  function decompress(bytes) {
+    if (!bytes || bytes.length < 16) return null;
+    const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const compSize = dv.getUint32(0, true);
+    const rawSize = dv.getUint32(4, true);
+    const magic = dv.getUint32(8, true);
+    if (magic === UNCOMPRESSED) {
+      return bytes.subarray(16, Math.min(bytes.length, 16 + rawSize));
+    }
+    if (magic !== COMPRESSED) return null;
+    const dict = new Uint8Array(4096);
+    for (let i = 0; i < INIT_DICT.length; i++) dict[i] = INIT_DICT.charCodeAt(i) & 255;
+    let writeAt = INIT_DICT.length;
+    const out = new Uint8Array(rawSize);
+    let outPos = 0;
+    let pos = 16;
+    const end = Math.min(bytes.length, compSize + 4);
+    while (pos < end && outPos < rawSize) {
+      const control = bytes[pos++];
+      for (let bit = 0; bit < 8 && pos < end && outPos < rawSize; bit++) {
+        if (control & 1 << bit) {
+          if (pos + 1 >= end) return out.subarray(0, outPos);
+          const b1 = bytes[pos++];
+          const b2 = bytes[pos++];
+          const offset = b1 << 4 | b2 >> 4;
+          const length = (b2 & 15) + 2;
+          if (offset === writeAt % 4096) return out.subarray(0, outPos);
+          for (let n = 0; n < length && outPos < rawSize; n++) {
+            const byte = dict[(offset + n) % 4096];
+            out[outPos++] = byte;
+            dict[writeAt % 4096] = byte;
+            writeAt++;
+          }
+        } else {
+          const lit = bytes[pos++];
+          out[outPos++] = lit;
+          dict[writeAt % 4096] = lit;
+          writeAt++;
+        }
+      }
+    }
+    return out.subarray(0, outPos);
+  }
+
+  // src/rtf/deencapsulate.js
+  var ENTITIES = { "&": "&amp;", "<": "&lt;", ">": "&gt;" };
+  var esc = (s) => s.replace(/[&<>]/g, (c) => ENTITIES[c]);
+  var SIMPLE = {
+    lquote: "&lsquo;",
+    rquote: "&rsquo;",
+    ldblquote: "&ldquo;",
+    rdblquote: "&rdquo;",
+    emdash: "&mdash;",
+    endash: "&ndash;",
+    bullet: "&bull;",
+    nbsp: "&nbsp;"
+  };
+  var SKIP_DESTINATIONS = /* @__PURE__ */ new Set([
+    "fonttbl",
+    "colortbl",
+    "stylesheet",
+    "info",
+    "pntext",
+    "generator"
+  ]);
+  function isEncapsulated(rtf) {
+    return /\\from(html|text)1?/.test(rtf.slice(0, 4096));
+  }
+  function deencapsulate(rtf, decode) {
+    const out = [];
+    const suppressStack = [];
+    let i = 0;
+    const len = rtf.length;
+    let suppress = false;
+    let inHtmlTag = 0;
+    let depth = 0;
+    let skipDest = 0;
+    let pendingSkipWord = false;
+    let textBytes = [];
+    const fromText = /\\fromtext/.test(rtf.slice(0, 4096));
+    function emit(s) {
+      if (skipDest || suppress && !inHtmlTag) return;
+      out.push(s);
+    }
+    function flushBytes() {
+      if (!textBytes.length) return;
+      const s = decode(new Uint8Array(textBytes));
+      textBytes = [];
+      emit(inHtmlTag ? s : esc(s));
+    }
+    while (i < len) {
+      const c = rtf[i];
+      if (c === "\\") {
+        const next = rtf[i + 1];
+        if (next === "\\" || next === "{" || next === "}") {
+          textBytes.push(next.charCodeAt(0));
+          i += 2;
+          continue;
+        }
+        if (next === "'") {
+          textBytes.push(parseInt(rtf.substr(i + 2, 2), 16) || 0);
+          i += 4;
+          continue;
+        }
+        if (next === "*") {
+          i += 2;
+          pendingSkipWord = true;
+          continue;
+        }
+        const m = /^\\([a-zA-Z]+)(-?\d+)? ?/.exec(rtf.slice(i));
+        if (!m) {
+          i += 2;
+          continue;
+        }
+        const word = m[1];
+        const param = m[2] === void 0 ? null : parseInt(m[2], 10);
+        i += m[0].length;
+        flushBytes();
+        if (word === "htmltag") {
+          pendingSkipWord = false;
+          inHtmlTag = depth;
+          continue;
+        }
+        if (word === "htmlrtf") {
+          suppress = param !== 0;
+          continue;
+        }
+        if (word === "mhtmltag") {
+          skipDest = depth;
+          pendingSkipWord = false;
+          continue;
+        }
+        if (pendingSkipWord) {
+          skipDest = depth;
+          pendingSkipWord = false;
+          continue;
+        }
+        if (word === "u" && param !== null) {
+          if (!suppress || inHtmlTag) {
+            const cp = param < 0 ? param + 65536 : param;
+            emit(inHtmlTag ? String.fromCharCode(cp) : esc(String.fromCharCode(cp)));
+          }
+          if (rtf[i] === "?") i++;
+          continue;
+        }
+        if (word === "par" || word === "line") {
+          if (fromText) emit("\n");
+          continue;
+        }
+        if (word === "tab") {
+          emit("	");
+          continue;
+        }
+        if (SIMPLE[word]) {
+          emit(SIMPLE[word]);
+          continue;
+        }
+        if (SKIP_DESTINATIONS.has(word)) {
+          skipDest = depth;
+          continue;
+        }
+        continue;
+      }
+      if (c === "{") {
+        flushBytes();
+        depth++;
+        suppressStack.push({ suppress, inHtmlTag });
+        i++;
+        continue;
+      }
+      if (c === "}") {
+        flushBytes();
+        if (skipDest && depth === skipDest) skipDest = 0;
+        if (inHtmlTag && depth === inHtmlTag) inHtmlTag = 0;
+        depth--;
+        const st = suppressStack.pop();
+        if (st) suppress = st.suppress;
+        pendingSkipWord = false;
+        i++;
+        continue;
+      }
+      if (c === "\r" || c === "\n") {
+        i++;
+        continue;
+      }
+      textBytes.push(rtf.charCodeAt(i) & 255);
+      i++;
+    }
+    flushBytes();
+    const html = out.join("");
+    if (fromText) {
+      return '<html><body><pre style="font-family:inherit;white-space:pre-wrap">' + html + "</pre></body></html>";
+    }
+    return html;
+  }
+  function rtfToHtml(rtfBytes, decode) {
+    if (!rtfBytes || !rtfBytes.length) return null;
+    let rtf = "";
+    for (let i = 0; i < rtfBytes.length; i++) rtf += String.fromCharCode(rtfBytes[i]);
+    if (!isEncapsulated(rtf)) return null;
+    try {
+      const html = deencapsulate(rtf, decode);
+      return html && html.trim() ? html : null;
+    } catch {
+      return null;
+    }
+  }
+
+  // src/util.js
+  var MIME_BY_EXT = {
+    pdf: "application/pdf",
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    bmp: "image/bmp",
+    webp: "image/webp",
+    svg: "image/svg+xml",
+    txt: "text/plain",
+    csv: "text/csv",
+    html: "text/html",
+    htm: "text/html",
+    xml: "application/xml",
+    json: "application/json",
+    zip: "application/zip",
+    doc: "application/msword",
+    dot: "application/msword",
+    docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    xls: "application/vnd.ms-excel",
+    xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ppt: "application/vnd.ms-powerpoint",
+    pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    eml: "message/rfc822",
+    msg: "application/vnd.ms-outlook",
+    ics: "text/calendar",
+    rtf: "application/rtf",
+    mp3: "audio/mpeg",
+    mp4: "video/mp4"
+  };
+  function guessMime(name) {
+    const m = /\.([A-Za-z0-9]+)$/.exec(name || "");
+    return m && MIME_BY_EXT[m[1].toLowerCase()] || "application/octet-stream";
+  }
+  function safeName(s) {
+    return String(s || "file").replace(/[\\/:*?"<>|\r\n\t]+/g, "_").replace(/^\.+/, "").slice(0, 120) || "file";
+  }
+  function shortName(name) {
+    const m = /^(.*?)(\.[A-Za-z0-9]{1,3})?$/.exec(name || "file");
+    const base = (m[1] || "file").replace(/[^A-Za-z0-9_-]/g, "").slice(0, 8) || "file";
+    return base + (m[2] || "");
+  }
+  function replaceExt(name, ext) {
+    return (String(name).replace(/\.[^.\\/]+$/, "") || "message") + ext;
+  }
+
+  // src/msg/read.js
+  function sniffHtmlCharset(bytes, fallback) {
+    let head = "";
+    for (let i = 0; i < Math.min(bytes.length, 2048); i++) head += String.fromCharCode(bytes[i]);
+    const m = /charset\s*=\s*["']?\s*([\w-]+)/i.exec(head);
+    return m ? m[1] : fallback;
+  }
+  function pickAddress(bag, nameId, emailId, addrTypeId, smtpId) {
+    const name = bag.str(nameId);
+    let email = bag.str(smtpId);
+    if (!email) {
+      const at = (bag.str(addrTypeId) || "").toUpperCase();
+      const raw = bag.str(emailId);
+      if (at === "SMTP" || raw && raw.indexOf("@") > 0 && raw.indexOf("/") < 0) email = raw;
+    }
+    return { name, email };
+  }
+  function readMessageStorage(cfb, storage, headerSize, opts, depth) {
+    const bag = new PropertyBag(cfb, storage, headerSize);
+    const data = {
+      messageClass: bag.str(PropId.MESSAGE_CLASS),
+      subject: bag.str(PropId.SUBJECT) || bag.str(PropId.NORMALIZED_SUBJECT),
+      messageId: bag.str(PropId.INTERNET_MESSAGE_ID),
+      inReplyTo: bag.str(PropId.IN_REPLY_TO_ID),
+      references: bag.str(PropId.INTERNET_REFERENCES),
+      date: bag.date(PropId.CLIENT_SUBMIT_TIME) || bag.date(PropId.DELIVERY_TIME) || bag.date(PropId.LAST_MODIFICATION_TIME) || null,
+      importance: bag.int(PropId.IMPORTANCE),
+      text: bag.str(PropId.BODY),
+      html: "",
+      to: [],
+      cc: [],
+      bcc: [],
+      attachments: [],
+      headers: Headers.parse(bag.str(PropId.TRANSPORT_HEADERS)),
+      props: bag
+    };
+    let from = pickAddress(
+      bag,
+      PropId.SENT_REP_NAME,
+      PropId.SENT_REP_EMAIL,
+      PropId.SENT_REP_ADDRTYPE,
+      PropId.SENT_REP_SMTP
+    );
+    if (!from.email && !from.name) {
+      from = pickAddress(
+        bag,
+        PropId.SENDER_NAME,
+        PropId.SENDER_EMAIL,
+        PropId.SENDER_ADDRTYPE,
+        PropId.SENDER_SMTP
+      );
+    } else if (!from.email) {
+      const s = pickAddress(
+        bag,
+        PropId.SENDER_NAME,
+        PropId.SENDER_EMAIL,
+        PropId.SENDER_ADDRTYPE,
+        PropId.SENDER_SMTP
+      );
+      if (s.email) from.email = s.email;
+    }
+    data.from = from;
+    const htmlBin = bag.bin(PropId.HTML);
+    if (htmlBin && htmlBin.length) {
+      data.html = decodeBytes(htmlBin, sniffHtmlCharset(htmlBin, bag.charset));
+    } else if (bag.vars[hex4(PropId.HTML) + "001F"]) {
+      data.html = utf16Decode(bag.vars[hex4(PropId.HTML) + "001F"]);
+    }
+    if (!data.html) {
+      const comp = bag.bin(PropId.RTF_COMPRESSED);
+      if (comp) {
+        const rtfBytes = decompress(comp);
+        if (rtfBytes) {
+          const cs = bag.charset;
+          const html = rtfToHtml(rtfBytes, (b) => decodeBytes(b, cs));
+          if (html) data.html = html;
+        }
+      }
+    }
+    for (const r of bag.storagesMatching(/^__recip_version1\.0_/)) {
+      const rb = new PropertyBag(cfb, r, HeaderSize.RECIPIENT);
+      const addr = pickAddress(
+        rb,
+        PropId.DISPLAY_NAME,
+        PropId.EMAIL_ADDRESS,
+        PropId.ADDRTYPE,
+        PropId.SMTP_ADDRESS
+      );
+      if (!addr.email && !addr.name) continue;
+      const type = rb.int(PropId.RECIPIENT_TYPE);
+      if (type === RecipientType.CC) data.cc.push(addr);
+      else if (type === RecipientType.BCC) data.bcc.push(addr);
+      else data.to.push(addr);
+    }
+    if (!data.to.length && !data.cc.length) {
+      data.to = parseAddressList(bag.str(PropId.DISPLAY_TO));
+      data.cc = parseAddressList(bag.str(PropId.DISPLAY_CC));
+    }
+    for (const a of bag.storagesMatching(/^__attach_version1\.0_/)) {
+      const ab = new PropertyBag(cfb, a, HeaderSize.ATTACHMENT);
+      const method = ab.int(PropId.ATTACH_METHOD);
+      const filename = ab.str(PropId.ATTACH_LONG_FILENAME) || ab.str(PropId.ATTACH_FILENAME);
+      const cid = ab.str(PropId.ATTACH_CONTENT_ID);
+      const mime = ab.str(PropId.ATTACH_MIME_TAG);
+      const flags = ab.int(PropId.ATTACH_FLAGS) || 0;
+      const hidden = ab.bool(PropId.ATTACHMENT_HIDDEN);
+      if (method === AttachMethod.EMBEDDED_MSG) {
+        const embedded = ab.childMap[tagName(PropId.ATTACH_DATA_BIN, PropType.OBJECT)];
+        if (embedded && depth < 10) {
+          try {
+            const inner = readMessageStorage(cfb, embedded, HeaderSize.EMBEDDED, opts, depth + 1);
+            data.attachments.push({
+              filename: safeName(filename || inner.subject || "message") + ".eml",
+              mime: "message/rfc822",
+              embedded: inner,
+              cid,
+              inline: false
+            });
+          } catch {
+          }
+        }
+        continue;
+      }
+      const name = filename || "attachment" + (data.attachments.length + 1) + (ab.str(PropId.ATTACH_EXTENSION) || ".bin");
+      const att = {
+        filename: name,
+        mime: mime || guessMime(name),
+        cid,
+        inline: !!cid && ((flags & 4) !== 0 || hidden === true || !!data.html && data.html.indexOf("cid:" + cid) >= 0)
+      };
+      if (opts.lazy) {
+        let cached = null;
+        Object.defineProperty(att, "data", {
+          enumerable: true,
+          configurable: true,
+          get() {
+            if (!cached) cached = ab.bin(PropId.ATTACH_DATA_BIN) || new Uint8Array(0);
+            return cached;
+          }
+        });
+        if (!ab.has(PropId.ATTACH_DATA_BIN)) continue;
+      } else {
+        const bin = ab.bin(PropId.ATTACH_DATA_BIN);
+        if (!bin) continue;
+        att.data = bin;
+      }
+      data.attachments.push(att);
+    }
+    return data;
+  }
+  function readMsg(bytes, opts = {}) {
+    const cfb = read(bytes);
+    return readMessageStorage(cfb, cfb.root, HeaderSize.TOP_LEVEL, opts, 0);
+  }
+
+  // src/msg/write.js
+  var MSGFLAG_READ = 1;
+  var STORE_UNICODE_OK = 262144;
+  var CP_UTF8 = 65001;
+  var ATT_MHTML_REF = 4;
+  var displayName = (a) => a.name || a.email;
+  function writeMsg(msg) {
+    const root = newRoot(MSG_CLSID);
+    const nameid = addStorage(root, "__nameid_version1.0");
+    addStream(nameid, "__substg1.0_00020102", new Uint8Array(0));
+    addStream(nameid, "__substg1.0_00030102", new Uint8Array(0));
+    addStream(nameid, "__substg1.0_00040102", new Uint8Array(0));
+    const to = msg.to || [];
+    const cc = msg.cc || [];
+    const bcc = msg.bcc || [];
+    const attachments = msg.attachments || [];
+    const from = msg.from || { name: "", email: "" };
+    const p = new PropertyWriter(root, HeaderSize.TOP_LEVEL);
+    p.str(PropId.MESSAGE_CLASS, msg.messageClass || "IPM.Note");
+    p.str(PropId.SUBJECT, msg.subject || "");
+    p.str(PropId.NORMALIZED_SUBJECT, (msg.subject || "").replace(/^\s*(re|fw|fwd)\s*:\s*/i, ""));
+    p.str(PropId.BODY, msg.text || "");
+    if (msg.html) p.bin(PropId.HTML, utf8Encode(msg.html));
+    if (msg.headersRaw) p.str(PropId.TRANSPORT_HEADERS, msg.headersRaw);
+    p.str(PropId.INTERNET_MESSAGE_ID, msg.messageId || "");
+    p.str(PropId.IN_REPLY_TO_ID, msg.inReplyTo || "");
+    p.str(PropId.INTERNET_REFERENCES, msg.references || "");
+    const addrType = from.email ? "SMTP" : "";
+    p.str(PropId.SENDER_NAME, from.name || from.email || "");
+    p.str(PropId.SENDER_EMAIL, from.email || "");
+    p.str(PropId.SENDER_ADDRTYPE, addrType);
+    p.str(PropId.SENDER_SMTP, from.email || "");
+    p.str(PropId.SENT_REP_NAME, from.name || from.email || "");
+    p.str(PropId.SENT_REP_EMAIL, from.email || "");
+    p.str(PropId.SENT_REP_ADDRTYPE, addrType);
+    p.str(PropId.SENT_REP_SMTP, from.email || "");
+    p.str(PropId.DISPLAY_TO, to.map(displayName).join("; "));
+    p.str(PropId.DISPLAY_CC, cc.map(displayName).join("; "));
+    p.str(PropId.DISPLAY_BCC, bcc.map(displayName).join("; "));
+    p.time(PropId.CLIENT_SUBMIT_TIME, msg.date);
+    p.time(PropId.DELIVERY_TIME, msg.date);
+    p.time(PropId.CREATION_TIME, msg.date || /* @__PURE__ */ new Date());
+    p.time(PropId.LAST_MODIFICATION_TIME, /* @__PURE__ */ new Date());
+    p.int32(PropId.MESSAGE_FLAGS, MSGFLAG_READ);
+    p.int32(PropId.STORE_SUPPORT_MASK, STORE_UNICODE_OK);
+    p.int32(PropId.INTERNET_CPID, CP_UTF8);
+    p.int32(PropId.MESSAGE_CODEPAGE, CP_UTF8);
+    if (msg.importance != null) p.int32(PropId.IMPORTANCE, msg.importance);
+    p.bool(PropId.HASATTACH, attachments.length > 0);
+    const recipients = [
+      ...to.map((a) => ({ a, t: RecipientType.TO })),
+      ...cc.map((a) => ({ a, t: RecipientType.CC })),
+      ...bcc.map((a) => ({ a, t: RecipientType.BCC }))
+    ];
+    recipients.forEach((r, i) => {
+      const node = addStorage(root, "__recip_version1.0_#" + hex8(i));
+      const rp = new PropertyWriter(node, HeaderSize.RECIPIENT);
+      rp.int32(PropId.ROWID, i);
+      rp.int32(PropId.RECIPIENT_TYPE, r.t);
+      rp.int32(PropId.OBJECT_TYPE, 6);
+      rp.int32(PropId.DISPLAY_TYPE, 0);
+      rp.str(PropId.DISPLAY_NAME, r.a.name || r.a.email);
+      rp.str(PropId.EMAIL_ADDRESS, r.a.email);
+      rp.str(PropId.SMTP_ADDRESS, r.a.email);
+      rp.str(PropId.ADDRTYPE, "SMTP");
+      rp.finish();
+    });
+    attachments.forEach((att, i) => {
+      const node = addStorage(root, "__attach_version1.0_#" + hex8(i));
+      const ap = new PropertyWriter(node, HeaderSize.ATTACHMENT);
+      ap.int32(PropId.ATTACH_NUM, i);
+      ap.int32(PropId.ATTACH_METHOD, 1);
+      ap.int32(PropId.OBJECT_TYPE, 7);
+      ap.int32(PropId.ATTACH_SIZE, att.data.length);
+      ap.int32(PropId.RENDERING_POSITION, -1);
+      ap.bin(PropId.ATTACH_DATA_BIN, att.data);
+      ap.str(PropId.ATTACH_LONG_FILENAME, att.filename);
+      ap.str(PropId.ATTACH_FILENAME, shortName(att.filename));
+      const ext = /\.[A-Za-z0-9]+$/.exec(att.filename);
+      if (ext) ap.str(PropId.ATTACH_EXTENSION, ext[0]);
+      ap.str(PropId.ATTACH_MIME_TAG, att.mime || guessMime(att.filename));
+      if (att.cid) {
+        ap.str(PropId.ATTACH_CONTENT_ID, att.cid);
+        if (att.inline) {
+          ap.int32(PropId.ATTACH_FLAGS, ATT_MHTML_REF);
+          ap.bool(PropId.ATTACHMENT_HIDDEN, true);
+        }
+      }
+      ap.finish();
+    });
+    p.finish((dv) => {
+      dv.setUint32(8, recipients.length, true);
+      dv.setUint32(12, attachments.length, true);
+      dv.setUint32(16, recipients.length, true);
+      dv.setUint32(20, attachments.length, true);
+    });
+    return write(root);
+  }
+
+  // src/message.js
+  var CONTENT_HEADERS = /* @__PURE__ */ new Set([
+    "mime-version",
+    "content-type",
+    "content-transfer-encoding",
+    "content-disposition",
+    "content-id",
+    "content-description",
+    "content-language",
+    "content-location"
+  ]);
+  var IMPORTANCE = { low: 0, normal: 1, high: 2 };
+  var Message = class _Message {
+    /** @param {Partial<Message>} [data] */
+    constructor(data = {}) {
+      this.subject = data.subject || "";
+      this.from = data.from || { name: "", email: "" };
+      this.to = data.to || [];
+      this.cc = data.cc || [];
+      this.bcc = data.bcc || [];
+      this.date = data.date || null;
+      this.messageId = data.messageId || "";
+      this.inReplyTo = data.inReplyTo || "";
+      this.references = data.references || "";
+      this.importance = data.importance == null ? null : data.importance;
+      this.messageClass = data.messageClass || "IPM.Note";
+      this.text = data.text || "";
+      this.html = data.html || "";
+      this.attachments = data.attachments || [];
+      this.headers = data.headers instanceof Headers ? data.headers : new Headers(data.headers || []);
+      this.props = data.props || null;
+    }
+    /**
+     * Parse an Outlook `.msg` file.
+     * @param {Uint8Array} bytes
+     * @param {{lazy?: boolean}} [opts] `lazy` defers attachment byte extraction
+     *   until `.data` is read — useful when you only want headers.
+     * @returns {Message}
+     */
+    static fromMsg(bytes, opts = {}) {
+      const data = readMsg(bytes, opts);
+      data.attachments = data.attachments.map((a) => {
+        if (!a.embedded) return a;
+        const { embedded, ...rest } = a;
+        return { ...rest, data: new _Message(embedded).toEml() };
+      });
+      return new _Message(data);
+    }
+    /**
+     * Parse an RFC 5322 `.eml` file.
+     * @param {Uint8Array} bytes
+     * @returns {Message}
+     */
+    static fromEml(bytes) {
+      const parsed = parseEml(bytes);
+      const h = parsed.headers;
+      return new _Message({
+        subject: decodeWords(h.get("subject") || ""),
+        from: parseAddressList(h.get("from") || "")[0] || { name: "", email: "" },
+        to: parseAddressList(h.get("to") || ""),
+        cc: parseAddressList(h.get("cc") || ""),
+        bcc: parseAddressList(h.get("bcc") || ""),
+        date: parseDate(h.get("date")),
+        messageId: h.get("message-id") || "",
+        inReplyTo: h.get("in-reply-to") || "",
+        references: h.get("references") || "",
+        importance: IMPORTANCE[(h.get("importance") || "").toLowerCase()] ?? null,
+        text: parsed.text,
+        html: parsed.html,
+        attachments: parsed.attachments,
+        headers: h
+      });
+    }
+    /**
+     * Serialise to an RFC 5322 `.eml` document.
+     *
+     * Headers carried in from the source are preserved verbatim — minus the
+     * content headers, which are regenerated to match the body actually written.
+     * @returns {Uint8Array}
+     */
+    toEml() {
+      const out = [];
+      const seen = /* @__PURE__ */ new Set();
+      for (const [k, v] of this.headers) {
+        if (CONTENT_HEADERS.has(k.toLowerCase())) continue;
+        out.push([k, v]);
+        seen.add(k.toLowerCase());
+      }
+      const put = (name, value) => {
+        if (!value || seen.has(name.toLowerCase())) return;
+        out.push([name, value]);
+        seen.add(name.toLowerCase());
+      };
+      const list = (addrs) => addrs.map((a) => formatAddress(a.name, a.email)).filter(Boolean).join(", ");
+      if (this.date) put("Date", formatDate(this.date));
+      if (this.from.email || this.from.name) {
+        put("From", formatAddress(this.from.name, this.from.email));
+      }
+      if (this.to.length) put("To", list(this.to));
+      if (this.cc.length) put("Cc", list(this.cc));
+      if (this.bcc.length) put("Bcc", list(this.bcc));
+      if (!seen.has("subject")) put("Subject", encodeWord(this.subject || "") || " ");
+      put("Message-ID", this.messageId);
+      put("In-Reply-To", this.inReplyTo);
+      put("References", this.references);
+      return buildEml({
+        headers: out,
+        text: this.text,
+        html: this.html,
+        attachments: this.attachments
+      });
+    }
+    /**
+     * Serialise to an Outlook `.msg` file.
+     * @returns {Uint8Array}
+     */
+    toMsg() {
+      return writeMsg({
+        messageClass: this.messageClass,
+        subject: this.subject,
+        from: this.from,
+        to: this.to,
+        cc: this.cc,
+        bcc: this.bcc,
+        date: this.date,
+        messageId: this.messageId,
+        inReplyTo: this.inReplyTo,
+        references: this.references,
+        importance: this.importance,
+        text: this.text,
+        html: this.html,
+        attachments: this.attachments,
+        // Keeping the original header block lets a later .msg -> .eml
+        // conversion restore the full Received: trail.
+        headersRaw: this.headers.entries.length ? this.headers.raw : ""
+      });
+    }
+  };
+
+  // src/index.js
+  var version = "0.1.0";
+  var MSG_MAGIC = [208, 207, 17, 224, 161, 177, 26, 225];
+  function detect(bytes, filename) {
+    if (bytes && bytes.length >= 8) {
+      let match = true;
+      for (let i = 0; i < 8; i++) {
+        if (bytes[i] !== MSG_MAGIC[i]) {
+          match = false;
+          break;
+        }
+      }
+      if (match) return "msg";
+    }
+    const ext = (/\.([^.]+)$/.exec(filename || "") || [])[1];
+    if (ext && ext.toLowerCase() === "msg") return "msg";
+    return "eml";
+  }
+  function convert(bytes, opts = {}) {
+    if (!bytes || !bytes.length) {
+      throw new MailfileError(ErrorCode.EMPTY_INPUT, "File is empty");
+    }
+    const sourceFormat = opts.from || detect(bytes, opts.filename);
+    const target = opts.to || (sourceFormat === "msg" ? "eml" : "msg");
+    const message = sourceFormat === "msg" ? Message.fromMsg(bytes, { lazy: opts.lazy }) : Message.fromEml(bytes);
+    const data = target === "msg" ? message.toMsg() : message.toEml();
+    return {
+      data,
+      format: target,
+      sourceFormat,
+      mime: target === "msg" ? "application/vnd.ms-outlook" : "message/rfc822",
+      filename: opts.filename ? replaceExt(opts.filename, "." + target) : void 0,
+      message
+    };
+  }
+  return __toCommonJS(index_exports);
+})();