@shbernal/ts-xlsx 3.1.0 → 3.2.0

package/dist/vba/cfb-format.d.ts

@@ -1,3 +1,43 @@
+/** The header's first eight bytes, as the two little-endian `u32`s both directions handle them as. */
+export declare const CFB_SIGNATURE: {
+    readonly low: 3759263696;
+    readonly high: 3776623009;
+};
+/** Byte offsets of the header fields either direction reads or writes ([MS-CFB] 2.2). */
+export declare const HEADER_FIELD: {
+    readonly signatureLow: 0;
+    readonly signatureHigh: 4;
+    readonly minorVersion: 24;
+    readonly majorVersion: 26;
+    readonly byteOrder: 28;
+    readonly sectorShift: 30;
+    readonly miniSectorShift: 32;
+    readonly fatSectors: 44;
+    readonly firstDirectorySector: 48;
+    readonly miniStreamCutoff: 56;
+    readonly firstMiniFatSector: 60;
+    readonly miniFatSectors: 64;
+    readonly firstDifatSector: 68;
+    readonly difatSectors: 72;
+    readonly difat: 76;
+};
+/** Byte offsets within a directory entry, from the entry's start ([MS-CFB] 2.6.1). The name's UTF-16
+ * code units begin at offset 0. */
+export declare const DIR_ENTRY_FIELD: {
+    readonly nameLength: 64;
+    readonly objectType: 66;
+    readonly color: 67;
+    readonly leftSibling: 68;
+    readonly rightSibling: 72;
+    readonly child: 76;
+    readonly startSector: 116;
+    readonly sizeLow: 120;
+    readonly sizeHigh: 124;
+};
+/** FAT-sector pointers the header holds before a DIFAT sector is needed ([MS-CFB] 2.2). */
+export declare const HEADER_DIFAT_SLOTS = 109;
+/** 64-byte mini sectors: [MS-CFB] 2.2 fixes the shift at 6 for both versions. */
+export declare const MINI_SECTOR_SHIFT = 6;
 /** Sector chain markers ([MS-CFB] 2.2). */
 export declare const FREESECT = 4294967295;
 export declare const ENDOFCHAIN = 4294967294;
@@ -30,3 +70,10 @@ export declare const DIR_ENTRY_SIZE = 128;
 /** 32 UTF-16 code units including the NUL terminator. This is also why a VBA module name is capped
  * at 31: the module is a stream, and the stream's name is the module's. */
 export declare const MAX_NAME_CHARS = 31;
+/**
+ * Whether two directory-entry names are the same entry. [MS-CFB] 2.6.4 orders siblings by length and
+ * then by their uppercase forms, and forbids two siblings that compare equal, so a host looking a name
+ * up treats `dir` and `DIR` as one entry. A lookup here does the same, or a file whose producer cased a
+ * name differently would read as missing a stream it has.
+ */
+export declare function sameEntryName(a: string, b: string): boolean;

package/dist/vba/cfb-format.js

@@ -1,3 +1,34 @@
+export const CFB_SIGNATURE = { low: 0xe011cfd0, high: 0xe11ab1a1 };
+export const HEADER_FIELD = {
+    signatureLow: 0,
+    signatureHigh: 4,
+    minorVersion: 24,
+    majorVersion: 26,
+    byteOrder: 28,
+    sectorShift: 30,
+    miniSectorShift: 32,
+    fatSectors: 44,
+    firstDirectorySector: 48,
+    miniStreamCutoff: 56,
+    firstMiniFatSector: 60,
+    miniFatSectors: 64,
+    firstDifatSector: 68,
+    difatSectors: 72,
+    difat: 76,
+};
+export const DIR_ENTRY_FIELD = {
+    nameLength: 64,
+    objectType: 66,
+    color: 67,
+    leftSibling: 68,
+    rightSibling: 72,
+    child: 76,
+    startSector: 116,
+    sizeLow: 120,
+    sizeHigh: 124,
+};
+export const HEADER_DIFAT_SLOTS = 109;
+export const MINI_SECTOR_SHIFT = 6;
 export const FREESECT = 0xffffffff;
 export const ENDOFCHAIN = 0xfffffffe;
 export const FATSECT = 0xfffffffd;
@@ -11,3 +42,6 @@ export const TYPE_ROOT = 5;
 export const MINI_STREAM_CUTOFF = 4096;
 export const DIR_ENTRY_SIZE = 128;
 export const MAX_NAME_CHARS = 31;
