@shbernal/ts-xlsx 3.0.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;
@@ -17,8 +57,23 @@ export declare const TYPE_EMPTY = 0;
 export declare const TYPE_STORAGE = 1;
 export declare const TYPE_STREAM = 2;
 export declare const TYPE_ROOT = 5;
+/**
+ * The stream size at or above which a stream lives in the regular FAT rather than the mini stream
+ * ([MS-CFB] 2.2, header offset 56). The spec fixes it at 4096, so the reader checks the header's value
+ * against this rather than believing it: a crafted 0 or 0xFFFFFFFF routes every stream through the
+ * wrong allocator, and since both destinations are bounds-checked the result is a module's source read
+ * back as something nobody wrote rather than a clean rejection.
+ */
+export declare const MINI_STREAM_CUTOFF = 4096;
 /** A directory entry is a fixed 128 bytes ([MS-CFB] 2.6.1), whatever the sector size. */
 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;
@@ -8,5 +39,9 @@ export const TYPE_EMPTY = 0;
 export const TYPE_STORAGE = 1;
 export const TYPE_STREAM = 2;
 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

@@ -8,6 +8,14 @@ export interface CfbStorage {
     readonly children: readonly CfbNode[];
 }
 export type CfbNode = CfbStream | CfbStorage;
+/**
+ * Which arm of {@link CfbNode} a node is.
+ *
+ * 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 a node it answers `false` for is a storage.
+ */
+export declare function isStream(node: CfbNode): node is CfbStream;
 /**
  * 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,15 +1,15 @@
-import { DIFSECT, DIR_ENTRY_SIZE, ENDOFCHAIN, FATSECT, FREESECT, MAX_NAME_CHARS, NOSTREAM, TYPE_ROOT, TYPE_STORAGE, TYPE_STREAM, } from './cfb-format.js';
+import { quoted } from '../errors.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';
-const SECTOR = 512;
-const MINI_SECTOR = 64;
-const MINI_CUTOFF = 4096;
+export function isStream(node) {
+    return 'data' in node;
+}
+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;
-function isStream(node) {
-    return 'data' in node;
-}
 export function writeCompoundFile(root) {
     const entries = [];
     const addEntry = (name, type, startSector) => {
@@ -38,7 +38,7 @@ export function writeCompoundFile(root) {
             siblings.push(entry);
             if (node.data.length === 0) {
             }
-            else if (node.data.length >= MINI_CUTOFF) {
+            else if (node.data.length >= MINI_STREAM_CUTOFF) {
                 bigStreams.push({ entry, data: node.data, sectors: Math.ceil(node.data.length / SECTOR) });
             }
             else {
@@ -79,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;
@@ -155,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);
@@ -168,10 +168,10 @@ function validateSiblingNames(storageName, siblings) {
         if (node.name.length === 0)
             throw new VbaAuthorError('entry name must not be empty');
         if (node.name.length > MAX_NAME_CHARS) {
-            throw new VbaAuthorError(`entry name '${node.name}' exceeds the ${MAX_NAME_CHARS}-character CFB limit`);
+            throw new VbaAuthorError(`entry name ${quoted(node.name)} exceeds the ${MAX_NAME_CHARS}-character CFB limit`);
         }
         if (seen.has(node.name)) {
-            throw new VbaAuthorError(`duplicate entry name '${node.name}' under storage '${storageName}'`);
+            throw new VbaAuthorError(`duplicate entry name ${quoted(node.name)} under storage ${quoted(storageName)}`);
         }
         seen.add(node.name);
         if (!isStream(node))
@@ -198,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_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,15 +2,32 @@ 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. */
-    readStream(name: string): Uint8Array | undefined;
+    /**
+     * 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
+     *   lone chunk straight back; anything larger is copied into a fresh buffer. So whether the result
+     *   aliases the source depends on the stream's size, which is a rule no caller should have to know
+     *   and none here relies on: nothing mutates what this returns. Stated because it is the sort of
+     *   thing that is true until someone writes the first mutation, and then true only for large
+     *   streams. Copy before mutating.
+     */
+    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}.
      * Walks the red-black sibling tree each storage navigates (not the linear directory scan), so any part
      * a host reaches is carried through. Cycle- and bounds-guarded like every other chain walk here.
+     *
+     * @returns nodes whose stream bytes carry {@link readStream}'s aliasing caveat.
      */
     tree(): CfbNode[];
 }

package/dist/vba/cfb.js

@@ -1,8 +1,8 @@
+import { quoted } from '../errors.js';
 import { concat, decodeUtf16le, readU16, readU32 } from './bytes.js';
