mailfile 0.1.0

package/src/cfb/write.js

@@ -0,0 +1,262 @@
+/**
+ * Compound File Binary (OLE2 / CFBF) writer — MS-CFB.
+ * Emits version 3 files (512-byte sectors), including the DIFAT path for
+ * files large enough to need more than 109 FAT sectors.
+ */
+
+const SIG = [0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1];
+const FREESECT = 0xFFFFFFFF;
+const ENDOFCHAIN = 0xFFFFFFFE;
+const FATSECT = 0xFFFFFFFD;
+const DIFSECT = 0xFFFFFFFC;
+const NOSTREAM = 0xFFFFFFFF;
+const MINI_CUTOFF = 4096;
+
+/**
+ * A node in the storage tree being built.
+ *
+ * The `id`/`leftId`/`rightId`/`childId`/`startSector`/`streamSize` fields are
+ * assigned by {@link write} while laying the file out; callers never set them.
+ *
+ * @typedef {object} CfbNode
+ * @property {string} name
+ * @property {number} type 1 = storage, 2 = stream, 5 = root
+ * @property {Uint8Array|null} [clsid]
+ * @property {CfbNode[]} [children]
+ * @property {Uint8Array} [data]
+ * @property {number} [id]
+ * @property {number} [leftId]
+ * @property {number} [rightId]
+ * @property {number} [childId]
+ * @property {number} [startSector]
+ * @property {number} [streamSize]
+ */
+
+/**
+ * Create an empty root storage.
+ * @param {Uint8Array|null} [clsid] 16-byte class id written to the root entry.
+ * @returns {CfbNode}
+ */
+export function newRoot(clsid) {
+  return { name: 'Root Entry', type: 5, clsid: clsid || null, children: [] };
+}
+
+/**
+ * @param {CfbNode} parent
+ * @param {string} name
+ * @param {Uint8Array|null} [clsid]
+ * @returns {CfbNode}
+ */
+export function addStorage(parent, name, clsid) {
+  const n = { name, type: 1, clsid: clsid || null, children: [] };
+  parent.children.push(n);
+  return n;
+}
+
+/**
+ * @param {CfbNode} parent
+ * @param {string} name
+ * @param {Uint8Array} [data]
+ * @returns {CfbNode}
+ */
+export function addStream(parent, name, data) {
+  const n = { name, type: 2, data: data || new Uint8Array(0) };
+  parent.children.push(n);
+  return n;
+}
+
+// Directory ordering per MS-CFB: shorter names first, then case-insensitive UTF-16.
+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;
+}
+
+/**
+ * Serialise a storage tree to compound file bytes.
+ * @param {CfbNode} root
+ * @returns {Uint8Array}
+ */
+export 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 NOSTREAM;
+    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 = NOSTREAM; 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;
+
+  // Streams >= 4096 bytes get their own sectors; smaller ones go in the mini stream.
+  const bigStreams = [];
+  const miniStreams = [];
+  for (let i = 1; i < flat.length; i++) {
+    const n = flat[i];
+    if (n.type !== 2) { n.startSector = ENDOFCHAIN; n.streamSize = 0; continue; }
+    n.streamSize = n.data.length;
+    if (n.data.length === 0) n.startSector = ENDOFCHAIN;
+    else if (n.data.length >= MINI_CUTOFF) 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);
+
+  // FAT and DIFAT sizes depend on the total sector count, which depends on
+  // them in turn. Iterate to a fixed point.
+  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 : ENDOFCHAIN;
+  cursor += miniStreamSectors;
+  const miniFatStart = miniFatSectors ? cursor : ENDOFCHAIN;
+  cursor += miniFatSectors;
+  const dirStart = cursor;
+  cursor += dirSectors;
+  const fatStart = cursor;
+  cursor += fatSectors;
+  const difatStart = difatSectors ? cursor : ENDOFCHAIN;
+  cursor += difatSectors;
+
+  const fat = new Uint32Array(fatSectors * PER);
+  fat.fill(FREESECT);
+  function runChain(start, count) {
+    for (let i = 0; i < count; i++) {
+      fat[start + i] = (i === count - 1) ? ENDOFCHAIN : 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(FREESECT);
+  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) ? ENDOFCHAIN : 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] = SIG[i];
+  dv.setUint16(24, 0x003E, true);  // minor version
+  dv.setUint16(26, 0x0003, true);  // major version -> 512-byte sectors
+  dv.setUint16(28, 0xFFFE, true);  // little endian
+  dv.setUint16(30, 9, true);       // sector shift
+  dv.setUint16(32, 6, true);       // mini sector shift
+  dv.setUint32(44, fatSectors, true);
+  dv.setUint32(48, dirStart, true);
+  dv.setUint32(56, MINI_CUTOFF, 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 : FREESECT, 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 : FREESECT, true);
+    }
+    dv.setUint32(dbase + SECTOR - 4,
+      w === difatSectors - 1 ? ENDOFCHAIN : 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); // black
+    dv.setUint32(base + 68, node.leftId == null ? NOSTREAM : node.leftId, true);
+    dv.setUint32(base + 72, node.rightId == null ? NOSTREAM : node.rightId, true);
+    dv.setUint32(base + 76, node.childId == null ? NOSTREAM : node.childId, true);
+    if (node.clsid) out.set(node.clsid, base + 80);
+    dv.setUint32(base + 116, node.startSector == null ? ENDOFCHAIN : 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, NOSTREAM, true);
+    dv.setUint32(base + 72, NOSTREAM, true);
+    dv.setUint32(base + 76, NOSTREAM, true);
+    dv.setUint32(base + 116, ENDOFCHAIN, true);
+  }
+
+  return out;
+}