+export function sameEntryName(a, b) {
+    return a.length === b.length && a.toUpperCase() === b.toUpperCase();
+}

package/dist/vba/cfb-writer.d.ts

@@ -13,10 +13,9 @@ export type CfbNode = CfbStream | CfbStorage;
  *
  * Exported beside the union rather than kept private, because the discriminant is `'data' in node`
  * and that is the sort of test callers re-spell inline: `project-editor.ts` had it three times, once
- * negated. The name says what the test means, and the pair says that a node is one or the other.
+ * negated. The name says what the test means, and a node it answers `false` for is a storage.
  */
 export declare function isStream(node: CfbNode): node is CfbStream;
-export declare function isStorage(node: CfbNode): node is CfbStorage;
 /**
  * Encode a hierarchy of storages and streams into a v3 compound file. The Root Entry is synthesized
  * automatically; `root` is its top-level children. Every stream becomes a directory entry reachable both

package/dist/vba/cfb-writer.js

@@ -1,17 +1,14 @@
 import { quoted } from '../errors.js';
-import { DIFSECT, DIR_ENTRY_SIZE, ENDOFCHAIN, FATSECT, FREESECT, MAX_NAME_CHARS, MINI_STREAM_CUTOFF, NOSTREAM, TYPE_ROOT, TYPE_STORAGE, TYPE_STREAM, } from './cfb-format.js';
+import { CFB_SIGNATURE, DIFSECT, DIR_ENTRY_FIELD, DIR_ENTRY_SIZE, ENDOFCHAIN, FATSECT, FREESECT, HEADER_DIFAT_SLOTS, HEADER_FIELD, MAX_NAME_CHARS, MINI_SECTOR_SHIFT, MINI_STREAM_CUTOFF, NOSTREAM, TYPE_ROOT, TYPE_STORAGE, TYPE_STREAM, } from './cfb-format.js';
 import { VbaAuthorError } from './errors.js';
 export function isStream(node) {
     return 'data' in node;
 }
-export function isStorage(node) {
-    return !isStream(node);
-}
-const SECTOR = 512;
-const MINI_SECTOR = 64;
+const SECTOR_SHIFT = 9;
+const SECTOR = 1 << SECTOR_SHIFT;
+const MINI_SECTOR = 1 << MINI_SECTOR_SHIFT;
 const ENTRIES_PER_DIR_SECTOR = SECTOR / DIR_ENTRY_SIZE;
 const FAT_ENTRIES_PER_SECTOR = SECTOR / 4;
-const DIFAT_HEADER_SLOTS = 109;
 const COLOR_BLACK = 1;
 export function writeCompoundFile(root) {
     const entries = [];
@@ -82,16 +79,16 @@ export function writeCompoundFile(root) {
     for (;;) {
         const total = baseSectors + fatSectors + difatSectors;
         const needFat = Math.ceil(total / FAT_ENTRIES_PER_SECTOR);
-        const needDifat = needFat > DIFAT_HEADER_SLOTS
-            ? Math.ceil((needFat - DIFAT_HEADER_SLOTS) / (FAT_ENTRIES_PER_SECTOR - 1))
+        const needDifat = needFat > HEADER_DIFAT_SLOTS
+            ? Math.ceil((needFat - HEADER_DIFAT_SLOTS) / (FAT_ENTRIES_PER_SECTOR - 1))
             : 0;
         if (needFat === fatSectors && needDifat === difatSectors)
             break;
         fatSectors = needFat;
         difatSectors = needDifat;
     }
-    if (fatSectors > DIFAT_HEADER_SLOTS) {
-        throw new VbaAuthorError(`project needs ${fatSectors} FAT sectors, exceeding the ${DIFAT_HEADER_SLOTS}-sector single-header bound`);
+    if (fatSectors > HEADER_DIFAT_SLOTS) {
+        throw new VbaAuthorError(`project needs ${fatSectors} FAT sectors, exceeding the ${HEADER_DIFAT_SLOTS}-sector single-header bound`);
     }
     let cursor = 0;
     const dirStart = cursor;
@@ -158,7 +155,7 @@ export function writeCompoundFile(root) {
     for (let d = 0; d < difatSectors; d++) {
         const base = at(difatStart + d);
         for (let i = 0; i < FAT_ENTRIES_PER_SECTOR - 1; i++) {
-            const fatIdx = DIFAT_HEADER_SLOTS + d * (FAT_ENTRIES_PER_SECTOR - 1) + i;
+            const fatIdx = HEADER_DIFAT_SLOTS + d * (FAT_ENTRIES_PER_SECTOR - 1) + i;
             dv.setUint32(base + i * 4, fatIdx < fatSectors ? fatStart + fatIdx : FREESECT, true);
         }
         dv.setUint32(base + (FAT_ENTRIES_PER_SECTOR - 1) * 4, d < difatSectors - 1 ? difatStart + d + 1 : ENDOFCHAIN, true);
@@ -201,33 +198,33 @@ function compareNames(a, b) {
     return ua < ub ? -1 : ua > ub ? 1 : 0;
 }
 function writeHeader(dv, p) {
-    dv.setUint32(0, 0xe011cfd0, true);
-    dv.setUint32(4, 0xe11ab1a1, true);
-    dv.setUint16(24, 0x003e, true);
-    dv.setUint16(26, 0x0003, true);
-    dv.setUint16(28, 0xfffe, true);
-    dv.setUint16(30, 9, true);
-    dv.setUint16(32, 6, true);
-    dv.setUint32(44, p.fatSectors, true);
-    dv.setUint32(48, p.dirStart, true);
-    dv.setUint32(56, MINI_STREAM_CUTOFF, true);
-    dv.setUint32(60, p.miniFatStart, true);
-    dv.setUint32(64, p.miniFatSectors, true);
-    dv.setUint32(68, p.difatSectors > 0 ? p.difatStart : ENDOFCHAIN, true);
-    dv.setUint32(72, p.difatSectors, true);
-    for (let i = 0; i < DIFAT_HEADER_SLOTS; i++) {
-        dv.setUint32(76 + i * 4, i < p.fatSectors ? p.fatStart + i : FREESECT, true);
+    dv.setUint32(HEADER_FIELD.signatureLow, CFB_SIGNATURE.low, true);
+    dv.setUint32(HEADER_FIELD.signatureHigh, CFB_SIGNATURE.high, true);
+    dv.setUint16(HEADER_FIELD.minorVersion, 0x003e, true);
+    dv.setUint16(HEADER_FIELD.majorVersion, 0x0003, true);
+    dv.setUint16(HEADER_FIELD.byteOrder, 0xfffe, true);
+    dv.setUint16(HEADER_FIELD.sectorShift, SECTOR_SHIFT, true);
+    dv.setUint16(HEADER_FIELD.miniSectorShift, MINI_SECTOR_SHIFT, true);
+    dv.setUint32(HEADER_FIELD.fatSectors, p.fatSectors, true);
+    dv.setUint32(HEADER_FIELD.firstDirectorySector, p.dirStart, true);
+    dv.setUint32(HEADER_FIELD.miniStreamCutoff, MINI_STREAM_CUTOFF, true);
+    dv.setUint32(HEADER_FIELD.firstMiniFatSector, p.miniFatStart, true);
+    dv.setUint32(HEADER_FIELD.miniFatSectors, p.miniFatSectors, true);
+    dv.setUint32(HEADER_FIELD.firstDifatSector, p.difatSectors > 0 ? p.difatStart : ENDOFCHAIN, true);
+    dv.setUint32(HEADER_FIELD.difatSectors, p.difatSectors, true);
+    for (let i = 0; i < HEADER_DIFAT_SLOTS; i++) {
+        dv.setUint32(HEADER_FIELD.difat + i * 4, i < p.fatSectors ? p.fatStart + i : FREESECT, true);
     }
 }
 function writeDirEntry(dv, off, e) {
     for (let i = 0; i < e.name.length; i++)
         dv.setUint16(off + i * 2, e.name.charCodeAt(i), true);
-    dv.setUint16(off + 64, (e.name.length + 1) * 2, true);
-    dv.setUint8(off + 66, e.type);
-    dv.setUint8(off + 67, COLOR_BLACK);
-    dv.setUint32(off + 68, e.left, true);
-    dv.setUint32(off + 72, e.right, true);
-    dv.setUint32(off + 76, e.child, true);
-    dv.setUint32(off + 116, e.startSector, true);
-    dv.setUint32(off + 120, e.size, true);
+    dv.setUint16(off + DIR_ENTRY_FIELD.nameLength, (e.name.length + 1) * 2, true);
+    dv.setUint8(off + DIR_ENTRY_FIELD.objectType, e.type);
+    dv.setUint8(off + DIR_ENTRY_FIELD.color, COLOR_BLACK);
+    dv.setUint32(off + DIR_ENTRY_FIELD.leftSibling, e.left, true);
+    dv.setUint32(off + DIR_ENTRY_FIELD.rightSibling, e.right, true);
+    dv.setUint32(off + DIR_ENTRY_FIELD.child, e.child, true);
+    dv.setUint32(off + DIR_ENTRY_FIELD.startSector, e.startSector, true);
+    dv.setUint32(off + DIR_ENTRY_FIELD.sizeLow, e.size, true);
 }

package/dist/vba/cfb.d.ts

@@ -2,10 +2,15 @@ import type { CfbNode } from './cfb-writer.ts';
 export declare class CompoundFile {
     #private;
     constructor(buf: Uint8Array);
-    /** List every stream/storage name in the directory (order as stored). */
-    names(): string[];
     /**
-     * Read a stream's raw bytes by exact entry name, or `undefined` if absent.
+     * Read a stream's raw bytes by its storage path from the root (`['VBA', 'dir']`), or `undefined` when
+     * no stream sits there. Each segment is matched among one storage's children, as [MS-CFB] compares
+     * names, by walking the sibling tree that storage links.
+     *
+     * A path because a name is not an address. [MS-OVBA] puts `PROJECT` at the root, `dir` and every
+     * module stream in `VBA`, and each UserForm's `f` and `o` in a storage of its own, so a bare name
+     * repeats. Looked up by name, the first entry in directory order won: a module named `f` read a
+     * UserForm's form data, and an edit wrote a module named `PROJECT` over the root `PROJECT`.
      *
      * @returns bytes that may be a **view onto the caller's buffer** rather than a copy. A stream small
      *   enough to fit in one sector is assembled by `concat` from a single chunk, and `concat` hands a
@@ -15,7 +20,7 @@ export declare class CompoundFile {
      *   thing that is true until someone writes the first mutation, and then true only for large
      *   streams. Copy before mutating.
      */
