@shbernal/ts-xlsx 3.1.0 → 3.2.0

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

@@ -3,13 +3,15 @@ import { PassThrough } from 'node:stream';
 import { Zip, ZipDeflate } from 'fflate';
 import { concat } from '../../bytes.js';
 import { encodeAddress, tryDecodeCellRef } from '../../core/address.js';
+import { formulaPlacement } from '../../core/array-formula-ranges.js';
+import { formulaNamesInScope } from '../../core/formula.js';
 import { INTERNAL } from '../../core/internal.js';
 import { isSharedFormulaValue } from '../../core/value.js';
-import { Workbook } from '../../core/workbook.js';
+import { Workbook, } from '../../core/workbook.js';
 import { AuthoringError, quoted } from '../../errors.js';
 import { FIXED_ENTRY_MTIME } from '../opc/zip-mtime.js';
+import { WorkbookMetadataTable } from './cell-metadata.js';
 import { collectNotes } from './comments.js';
-import { collectHyperlinks } from './hyperlinks.js';
 import { buildColumnDefaults, Extent, renderRow, } from './row-xml.js';
 import { buildPackageParts, createStyleRegistry } from './write.js';
 export class StreamedRow {
@@ -22,6 +24,11 @@ export class StreamedRow {
         this.#sheet = sheet;
         this.#number = number;
     }
+    static [INTERNAL] = {
+        create(cells, sheet, number) {
+            return new StreamedRow(cells, sheet, number);
+        },
+    };
     get cells() {
         return this.#cells;
     }
@@ -29,7 +36,7 @@ export class StreamedRow {
         if (this.#committed)
             return;
         this.#committed = true;
-        this.#sheet?.[INTERNAL].flushRow(this.#number, this.#cells);
+        this.#sheet?.[INTERNAL].flushRow(this.#number);
     }
 }
 export class WorksheetStreamWriter {
@@ -43,18 +50,22 @@ export class WorksheetStreamWriter {
     #flushedNumbers = new Set();
     #extent = new Extent();
     #rowOutline = new Map();
-    #hyperlinks = [];
     #notes = [];
+    #formulas = [];
     #dateEpoch;
-    constructor(sheet, eager, styles, dateEpoch) {
+    #definedNames;
+    #cellMetadata;
+    constructor(sheet, eager, styles, cellMetadata, dateEpoch, definedNames) {
         this.#sheet = sheet;
         this.#eager = eager;
         this.#styles = styles;
+        this.#cellMetadata = cellMetadata;
         this.#dateEpoch = dateEpoch;
+        this.#definedNames = definedNames;
     }
     static [INTERNAL] = {
-        create(sheet, eager, styles, dateEpoch) {
-            return new WorksheetStreamWriter(sheet, eager, styles, dateEpoch);
+        create(sheet, eager, styles, cellMetadata, dateEpoch, definedNames) {
+            return new WorksheetStreamWriter(sheet, eager, styles, cellMetadata, dateEpoch, definedNames);
         },
     };
     get name() {
@@ -66,14 +77,14 @@ export class WorksheetStreamWriter {
     addRow(values) {
         this.#assertOpen();
         if (!this.#eager)
-            return new StreamedRow(this.#sheet.addRow(values), null, 0);
+            return StreamedRow[INTERNAL].create(this.#sheet.addRow(values), null, 0);
         const number = this.#nextRowNumber();
-        return new StreamedRow(this.#placeRow(number, values), this, number);
+        return StreamedRow[INTERNAL].create(this.#placeRow(number, values), this, number);
     }
     addRows(rows) {
         this.#assertOpen();
         if (!this.#eager)
-            return this.#sheet.addRows(rows).map((cells) => new StreamedRow(cells, null, 0));
+            return this.#sheet.addRows(rows).map((cells) => StreamedRow[INTERNAL].create(cells, null, 0));
         return rows.map((values) => this.addRow(values));
     }
     #nextRowNumber() {
@@ -89,7 +100,9 @@ export class WorksheetStreamWriter {
         });
         return cells;
     }
-    #flushRow(number, cells) {
+    #flushRow(number) {
+        const row = this.#sheet.getRow(number);
+        const { cells } = row;
         for (const cell of cells) {
             if (isSharedFormulaValue(cell.value)) {
                 throw new AuthoringError(`row ${number} of streamed sheet ${quoted(this.#sheet.name)} carries a shared-formula cell; a ` +
@@ -98,13 +111,17 @@ export class WorksheetStreamWriter {
             }
         }
         this.#columnDefaults ??= buildColumnDefaults(this.#sheet);
-        const properties = this.#sheet.getRow(number).properties;
+        const { properties } = row;
         this.#rowOutline.set(number, {
             outlineLevel: properties?.outlineLevel ?? 0,
             hidden: properties?.hidden ?? false,
         });
-        this.#hyperlinks.push(...collectHyperlinks(cells));
         this.#notes.push(...collectNotes(cells));
+        for (const cell of cells) {
+            const placement = formulaPlacement(cell.address, cell.col, cell.row, cell.value);
+            if (placement !== undefined)
+                this.#formulas.push(placement);
+        }
         const { xml, attrs, minCol, maxCol } = renderRow({ number, cells, properties }, {
             columnDefaults: this.#columnDefaults,
             styles: this.#styles,
@@ -112,6 +129,8 @@ export class WorksheetStreamWriter {
             sharedRoles: new Map(),
             collapsedSummaries: new Set(),
             dateEpoch: this.#dateEpoch,
+            formulaNames: formulaNamesInScope(this.#definedNames, this.#sheet.name),
+            cellMetadata: this.#cellMetadata,
         });
         if (xml !== '') {
             this.#flushedRows.push({ number, xml, attrs });
@@ -127,8 +146,8 @@ export class WorksheetStreamWriter {
             rows: this.#flushedRows,
             extent: this.#extent,
             rowOutline: this.#rowOutline,
-            hyperlinks: this.#hyperlinks,
             notes: this.#notes,
+            formulas: this.#formulas,
         };
     }
     getCell(reference) {
@@ -145,6 +164,10 @@ export class WorksheetStreamWriter {
         this.#assertOpen();
         this.#sheet.addDataValidation(sqref, rule, options);
     }
+    addHyperlink(link) {
+        this.#assertOpen();
+        this.#sheet.addHyperlink(link);
+    }
     addConditionalFormatting(formatting) {
         this.#assertOpen();
         this.#sheet.addConditionalFormatting(formatting);
@@ -174,8 +197,8 @@ export class WorksheetStreamWriter {
         return this.#sheet;
     }
     [INTERNAL] = {
-        flushRow: (number, cells) => {
-            this.#flushRow(number, cells);
+        flushRow: (number) => {
+            this.#flushRow(number);
         },
         flushedSheet: () => this.#flushedSheet(),
     };
@@ -191,6 +214,7 @@ export class WorkbookStreamWriter {
     #writeOptions;
     #sink;
     #styles;
+    #cellMetadata = new WorkbookMetadataTable();
     #eager;
     #stream;
     #committed = false;
@@ -220,7 +244,7 @@ export class WorkbookStreamWriter {
     }
     addWorksheet(name, options = {}) {
         this.#assertOpen('no more worksheets can be added');
-        const sheet = WorksheetStreamWriter[INTERNAL].create(this.#workbook.addWorksheet(name, options), this.#eager, this.#styles, this.#workbook.dateEpoch);
+        const sheet = WorksheetStreamWriter[INTERNAL].create(this.#workbook.addWorksheet(name, options), this.#eager, this.#styles, this.#cellMetadata, this.#workbook.dateEpoch, this.#workbook.definedNames);
         this.#sheets.push(sheet);
         return sheet;
     }
@@ -245,6 +269,7 @@ export class WorkbookStreamWriter {
             const parts = buildPackageParts(this.#workbook, {
                 ...this.#writeOptions,
                 styles: this.#styles,
+                cellMetadata: this.#cellMetadata,
                 flushed,
             });
             const bytes = await streamZipPackage(parts, (chunk) => {

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

@@ -1,14 +1,15 @@
 import type { Workbook } from '../../core/workbook.ts';
 import type { Worksheet } from '../../core/worksheet.ts';
+import { WorkbookMetadataTable } from './cell-metadata.ts';
 import type { FlushedSheet } from './row-xml.ts';
 import { StyleRegistry } from './styles.ts';
 /** Options controlling how {@link writeXlsx} serialises a workbook. */
 export interface WriteOptions {
     /**
-     * Pool plain string cell values into a shared-strings table (`xl/sharedStrings.xml`) that cells
-     * reference by index, rather than storing each string inline in its cell. Deduplicates repeated
-     * text and matches Excel's own storage; off by default, which keeps strings inline and omits the
-     * part. Rich-text values stay inline regardless, so their run formatting is unaffected.
+     * Pool string and rich-text cell values into a shared-strings table (`xl/sharedStrings.xml`) that
+     * cells reference by index, rather than storing each inline in its cell. Deduplicates repeated text
+     * and matches Excel's own storage; a rich value is pooled as a `<si>` of its runs, so its formatting
+     * survives. Off by default, which keeps strings inline and omits the part.
      */
     readonly useSharedStrings?: boolean;
 }
@@ -27,6 +28,12 @@ export interface InternalWriteOptions extends WriteOptions {
      * so its output is unchanged.
      */
     readonly styles?: StyleRegistry;
+    /**
+     * The workbook metadata to record into, in place of a fresh table, for the reason {@link styles} is
+     * shared: a row the streaming writer rendered eagerly may already point a dynamic-array formula or a
+     * rich-value error at the parts this table decides whether to emit.
+     */
+    readonly cellMetadata?: WorkbookMetadataTable;
     /**
      * Per-sheet rows already serialised and evicted from the model by the streaming writer, keyed by
      * the model worksheet. Their XML is emitted ahead of the sheet's remaining live rows and their

package/dist/io/xlsx/write.js

@@ -1,14 +1,17 @@
 import { strToU8, zip, zipSync } from 'fflate';
+import { formulaNamesInScope } from '../../core/formula.js';
+import { pictureProperties } from '../../core/image.js';
 import { AuthoringError, InternalError, quoted } from '../../errors.js';
 import { isRelType } from '../../rel-type.js';
-import { relativePartPath, relsPathFor, THEME_PART_PATH } from '../opc/part-paths.js';
+import { 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, liveCells, planHyperlinks } from './hyperlinks.js';
-import { drawingRelsXml, drawingXml } from './images.js';
-import { planMedia, planPreservedParts, RelIdAllocator, } 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 { RICH_VALUE_STRUCTURES_XML, WorkbookMetadataTable } from './cell-metadata.js';
+import { collectComments, commentsXml, liveCells, vmlDrawingXml } from './comments.js';
+import { planHyperlinks } from './hyperlinks.js';
+import { drawingXml } from './images.js';
+import { planMedia, planPreservedParts, RelationshipLedger, } from './package-plan.js';
+import { APP_PROPS_PART, commentsPart, CORE_PROPS_PART, drawingPart, mediaPart, METADATA_PART, PERSONS_PART, pivotCacheDefinitionPart, pivotCacheRecordsPart, pivotTablePart, printerSettingsPart, RICH_VALUE_STRUCTURES_PART, RICH_VALUES_PART, 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';
@@ -16,8 +19,8 @@ import { StyleRegistry } from './styles.js';
 import { tableXml } from './tables.js';
 import { applyThemeOverrides, DEFAULT_THEME_XML } from './theme-xml.js';
 import { personsXml, threadedCommentsXml } from './threaded-comments.js';
-import { appPropsXml, contentTypesXml, corePropsXml, rootRelsXml, workbookRelsXml, workbookXml, } from './workbook-xml.js';
-import { worksheetRelsXml, worksheetXml } from './worksheet-xml.js';
+import { appPropsXml, contentTypesXml, corePropsXml, workbookXml, } from './workbook-xml.js';
+import { worksheetXml } from './worksheet-xml.js';
 export function writeXlsx(workbook, options = {}) {
     return zipSync(buildPackageParts(workbook, options), { level: 6, mtime: FIXED_ENTRY_MTIME });
 }
@@ -48,52 +51,77 @@ export function createStyleRegistry(workbook) {
         styles.addTableStyle(style);
     return styles;
 }
+function keptDrawingPath(sheet) {
+    return sheet.preservedReferences.find((reference) => reference.element === 'drawing')?.entryPath;
+}
+function drawingImages(sheet, media, drawingRels) {
+    return sheet.images.map((image) => {
+        const { number: mediaNumber, image: registered } = media.resolve(image.imageId);
+        const embedId = drawingRels.add(REL.image, mediaPart(mediaNumber, registered.extension));
+        const properties = pictureProperties(image);
+        const target = properties.hyperlink?.target;
+        if (target === undefined)
+            return { anchor: image.anchor, embedId, properties };
+        const hyperlinkId = target.startsWith('#')
+            ? drawingRels.addInDocument(REL.hyperlink, target)
+            : drawingRels.addExternal(REL.hyperlink, target);
+        return { anchor: image.anchor, embedId, properties, hyperlinkId };
+    });
+}
 function planSheet(context) {
     const { sheet, index, media, preserved, numbering, flushed } = context;
-    const rels = new RelIdAllocator();
-    const tables = sheet.tables.map((table) => ({
-        table,
-        number: ++numbering.table,
-        relId: rels.next(),
-    }));
+    const rels = new RelationshipLedger(worksheetPart(index + 1));
+    const tables = sheet.tables.map((table) => {
+        const number = ++numbering.table;
+        return { table, number, relId: rels.add(REL.table, tablePart(number)) };
+    });
     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 };
+    if (sheet.images.length > 0 && keptDrawingPath(sheet) === undefined) {
+        const number = ++numbering.drawing;
+        const path = drawingPart(number);
+        const drawingRels = new RelationshipLedger(path);
+        drawing = {
+            number,
+            relId: rels.add(REL.drawing, path),
+            images: drawingImages(sheet, media, drawingRels),
+            relationships: drawingRels.relationships,
+        };
     }
     const threads = sheet.commentThreads.filter((thread) => thread.comments.length > 0);
     const sheetComments = collectComments(liveCells(sheet), threads, flushed?.notes ?? []);
-    const comments = sheetComments.length === 0
+    let comments = null;
+    if (sheetComments.length > 0) {
+        const vmlRelId = rels.add(REL.vmlDrawing, vmlDrawingPart(index + 1));
+        rels.add(REL.comments, commentsPart(index + 1));
+        comments = { number: index + 1, comments: sheetComments, vmlRelId };
+    }
+    let threadedComments = null;
+    if (threads.length > 0) {
+        rels.add(REL.threadedComment, threadedCommentsPart(index + 1));
+        threadedComments = { number: index + 1, threads };
+    }
+    const printerData = sheet.pageSetup.printerSettings;
+    const printerSettings = printerData === undefined
         ? null
         : {
             number: index + 1,
-            comments: sheetComments,
-            vmlRelId: rels.next(),
-            commentsRelId: rels.next(),
+            data: printerData,
+            relId: rels.add(REL.printerSettings, printerSettingsPart(index + 1)),
         };
-    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(liveCells(sheet)), ...(flushed?.hyperlinks ?? [])].sort((a, b) => a.row - b.row || a.col - b.col), rels);
+    const hyperlinks = planHyperlinks(sheet.hyperlinks, rels);
     let background = null;
     if (sheet.backgroundImageId !== undefined) {
         const { number, image } = media.resolve(sheet.backgroundImageId);
-        background = { relId: rels.next(), mediaNumber: number, extension: image.extension };
+        background = { relId: rels.add(REL.image, mediaPart(number, image.extension)) };
     }
-    const preservedRefs = (preserved.perSheet[index] ?? []).map((reference) => ({ ...reference, relId: rels.next() }));
+    const preservedRefs = (preserved.perSheet[index] ?? []).map((reference) => ({ ...reference, relId: rels.add(reference.relType, reference.entryPath) }));
     const pivots = sheet.pivotTables.map((table) => {
         const number = ++numbering.pivot;
-        return { number, cacheId: String(number), table, sheetRelId: rels.next(), workbookRelId: '' };
+        rels.add(REL.pivotTable, pivotTablePart(number));
+        return { number, cacheId: String(number), table, workbookRelId: '' };
     });
     return {
+        relationships: rels.relationships,
         tables,
         drawing,
         comments,
@@ -130,31 +158,55 @@ function resolveSheetReferences(plan) {
         slicerRelIds,
     };
 }
-function assignWorkbookRelIds(context) {
-    const { sheetCount, hasSharedStrings, hasPersons, preservedWorkbook, pivots } = context;
-    const ids = new RelIdAllocator();
-    const sheetRelIds = Array.from({ length: sheetCount }, () => ids.next());
-    const stylesRelId = ids.next();
-    const themeRelId = ids.next();
-    const sharedStringsRelId = hasSharedStrings ? ids.next() : null;
-    const personsRelId = hasPersons ? ids.next() : null;
-    const preservedWorkbookRels = preservedWorkbook.map((ref) => ({ ...ref, relId: ids.next() }));
-    for (const pivot of pivots)
-        pivot.workbookRelId = ids.next();
-    return {
-        sheetRelIds,
-        stylesRelId,
-        themeRelId,
-        sharedStringsRelId,
-        personsRelId,
-        preservedWorkbookRels,
-    };
+function planWorkbookRelationships(context) {
+    const { sheetCount, hasSharedStrings, hasPersons, hasCellMetadata, hasRichValues, preservedWorkbook, pivots, } = context;
+    const rels = new RelationshipLedger(WORKBOOK_PART);
+    const sheetRelIds = Array.from({ length: sheetCount }, (_, i) => rels.add(REL.worksheet, worksheetPart(i + 1)));
+    rels.add(REL.styles, STYLES_PART);
+    rels.add(REL.theme, THEME_PART_PATH);
+    if (hasSharedStrings)
+        rels.add(REL.sharedStrings, SHARED_STRINGS_PART);
+    if (hasPersons)
+        rels.add(REL.person, PERSONS_PART);
+    if (hasCellMetadata)
+        rels.add(REL.sheetMetadata, METADATA_PART);
+    if (hasRichValues) {
+        rels.add(REL.rdRichValue, RICH_VALUES_PART);
+        rels.add(REL.rdRichValueStructure, RICH_VALUE_STRUCTURES_PART);
+    }
+    const preservedWorkbookRels = preservedWorkbook.map((ref) => ({
+        ...ref,
+        relId: rels.add(ref.relType, ref.entryPath),
+    }));
+    for (const pivot of pivots) {
+        pivot.workbookRelId = rels.add(REL.pivotCacheDefinition, pivotCacheDefinitionPart(pivot.number));
+    }
+    return { sheetRelIds, preservedWorkbookRels, relationships: rels.relationships };
+}
+function planRootRelationships(rootRefs) {
+    const rels = new RelationshipLedger('');
+    rels.add(REL.officeDocument, WORKBOOK_PART);
+    rels.add(REL.coreProps, CORE_PROPS_PART);
+    rels.add(REL.extProps, APP_PROPS_PART);
+    for (const ref of rootRefs)
+        rels.add(ref.relType, ref.entryPath);
+    return rels.relationships;
 }
 function planPackage(workbook, sheets, flushed) {
     const media = planMedia(workbook, sheets);
-    const generatedDrawingCount = sheets.filter((sheet) => sheet.images.length > 0).length;
+    const pictures = new Map();
+    let generatedDrawingCount = 0;
+    for (const sheet of sheets) {
+        if (sheet.images.length === 0)
+            continue;
+        const kept = keptDrawingPath(sheet);
+        if (kept === undefined)
+            generatedDrawingCount += 1;
+        else
+            pictures.set(kept, (ledger) => drawingImages(sheet, media, ledger));
+    }
     const generatedPivotCount = sheets.reduce((total, sheet) => total + sheet.pivotTables.length, 0);
-    const preserved = planPreservedParts(workbook, generatedDrawingCount, media.parts.length, generatedPivotCount);
+    const preserved = planPreservedParts(workbook, generatedDrawingCount, media.parts.length, generatedPivotCount, pictures);
     const numbering = { table: 0, drawing: 0, pivot: 0 };
     const perSheet = sheets.map((sheet, index) => planSheet({ sheet, index, media, preserved, numbering, flushed: flushed?.get(sheet) }));
     return {
@@ -166,7 +218,7 @@ function planPackage(workbook, sheets, flushed) {
     };
 }
 function serialiseSheets(context) {
-    const { workbook, sheets, plan, styles, sharedStrings, flushed } = context;
+    const { workbook, sheets, plan, styles, sharedStrings, cellMetadata, flushed } = context;
     return sheets.map((sheet, i) => {
         const sheetPlan = plan.perSheet[i];
         return worksheetXml({
@@ -176,25 +228,31 @@ function serialiseSheets(context) {
             references: resolveSheetReferences(sheetPlan),
             hyperlinks: sheetPlan.hyperlinks,
             sharedStrings,
+            cellMetadata,
             dateEpoch: workbook.dateEpoch,
+            formulaNames: formulaNamesInScope(workbook.definedNames, sheet.name),
             active: i === workbook.activeTabIndex,
             flushed: flushed?.get(sheet),
         });
     });
 }
 function emitPackageParts(context) {
-    const { workbook, sheets, plan, styles, sharedStrings, sheetXml } = context;
+    const { workbook, sheets, plan, styles, sharedStrings, cellMetadata, sheetXml } = context;
     const { media, preserved, perSheet, allTables, allPivots } = plan;
     const hasSharedStrings = sharedStrings !== null && !sharedStrings.isEmpty;
+    const hasCellMetadata = !cellMetadata.isEmpty;
+    const hasRichValues = cellMetadata.hasRichValues;
     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 workbookRels = assignWorkbookRelIds({
+    const workbookRels = planWorkbookRelationships({
         sheetCount: sheets.length,
         hasSharedStrings,
         hasPersons: persons.length > 0,
+        hasCellMetadata,
+        hasRichValues,
         preservedWorkbook: preserved.workbook,
         pivots: allPivots,
     });
@@ -213,12 +271,14 @@ function emitPackageParts(context) {
         preservedWorkbookRefs: preservedWorkbookRels,
         threadedCommentNumbers,
         hasPersons: persons.length > 0,
+        hasCellMetadata,
+        hasRichValues,
     })));
-    files.add('_rels/.rels', strToU8(rootRelsXml(preserved.root)));
+    files.add(relsPathFor(''), strToU8(relsPartXml(planRootRelationships(preserved.root))));
     files.add(CORE_PROPS_PART, strToU8(corePropsXml(workbook.properties)));
     files.add(APP_PROPS_PART, strToU8(appPropsXml(workbook.properties)));
     files.add(WORKBOOK_PART, strToU8(workbookXml(workbook, workbookRels, allPivots)));
-    files.add(relsPathFor(WORKBOOK_PART), strToU8(workbookRelsXml(workbookRels, allPivots)));
+    files.add(relsPathFor(WORKBOOK_PART), strToU8(relsPartXml(workbookRels.relationships)));
     files.add(STYLES_PART, strToU8(styles.toXml()));
     if (!preserved.themeEmitted) {
         const overrides = workbook.themeOverrides;
@@ -231,13 +291,22 @@ function emitPackageParts(context) {
     }
     if (persons.length > 0)
         files.add(PERSONS_PART, strToU8(personsXml(persons)));
+    if (hasCellMetadata)
+        files.add(METADATA_PART, strToU8(cellMetadata.toXml()));
+    if (hasRichValues) {
+        files.add(RICH_VALUES_PART, strToU8(cellMetadata.richValuesXml()));
+        files.add(RICH_VALUE_STRUCTURES_PART, strToU8(RICH_VALUE_STRUCTURES_XML));
+    }
     for (const part of media.parts) {
         files.add(mediaPart(part.number, part.extension), part.data);
     }
-    emitSheetParts(files, perSheet, sheetXml);
-    for (const { table, number } of allTables) {
-        files.add(tablePart(number), strToU8(tableXml(table, number)));
-    }
+    emitSheetParts(files, perSheet, sheetXml, (id) => workbook.getPerson(id));
+    perSheet.forEach(({ tables }, index) => {
+        const formulaNames = formulaNamesInScope(workbook.definedNames, sheets[index]?.name);
+        for (const { table, number } of tables) {
+            files.add(tablePart(number), strToU8(tableXml(table, number, formulaNames)));
+        }
+    });
     emitPivotParts(files, allPivots);
     emitPreservedParts(files, preserved.parts);
     return files.toRecord();
@@ -249,6 +318,7 @@ export function buildPackageParts(workbook, options = {}) {
     }
     const sharedStrings = options.useSharedStrings ? new SharedStringTable() : null;
     const styles = options.styles ?? createStyleRegistry(workbook);
+    const cellMetadata = options.cellMetadata ?? new WorkbookMetadataTable();
     const plan = planPackage(workbook, sheets, options.flushed);
     const sheetXml = serialiseSheets({
         workbook,
@@ -256,9 +326,10 @@ export function buildPackageParts(workbook, options = {}) {
         plan,
         styles,
         sharedStrings,
+        cellMetadata,
         flushed: options.flushed,
     });
-    return emitPackageParts({ workbook, sheets, plan, styles, sharedStrings, sheetXml });
+    return emitPackageParts({ workbook, sheets, plan, styles, sharedStrings, cellMetadata, sheetXml });
 }
 class PackageFiles {
     #files = Object.create(null);
@@ -272,21 +343,12 @@ class PackageFiles {
         return this.#files;
     }
 }
-function emitSheetParts(files, perSheet, sheetXml) {
+function emitSheetParts(files, perSheet, sheetXml, personById) {
     perSheet.forEach((plan, i) => {
-        const { tables, drawing, comments, threadedComments, printerSettings, background, hyperlinks, preservedRefs, pivots, } = plan;
-        const hasExternalHyperlink = hyperlinks.some((link) => link.relId !== undefined);
+        const { relationships, drawing, comments, threadedComments, printerSettings } = plan;
         files.add(worksheetPart(i + 1), strToU8(sheetXml[i]));
-        if (tables.length > 0 ||
-            drawing !== null ||
-            comments !== null ||
-            threadedComments !== null ||
-            printerSettings !== null ||
-            background !== null ||
-            hasExternalHyperlink ||
-            preservedRefs.length > 0 ||
-            pivots.length > 0) {
-            files.add(relsPathFor(worksheetPart(i + 1)), strToU8(worksheetRelsXml(plan)));
+        if (relationships.length > 0) {
+            files.add(relsPathFor(worksheetPart(i + 1)), strToU8(relsPartXml(relationships)));
         }
         if (printerSettings !== null) {
             files.add(printerSettingsPart(printerSettings.number), printerSettings.data);
@@ -294,15 +356,14 @@ function emitSheetParts(files, perSheet, sheetXml) {
         if (drawing !== null) {
             const drawingPath = drawingPart(drawing.number);
             files.add(drawingPath, strToU8(drawingXml(drawing.images)));
-            const targets = drawing.images.map((image) => relativePartPath(drawingPath, mediaPart(image.mediaNumber, image.extension)));
-            files.add(relsPathFor(drawingPath), strToU8(drawingRelsXml(targets)));
+            files.add(relsPathFor(drawingPath), strToU8(relsPartXml(drawing.relationships)));
         }
         if (comments !== null) {
             files.add(commentsPart(comments.number), strToU8(commentsXml(comments.comments)));
             files.add(vmlDrawingPart(comments.number), strToU8(vmlDrawingXml(comments.comments)));
         }
         if (threadedComments !== null) {
-            files.add(threadedCommentsPart(threadedComments.number), strToU8(threadedCommentsXml(threadedComments.threads)));
+            files.add(threadedCommentsPart(threadedComments.number), strToU8(threadedCommentsXml(threadedComments.threads, personById)));
         }
     });
 }
@@ -311,16 +372,18 @@ function emitPivotParts(files, allPivots) {
         const { number, cacheId, table } = pivot;
         const tablePath = pivotTablePart(number);
         const definitionPath = pivotCacheDefinitionPart(number);
+        const recordsPath = pivotCacheRecordsPart(number);
+        const tableRels = new RelationshipLedger(tablePath);
+        tableRels.add(REL.pivotCacheDefinition, definitionPath);
         files.add(tablePath, strToU8(pivotTableXml(table, `PivotTable${number}`, cacheId)));
-        addSingleRelPart(files, tablePath, REL.pivotCacheDefinition, definitionPath);
-        files.add(definitionPath, strToU8(pivotCacheDefinitionXml(table)));
-        addSingleRelPart(files, definitionPath, REL.pivotCacheRecords, pivotCacheRecordsPart(number));
-        files.add(pivotCacheRecordsPart(number), strToU8(pivotCacheRecordsXml(table)));
+        files.add(relsPathFor(tablePath), strToU8(relsPartXml(tableRels.relationships)));
+        const definitionRels = new RelationshipLedger(definitionPath);
+        const recordsRelId = definitionRels.add(REL.pivotCacheRecords, recordsPath);
+        files.add(definitionPath, strToU8(pivotCacheDefinitionXml(table, recordsRelId)));
+        files.add(relsPathFor(definitionPath), strToU8(relsPartXml(definitionRels.relationships)));
+        files.add(recordsPath, strToU8(pivotCacheRecordsXml(table)));
     }
 }
-function addSingleRelPart(files, from, type, to) {
-    files.add(relsPathFor(from), strToU8(relsPartXml([{ id: 'rId1', type, target: relativePartPath(from, to) }])));
-}
 function emitPreservedParts(files, parts) {
     for (const part of parts) {
         files.add(part.path, part.bytes);

package/dist/rel-type.d.ts

@@ -1,3 +1,12 @@
+/**
+ * The last segment of a relationship Type (`vbaProjectSignatureAgile` in
+ * `http://schemas.microsoft.com/office/2014/relationships/vbaProjectSignatureAgile`), or the whole Type
+ * when it has no `/`: for a caller that looks the segment up rather than testing for one class.
+ *
+ * {@link isRelType} is not built on it, because a class name may span segments: the ribbon's is
+ * `ui/extensibility`.
+ */
+export declare function relTypeSegment(type: string): string;
 /**
  * Does a relationship Type name this class of part?
  *

package/dist/rel-type.js

@@ -1,3 +1,6 @@
+export function relTypeSegment(type) {
+    return type.slice(type.lastIndexOf('/') + 1);
+}
 export function isRelType(type, name) {
     return type.endsWith(`/${name}`);
 }

package/dist/vba/bytes.d.ts

@@ -9,6 +9,8 @@ export declare function readU32(buf: Uint8Array, at: number): number;
  * `0xffff` turns that into a `dir` stream declaring 65,535 modules.
  */
 export declare function writeU16(buf: Uint8Array, at: number, value: number): void;
+/** Write a little-endian `uint32` over bytes already in `buf`, asserted rather than masked as {@link writeU16} is. */
+export declare function writeU32(buf: Uint8Array, at: number, value: number): void;
 /**
  * Replace `src[start..end)` with `insert`, returning a new array.
  *

package/dist/vba/bytes.js

@@ -29,6 +29,17 @@ export function writeU16(buf, at, value) {
     buf[at] = value & 0xff;
     buf[at + 1] = (value >> 8) & 0xff;
 }
+export function writeU32(buf, at, value) {
+    if (!Number.isInteger(value) || value < 0 || value > 0xffff_ffff) {
+        throw new VbaParseError(`${value} does not fit the uint32 at offset ${at}`);
+    }
+    if (at + 3 >= buf.length)
+        throw truncated(at, 4, buf.length);
+    buf[at] = value & 0xff;
+    buf[at + 1] = (value >>> 8) & 0xff;
+    buf[at + 2] = (value >>> 16) & 0xff;
+    buf[at + 3] = (value >>> 24) & 0xff;
+}
 export function spliceBytes(src, start, end, insert = EMPTY) {
     const out = new Uint8Array(src.length - (end - start) + insert.length);
     out.set(src.subarray(0, start), 0);