package/src/errors.js

@@ -0,0 +1,49 @@
+/**
+ * Error codes thrown by mailfile. Callers should branch on `error.code`
+ * rather than on message text.
+ * @readonly
+ * @enum {string}
+ */
+export const 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'
+};
+
+/**
+ * All errors raised by mailfile.
+ */
+export class MailfileError 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';
+    /** @type {string} */
+    this.code = code;
+    if (options && options.cause !== undefined) this.cause = options.cause;
+  }
+}
+
+/**
+ * @param {string} code
+ * @param {string} message
+ * @returns {never}
+ */
+export function fail(code, message) {
+  throw new MailfileError(code, message);
+}

package/src/index.js

@@ -0,0 +1,86 @@
+/**
+ * mailfile — read and write Outlook `.msg` and RFC 5322 `.eml` files.
+ * Zero dependencies; runs in browsers, Node, Deno, Bun and workers.
+ */
+import { Message } from './message.js';
+import { MailfileError, ErrorCode } from './errors.js';
+import { replaceExt } from './util.js';
+
+export { Message } from './message.js';
+export { MailfileError, ErrorCode } from './errors.js';
+export { Headers } from './mime/headers.js';
+
+/** @type {string} */
+export const version = '0.1.0';
+
+const MSG_MAGIC = [0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1];
+
+/**
+ * Identify a message file from its content, falling back to the extension.
+ *
+ * Compound-file magic bytes are authoritative, so a `.msg` renamed to `.eml`
+ * is still detected correctly.
+ *
+ * @param {Uint8Array} bytes
+ * @param {string} [filename]
+ * @returns {'msg'|'eml'}
+ */
+export 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';
+}
+
+/**
+ * @typedef {object} ConvertResult
+ * @property {Uint8Array} data Converted bytes.
+ * @property {'msg'|'eml'} format Format of `data`.
+ * @property {'msg'|'eml'} sourceFormat Format that was detected on input.
+ * @property {string} mime Content type for `data`.
+ * @property {string} [filename] Suggested output name, when one was given.
+ * @property {Message} message The parsed message.
+ */
+
+/**
+ * Convert a message to the other format, detecting the input automatically.
+ *
+ * @example
+ * const { data, format } = convert(bytes, { filename: 'note.msg' })
+ * // data is .eml bytes, format === 'eml'
+ *
+ * @param {Uint8Array} bytes
+ * @param {object} [opts]
+ * @param {string} [opts.filename] Used for detection and for naming the output.
+ * @param {'msg'|'eml'} [opts.to] Force the target format instead of flipping.
+ * @param {'msg'|'eml'} [opts.from] Skip detection and assume this input format.
+ * @param {boolean} [opts.lazy] Defer attachment extraction (`.msg` input only).
+ * @returns {ConvertResult}
+ */
+export 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) : undefined,
+    message
+  };
+}

package/src/mapi/bag.js

@@ -0,0 +1,195 @@
+/** Reading and writing MAPI property bags inside a compound file — MS-OXMSG. */
+import { addStream } from '../cfb/write.js';
+import { decodeBytes, utf16Decode, utf16Encode } from '../mime/encodings.js';
+import {
+  CODEPAGES, PropId, PropType, filetimeToDate, dateToFiletime, hex4, tagName
+} from './tags.js';
+
+/**
+ * A read-only view of one object's MAPI properties.
+ *
+ * Variable-length properties live in `__substg1.0_*` streams; fixed-length
+ * ones live in `__properties_version1.0`.
+ */
+export class PropertyBag {
+  /**
+   * @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);
+    /** @type {Record<string, Uint8Array>} keyed by 8-hex-digit tag */
+    this.vars = Object.create(null);
+    /** @type {Record<number, {type:number, lo:number, hi:number, i32:number}>} */
+    this.fixed = Object.create(null);
+    /** @type {object[]} Nested storages (recipients, attachments, embedded messages). */
+    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;
+    /** Encoding used for 8-bit string properties in this object. */
+    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));
+  }
+}
+
+/**
+ * Accumulates properties and emits the streams for one object.
+ */
+export class PropertyWriter {
+  /**
+   * @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);
+    // The declared size includes the terminating null, which is not stored.
+    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, 0x00000006, true); // readable | writable
+      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);
+  }
+}

package/src/mapi/index.js

@@ -0,0 +1,6 @@
+/** MAPI property tags and property-bag access over a compound file. */
+export { PropertyBag, PropertyWriter } from './bag.js';
+export {
+  PropId, PropType, RecipientType, AttachMethod, HeaderSize,
+  MSG_CLSID, CODEPAGES, hex4, hex8, tagName, filetimeToDate, dateToFiletime
+} from './tags.js';