-    readStream(name: string): Uint8Array | undefined;
+    readStream(path: readonly string[]): Uint8Array | undefined;
     /**
      * Reconstruct the container's top-level children as the writer's node shape, recursing into every
      * storage, so a caller can swap one stream and re-emit the whole hierarchy with {@link writeCompoundFile}.

package/dist/vba/cfb.js

@@ -1,9 +1,7 @@
 import { quoted } from '../errors.js';
 import { concat, decodeUtf16le, readU16, readU32 } from './bytes.js';
-import { DIR_ENTRY_SIZE, MAX_REGULAR_SECTOR, MINI_STREAM_CUTOFF, NOSTREAM, TYPE_EMPTY, TYPE_ROOT, TYPE_STORAGE, TYPE_STREAM, } from './cfb-format.js';
+import { CFB_SIGNATURE, DIR_ENTRY_FIELD, DIR_ENTRY_SIZE, HEADER_DIFAT_SLOTS, HEADER_FIELD, MAX_REGULAR_SECTOR, MINI_SECTOR_SHIFT, MINI_STREAM_CUTOFF, NOSTREAM, sameEntryName, TYPE_EMPTY, TYPE_ROOT, TYPE_STORAGE, TYPE_STREAM, } from './cfb-format.js';
 import { VbaParseError } from './errors.js';
-const CFB_SIGNATURE_LO = 0xe011cfd0;
-const CFB_SIGNATURE_HI = 0xe11ab1a1;
 const MAX_TREE_DEPTH = 256;
 export class CompoundFile {
     #buf;
@@ -19,28 +17,29 @@ export class CompoundFile {
         this.#buf = buf;
         if (buf.length < 512)
             throw new VbaParseError('compound file shorter than its 512-byte header');
-        if (readU32(this.#buf, 0) !== CFB_SIGNATURE_LO || readU32(this.#buf, 4) !== CFB_SIGNATURE_HI) {
+        if (readU32(this.#buf, HEADER_FIELD.signatureLow) !== CFB_SIGNATURE.low ||
+            readU32(this.#buf, HEADER_FIELD.signatureHigh) !== CFB_SIGNATURE.high) {
             throw new VbaParseError('not a compound file (bad OLE2 signature)');
         }
-        const sectorShift = readU16(this.#buf, 30);
-        const miniSectorShift = readU16(this.#buf, 32);
+        const sectorShift = readU16(this.#buf, HEADER_FIELD.sectorShift);
+        const miniSectorShift = readU16(this.#buf, HEADER_FIELD.miniSectorShift);
         if (sectorShift !== 9 && sectorShift !== 12) {
             throw new VbaParseError(`unsupported sector shift ${sectorShift}`);
         }
-        if (miniSectorShift !== 6)
+        if (miniSectorShift !== MINI_SECTOR_SHIFT)
             throw new VbaParseError(`unsupported mini-sector shift ${miniSectorShift}`);
         this.#sectorSize = 1 << sectorShift;
         this.#miniSectorSize = 1 << miniSectorShift;
         this.#maxSector = Math.floor(buf.length / this.#sectorSize);
-        const numFatSectors = readU32(this.#buf, 44);
-        const firstDirSector = readU32(this.#buf, 48);
-        this.#miniCutoff = readU32(this.#buf, 56);
+        const numFatSectors = readU32(this.#buf, HEADER_FIELD.fatSectors);
+        const firstDirSector = readU32(this.#buf, HEADER_FIELD.firstDirectorySector);
+        this.#miniCutoff = readU32(this.#buf, HEADER_FIELD.miniStreamCutoff);
         if (this.#miniCutoff !== MINI_STREAM_CUTOFF) {
             throw new VbaParseError(`unsupported mini-stream cutoff ${this.#miniCutoff}`);
         }
-        const firstMiniFatSector = readU32(this.#buf, 60);
-        const firstDifatSector = readU32(this.#buf, 68);
-        const numDifatSectors = readU32(this.#buf, 72);
+        const firstMiniFatSector = readU32(this.#buf, HEADER_FIELD.firstMiniFatSector);
+        const firstDifatSector = readU32(this.#buf, HEADER_FIELD.firstDifatSector);
+        const numDifatSectors = readU32(this.#buf, HEADER_FIELD.difatSectors);
         const fatSectorIds = this.#readDifat(numFatSectors, firstDifatSector, numDifatSectors);
         this.#fat = this.#readFat(fatSectorIds);
         this.#miniFat = this.#readChainValues(firstMiniFatSector);
@@ -50,28 +49,46 @@ export class CompoundFile {
             throw new VbaParseError('compound file has no root storage entry');
         this.#miniStream = this.#readViaFat(root.startSector, root.size);
     }
-    names() {
-        return this.#dir
-            .filter((e) => e.type === TYPE_STREAM || e.type === TYPE_STORAGE)
-            .map((e) => e.name);
-    }
-    readStream(name) {
-        const entry = this.#dir.find((e) => e.type === TYPE_STREAM && e.name === name);
-        if (!entry)
-            return undefined;
-        return this.#readEntryData(entry);
+    readStream(path) {
+        const rootIdx = this.#rootIndex();
+        const seen = new Set([rootIdx]);
+        let firstChild = this.#dir[rootIdx].child;
+        for (const [depth, segment] of path.entries()) {
+            const stream = depth === path.length - 1;
+            const entry = this.#childIndices(firstChild, seen, depth)
+                .map((idx) => this.#dir[idx])
+                .find((e) => (stream ? e.type === TYPE_STREAM : e.type === TYPE_STORAGE) &&
+                sameEntryName(e.name, segment));
+            if (entry === undefined)
+                return undefined;
+            if (stream)
+                return this.#readEntryData(entry);
+            firstChild = entry.child;
+        }
+        return undefined;
     }
     tree() {
+        const rootIdx = this.#rootIndex();
+        return this.#buildSiblings(this.#dir[rootIdx].child, new Set([rootIdx]));
+    }
+    #rootIndex() {
         const rootIdx = this.#dir.findIndex((e) => e.type === TYPE_ROOT);
         if (rootIdx < 0)
             throw new VbaParseError('compound file has no root storage entry');
-        const root = this.#dir[rootIdx];
-        return this.#buildSiblings(root.child, new Set([rootIdx]));
+        return rootIdx;
     }
     #buildSiblings(firstChild, seen, depth = 0) {
         if (depth > MAX_TREE_DEPTH)
             throw new VbaParseError('directory tree nests too deep');
-        const nodes = [];
+        return this.#childIndices(firstChild, seen, depth).map((idx) => {
+            const e = this.#dir[idx];
+            return e.type === TYPE_STORAGE
+                ? { name: e.name, children: this.#buildSiblings(e.child, seen, depth + 1) }
+                : { name: e.name, data: this.#readEntryData(e) };
+        });
+    }
+    #childIndices(firstChild, seen, depth) {
+        const indices = [];
         const walk = (idx, siblingDepth) => {
             if (idx >= MAX_REGULAR_SECTOR)
                 return;
@@ -86,16 +103,11 @@ export class CompoundFile {
             if (e.type === TYPE_EMPTY)
                 throw new VbaParseError('directory tree links an empty entry');
             walk(e.left, siblingDepth + 1);
-            if (e.type === TYPE_STORAGE) {
-                nodes.push({ name: e.name, children: this.#buildSiblings(e.child, seen, depth + 1) });
-            }
-            else {
-                nodes.push({ name: e.name, data: this.#readEntryData(e) });
-            }
+            indices.push(idx);
             walk(e.right, siblingDepth + 1);
         };
         walk(firstChild, depth);
-        return nodes;
+        return indices;
     }
     #readEntryData(entry) {
         if (entry.size >= this.#miniCutoff)
@@ -105,8 +117,8 @@ export class CompoundFile {
     #readDifat(numFatSectors, firstDifat, numDifat) {
         const wanted = Math.min(numFatSectors, this.#maxSector);
         const ids = [];
-        for (let i = 0; i < 109 && ids.length < wanted; i++) {
-            const v = readU32(this.#buf, 76 + i * 4);
+        for (let i = 0; i < HEADER_DIFAT_SLOTS && ids.length < wanted; i++) {
+            const v = readU32(this.#buf, HEADER_FIELD.difat + i * 4);
             if (v >= MAX_REGULAR_SECTOR)
                 break;
             ids.push(v);
@@ -163,16 +175,16 @@ export class CompoundFile {
         const raw = this.#readChainFull(firstDirSector);
         const entries = [];
         for (let off = 0; off + DIR_ENTRY_SIZE <= raw.length; off += DIR_ENTRY_SIZE) {
-            const type = raw[off + 66];
+            const type = raw[off + DIR_ENTRY_FIELD.objectType];
             if (type !== TYPE_EMPTY &&
                 type !== TYPE_STORAGE &&
                 type !== TYPE_STREAM &&
                 type !== TYPE_ROOT) {
                 throw new VbaParseError(`directory entry has invalid object type ${type}`);
             }
-            const left = readU32(raw, off + 68);
-            const right = readU32(raw, off + 72);
-            const child = readU32(raw, off + 76);
+            const left = readU32(raw, off + DIR_ENTRY_FIELD.leftSibling);
+            const right = readU32(raw, off + DIR_ENTRY_FIELD.rightSibling);
+            const child = readU32(raw, off + DIR_ENTRY_FIELD.child);
             if (type === TYPE_EMPTY) {
                 entries.push({
                     name: '',
@@ -185,14 +197,14 @@ export class CompoundFile {
                 });
                 continue;
             }
-            const nameLen = readU16(raw, off + 64);
+            const nameLen = readU16(raw, off + DIR_ENTRY_FIELD.nameLength);
             if (nameLen > 64 || nameLen % 2 !== 0) {
                 throw new VbaParseError(`directory entry has invalid name length ${nameLen}`);
             }
             const name = decodeUtf16le(raw.subarray(off, off + Math.max(0, nameLen - 2)));
-            const startSector = readU32(raw, off + 116);
-            const size = readU32(raw, off + 120);
-            if (readU32(raw, off + 124) !== 0) {
+            const startSector = readU32(raw, off + DIR_ENTRY_FIELD.startSector);
+            const size = readU32(raw, off + DIR_ENTRY_FIELD.sizeLow);
+            if (readU32(raw, off + DIR_ENTRY_FIELD.sizeHigh) !== 0) {
                 throw new VbaParseError(`directory entry ${quoted(name)} declares a stream larger than 4 GiB`);
             }
             entries.push({ name, type, startSector, size, left, right, child });

package/dist/vba/dir-records.d.ts

@@ -51,3 +51,9 @@ export interface DirRecord {
  * @throws {VbaParseError} when a record's payload runs past the end of the stream.
  */
 export declare function dirRecords(dir: Uint8Array, context: string): Generator<DirRecord>;
