mailfile 0.1.0

package/src/mime/headers.js

@@ -0,0 +1,344 @@
+/** Header field parsing and generation: RFC 2047 words, RFC 2231 parameters,
+ *  address lists, folding, and the ordered Headers multimap. */
+import {
+  base64ToBytes, bytesToBase64, decodeBytes, decodeQP, utf8Encode
+} from './encodings.js';
+
+/**
+ * @typedef {object} Address
+ * @property {string} name Display name, already decoded.
+ * @property {string} email
+ */
+
+/**
+ * Decode RFC 2047 encoded words (`=?UTF-8?B?...?=`) anywhere in a string.
+ * @param {string} str
+ * @returns {string}
+ */
+export function decodeWords(str) {
+  if (!str || str.indexOf('=?') < 0) return str || '';
+  // Whitespace between adjacent encoded words is not significant, including
+  // the folding whitespace a long run of words is broken across.
+  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;
+    }
+  });
+}
+
+/**
+ * @param {string} s
+ * @returns {boolean}
+ */
+export function needsEncoding(s) {
+  return /[^\x20-\x7E]/.test(s);
+}
+
+/**
+ * Encode a string as one or more RFC 2047 words, if it needs it.
+ * @param {string} s
+ * @returns {string}
+ */
+export function encodeWord(s) {
+  if (!needsEncoding(s)) return s;
+  // Chunk on code points so a multi-byte character never straddles two words.
+  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 ');
+}
+
+/**
+ * Fold a long header onto continuation lines.
+ * @param {string} name
+ * @param {string} value
+ * @returns {string}
+ */
+export 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;
+}
+
+/**
+ * @param {string} name
+ * @param {string} email
+ * @returns {string}
+ */
+export 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 + '>';
+}
+
+// Split on commas that are not inside quotes, angle brackets or comments.
+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);
+}
+
+/**
+ * @param {string} str
+ * @returns {Address}
+ */
+export 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() };
+}
+
+/**
+ * @param {string} str
+ * @returns {Address[]}
+ */
+export function parseAddressList(str) {
+  if (!str) return [];
+  return splitAddressList(String(str)).map(parseAddress).filter((a) => a.email || a.name);
+}
+
+/**
+ * Parse a structured header into its value and parameters, reassembling
+ * RFC 2231 continuations and percent-encoding (`filename*0*=`, `filename*=`).
+ * @param {string} raw
+ * @returns {{value: string, params: Record<string, string>}}
+ */
+export function parseHeaderValue(raw) {
+  let value = '';
+  /** @type {Record<string, string>} */
+  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] === undefined ? -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) & 0xFF);
+        }
+      }
+      params[base] = decodeBytes(new Uint8Array(bytes), charset || 'utf-8');
+    } else {
+      params[base] = decodeWords(acc);
+    }
+  }
+  return { value: value.trim(), params };
+}
+
+/**
+ * Emit a parameter, using RFC 2231 with an ASCII fallback when non-ASCII.
+ * @param {string} name
+ * @param {string} val
+ * @returns {string}
+ */
+export 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;
+}
+
+/**
+ * An ordered, case-insensitive, repeat-preserving header collection.
+ */
+export class Headers {
+  /** @param {Array<[string, string]>} [entries] */
+  constructor(entries) {
+    /** @type {Array<[string, string]>} */
+    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, ' ');
+    /** @type {Array<[string, string]>} */
+    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]();
+  }
+}
+
+/**
+ * Format a Date as an RFC 5322 date-time in local time.
+ * @param {Date} d
+ * @returns {string}
+ */
+export 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);
+}
+
+/**
+ * Parse an RFC 5322 date, tolerating a trailing `(GMT)`-style comment.
+ * @param {string} str
+ * @returns {Date|null}
+ */
+export function parseDate(str) {
+  if (!str) return null;
+  const d = new Date(String(str).replace(/\s*\([^)]*\)\s*$/, ''));
+  return isNaN(d.getTime()) ? null : d;
+}

package/src/mime/index.js

