ooxml-core 1.6.1 → 1.7.0

package/dist/crypto/index.mjs

@@ -1,4 +1,4 @@
-// ../../node_modules/.bun/@christophervr+ole2@0.12.0/node_modules/@christophervr/ole2/dist/ole2-parser-types.js
+// ../../node_modules/.bun/@christophervr+ole2@0.13.0/node_modules/@christophervr/ole2/dist/ole2-parser-types.js
 var OLE_MAGIC = new Uint8Array([208, 207, 17, 224, 161, 177, 26, 225]);
 var ENDOFCHAIN = 4294967294;
 var FREESECT = 4294967295;
@@ -6,7 +6,9 @@ var FATSECT = 4294967293;
 var DIFSECT = 4294967292;
 var MAXREGSECT = 4294967290;
 var ENTRY_TYPE_EMPTY = 0;
+var ENTRY_TYPE_STORAGE = 1;
 var ENTRY_TYPE_STREAM = 2;
+var NOSTREAM = 4294967295;
 var ENTRY_TYPE_ROOT = 5;
 var DIR_ENTRY_SIZE = 128;
 var Ole2ParseError = class extends Error {
@@ -16,10 +18,174 @@ var Ole2ParseError = class extends Error {
   }
 };
 
-// ../../node_modules/.bun/@christophervr+ole2@0.12.0/node_modules/@christophervr/ole2/dist/ole2-parser-read.js
-function parseOle2(buffer) {
-  const data = new Uint8Array(buffer);
-  const view = new DataView(buffer);
+// ../../node_modules/.bun/@christophervr+ole2@0.13.0/node_modules/@christophervr/ole2/dist/ole2-directory.js
+var FILETIME_UNIX_EPOCH = 116444736000000000n;
+function readFileTime(view, offset) {
+  const ticks = view.getBigUint64(offset, true);
+  if (ticks === 0n)
+    return void 0;
+  const ms = Number((ticks - FILETIME_UNIX_EPOCH) / 10000n);
+  const date = new Date(ms);
+  return Number.isNaN(date.getTime()) ? void 0 : date;
+}
+function decodeSlot(dir, id, majorVersion, warnings) {
+  const view = new DataView(dir.buffer, dir.byteOffset + id * DIR_ENTRY_SIZE, DIR_ENTRY_SIZE);
+  const nameLen = view.getUint16(64, true);
+  const type = view.getUint8(66);
+  const nameValid = nameLen >= 2 && nameLen <= 64 && nameLen % 2 === 0 && view.getUint16(nameLen - 2, true) === 0;
+  let name = "";
+  if (nameValid)
+    for (let j = 0; j < nameLen - 2; j += 2)
+      name += String.fromCharCode(view.getUint16(j, true));
+  const link = (offset) => {
+    const value = view.getUint32(offset, true);
+    return value === NOSTREAM ? -1 : value;
+  };
+  const sizeLow = view.getUint32(120, true);
+  const sizeHigh = view.getUint32(124, true);
+  let size = sizeLow;
+  if (majorVersion === 4)
+    size = sizeLow + sizeHigh * 4294967296;
+  else if (sizeHigh !== 0 && type !== ENTRY_TYPE_EMPTY) {
+    warnings.push({ code: "size-high-bits", message: `Ignored v3 stream-size high bits on directory entry ${id}` });
+  }
+  return {
+    id,
+    type,
+    nameValid,
+    entry: {
+      id,
+      name,
+      type,
+      color: view.getUint8(67),
+      leftSiblingId: link(68),
+      rightSiblingId: link(72),
+      childId: link(76),
+      clsid: new Uint8Array(view.buffer.slice(view.byteOffset + 80, view.byteOffset + 96)),
+      stateBits: view.getUint32(96, true),
+      created: readFileTime(view, 100),
+      modified: readFileTime(view, 108),
+      startSector: view.getUint32(116, true),
+      size,
+      parentId: -1
+    }
+  };
+}
+function readDirectory(dir, majorVersion, strict, warnings) {
+  const count = Math.floor(dir.length / DIR_ENTRY_SIZE);
+  const slots = [];
+  for (let id = 0; id < count; id++)
+    slots.push(decodeSlot(dir, id, majorVersion, warnings));
+  const roots = slots.filter((slot) => slot.type === ENTRY_TYPE_ROOT);
+  if (roots.length !== 1 || !roots[0].nameValid)
+    throw new Ole2ParseError("Invalid root directory entry");
+  const root = roots[0];
+  root.entry.path = [];
+  const reached = /* @__PURE__ */ new Set([root.id]);
+  const fail = (message) => {
+    if (strict)
+      throw new Ole2ParseError(message);
+    warnings.push({ code: "directory-link", message });
+  };
+  const pending = [];
+  const push = (id, parent, from) => {
+    if (id === -1)
+      return;
+    const target = slots[id];
+    if (!target || target.type === ENTRY_TYPE_EMPTY || target.type === ENTRY_TYPE_ROOT) {
+      fail(`Directory entry ${from} links to invalid entry ${id}`);
+      return;
+    }
+    if (reached.has(id)) {
+      fail(`Cyclic directory tree at entry ${id}`);
+      return;
+    }
+    reached.add(id);
+    pending.push({ id, parent });
+  };
+  push(root.entry.childId, root, root.id);
+  while (pending.length) {
+    const { id, parent } = pending.pop();
+    const slot = slots[id];
+    if (!slot.nameValid)
+      throw new Ole2ParseError("Invalid directory entry name");
+    slot.entry.parentId = parent.id;
+    slot.entry.path = [...parent.entry.path, slot.entry.name];
+    push(slot.entry.leftSiblingId, parent, id);
+    push(slot.entry.rightSiblingId, parent, id);
+    if (slot.type === ENTRY_TYPE_STORAGE)
+      push(slot.entry.childId, slot, id);
+  }
+  const entries = [];
+  for (const slot of slots) {
+    if (slot.type === ENTRY_TYPE_EMPTY)
+      continue;
+    if (!reached.has(slot.id)) {
+      if (!slot.nameValid) {
+        if (strict)
+          throw new Ole2ParseError("Invalid directory entry name");
+        warnings.push({ code: "invalid-unreachable-entry", message: `Skipped undecodable stale directory entry ${slot.id}` });
+        continue;
+      }
+      if (strict)
+        throw new Ole2ParseError(`Directory entry ${slot.id} is not reachable from the root`);
+      warnings.push({ code: "unreachable-entry", message: `Directory entry ${slot.id} (${slot.entry.name}) is not reachable from the root` });
+    }
+    entries.push(slot.entry);
+  }
+  return entries;
+}
+function sameName(a, b) {
+  return a.length === b.length && a.toUpperCase() === b.toUpperCase();
+}
+function bareName(name) {
+  return name.replace(/^[\u0001-\u0006]/, "");
+}
+function normalizePath(path, rootName) {
+  const parts = typeof path === "string" ? path.split("/").filter((part) => part !== "") : [...path];
+  if (parts.length && sameName(parts[0], rootName) && typeof path === "string")
+    parts.shift();
+  return parts;
+}
+function child(entries, parentId, name) {
+  const children = entries.filter((entry) => entry.parentId === parentId && entry.path !== void 0);
+  const pick = (matches) => matches.length === 1 ? matches[0] : void 0;
+  const exact = children.filter((entry) => entry.name === name);
+  if (exact.length)
+    return pick(exact);
+  const folded = children.filter((entry) => sameName(entry.name, name));
+  if (folded.length)
+    return pick(folded);
+  return pick(children.filter((entry) => sameName(bareName(entry.name), bareName(name))));
+}
+function findDirectoryEntry(entries, path) {
+  const root = entries.find((entry) => entry.type === ENTRY_TYPE_ROOT);
+  if (!root)
+    return void 0;
+  let current = root;
+  for (const name of normalizePath(path, root.name)) {
+    if (current.type !== ENTRY_TYPE_ROOT && current.type !== ENTRY_TYPE_STORAGE)
+      return void 0;
+    current = child(entries, current.id, name);
+    if (!current)
+      return void 0;
+  }
+  return current;
+}
+function findStreamByName(entries, name, isReadable) {
+  const root = entries.find((entry) => entry.type === ENTRY_TYPE_ROOT);
+  if (root && root.name === name)
+    return root;
+  const top = entries.filter((entry) => entry.parentId === root?.id && isReadable(entry));
+  return top.find((entry) => entry.name === name) ?? top.find((entry) => sameName(entry.name, name)) ?? entries.find((entry) => entry.name === name && isReadable(entry));
+}
+
+// ../../node_modules/.bun/@christophervr+ole2@0.13.0/node_modules/@christophervr/ole2/dist/ole2-parser-read.js
+function parseOle2(buffer, options = {}) {
+  const strict = options.strict === true;
+  const data = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const warnings = [];
   if (data.length < 512) {
     throw new Ole2ParseError("Truncated OLE2 compound file header");
   }
@@ -28,11 +194,12 @@ function parseOle2(buffer) {
       throw new Ole2ParseError("Not a valid OLE2 compound file");
     }
   }
-  view.getUint16(24, true);
   const majorVersion = view.getUint16(26, true);
   const byteOrder = view.getUint16(28, true);
   if (byteOrder !== 65534) {
-    throw new Ole2ParseError("Invalid byte order mark");
+    if (strict)
+      throw new Ole2ParseError("Invalid byte order mark");
+    warnings.push({ code: "byte-order", message: `Ignored byte order mark 0x${byteOrder.toString(16)}` });
   }
   const sectorSizePower = view.getUint16(30, true);
   const miniSectorSizePower = view.getUint16(32, true);
@@ -41,10 +208,14 @@ function parseOle2(buffer) {
   }
   const sectorSize = 1 << sectorSizePower;
   const miniSectorSize = 1 << miniSectorSizePower;
-  if (data.length < sectorSize || data.length % sectorSize !== 0) {
+  if (data.length < sectorSize)
     throw new Ole2ParseError("Truncated OLE2 sector");
+  if (data.length % sectorSize !== 0) {
+    if (strict)
+      throw new Ole2ParseError("Truncated OLE2 sector");
+    warnings.push({ code: "unaligned-length", message: `File length ${data.length} is not a multiple of ${sectorSize}` });
   }
-  const sectorCount = data.length / sectorSize - 1;
+  const sectorCount = Math.ceil(data.length / sectorSize) - 1;
   const totalFATSectors = view.getUint32(44, true);
   const firstDirectorySector = view.getUint32(48, true);
   const miniStreamCutoff = view.getUint32(56, true);
@@ -65,6 +236,13 @@ function parseOle2(buffer) {
     }
     return data.subarray(offset, offset + sectorSize);
   }
+  function copySector(sector, target, at, want) {
+    const offset = sectorOffset(sector);
+    if (sector >= sectorCount || offset + want > data.length) {
+      throw new Ole2ParseError(`Sector ${sector} at offset ${offset} exceeds file size ${data.length}`);
+    }
+    target.set(data.subarray(offset, offset + want), at);
+  }
   const fatSectors = [];
   for (let i2 = 0; i2 < 109 && fatSectors.length < totalFATSectors; i2++) {
     const sector = view.getUint32(76 + i2 * 4, true);
@@ -100,29 +278,36 @@ function parseOle2(buffer) {
       fatEntries.push(fatView.getUint32(i2 * 4, true));
     }
   }
-  function readSectorChain(startSector) {
-    const sectors = [];
-    let current = startSector;
+  function followChain(table, start, label, needed) {
+    const ids = [];
     const visited = /* @__PURE__ */ new Set();
+    let current = start;
     while (current <= MAXREGSECT) {
+      if (!strict && needed !== void 0 && ids.length >= needed)
+        return ids;
       if (visited.has(current)) {
-        throw new Ole2ParseError(`Circular reference in FAT chain at sector ${current}`);
+        throw new Ole2ParseError(`Circular reference in ${label} chain at sector ${current}`);
       }
       visited.add(current);
-      sectors.push(readSector(current));
-      if (fatEntries[current] === void 0)
-        throw new Ole2ParseError("Missing FAT chain entry");
-      current = fatEntries[current];
+      ids.push(current);
+      if (table[current] === void 0)
+        throw new Ole2ParseError(`Missing ${label} chain entry`);
+      current = table[current];
     }
-    if (current !== ENDOFCHAIN)
-      throw new Ole2ParseError("Invalid FAT chain terminator");
-    const totalLength = sectors.length * sectorSize;
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    for (const sector of sectors) {
-      result.set(sector, offset);
-      offset += sectorSize;
+    if (current !== ENDOFCHAIN) {
+      if (strict || needed === void 0 || ids.length < needed) {
+        throw new Ole2ParseError(`Invalid ${label} chain terminator`);
+      }
+      warnings.push({ code: "chain-terminator", message: `Accepted ${label} chain ending in 0x${current.toString(16)}` });
     }
+    return ids;
+  }
+  function readMetadataChain(startSector, label) {
+    if (startSector > MAXREGSECT)
+      return new Uint8Array(0);
+    const ids = followChain(fatEntries, startSector, label === "directory" ? "FAT" : label);
+    const result = new Uint8Array(ids.length * sectorSize);
+    ids.forEach((id, i2) => result.set(readSector(id), i2 * sectorSize));
     return result;
   }
   function readStream(startSector, size) {
@@ -130,68 +315,44 @@ function parseOle2(buffer) {
       return new Uint8Array(0);
     if (size > sectorCount * sectorSize)
       throw new Ole2ParseError("Stream size exceeds file size");
-    const raw = readSectorChain(startSector);
-    if (raw.length < size)
+    const needed = Math.ceil(size / sectorSize);
+    const ids = followChain(fatEntries, startSector, "FAT", needed);
+    if (ids.length < needed)
       throw new Ole2ParseError("Truncated stream sector chain");
-    return raw.subarray(0, size);
-  }
-  const dirRaw = readSectorChain(firstDirectorySector);
-  const numEntries = Math.floor(dirRaw.length / DIR_ENTRY_SIZE);
-  const entries = [];
-  for (let i2 = 0; i2 < numEntries; i2++) {
-    const entryOffset = i2 * DIR_ENTRY_SIZE;
-    const entryView = new DataView(dirRaw.buffer, dirRaw.byteOffset + entryOffset, DIR_ENTRY_SIZE);
-    const nameLen = entryView.getUint16(64, true);
-    const objectType = entryView.getUint8(66);
-    if (objectType === ENTRY_TYPE_EMPTY) {
-      continue;
+    const result = new Uint8Array(size);
+    for (let i2 = 0; i2 < needed; i2++) {
+      copySector(ids[i2], result, i2 * sectorSize, Math.min(sectorSize, size - i2 * sectorSize));
     }
-    if (nameLen < 2 || nameLen > 64 || nameLen % 2 !== 0 || entryView.getUint16(nameLen - 2, true) !== 0) {
-      throw new Ole2ParseError("Invalid directory entry name");
-    }
-    const nameBytes = Math.max(0, nameLen - 2);
-    let name = "";
-    for (let j = 0; j < nameBytes; j += 2) {
-      name += String.fromCharCode(entryView.getUint16(j, true));
-    }
-    const leftSiblingId = entryView.getUint32(68, true);
-    const rightSiblingId = entryView.getUint32(72, true);
-    const childId = entryView.getUint32(76, true);
-    const clsid = new Uint8Array(entryView.buffer.slice(entryView.byteOffset + 80, entryView.byteOffset + 96));
-    const startSector = entryView.getUint32(116, true);
-    const sizeLow = entryView.getUint32(120, true);
-    let size = sizeLow;
-    if (majorVersion === 4) {
-      const sizeHigh = entryView.getUint32(124, true);
-      size = sizeLow + sizeHigh * 4294967296;
-      if (!Number.isSafeInteger(size) || size > sectorCount * sectorSize) {
-        throw new Ole2ParseError("Stream size exceeds supported file bounds");
-      }
+    return result;
+  }
+  if (firstDirectorySector > MAXREGSECT)
+    throw new Ole2ParseError("Missing directory chain");
+  const entries = readDirectory(readMetadataChain(firstDirectorySector, "directory"), majorVersion, strict, warnings);
+  for (const entry of entries) {
+    if (majorVersion === 4 && (!Number.isSafeInteger(entry.size) || entry.size > sectorCount * sectorSize)) {
+      throw new Ole2ParseError("Stream size exceeds supported file bounds");
     }
-    entries.push({
-      name,
-      type: objectType,
-      startSector,
-      size,
-      childId: childId === 4294967295 ? -1 : childId,
-      leftSiblingId: leftSiblingId === 4294967295 ? -1 : leftSiblingId,
-      rightSiblingId: rightSiblingId === 4294967295 ? -1 : rightSiblingId,
-      clsid
-    });
   }
   const rootEntry = entries.find((e) => e.type === ENTRY_TYPE_ROOT);
-  if (!rootEntry || entries.filter((e) => e.type === ENTRY_TYPE_ROOT).length !== 1) {
-    throw new Ole2ParseError("Invalid root directory entry");
-  }
   let miniStreamData;
-  if (rootEntry && rootEntry.startSector <= MAXREGSECT) {
+  if (rootEntry.startSector <= MAXREGSECT) {
     miniStreamData = readStream(rootEntry.startSector, rootEntry.size);
   }
   const miniFatEntries = [];
-  if (firstMiniFATSector <= MAXREGSECT && totalMiniFATSectors > 0) {
-    const miniFatRaw = readSectorChain(firstMiniFATSector);
-    if (miniFatRaw.length !== totalMiniFATSectors * sectorSize) {
+  if (firstMiniFATSector > MAXREGSECT && totalMiniFATSectors > 0) {
+    if (strict)
       throw new Ole2ParseError("Unexpected mini FAT chain length");
+    warnings.push({ code: "mini-fat-count", message: `Header lists ${totalMiniFATSectors} mini FAT sectors but no chain` });
+  }
+  if (firstMiniFATSector <= MAXREGSECT && (totalMiniFATSectors > 0 || !strict)) {
+    const miniFatRaw = readMetadataChain(firstMiniFATSector, "mini FAT");
+    if (miniFatRaw.length !== totalMiniFATSectors * sectorSize) {
+      if (strict)
+        throw new Ole2ParseError("Unexpected mini FAT chain length");
+      warnings.push({
+        code: "mini-fat-count",
+        message: `Header lists ${totalMiniFATSectors} mini FAT sectors; chain has ${miniFatRaw.length / sectorSize}`
+      });
     }
     const miniFatView = new DataView(miniFatRaw.buffer, miniFatRaw.byteOffset, miniFatRaw.byteLength);
     const miniCapacity = Math.floor((miniStreamData?.length ?? 0) / miniSectorSize);
@@ -205,45 +366,56 @@ function parseOle2(buffer) {
     if (!miniStreamData) {
       throw new Ole2ParseError("Mini stream container not found");
     }
-    const sectors = [];
-    let current = startSector;
-    const visited = /* @__PURE__ */ new Set();
-    while (current <= MAXREGSECT) {
-      if (visited.has(current)) {
-        throw new Ole2ParseError(`Circular reference in mini FAT chain at sector ${current}`);
+    const needed = Math.ceil(size / miniSectorSize);
+    const capacity = miniStreamData.length / miniSectorSize;
+    let ids;
+    try {
+      ids = followChain(miniFatEntries, startSector, "mini FAT", needed);
+    } catch (error) {
+      if (error instanceof Ole2ParseError && /Missing mini FAT/.test(error.message)) {
+        throw new Ole2ParseError("Mini stream sector exceeds allocation bounds");
       }
-      visited.add(current);
-      const offset2 = current * miniSectorSize;
-      if (offset2 + miniSectorSize > miniStreamData.length || miniFatEntries[current] === void 0) {
+      throw error;
+    }
+    const result = new Uint8Array(size);
+    for (let i2 = 0; i2 < ids.length && i2 < needed; i2++) {
+      const id = ids[i2];
+      if (id >= capacity || (id + 1) * miniSectorSize > miniStreamData.length) {
         throw new Ole2ParseError("Mini stream sector exceeds allocation bounds");
       }
-      sectors.push(miniStreamData.subarray(offset2, offset2 + miniSectorSize));
-      current = miniFatEntries[current];
+      const want = Math.min(miniSectorSize, size - i2 * miniSectorSize);
+      result.set(miniStreamData.subarray(id * miniSectorSize, id * miniSectorSize + want), i2 * miniSectorSize);
     }
-    if (current !== ENDOFCHAIN)
-      throw new Ole2ParseError("Invalid mini FAT chain terminator");
-    const totalLength = sectors.length * miniSectorSize;
-    if (totalLength < size)
+    if (ids.length < needed)
       throw new Ole2ParseError("Truncated mini stream sector chain");
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    for (const sector of sectors) {
-      result.set(sector, offset);
-      offset += miniSectorSize;
-    }
-    return result.subarray(0, size);
+    return result;
   }
-  function getStream(name) {
-    const entry = entries.find((e) => (e.type === ENTRY_TYPE_STREAM || e.type === ENTRY_TYPE_ROOT) && e.name === name);
-    if (!entry) {
-      return void 0;
-    }
+  function readEntry(entry) {
     if (entry.size < miniStreamCutoff && entry.type !== ENTRY_TYPE_ROOT) {
       return readMiniStream(entry.startSector, entry.size);
     }
     return readStream(entry.startSector, entry.size);
   }
-  return { entries, getStream };
+  const readable = (entry) => entry.type === ENTRY_TYPE_STREAM || entry.type === ENTRY_TYPE_ROOT;
+  return {
+    entries,
+    warnings,
+    getStream(name) {
+      const entry = findStreamByName(entries, name, readable);
+      return entry ? readEntry(entry) : void 0;
+    },
+    getStreamByPath(path) {
+      const entry = findDirectoryEntry(entries, path);
+      return entry && entry.type === ENTRY_TYPE_STREAM ? readEntry(entry) : void 0;
+    },
+    getStreamById(id) {
+      const entry = entries.find((candidate) => candidate.id === id);
+      return entry && readable(entry) ? readEntry(entry) : void 0;
+    },
+    findEntry(path) {
+      return findDirectoryEntry(entries, path);
+    }
+  };
 }
 
 // crypto/uuid.ts
@@ -263,7 +435,7 @@ function createOfficeGuid() {
   return `{${uuid.toUpperCase()}}`;
 }
 
-// ../../node_modules/.bun/@christophervr+ole2@0.12.0/node_modules/@christophervr/ole2/dist/utils/ooxml-crypto-primitives.js
+// ../../node_modules/.bun/@christophervr+ole2@0.13.0/node_modules/@christophervr/ole2/dist/utils/ooxml-crypto-primitives.js
 function getSubtle() {
   if (typeof globalThis.crypto !== "undefined" && globalThis.crypto.subtle) {
     return globalThis.crypto.subtle;
@@ -2417,7 +2589,7 @@ var EncryptedFileError = class extends Error {
   }
 };
 
-// ../../node_modules/.bun/@christophervr+ole2@0.12.0/node_modules/@christophervr/ole2/dist/ole2-parser-write-helpers.js
+// ../../node_modules/.bun/@christophervr+ole2@0.13.0/node_modules/@christophervr/ole2/dist/ole2-parser-write-helpers.js
 function compareDirEntryNames(a, b) {
   const ua = a.toUpperCase();
   const ub = b.toUpperCase();
@@ -2484,7 +2656,7 @@ function writeInt32Sectors(outBytes, int32Data, firstSector, numSectors, sectorS
   }
 }
 
-// ../../node_modules/.bun/@christophervr+ole2@0.12.0/node_modules/@christophervr/ole2/dist/ole2-parser-write-serialize.js
+// ../../node_modules/.bun/@christophervr+ole2@0.13.0/node_modules/@christophervr/ole2/dist/ole2-parser-write-serialize.js
 function writeHeader(outView, outBytes, params) {
   outBytes.set(OLE_MAGIC, 0);
   outView.setUint16(24, 62, true);
@@ -2577,7 +2749,7 @@ function writeStreamSectors(outBytes, streamData, chain, sectorSize) {
   }
 }
 
-// ../../node_modules/.bun/@christophervr+ole2@0.12.0/node_modules/@christophervr/ole2/dist/ole2-parser-write.js
+// ../../node_modules/.bun/@christophervr+ole2@0.13.0/node_modules/@christophervr/ole2/dist/ole2-parser-write.js
 function buildOle2(streams2, rootClsid, miniStreamCutoff = 4096) {
   const sectorSize = 512;
   const miniSectorSize = 64;