+/**
+ * One record's bytes, `Id(u16) Size(u32) data[Size]`: the grammar {@link dirRecords} walks, written.
+ * Built as bytes rather than spread into a `number[]`, which overflowed the call stack on a payload of a
+ * few hundred thousand bytes. Not for PROJECTVERSION, whose uncounted VersionMinor no edit here writes.
+ */
+export declare function dirRecord(id: number, data: Uint8Array): Uint8Array;

package/dist/vba/dir-records.js

@@ -1,4 +1,5 @@
-import { readU16, readU32 } from './bytes.js';
+import { hex } from '../hex.js';
+import { readU16, readU32, writeU16, writeU32 } from './bytes.js';
 import { VbaParseError } from './errors.js';
 export const REC_PROJECT_CODEPAGE = 0x0003;
 export const REC_PROJECT_VERSION = 0x0009;
@@ -19,10 +20,17 @@ export function* dirRecords(dir, context) {
         const size = readU32(dir, pos + 2);
         const dataStart = pos + 6;
         if (dataStart + size > dir.length) {
-            throw new VbaParseError(`dir record 0x${id.toString(16)} ${context}`);
+            throw new VbaParseError(`dir record 0x${hex(id, 4)} ${context}`);
         }
         const end = dataStart + size + (id === REC_PROJECT_VERSION ? 2 : 0);
         yield { id, recordStart: pos, dataStart, size, end };
         pos = end;
     }
 }