-import { DIR_ENTRY_SIZE, MAX_REGULAR_SECTOR, 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;
     #sectorSize;
@@ -17,25 +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 firstMiniFatSector = readU32(this.#buf, 60);
-        const firstDifatSector = readU32(this.#buf, 68);
-        const numDifatSectors = readU32(this.#buf, 72);
+        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, 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);
@@ -45,29 +49,51 @@ 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');
+        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) };
+        });
     }
-    #buildSiblings(firstChild, seen) {
-        const nodes = [];
-        const walk = (idx) => {
+    #childIndices(firstChild, seen, depth) {
+        const indices = [];
+        const walk = (idx, siblingDepth) => {
             if (idx >= MAX_REGULAR_SECTOR)
                 return;
+            if (siblingDepth > MAX_TREE_DEPTH)
+                throw new VbaParseError('directory tree nests too deep');
             if (idx >= this.#dir.length)
                 throw new VbaParseError('directory sibling index out of range');
             if (seen.has(idx))
@@ -76,17 +102,12 @@ export class CompoundFile {
             const e = this.#dir[idx];
             if (e.type === TYPE_EMPTY)
                 throw new VbaParseError('directory tree links an empty entry');
-            walk(e.left);
-            if (e.type === TYPE_STORAGE) {
-                nodes.push({ name: e.name, children: this.#buildSiblings(e.child, seen) });
-            }
-            else {
-                nodes.push({ name: e.name, data: this.#readEntryData(e) });
-            }
-            walk(e.right);
+            walk(e.left, siblingDepth + 1);
+            indices.push(idx);
+            walk(e.right, siblingDepth + 1);
         };
-        walk(firstChild);
-        return nodes;
+        walk(firstChild, depth);
+        return indices;
     }
     #readEntryData(entry) {
         if (entry.size >= this.#miniCutoff)
@@ -94,9 +115,10 @@ export class CompoundFile {
         return this.#readViaMiniFat(entry.startSector, entry.size);
     }
     #readDifat(numFatSectors, firstDifat, numDifat) {
+        const wanted = Math.min(numFatSectors, this.#maxSector);
         const ids = [];
-        for (let i = 0; i < 109 && ids.length < numFatSectors; 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);
@@ -104,12 +126,12 @@ export class CompoundFile {
         const seen = new Set();
         let sector = firstDifat;
         const perSector = this.#sectorSize / 4 - 1;
-        for (let s = 0; s < numDifat && sector < MAX_REGULAR_SECTOR; s++) {
+        for (let s = 0; s < numDifat && sector < MAX_REGULAR_SECTOR && ids.length < wanted; s++) {
             if (seen.has(sector))
                 throw new VbaParseError('cycle in DIFAT sector chain');
             seen.add(sector);
             const base = this.#dataSectorOffset(sector);
-            for (let i = 0; i < perSector; i++) {
+            for (let i = 0; i < perSector && ids.length < wanted; i++) {
                 const v = readU32(this.#buf, base + i * 4);
                 if (v < MAX_REGULAR_SECTOR)
                     ids.push(v);
@@ -123,23 +145,28 @@ export class CompoundFile {
         const perSector = this.#sectorSize / 4;
         for (const sid of fatSectorIds) {
             const base = this.#dataSectorOffset(sid);
-            for (let i = 0; i < perSector; i++)
+            for (let i = 0; i < perSector && fat.length < this.#maxSector; i++) {
                 fat.push(readU32(this.#buf, base + i * 4));
+            }
+            if (fat.length >= this.#maxSector)
+                break;
         }
         return fat;
     }
     #readChainValues(firstSector) {
         const values = [];
         const perSector = this.#sectorSize / 4;
+        const cap = this.#maxSector * (this.#sectorSize / this.#miniSectorSize);
         const seen = new Set();
         let sector = firstSector;
-        while (sector < MAX_REGULAR_SECTOR) {
+        while (sector < MAX_REGULAR_SECTOR && values.length < cap) {
             if (seen.has(sector))
                 throw new VbaParseError('cycle in mini-FAT sector chain');
             seen.add(sector);
             const base = this.#dataSectorOffset(sector);
-            for (let i = 0; i < perSector; i++)
+            for (let i = 0; i < perSector && values.length < cap; i++) {
                 values.push(readU32(this.#buf, base + i * 4));
+            }
             sector = this.#nextInFat(sector);
         }
         return values;
@@ -148,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: '',
@@ -170,70 +197,77 @@ 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);
+            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 });
         }
         return entries;
     }
     #readChainFull(startSector) {
-        const chunks = [];
-        const seen = new Set();
-        let sector = startSector;
-        while (sector < MAX_REGULAR_SECTOR) {
-            if (seen.has(sector))
-                throw new VbaParseError('cycle in FAT sector chain');
-            seen.add(sector);
-            const base = this.#dataSectorOffset(sector);
-            chunks.push(this.#buf.subarray(base, base + this.#sectorSize));
-            sector = this.#nextInFat(sector);
-        }
-        return concat(chunks);
+        return this.#walkChain(startSector, undefined, this.#fatChain('FAT sector chain'));
     }
     #readViaFat(startSector, size) {
-        const chunks = [];
-        const seen = new Set();
-        let sector = startSector;
-        let remaining = size;
-        while (sector < MAX_REGULAR_SECTOR && remaining > 0) {
-            if (seen.has(sector))
-                throw new VbaParseError('cycle in stream FAT chain');
-            seen.add(sector);
-            const base = this.#dataSectorOffset(sector);
-            const take = Math.min(this.#sectorSize, remaining);
-            chunks.push(this.#buf.subarray(base, base + take));
-            remaining -= take;
-            sector = this.#nextInFat(sector);
-        }
-        return concat(chunks);
+        return this.#walkChain(startSector, size, this.#fatChain('stream FAT chain'));
     }
     #readViaMiniFat(startSector, size) {
+        return this.#walkChain(startSector, size, this.#miniFatChain());
+    }
+    #walkChain(startSector, size, chain) {
         const chunks = [];
         const seen = new Set();
         let sector = startSector;
-        let remaining = size;
+        let remaining = size ?? Infinity;
         while (sector < MAX_REGULAR_SECTOR && remaining > 0) {
             if (seen.has(sector))
-                throw new VbaParseError('cycle in stream mini-FAT chain');
+                throw new VbaParseError(`cycle in ${chain.what}`);
             seen.add(sector);
-            const base = sector * this.#miniSectorSize;
-            const take = Math.min(this.#miniSectorSize, remaining);
-            if (base + take > this.#miniStream.length) {
-                throw new VbaParseError('mini-stream sector runs past end of the mini stream');
-            }
-            chunks.push(this.#miniStream.subarray(base, base + take));
+            const take = Math.min(chain.sectorSize, remaining);
+            chunks.push(chain.sliceAt(sector, take));
             remaining -= take;
-            if (sector >= this.#miniFat.length)
-                throw new VbaParseError('mini-FAT index out of range');
-            sector = this.#miniFat[sector];
+            sector = chain.next(sector);
+        }
+        if (size !== undefined && remaining > 0) {
+            throw new VbaParseError(`${chain.what} ends after ${size - remaining} bytes, but ${size} were declared`);
         }
         return concat(chunks);
     }
+    #fatChain(what) {
+        return {
+            what,
+            sectorSize: this.#sectorSize,
+            sliceAt: (sector, take) => {
+                const base = this.#dataSectorOffset(sector);
+                return this.#buf.subarray(base, base + take);
+            },
+            next: (sector) => this.#nextInFat(sector),
+        };
+    }
+    #miniFatChain() {
+        return {
+            what: 'stream mini-FAT chain',
+            sectorSize: this.#miniSectorSize,
+            sliceAt: (sector, take) => {
+                const base = sector * this.#miniSectorSize;
+                if (base + take > this.#miniStream.length) {
+                    throw new VbaParseError('mini-stream sector runs past end of the mini stream');
+                }
+                return this.#miniStream.subarray(base, base + take);
+            },
+            next: (sector) => {
+                if (sector >= this.#miniFat.length)
+                    throw new VbaParseError('mini-FAT index out of range');
+                return this.#miniFat[sector];
+            },
+        };
+    }
     #nextInFat(sector) {
         if (sector >= this.#fat.length)
             throw new VbaParseError('FAT index out of range');

package/dist/vba/codepage.js

@@ -1,3 +1,4 @@
+import { hex } from '../hex.js';
 import { VbaAuthorError, VbaParseError } from './errors.js';
 const CODEPAGE_LABEL = new Map([
     [1250, 'windows-1250'],
@@ -56,7 +57,7 @@ export function encoderForCodePage(codePage) {
             const code = text.charCodeAt(i);
             const byte = charToByte.get(code);
             if (byte === undefined) {
-                throw new VbaAuthorError(`character U+${code.toString(16).toUpperCase().padStart(4, '0')} is not representable in code page ${codePage}`);
+                throw new VbaAuthorError(`character U+${hex(code, 4)} is not representable in code page ${codePage}`);
             }
             out[i] = byte;
         }