@@ -0,0 +1,12 @@
+/** RFC 5322 / MIME parsing and generation. */
+export { parseEml, parseNode } from './parse.js';
+export { buildEml } from './build.js';
+export {
+  Headers, decodeWords, encodeWord, foldHeader, formatAddress, formatDate,
+  parseAddress, parseAddressList, parseDate, parseHeaderValue, encodeParamValue,
+  needsEncoding
+} from './headers.js';
+export {
+  base64ToBytes, bytesToBase64, decodeBytes, decodeQP, encodeQP,
+  utf8Encode, utf16Decode, utf16Encode, wrap
+} from './encodings.js';

package/src/mime/parse.js

@@ -0,0 +1,153 @@
+/** MIME document parsing. */
+import { base64ToBytes, decodeBytes, decodeQP, utf8Encode } from './encodings.js';
+import { Headers, decodeWords, parseHeaderValue } from './headers.js';
+
+/**
+ * @typedef {object} MimeNode
+ * @property {Headers} headers
+ * @property {string} contentType Lower-cased, without parameters.
+ * @property {Record<string,string>} params
+ * @property {MimeNode[]} children
+ * @property {Uint8Array} [content] Decoded body, for leaf nodes only.
+ */
+
+/**
+ * @typedef {object} ParsedEml
+ * @property {Headers} headers Top-level headers.
+ * @property {string} text
+ * @property {string} html
+ * @property {Array<{filename: string, mime: string, data: Uint8Array, cid: string, inline: boolean}>} attachments
+ * @property {MimeNode} root
+ */
+
+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;
+    // A delimiter must be followed by optional whitespace then CRLF (or EOF).
+    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;
+}
+
+/**
+ * Parse a MIME entity and its children.
+ * @param {Uint8Array} bytes
+ * @param {number} [depth]
+ * @returns {MimeNode}
+ */
+export 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');
+  /** @type {MimeNode} */
+  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;
+}
+
+const 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')
+  });
+}
+
+/**
+ * Parse a complete `.eml` document.
+ * @param {Uint8Array} bytes
+ * @returns {ParsedEml}
+ */
+export function parseEml(bytes) {
+  const root = parseNode(bytes, 0);
+  const out = { text: '', html: '', attachments: [], headers: root.headers, root };
+  collectParts(root, out, root.contentType);
+  return out;
+}

package/src/msg/read.js

@@ -0,0 +1,178 @@
+/** Compound file + MAPI properties -> message data. */
+import { read as readCfb } from '../cfb/read.js';
+import { PropertyBag } from '../mapi/bag.js';
+import {
+  AttachMethod, HeaderSize, PropId, PropType, RecipientType, hex4, tagName
+} from '../mapi/tags.js';
+import { decodeBytes, utf16Decode } from '../mime/encodings.js';
+import { Headers, parseAddressList } from '../mime/headers.js';
+import { decompress } from '../rtf/lzfu.js';
+import { rtfToHtml } from '../rtf/deencapsulate.js';
+import { guessMime, safeName } from '../util.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;
+}
+
+/**
+ * Resolve a display name / address pair, preferring a real SMTP address over
+ * an Exchange (`/O=…/CN=…`) one.
+ */
+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 };
+}
+
+/**
+ * @param {import('../cfb/read.js').CfbFile} cfb
+ * @param {object} storage
+ * @param {number} headerSize
+ * @param {{lazy?: boolean}} opts
+ * @param {number} depth
+ */
+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
+  };
+
+  // From: the "sent representing" identity is what a client displays.
+  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;
+
+  // HTML body: PR_HTML, then its Unicode variant, then encapsulated RTF.
+  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);
+  }
+  // Some senders write only the display strings, with no recipient table.
+  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 { /* an unreadable embedded message should not fail the parent */ }
+      }
+      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 & 0x4) !== 0 || hidden === true ||
+        (!!data.html && data.html.indexOf('cid:' + cid) >= 0))
+    };
+    if (opts.lazy) {
+      // Defer walking the sector chain until the bytes are actually wanted.
+      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;
+}
+
+/**
+ * Read a `.msg` file into plain message data.
+ * @param {Uint8Array} bytes
+ * @param {{lazy?: boolean}} [opts]
+ */
+export function readMsg(bytes, opts = {}) {
+  const cfb = readCfb(bytes);
+  return readMessageStorage(cfb, cfb.root, HeaderSize.TOP_LEVEL, opts, 0);
+}