+export function dirRecord(id, data) {
+    const out = new Uint8Array(6 + data.length);
+    writeU16(out, 0, id);
+    writeU32(out, 2, data.length);
+    out.set(data, 6);
+    return out;
+}

package/dist/vba/errors.d.ts

@@ -12,10 +12,10 @@ export declare class VbaParseError extends XlsxError {
     readonly code = "malformed-input";
 }
 /**
- * Thrown when authoring a VBA project (synthesizing a `vbaProject.bin` from module source) is asked to
- * produce something that cannot be encoded to a well-formed container: a stream name longer than the
- * [MS-CFB] 31-character limit, a duplicate stream name, or a project so large it would exceed the
- * writer's single-header DIFAT bound. This is a caller-side contract violation, distinct from
+ * Thrown when a structural edit of a VBA project (removing a module, adding a library reference) is
+ * asked to produce something that cannot be encoded to a well-formed container: a stream name longer
+ * than the [MS-CFB] 31-character limit, a duplicate stream name, or a project so large it would exceed
+ * the writer's single-header DIFAT bound. This is a caller-side contract violation, distinct from
  * {@link VbaParseError} (which reports a malformed blob *read* from an untrusted file).
  *
  * It shares `code: 'authoring'` with `AuthoringError` rather than being one, and it is the only

package/dist/vba/index.d.ts

@@ -1,5 +1,3 @@
-export { type CfbNode, type CfbStorage, type CfbStream, writeCompoundFile } from './cfb-writer.ts';
 export { VbaAuthorError, VbaParseError } from './errors.ts';
-export { compressContainer, decompressContainer } from './ms-ovba.ts';
 export { parseVbaProject, VBA_PROJECT_CONTENT_TYPE, VBA_PROJECT_PART_PATH, VBA_PROJECT_REL_TYPE, type VbaModule, type VbaModuleKind, type VbaProject, type VbaProjectSignature, type VbaProjectSignatureKind, vbaProjectSignatureKind, } from './project.ts';
 export { addVbaReference, removeVbaModule, type VbaLibraryReference } from './project-editor.ts';

package/dist/vba/index.js

@@ -1,5 +1,3 @@
-export { writeCompoundFile } from './cfb-writer.js';
 export { VbaAuthorError, VbaParseError } from './errors.js';
-export { compressContainer, decompressContainer } from './ms-ovba.js';
 export { parseVbaProject, VBA_PROJECT_CONTENT_TYPE, VBA_PROJECT_PART_PATH, VBA_PROJECT_REL_TYPE, vbaProjectSignatureKind, } from './project.js';
 export { addVbaReference, removeVbaModule } from './project-editor.js';

package/dist/vba/ms-ovba.d.ts

@@ -6,7 +6,11 @@ export declare function decompressContainer(buf: Uint8Array, start?: number, max
 /**
  * Compress `data` into an MS-OVBA CompressedContainer: the inverse of {@link decompressContainer}.
  * Every 4096-decompressed-byte window is emitted as a compressed chunk of literal and copy tokens, or
- * stored verbatim when compression would not shrink it (so the encoded chunk never exceeds the 12-bit
- * size field). The result re-expands to `data` byte-for-byte.
+ * stored raw when those tokens would not fit the 4096 bytes a chunk's data may hold.
+ *
+ * The result re-expands to `data` byte-for-byte, with one exception the format itself prescribes: a
+ * final window that is shorter than 4096 bytes and does not compress (only possible past about 3640
+ * bytes, where a literal's flag-bit overhead first overflows the chunk) is stored raw and padded with
+ * `0x00` to 4096, so it re-expands with those zeros after it ([MS-OVBA] 2.4.1.3.10).
  */
 export declare function compressContainer(data: Uint8Array): Uint8Array;

