@shbernal/ts-xlsx 2.1.0 → 3.0.0

package/dist/io/xlsx/write-stream.js

@@ -187,23 +187,17 @@ export class WorkbookStreamWriter {
         return this.#stream;
     }
     addImage(options) {
-        if (this.#committed) {
-            throw new AuthoringError('the workbook is already committed: no more images can be registered');
-        }
+        this.#assertOpen('no more images can be registered');
         return this.#workbook.addImage(options);
     }
     addWorksheet(name, options = {}) {
-        if (this.#committed) {
-            throw new AuthoringError('the workbook is already committed: no more worksheets can be added');
-        }
+        this.#assertOpen('no more worksheets can be added');
         const sheet = new WorksheetStreamWriter(this.#workbook.addWorksheet(name, options), this.#eager, this.#styles);
         this.#sheets.push(sheet);
         return sheet;
     }
     async commit() {
-        if (this.#committed) {
-            throw new AuthoringError('the workbook is already committed');
-        }
+        this.#assertOpen('its package is already assembled and cannot be re-emitted');
         this.#committed = true;
         for (const sheet of this.#sheets)
             sheet.commit();
@@ -215,22 +209,36 @@ export class WorkbookStreamWriter {
             if (sheetFlushed)
                 flushed.set(sheet.model, sheetFlushed);
         }
-        const parts = buildPackageParts(this.#workbook, {
-            ...this.#writeOptions,
-            styles: this.#styles,
-            flushed,
-        });
         const owned = this.#stream;
         const sink = this.#sink;
         const sinkSettled = sink ? settleOnFinish(sink) : undefined;
-        const bytes = await streamZipPackage(parts, (chunk) => {
-            owned?.write(chunk);
-            sink?.write(chunk);
-        });
-        owned?.end();
-        sink?.end();
-        await sinkSettled;
-        return bytes;
+        try {
+            const parts = buildPackageParts(this.#workbook, {
+                ...this.#writeOptions,
+                styles: this.#styles,
+                flushed,
+            });
+            const bytes = await streamZipPackage(parts, (chunk) => {
+                owned?.write(chunk);
+                sink?.write(chunk);
+            });
+            owned?.end();
+            sink?.end();
+            await sinkSettled;
+            return bytes;
+        }
+        catch (error) {
+            const failure = error instanceof Error ? error : new Error(String(error));
+            sinkSettled?.catch(() => { });
+            owned?.destroy(failure);
+            sink?.destroy(failure);
+            throw error;
+        }
+    }
+    #assertOpen(what) {
+        if (this.#committed) {
+            throw new AuthoringError(`the workbook is already committed: ${what}`);
+        }
     }
 }
 function settleOnFinish(sink) {

package/dist/io/xlsx/write.d.ts

@@ -81,6 +81,11 @@ export declare function createStyleRegistry(workbook: Workbook): StyleRegistry;
  * streaming writer can drive the identical parts through a streamed zip container rather than
  * `zipSync`. Neither writer duplicates a byte of serialisation.
  *
+ * Three steps, and their order is load-bearing. The package is planned in full before anything is
+ * serialised, so a drawing's embed and a pivot's cache can target a part number that already exists.
+ * The sheets are serialised before the parts are emitted, because interning a style is a side effect
+ * of that pass and `xl/styles.xml` is one of the parts emitted in the third step.
+ *
  * @throws {AuthoringError} if the workbook has no worksheets, or holds a value the writer cannot represent.
  */
 export declare function buildPackageParts(workbook: Workbook, options?: InternalWriteOptions): Record<string, Uint8Array>;

package/dist/io/xlsx/write.js

@@ -1,12 +1,13 @@
 import { strToU8, zip, zipSync } from 'fflate';
 import { AuthoringError } from '../../errors.js';
-import { THEME_PART_PATH } from '../opc/part-paths.js';
+import { relativePartPath, relsPathFor, THEME_PART_PATH } from '../opc/part-paths.js';
 import { relsPartXml } from '../opc/rels.js';
 import { FIXED_ENTRY_MTIME } from '../opc/zip-mtime.js';
 import { collectComments, commentsXml, vmlDrawingXml } from './comments.js';
 import { collectHyperlinks, planHyperlinks } from './hyperlinks.js';
 import { drawingRelsXml, drawingXml } from './images.js';
 import { planMedia, planPreservedParts, SheetRelIds, } from './package-plan.js';
+import { APP_PROPS_PART, commentsPart, CORE_PROPS_PART, drawingPart, mediaPart, PERSONS_PART, pivotCacheDefinitionPart, pivotCacheRecordsPart, pivotTablePart, printerSettingsPart, SHARED_STRINGS_PART, STYLES_PART, tablePart, threadedCommentsPart, vmlDrawingPart, WORKBOOK_PART, worksheetPart, } from './part-names.js';
 import { pivotCacheDefinitionXml, pivotCacheRecordsXml, pivotTableXml } from './pivot.js';
 import { REL } from './relationships.js';
 import { SharedStringTable } from './shared-strings.js';
@@ -47,6 +48,72 @@ export function createStyleRegistry(workbook) {
         styles.addTableStyle(style);
     return styles;
 }
+function planSheet(context) {
+    const { sheet, index, media, preserved, numbering } = context;
+    const rels = new SheetRelIds();
+    const tables = sheet.tables.map((table) => ({
+        table,
+        number: ++numbering.table,
+        relId: rels.next(),
+    }));
+    let drawing = null;
+    if (sheet.images.length > 0) {
+        const images = sheet.images.map((image, j) => {
+            const { number, image: registered } = media.resolve(image.imageId);
+            return {
+                anchor: image.anchor,
+                embedId: `rId${j + 1}`,
+                mediaNumber: number,
+                extension: registered.extension,
+            };
+        });
+        drawing = { number: ++numbering.drawing, relId: rels.next(), images };
+    }
+    const threads = sheet.commentThreads.filter((thread) => thread.comments.length > 0);
+    const sheetComments = collectComments(sheet, threads);
+    const comments = sheetComments.length === 0
+        ? null
+        : {
+            number: index + 1,
+            comments: sheetComments,
+            vmlRelId: rels.next(),
+            commentsRelId: rels.next(),
+        };
+    const threadedComments = threads.length === 0 ? null : { number: index + 1, threads, relId: rels.next() };
+    const printerData = sheet.pageSetup.printerSettings;
+    const printerSettings = printerData === undefined ? null : { number: index + 1, data: printerData, relId: rels.next() };
+    const hyperlinks = planHyperlinks(collectHyperlinks(sheet), rels);
+    let background = null;
+    if (sheet.backgroundImageId !== undefined) {
+        const { number, image } = media.resolve(sheet.backgroundImageId);
+        background = { relId: rels.next(), mediaNumber: number, extension: image.extension };
+    }
+    const preservedRefs = (preserved.perSheet[index] ?? []).map((reference) => ({ ...reference, relId: rels.next() }));
+    const pivots = sheet.pivotTables.map((table) => {
+        const number = ++numbering.pivot;
+        return { number, cacheId: String(number), table, sheetRelId: rels.next(), workbookRelId: '' };
+    });
+    return {
+        tables,
+        drawing,
+        comments,
+        threadedComments,
+        printerSettings,
+        hyperlinks,
+        background,
+        preservedRefs,
+        pivots,
+    };
+}
+function numbersOf(plans, pick) {
+    const numbers = [];
+    for (const plan of plans) {
+        const part = pick(plan);
+        if (part !== null)
+            numbers.push(part.number);
+    }
+    return numbers;
+}
 function resolveSheetReferences(plan) {
     const refs = plan.preservedRefs;
     const preservedDrawingRelId = refs.find((ref) => ref.element === 'drawing')?.relId ?? null;
@@ -63,125 +130,65 @@ function resolveSheetReferences(plan) {
         slicerRelIds,
     };
 }
-export function buildPackageParts(workbook, options = {}) {
-    const sheets = workbook.worksheets;
-    if (sheets.length === 0) {
-        throw new AuthoringError('cannot write a workbook with no worksheets: a zero-sheet package is corrupt to Excel');
-    }
-    const sharedStrings = options.useSharedStrings ? new SharedStringTable() : null;
+function assignWorkbookRelIds(context) {
+    const { sheetCount, hasSharedStrings, hasPersons, preservedWorkbook, pivots } = context;
+    const modeledCount = sheetCount + FIXED_WORKBOOK_REL_COUNT + (hasSharedStrings ? 1 : 0);
+    const personsRelId = hasPersons ? `rId${modeledCount + 1}` : null;
+    const preservedBase = modeledCount + (personsRelId === null ? 0 : 1);
+    const preservedWorkbookRels = preservedWorkbook.map((ref, i) => ({
+        ...ref,
+        relId: `rId${preservedBase + 1 + i}`,
+    }));
+    const pivotBase = preservedBase + preservedWorkbook.length;
+    pivots.forEach((pivot, i) => {
+        pivot.workbookRelId = `rId${pivotBase + 1 + i}`;
+    });
+    return { personsRelId, preservedWorkbookRels };
+}
+function planPackage(workbook, sheets) {
     const media = planMedia(workbook, sheets);
     const generatedDrawingCount = sheets.filter((sheet) => sheet.images.length > 0).length;
     const preserved = planPreservedParts(workbook, generatedDrawingCount, media.parts.length);
-    let tableNumber = 0;
-    let drawingNumber = 0;
-    let pivotNumber = 0;
-    const perSheet = sheets.map((sheet, i) => {
-        const rels = new SheetRelIds();
-        const tables = sheet.tables.map((table) => ({
-            table,
-            number: ++tableNumber,
-            relId: rels.next(),
-        }));
-        let drawing = null;
-        if (sheet.images.length > 0) {
-            const images = sheet.images.map((image, j) => {
-                const registered = workbook.getImage(image.imageId);
-                return {
-                    anchor: image.anchor,
-                    embedId: `rId${j + 1}`,
-                    mediaNumber: media.numberById.get(image.imageId),
-                    extension: registered.extension,
-                };
-            });
-            drawing = { number: ++drawingNumber, relId: rels.next(), images };
-        }
-        const threads = sheet.commentThreads.filter((thread) => thread.comments.length > 0);
-        const sheetComments = collectComments(sheet, threads);
-        const comments = sheetComments.length === 0
-            ? null
-            : {
-                number: i + 1,
-                comments: sheetComments,
-                vmlRelId: rels.next(),
-                commentsRelId: rels.next(),
-            };
-        const threadedComments = threads.length === 0 ? null : { number: i + 1, threads, relId: rels.next() };
-        const printerData = sheet.pageSetup.printerSettings;
-        const printerSettings = printerData === undefined ? null : { number: i + 1, data: printerData, relId: rels.next() };
-        const hyperlinks = planHyperlinks(collectHyperlinks(sheet), rels);
-        let background = null;
-        if (sheet.backgroundImageId !== undefined) {
-            const registered = workbook.getImage(sheet.backgroundImageId);
-            if (registered === undefined) {
-                throw new AuthoringError(`sheet "${sheet.name}" sets background image id ${sheet.backgroundImageId}, which is not registered on the workbook`);
-            }
-            background = {
-                relId: rels.next(),
-                mediaNumber: media.numberById.get(sheet.backgroundImageId),
-                extension: registered.extension,
-            };
-        }
-        const preservedRefs = (preserved.perSheet[i] ?? []).map((reference) => ({ ...reference, relId: rels.next() }));
-        const pivots = sheet.pivotTables.map((table) => {
-            const number = ++pivotNumber;
-            return { number, cacheId: String(number), table, sheetRelId: rels.next(), workbookRelId: '' };
-        });
-        return {
-            tables,
-            drawing,
-            comments,
-            threadedComments,
-            printerSettings,
-            hyperlinks,
-            background,
-            preservedRefs,
-            pivots,
-        };
-    });
-    const allTables = perSheet.flatMap((plan) => plan.tables);
-    const allPivots = perSheet.flatMap((plan) => plan.pivots);
-    const styles = options.styles ?? createStyleRegistry(workbook);
-    const sheetXml = sheets.map((sheet, i) => {
-        const plan = perSheet[i];
-        return worksheetXml(sheet, plan.tables, styles, resolveSheetReferences(plan), plan.hyperlinks, sharedStrings, i === workbook.activeTabIndex, options.flushed?.get(sheet));
+    const numbering = { table: 0, drawing: 0, pivot: 0 };
+    const perSheet = sheets.map((sheet, index) => planSheet({ sheet, index, media, preserved, numbering }));
+    return {
+        media,
+        preserved,
+        perSheet,
+        allTables: perSheet.flatMap((plan) => plan.tables),
+        allPivots: perSheet.flatMap((plan) => plan.pivots),
+    };
+}
+function serialiseSheets(workbook, sheets, plan, styles, sharedStrings, flushed) {
+    return sheets.map((sheet, i) => {
+        const sheetPlan = plan.perSheet[i];
+        return worksheetXml(sheet, sheetPlan.tables, styles, resolveSheetReferences(sheetPlan), sheetPlan.hyperlinks, sharedStrings, i === workbook.activeTabIndex, flushed?.get(sheet));
     });
+}
+function emitPackageParts(context) {
+    const { workbook, sheets, plan, styles, sharedStrings, sheetXml } = context;
+    const { media, preserved, perSheet, allTables, allPivots } = plan;
     const hasSharedStrings = sharedStrings !== null && !sharedStrings.isEmpty;
-    const commentNumbers = perSheet
-        .map((plan) => plan.comments)
-        .filter((c) => c !== null)
-        .map((c) => c.number);
-    const drawingNumbers = perSheet
-        .map((plan) => plan.drawing)
-        .filter((d) => d !== null)
-        .map((d) => d.number);
-    const printerSettingsNumbers = perSheet
-        .map((plan) => plan.printerSettings)
-        .filter((p) => p !== null)
-        .map((p) => p.number);
-    const threadedCommentNumbers = perSheet
-        .map((plan) => plan.threadedComments)
-        .filter((t) => t !== null)
-        .map((t) => t.number);
+    const commentNumbers = numbersOf(perSheet, (sheetPlan) => sheetPlan.comments);
+    const drawingNumbers = numbersOf(perSheet, (sheetPlan) => sheetPlan.drawing);
+    const printerSettingsNumbers = numbersOf(perSheet, (sheetPlan) => sheetPlan.printerSettings);
+    const threadedCommentNumbers = numbersOf(perSheet, (sheetPlan) => sheetPlan.threadedComments);
     const persons = threadedCommentNumbers.length === 0 ? [] : workbook.persons;
-    const modeledWorkbookRelCount = sheets.length + FIXED_WORKBOOK_REL_COUNT + (hasSharedStrings ? 1 : 0);
-    const personsRelId = persons.length === 0 ? null : `rId${modeledWorkbookRelCount + 1}`;
-    const workbookRelBase = modeledWorkbookRelCount + (personsRelId === null ? 0 : 1);
-    const preservedWorkbookRels = preserved.workbook.map((ref, i) => ({
-        ...ref,
-        relId: `rId${workbookRelBase + 1 + i}`,
-    }));
-    const pivotWorkbookRelBase = workbookRelBase + preserved.workbook.length;
-    allPivots.forEach((pivot, i) => {
-        pivot.workbookRelId = `rId${pivotWorkbookRelBase + 1 + i}`;
+    const { personsRelId, preservedWorkbookRels } = assignWorkbookRelIds({
+        sheetCount: sheets.length,
+        hasSharedStrings,
+        hasPersons: persons.length > 0,
+        preservedWorkbook: preserved.workbook,
+        pivots: allPivots,
     });
     const files = {
         '[Content_Types].xml': strToU8(contentTypesXml(sheets.length, allTables, commentNumbers, drawingNumbers, printerSettingsNumbers, media.extensions, hasSharedStrings, preserved.parts, allPivots, preservedWorkbookRels, threadedCommentNumbers, persons.length > 0)),
         '_rels/.rels': strToU8(rootRelsXml(preserved.root)),
-        'docProps/core.xml': strToU8(corePropsXml(workbook.properties)),
-        'docProps/app.xml': strToU8(appPropsXml(workbook.properties)),
-        'xl/workbook.xml': strToU8(workbookXml(workbook, preservedWorkbookRels, allPivots)),
-        'xl/_rels/workbook.xml.rels': strToU8(workbookRelsXml(sheets.length, hasSharedStrings, personsRelId, preservedWorkbookRels, allPivots)),
-        'xl/styles.xml': strToU8(styles.toXml()),
+        [CORE_PROPS_PART]: strToU8(corePropsXml(workbook.properties)),
+        [APP_PROPS_PART]: strToU8(appPropsXml(workbook.properties)),
+        [WORKBOOK_PART]: strToU8(workbookXml(workbook, preservedWorkbookRels, allPivots)),
+        [relsPathFor(WORKBOOK_PART)]: strToU8(workbookRelsXml(sheets.length, hasSharedStrings, personsRelId, preservedWorkbookRels, allPivots)),
+        [STYLES_PART]: strToU8(styles.toXml()),
     };
     if (!preserved.themeEmitted) {
         const overrides = workbook.themeOverrides;
@@ -190,26 +197,37 @@ export function buildPackageParts(workbook, options = {}) {
             : applyThemeOverrides(DEFAULT_THEME_XML, overrides));
     }
     if (hasSharedStrings) {
-        files['xl/sharedStrings.xml'] = strToU8(sharedStrings.toXml());
+        files[SHARED_STRINGS_PART] = strToU8(sharedStrings.toXml());
     }
     if (persons.length > 0)
-        files['xl/persons/person.xml'] = strToU8(personsXml(persons));
+        files[PERSONS_PART] = strToU8(personsXml(persons));
     for (const part of media.parts) {
-        files[`xl/media/image${part.number}.${part.extension}`] = part.data;
+        files[mediaPart(part.number, part.extension)] = part.data;
     }
     emitSheetParts(files, perSheet, sheetXml);
     for (const { table, number } of allTables) {
-        files[`xl/tables/table${number}.xml`] = strToU8(tableXml(table, number));
+        files[tablePart(number)] = strToU8(tableXml(table, number));
     }
     emitPivotParts(files, allPivots);
     emitPreservedParts(files, preserved.parts);
     return files;
 }
+export function buildPackageParts(workbook, options = {}) {
+    const sheets = workbook.worksheets;
+    if (sheets.length === 0) {
+        throw new AuthoringError('cannot write a workbook with no worksheets: a zero-sheet package is corrupt to Excel');
+    }
+    const sharedStrings = options.useSharedStrings ? new SharedStringTable() : null;
+    const styles = options.styles ?? createStyleRegistry(workbook);
+    const plan = planPackage(workbook, sheets);
+    const sheetXml = serialiseSheets(workbook, sheets, plan, styles, sharedStrings, options.flushed);
+    return emitPackageParts({ workbook, sheets, plan, styles, sharedStrings, sheetXml });
+}
 function emitSheetParts(files, perSheet, sheetXml) {
     perSheet.forEach((plan, i) => {
         const { tables, drawing, comments, threadedComments, printerSettings, background, hyperlinks, preservedRefs, pivots, } = plan;
         const hasExternalHyperlink = hyperlinks.some((link) => link.relId !== undefined);
-        files[`xl/worksheets/sheet${i + 1}.xml`] = strToU8(sheetXml[i]);
+        files[worksheetPart(i + 1)] = strToU8(sheetXml[i]);
         if (tables.length > 0 ||
             drawing !== null ||
             comments !== null ||
@@ -219,42 +237,48 @@ function emitSheetParts(files, perSheet, sheetXml) {
             hasExternalHyperlink ||
             preservedRefs.length > 0 ||
             pivots.length > 0) {
-            files[`xl/worksheets/_rels/sheet${i + 1}.xml.rels`] = strToU8(worksheetRelsXml(tables, drawing, comments, threadedComments, printerSettings, background, hyperlinks, preservedRefs, pivots));
+            files[relsPathFor(worksheetPart(i + 1))] = strToU8(worksheetRelsXml(tables, drawing, comments, threadedComments, printerSettings, background, hyperlinks, preservedRefs, pivots));
         }
         if (printerSettings !== null) {
-            files[`xl/printerSettings/printerSettings${printerSettings.number}.bin`] =
-                printerSettings.data;
+            files[printerSettingsPart(printerSettings.number)] = printerSettings.data;
         }
         if (drawing !== null) {
-            files[`xl/drawings/drawing${drawing.number}.xml`] = strToU8(drawingXml(drawing.images));
-            const targets = drawing.images.map((image) => `../media/image${image.mediaNumber}.${image.extension}`);
-            files[`xl/drawings/_rels/drawing${drawing.number}.xml.rels`] = strToU8(drawingRelsXml(targets));
+            const drawingPath = drawingPart(drawing.number);
+            files[drawingPath] = strToU8(drawingXml(drawing.images));
+            const targets = drawing.images.map((image) => relativePartPath(drawingPath, mediaPart(image.mediaNumber, image.extension)));
+            files[relsPathFor(drawingPath)] = strToU8(drawingRelsXml(targets));
         }
         if (comments !== null) {
-            files[`xl/comments${comments.number}.xml`] = strToU8(commentsXml(comments.comments));
-            files[`xl/drawings/vmlDrawing${comments.number}.vml`] = strToU8(vmlDrawingXml(comments.comments));
+            files[commentsPart(comments.number)] = strToU8(commentsXml(comments.comments));
+            files[vmlDrawingPart(comments.number)] = strToU8(vmlDrawingXml(comments.comments));
         }
         if (threadedComments !== null) {
-            files[`xl/threadedComments/threadedComment${threadedComments.number}.xml`] = strToU8(threadedCommentsXml(threadedComments.threads));
+            files[threadedCommentsPart(threadedComments.number)] = strToU8(threadedCommentsXml(threadedComments.threads));
         }
     });
 }
 function emitPivotParts(files, allPivots) {
     for (const pivot of allPivots) {
         const { number, cacheId, table } = pivot;
-        files[`xl/pivotTables/pivotTable${number}.xml`] = strToU8(pivotTableXml(table, `PivotTable${number}`, cacheId));
-        files[`xl/pivotTables/_rels/pivotTable${number}.xml.rels`] = strToU8(relsPartXml([
+        const tablePath = pivotTablePart(number);
+        const definitionPath = pivotCacheDefinitionPart(number);
+        files[tablePath] = strToU8(pivotTableXml(table, `PivotTable${number}`, cacheId));
+        files[relsPathFor(tablePath)] = strToU8(relsPartXml([
             {
                 id: 'rId1',
                 type: REL.pivotCacheDefinition,
-                target: `../pivotCache/pivotCacheDefinition${number}.xml`,
+                target: relativePartPath(tablePath, definitionPath),
             },
         ]));
-        files[`xl/pivotCache/pivotCacheDefinition${number}.xml`] = strToU8(pivotCacheDefinitionXml(table));
-        files[`xl/pivotCache/_rels/pivotCacheDefinition${number}.xml.rels`] = strToU8(relsPartXml([
-            { id: 'rId1', type: REL.pivotCacheRecords, target: `pivotCacheRecords${number}.xml` },
+        files[definitionPath] = strToU8(pivotCacheDefinitionXml(table));
+        files[relsPathFor(definitionPath)] = strToU8(relsPartXml([
+            {
+                id: 'rId1',
+                type: REL.pivotCacheRecords,
+                target: relativePartPath(definitionPath, pivotCacheRecordsPart(number)),
+            },
         ]));
-        files[`xl/pivotCache/pivotCacheRecords${number}.xml`] = strToU8(pivotCacheRecordsXml(table));
+        files[pivotCacheRecordsPart(number)] = strToU8(pivotCacheRecordsXml(table));
     }
 }
 function emitPreservedParts(files, parts) {

package/dist/token-set.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Build a narrowing predicate for a closed token union.
+ *
+ * `members` is keyed by the union, so the compiler refuses a foreign member and an omitted one
+ * alike. A bare list of string literals is checked one way only: it cannot name a token the union
+ * does not, but it can quietly omit one the union does, and a guard narrower than its union
+ * silently drops a token real files legitimately carry.
+ *
+ * Deriving the union from the list instead (`(typeof TOKENS)[number]`, as `table-style.ts` does)
+ * would make divergence impossible rather than merely detected, and is the better shape for a type
+ * that is not public. It is not available to a published union: the API reference renders a
+ * declaration by slicing its own source text, so a derived alias reaches the docs as that
+ * expression instead of as its members.
+ */
+export declare function tokenSet<T extends string>(members: Record<T, true>): (value: string) => value is T;

package/dist/token-set.js

@@ -0,0 +1,4 @@
+export function tokenSet(members) {
+    const set = new Set(Object.keys(members));
+    return (value) => set.has(value);
+}

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

@@ -0,0 +1,24 @@
+/** Sector chain markers ([MS-CFB] 2.2). */
+export declare const FREESECT = 4294967295;
+export declare const ENDOFCHAIN = 4294967294;
+export declare const FATSECT = 4294967293;
+export declare const DIFSECT = 4294967292;
+/**
+ * Sector values 0xFFFFFFFA..0xFFFFFFFF are the reserved markers above, not data-sector indices, so
+ * any value at or above this ceiling is chain-terminal. A reader walking a hostile chain tests the
+ * ceiling rather than the four markers by name: an unassigned reserved value is terminal too.
+ */
+export declare const MAX_REGULAR_SECTOR = 4294967290;
+/** Directory-tree links reuse the sector convention: NOSTREAM, and any value at or above
+ * {@link MAX_REGULAR_SECTOR}, mean "no such sibling or child". */
+export declare const NOSTREAM = 4294967295;
+/** Object types ([MS-CFB] 2.6.1). */
+export declare const TYPE_EMPTY = 0;
+export declare const TYPE_STORAGE = 1;
+export declare const TYPE_STREAM = 2;
+export declare const TYPE_ROOT = 5;
+/** 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;

package/dist/vba/cfb-format.js

@@ -0,0 +1,12 @@
+export const FREESECT = 0xffffffff;
+export const ENDOFCHAIN = 0xfffffffe;
+export const FATSECT = 0xfffffffd;
+export const DIFSECT = 0xfffffffc;
+export const MAX_REGULAR_SECTOR = 0xfffffffa;
+export const NOSTREAM = 0xffffffff;
+export const TYPE_EMPTY = 0;
+export const TYPE_STORAGE = 1;
+export const TYPE_STREAM = 2;
+export const TYPE_ROOT = 5;
+export const DIR_ENTRY_SIZE = 128;
+export const MAX_NAME_CHARS = 31;

package/dist/vba/cfb-writer.js

@@ -1,20 +1,11 @@
+import { DIFSECT, DIR_ENTRY_SIZE, ENDOFCHAIN, FATSECT, FREESECT, MAX_NAME_CHARS, 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;
-const DIR_ENTRY_SIZE = 128;
 const ENTRIES_PER_DIR_SECTOR = SECTOR / DIR_ENTRY_SIZE;
 const FAT_ENTRIES_PER_SECTOR = SECTOR / 4;
 const DIFAT_HEADER_SLOTS = 109;
-const MAX_NAME_CHARS = 31;
-const FREESECT = 0xffffffff;
-const ENDOFCHAIN = 0xfffffffe;
-const FATSECT = 0xfffffffd;
-const DIFSECT = 0xfffffffc;
-const NOSTREAM = 0xffffffff;
-const TYPE_STORAGE = 1;
-const TYPE_STREAM = 2;
-const TYPE_ROOT = 5;
 const COLOR_BLACK = 1;
 function isStream(node) {
     return 'data' in node;
@@ -36,7 +27,8 @@ export function writeCompoundFile(root) {
         return entry;
     };
     const rootEntry = addEntry('Root Entry', TYPE_ROOT, ENDOFCHAIN);
-    const miniBytes = [];
+    const miniChunks = [];
+    let miniLength = 0;
     const miniFat = [];
     const bigStreams = [];
     const addNode = (node, siblings) => {
@@ -50,11 +42,14 @@ export function writeCompoundFile(root) {
                 bigStreams.push({ entry, data: node.data, sectors: Math.ceil(node.data.length / SECTOR) });
             }
             else {
-                const startMini = miniBytes.length / MINI_SECTOR;
+                const startMini = miniLength / MINI_SECTOR;
                 const numMini = Math.ceil(node.data.length / MINI_SECTOR);
                 for (let k = 0; k < numMini; k++)
                     miniFat.push(k < numMini - 1 ? startMini + k + 1 : ENDOFCHAIN);
-                miniBytes.push(...node.data, ...new Array(numMini * MINI_SECTOR - node.data.length).fill(0));
+                const padded = new Uint8Array(numMini * MINI_SECTOR);
+                padded.set(node.data);
+                miniChunks.push(padded);
+                miniLength += padded.length;
                 entry.startSector = startMini;
             }
         }
@@ -74,7 +69,7 @@ export function writeCompoundFile(root) {
     linkChildren(rootEntry, rootKids);
     const dirSectors = Math.ceil(entries.length / ENTRIES_PER_DIR_SECTOR);
     const miniFatSectors = miniFat.length > 0 ? Math.ceil((miniFat.length * 4) / FAT_ENTRIES_PER_SECTOR) : 0;
-    const miniStreamSectors = Math.ceil(miniBytes.length / SECTOR);
+    const miniStreamSectors = Math.ceil(miniLength / SECTOR);
     const baseSectors = dirSectors +
         miniFatSectors +
         miniStreamSectors +
@@ -112,7 +107,7 @@ export function writeCompoundFile(root) {
     cursor += difatSectors;
     const totalSectors = cursor;
     rootEntry.startSector = miniStreamStart;
-    rootEntry.size = miniBytes.length;
+    rootEntry.size = miniLength;
     const fat = new Array(fatSectors * FAT_ENTRIES_PER_SECTOR).fill(FREESECT);
     const chainRegion = (start, count) => {
         for (let k = 0; k < count; k++)
@@ -146,8 +141,13 @@ export function writeCompoundFile(root) {
     for (let i = 0; i < miniFatSectors * FAT_ENTRIES_PER_SECTOR; i++) {
         dv.setUint32(at(miniFatStart) + i * 4, miniFat[i] ?? FREESECT, true);
     }
-    if (miniBytes.length > 0)
-        buf.set(Uint8Array.from(miniBytes), at(miniStreamStart));
+    if (miniLength > 0) {
+        let offset = at(miniStreamStart);
+        for (const chunk of miniChunks) {
+            buf.set(chunk, offset);
+            offset += chunk.length;
+        }
+    }
     for (const big of bigStreams)
         buf.set(big.data, at(big.entry.startSector));
     for (const [i, sector] of fat.entries())

package/dist/vba/cfb.js

@@ -1,14 +1,8 @@
 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 { VbaParseError } from './errors.js';
-const MAX_REGULAR_SECTOR = 0xfffffffa;
-const NOSTREAM = 0xffffffff;
-const TYPE_EMPTY = 0;
-const TYPE_STORAGE = 1;
-const TYPE_STREAM = 2;
-const TYPE_ROOT = 5;
 const CFB_SIGNATURE_LO = 0xe011cfd0;
 const CFB_SIGNATURE_HI = 0xe11ab1a1;
-const DIR_ENTRY_SIZE = 128;
 export class CompoundFile {
     #buf;
     #sectorSize;