package/dist/vba/ms-ovba.js

@@ -1,7 +1,9 @@
+import { hex } from '../hex.js';
 import { readU16 } from './bytes.js';
 import { VbaParseError } from './errors.js';
 const MAX_CHUNK_DECOMPRESSED = 4096;
 const CHUNK_SIGNATURE = 0b011 << 12;
+const CHUNK_SIGNATURE_MASK = 0b111 << 12;
 const CHUNK_COMPRESSED_FLAG = 0x8000;
 const MAX_MATCH_CANDIDATES = 64;
 const HASH_BITS = 12;
@@ -12,7 +14,7 @@ export function decompressContainer(buf, start = 0, maxOutput = DEFAULT_MAX_OUTP
         throw new VbaParseError(`compressed container starts past end of stream (${start} >= ${buf.length})`);
     }
     if (buf[start] !== 0x01) {
-        throw new VbaParseError(`compressed container must begin with a 0x01 signature byte, found 0x${(buf[start] ?? 0).toString(16)}`);
+        throw new VbaParseError(`compressed container must begin with a 0x01 signature byte, found 0x${hex(buf[start] ?? 0, 2)}`);
     }
     const out = new ByteSink(maxOutput);
     let pos = start + 1;
@@ -20,9 +22,9 @@ export function decompressContainer(buf, start = 0, maxOutput = DEFAULT_MAX_OUTP
         const header = readU16(buf, pos);
         pos += 2;
         const chunkDataSize = (header & 0x0fff) + 1;
-        const compressed = (header & 0x8000) !== 0;
-        if (((header >> 12) & 0x7) !== 0b011) {
-            throw new VbaParseError(`chunk header has a bad 0b011 signature (0x${header.toString(16)})`);
+        const compressed = (header & CHUNK_COMPRESSED_FLAG) !== 0;
+        if ((header & CHUNK_SIGNATURE_MASK) !== CHUNK_SIGNATURE) {
+            throw new VbaParseError(`chunk header has a bad 0b011 signature (0x${hex(header, 4)})`);
         }
         const chunkEnd = pos + chunkDataSize;
         if (chunkEnd > buf.length) {
@@ -108,8 +110,8 @@ export function compressContainer(data) {
     for (let start = 0; start < data.length; start += MAX_CHUNK_DECOMPRESSED) {
         const chunk = data.subarray(start, Math.min(start + MAX_CHUNK_DECOMPRESSED, data.length));
         const tokens = compressChunk(chunk);
-        const compressed = tokens.length < chunk.length;
-        const body = compressed ? tokens : chunk;
+        const compressed = tokens.length <= MAX_CHUNK_DECOMPRESSED;
+        const body = compressed ? tokens : padToChunk(chunk);
         const header = (compressed ? CHUNK_COMPRESSED_FLAG : 0) | CHUNK_SIGNATURE | ((body.length - 1) & 0x0fff);
         out.push(header & 0xff);
         out.push((header >> 8) & 0xff);
@@ -117,6 +119,13 @@ export function compressContainer(data) {
     }
     return out.bytes();
 }
+function padToChunk(chunk) {
+    if (chunk.length === MAX_CHUNK_DECOMPRESSED)
+        return chunk;
+    const padded = new Uint8Array(MAX_CHUNK_DECOMPRESSED);
+    padded.set(chunk);
+    return padded;
+}
 function compressChunk(chunk) {
     const tokens = new ByteSink();
     const heads = new Int32Array(1 << HASH_BITS).fill(NO_CANDIDATE);