@shbernal/ts-xlsx 3.0.0 → 3.1.0

package/dist/io/xlsx/theme-xml.js

@@ -1,41 +1,85 @@
 import { DEFAULT_THEME_COLOR_SCHEME, isThemeColorSlot, normalizeThemeColor, } from '../../core/theme.js';
-import { decodeEntities } from '../../xml/xml-scan.js';
+import { elementRange, parseXml } from '../../xml/xml-read.js';
+import { localName } from '../../xml/xml-scan.js';
 import { escapeAttr } from '../../xml/xml.js';
-const SCHEME_SLOT = new RegExp('<a:(dk1|lt1|dk2|lt2|accent[1-6]|hlink|folHlink)\\b[^>]*>' + '\\s*<a:(srgbClr|sysClr)\\b([^>]*)>', 'g');
-export function parseThemeColorScheme(themeXml) {
-    const block = /<a:clrScheme\b[^>]*>([\s\S]*?)<\/a:clrScheme>/.exec(themeXml);
-    if (block === null)
-        return {};
+const COLOR_ELEMENTS = new Set(['srgbClr', 'sysClr']);
+function readThemeScheme(themeXml) {
+    const colors = {};
+    const elements = {};
+    const fonts = {};
+    let prefix = '';
+    let container;
+    let slot;
+    let fontSlot;
+    parseXml(themeXml, {
+        onOpen(name, attrs, _selfClosing, scope) {
+            const local = localName(name);
+            if (local === 'theme') {
+                const colon = name.indexOf(':');
+                prefix = colon === -1 ? '' : name.slice(0, colon + 1);
+                return;
+            }
+            if (local === 'clrScheme' || local === 'fontScheme') {
+                container = local;
+                return;
+            }
+            if (container === 'clrScheme') {
+                if (isThemeColorSlot(local)) {
+                    slot = local;
+                }
+                else if (slot !== undefined && COLOR_ELEMENTS.has(local)) {
+                    const value = local === 'sysClr' ? attrs.lastClr : attrs.val;
+                    if (value !== undefined && /^[0-9a-fA-F]{6}$/.test(value))
+                        colors[slot] = value;
+                    elements[slot] = emptyElement(name, attrs);
+                    slot = undefined;
+                }
+                return;
+            }
+            if (container === 'fontScheme') {
+                if (local === 'majorFont')
+                    fontSlot = 'major';
+                else if (local === 'minorFont')
+                    fontSlot = 'minor';
+                else if (local === 'latin' && fontSlot !== undefined && attrs.typeface !== undefined) {
+                    fonts[fontSlot] ??= attrs.typeface;
+                }
+            }
+            void scope;
+        },
+        onClose(name) {
+            const local = localName(name);
+            if (local === 'clrScheme' || local === 'fontScheme') {
+                container = undefined;
+                slot = undefined;
+                fontSlot = undefined;
+            }
+            else if (local === 'majorFont' || local === 'minorFont') {
+                fontSlot = undefined;
+            }
+            else if (slot !== undefined && local === slot) {
+                slot = undefined;
+            }
+        },
+    });
     const scheme = {};
-    for (const match of (block[1] ?? '').matchAll(SCHEME_SLOT)) {
-        const slot = match[1];
-        if (slot === undefined || !isThemeColorSlot(slot))
-            continue;
-        const attrs = match[3] ?? '';
-        const source = match[2] === 'sysClr' ? /\blastClr="([^"]*)"/ : /\bval="([^"]*)"/;
-        const value = source.exec(attrs)?.[1];
-        if (value !== undefined && /^[0-9a-fA-F]{6}$/.test(value))
-            scheme[slot] = value;
-    }
-    return scheme;
+    if (fonts.major !== undefined)
+        scheme.major = fonts.major;
+    if (fonts.minor !== undefined)
+        scheme.minor = fonts.minor;
+    return { colors, elements, fonts: scheme, prefix };
+}
+function emptyElement(name, attrs) {
+    let out = `<${name}`;
+    for (const key in attrs)
+        out += ` ${key}="${escapeAttr(attrs[key] ?? '')}"`;
+    return `${out}/>`;
+}
+export function parseThemeColorScheme(themeXml) {
+    return readThemeScheme(themeXml).colors;
 }
 export function parseThemeFontScheme(themeXml) {
-    const block = /<a:fontScheme\b[^>]*>([\s\S]*?)<\/a:fontScheme>/.exec(themeXml);
-    if (block === null)
-        return {};
-    const face = (which) => {
-        const font = new RegExp(`<a:${which}\\b[^>]*>([\\s\\S]*?)</a:${which}>`).exec(block[1] ?? '');
-        const typeface = /<a:latin\b[^>]*\btypeface="([^"]*)"/.exec(font?.[1] ?? '')?.[1];
-        return typeface === undefined ? undefined : decodeEntities(typeface);
-    };
-    const scheme = {};
-    const major = face('majorFont');
-    const minor = face('minorFont');
-    if (major !== undefined)
-        scheme.major = major;
-    if (minor !== undefined)
-        scheme.minor = minor;
-    return scheme;
+    return readThemeScheme(themeXml).fonts;
 }
 const SCHEME_ELEMENT_ORDER = [
     'dk1',
@@ -52,49 +96,43 @@ const SCHEME_ELEMENT_ORDER = [
     'folHlink',
 ];
 export function applyThemeOverrides(baseXml, overrides) {
-    let xml = baseXml;
+    const { elements: sourceElements, prefix } = readThemeScheme(baseXml);
+    const edits = [];
     const colors = overrides.colors ?? {};
     if (Object.keys(colors).length > 0) {
-        const sourceElements = parseThemeColorElements(baseXml);
-        const body = SCHEME_ELEMENT_ORDER.map((slot) => {
-            const authored = colors[slot];
-            const inner = authored !== undefined
-                ? `<a:srgbClr val="${normalizeThemeColor(authored)}"/>`
-                : (sourceElements[slot] ?? `<a:srgbClr val="${DEFAULT_THEME_COLOR_SCHEME[slot]}"/>`);
-            return `<a:${slot}>${inner}</a:${slot}>`;
-        }).join('');
-        xml = replaceBlockBody(xml, 'clrScheme', body);
+        const scheme = elementRange(baseXml, ['clrScheme']);
+        if (scheme !== undefined) {
+            const body = SCHEME_ELEMENT_ORDER.map((slot) => {
+                const authored = colors[slot];
+                const inner = authored !== undefined
+                    ? `<${prefix}srgbClr val="${normalizeThemeColor(authored)}"/>`
+                    : (sourceElements[slot] ??
+                        `<${prefix}srgbClr val="${DEFAULT_THEME_COLOR_SCHEME[slot]}"/>`);
+                return `<${prefix}${slot}>${inner}</${prefix}${slot}>`;
+            }).join('');
+            edits.push({ start: scheme.contentStart, end: scheme.contentEnd, text: body });
+        }
     }
     const { major, minor } = overrides.fonts ?? {};
+    const latin = (which, typeface) => {
+        const found = elementRange(baseXml, [which, 'latin']);
+        if (found === undefined)
+            return;
+        const attrs = { ...found.attrs, typeface };
+        let rendered = `<${found.name}`;
+        for (const key in attrs)
+            rendered += ` ${key}="${escapeAttr(attrs[key] ?? '')}"`;
+        edits.push({ start: found.start, end: found.end, text: `${rendered}/>` });
+    };
     if (major !== undefined)
-        xml = replaceLatinTypeface(xml, 'majorFont', major);
+        latin('majorFont', major);
     if (minor !== undefined)
-        xml = replaceLatinTypeface(xml, 'minorFont', minor);
-    return xml;
-}
-function parseThemeColorElements(themeXml) {
-    const block = /<a:clrScheme\b[^>]*>([\s\S]*?)<\/a:clrScheme>/.exec(themeXml);
-    if (block === null)
-        return {};
-    const elements = {};
-    const pattern = /<a:(dk1|lt1|dk2|lt2|accent[1-6]|hlink|folHlink)>([\s\S]*?)<\/a:\1>|<a:(dk1|lt1|dk2|lt2|accent[1-6]|hlink|folHlink)\/>/g;
-    for (const match of (block[1] ?? '').matchAll(pattern)) {
-        const slot = match[1] ?? match[3];
-        if (slot === undefined || !isThemeColorSlot(slot))
-            continue;
-        const inner = match[2];
-        if (inner !== undefined && inner !== '')
-            elements[slot] = inner;
+        latin('minorFont', minor);
+    let xml = baseXml;
+    for (const edit of edits.sort((a, b) => b.start - a.start)) {
+        xml = xml.slice(0, edit.start) + edit.text + xml.slice(edit.end);
     }
-    return elements;
-}
-function replaceBlockBody(xml, name, body) {
-    const pattern = new RegExp(`(<a:${name}\\b[^>]*>)[\\s\\S]*?(</a:${name}>)`);
-    return xml.replace(pattern, (_all, open, close) => `${open}${body}${close}`);
-}
-function replaceLatinTypeface(xml, which, typeface) {
-    const pattern = new RegExp(`(<a:${which}\\b[^>]*>[\\s\\S]*?<a:latin\\b)[^>]*(/>)`);
-    return xml.replace(pattern, (_all, open, close) => `${open} typeface="${escapeAttr(typeface)}"${close}`);
+    return xml;
 }
 export const DEFAULT_THEME_XML = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n' +
     '<a:theme xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" name="Office Theme">' +

package/dist/io/xlsx/threaded-comments.d.ts

@@ -1,14 +1,12 @@
 import { type CommentThread, type MentionRef, type Person } from '../../core/comment-thread.ts';
-/** A registered author of threaded comments: one `<person>` of `xl/persons/person.xml`. */
-export interface ParsedPerson {
-    /** Brace-wrapped GUID a message's `personId` points at. */
-    readonly id: string;
-    readonly displayName: string;
-    /** Identity-provider handle, `S::<email>::<tenant-guid>` for an AzureAD account. */
-    readonly userId?: string;
-    /** Identity provider, e.g. `AD`. */
-    readonly providerId?: string;
-}
+/**
+ * A registered author of threaded comments: one `<person>` of `xl/persons/person.xml`, which is the
+ * model's own {@link Person} with nothing added. Declared as an alias for the same reason
+ * {@link ParsedMention} is: this file's write half already emits `Person` directly, so re-declaring
+ * the four fields here made one feature module name one shape two ways, with nothing keeping the two
+ * in step.
+ */
+export type ParsedPerson = Person;
 /**
  * One `<mention>` of a message's `<mentions>` block: the model's own {@link MentionRef}, which is
  * exactly the four wire attributes with nothing resolved yet. Declaring it a second time here would

package/dist/io/xlsx/threaded-comments.js

@@ -1,7 +1,8 @@
 import { encodeAddress, tryDecodeCellRef } from '../../core/address.js';
 import { MENTION_OFFSET_MAX, } from '../../core/comment-thread.js';
+import { decodeSpreadsheetText, numInteger } from '../../xml/xml-attrs.js';
 import { parseXml, TextCapture } from '../../xml/xml-read.js';
-import { boolStrict, decodeSpreadsheetText, localName, numInteger, } from '../../xml/xml-scan.js';
+import { boolStrict, localName } from '../../xml/xml-scan.js';
 import { escapeAttr, escapeSpreadsheetText, textAttr, XML_DECLARATION } from '../../xml/xml.js';
 import { THREADED_COMMENTS_NS } from './namespaces.js';
 export function parsePersons(xml) {

package/dist/io/xlsx/workbook-xml.d.ts

@@ -3,10 +3,60 @@ import type { PivotPlan, PreservedPartPlan, PreservedRootReferencePlan, Preserve
 export type PreservedWorkbookRel = PreservedWorkbookReferencePlan & {
     readonly relId: string;
 };
-export declare function contentTypesXml(sheetCount: number, tables: readonly TablePlan[], commentNumbers: readonly number[], drawingNumbers: readonly number[], printerSettingsNumbers: readonly number[], mediaExtensions: readonly string[], hasSharedStrings: boolean, preservedParts: readonly PreservedPartPlan[], pivots: readonly PivotPlan[], preservedWorkbookRefs: readonly PreservedWorkbookReferencePlan[], threadedCommentNumbers: readonly number[], hasPersons: boolean): string;
+/**
+ * The workbook part's relationship ids, drawn once by the writer's `assignWorkbookRelIds` and handed
+ * to every consumer rather than re-derived by any of them.
+ *
+ * Declared here because both consumers are here: the rels part wires the ids, and the workbook body
+ * *references* them from `<sheet r:id>`. The body used to spell that reference `rId${i + 1}`, which
+ * agreed with the allocator only because sheets happen to be the first ids it hands out. Anything
+ * laid ahead of them would have re-pointed every sheet at the wrong part, and the package would have
+ * stayed schema-valid while doing it -- a class of corruption no validator catches and no round-trip
+ * through this library notices, because the reader resolves the same wrong ids consistently.
+ */
+export interface WorkbookRelPlan {
+    readonly sheetRelIds: readonly string[];
+    readonly stylesRelId: string;
+    readonly themeRelId: string;
+    readonly sharedStringsRelId: string | null;
+    readonly personsRelId: string | null;
+    readonly preservedWorkbookRels: readonly PreservedWorkbookRel[];
+}
+/**
+ * What `[Content_Types].xml` needs to know about a package: every part family it declares.
+ *
+ * One object rather than twelve positional parameters, eight of them arrays and four of those bare
+ * `readonly number[]`, which two adjacent ones could be silently transposed between. That is the same
+ * hazard `SheetReferences`, `SheetPlan` and `WorksheetXmlInputs` remove elsewhere in this writer, and
+ * it travels the whole way down: the two functions that render from this take it as it stands rather
+ * than re-scattering its fields across their own parameter lists.
+ */
+export interface ContentTypeInputs {
+    readonly sheetCount: number;
+    readonly tables: readonly TablePlan[];
+    readonly commentNumbers: readonly number[];
+    readonly drawingNumbers: readonly number[];
+    readonly printerSettingsNumbers: readonly number[];
+    readonly mediaExtensions: readonly string[];
+    readonly hasSharedStrings: boolean;
+    readonly preservedParts: readonly PreservedPartPlan[];
+    readonly pivots: readonly PivotPlan[];
+    readonly preservedWorkbookRefs: readonly PreservedWorkbookReferencePlan[];
+    readonly threadedCommentNumbers: readonly number[];
+    readonly hasPersons: boolean;
+}
+export declare function contentTypesXml(inputs: ContentTypeInputs): string;
 export declare function rootRelsXml(rootRefs: readonly PreservedRootReferencePlan[]): string;
-export declare function workbookXml(workbook: Workbook, preservedRels: readonly PreservedWorkbookRel[], pivots: readonly PivotPlan[]): string;
-export declare const FIXED_WORKBOOK_REL_COUNT = 2;
-export declare function workbookRelsXml(sheetCount: number, hasSharedStrings: boolean, personsRelId: string | null, preservedRels: readonly PreservedWorkbookRel[], pivots: readonly PivotPlan[]): string;
+export declare function workbookXml(workbook: Workbook, plan: WorkbookRelPlan, pivots: readonly PivotPlan[]): string;
+/**
+ * The workbook part's `.rels`, rendered from the ids the planner drew.
+ *
+ * Every id arrives in `plan`; none is computed here. It used to re-derive the styles, theme and
+ * shared-strings ids from the sheet count and a shared constant while `write.ts` independently summed
+ * the same inputs to place everything after them, so one sequence was spelled in two files and only
+ * its fixed part was shared. The relationship *order* is still stated here, because that is what this
+ * function is; the numbering is not, because two numberings of one sequence is how they drift apart.
+ */
+export declare function workbookRelsXml(plan: WorkbookRelPlan, pivots: readonly PivotPlan[]): string;
 export declare function corePropsXml(properties: WorkbookProperties): string;
 export declare function appPropsXml(properties: WorkbookProperties): string;

package/dist/io/xlsx/workbook-xml.js

@@ -1,7 +1,9 @@
 import { mangleFormula, quoteSheetName } from '../../core/formula.js';
 import { WORKBOOK_PROTECTION_CREDENTIAL_ATTRS } from '../../core/workbook-protection.js';
 import { isVisibility } from '../../core/worksheet.js';
-import { checkedToken, escapeAttr, escapeText, numAttr, textAttr, XML_DECLARATION, } from '../../xml/xml.js';
+import { AuthoringError, InternalError, quoted } from '../../errors.js';
+import { isRelType } from '../../rel-type.js';
+import { assertWritableDate, checkedToken, escapeAttr, escapeText, numAttr, textAttr, XML_DECLARATION, } from '../../xml/xml.js';
 import { extensionOf, THEME_PART_PATH } from '../opc/part-paths.js';
 import { relationship, relationshipsPart } from '../opc/rels.js';
 import { imageContentType } from './images.js';
@@ -29,15 +31,16 @@ const CT = {
     threadedComments: 'application/vnd.ms-excel.threadedcomments+xml',
     person: 'application/vnd.ms-excel.person+xml',
 };
-export function contentTypesXml(sheetCount, tables, commentNumbers, drawingNumbers, printerSettingsNumbers, mediaExtensions, hasSharedStrings, preservedParts, pivots, preservedWorkbookRefs, threadedCommentNumbers, hasPersons) {
-    const extensionDefaults = buildExtensionDefaults(commentNumbers, printerSettingsNumbers, mediaExtensions, preservedParts);
+export function contentTypesXml(inputs) {
+    const extensionDefaults = buildExtensionDefaults(inputs);
     return (XML_DECLARATION +
         `<Types xmlns="${NS.contentTypes}">` +
         contentTypeDefaults(extensionDefaults) +
-        contentTypeOverrides(sheetCount, tables, drawingNumbers, commentNumbers, hasSharedStrings, preservedParts, pivots, preservedWorkbookRefs, extensionDefaults, threadedCommentNumbers, hasPersons) +
+        contentTypeOverrides(inputs, extensionDefaults) +
         '</Types>');
 }
-function buildExtensionDefaults(commentNumbers, printerSettingsNumbers, mediaExtensions, preservedParts) {
+function buildExtensionDefaults(inputs) {
+    const { commentNumbers, printerSettingsNumbers, mediaExtensions, preservedParts } = inputs;
     const defaults = new Map();
     const add = (extension, contentType) => {
         const key = extension.toLowerCase();
@@ -54,25 +57,25 @@ function buildExtensionDefaults(commentNumbers, printerSettingsNumbers, mediaExt
         add(ext, imageContentType(ext));
     for (const part of preservedParts) {
         const ext = extensionOf(part.path);
-        if (ext.toLowerCase() === 'xml')
+        if (ext === 'xml')
             continue;
         add(ext, part.contentType);
     }
     return defaults;
 }
 function isMacroEnabled(preservedWorkbookRefs) {
-    return preservedWorkbookRefs.some((ref) => ref.relType.endsWith('/vbaProject'));
+    return preservedWorkbookRefs.some((ref) => isRelType(ref.relType, 'vbaProject'));
 }
 function contentTypeDefaults(extensionDefaults) {
     return [...extensionDefaults.values()]
         .map(({ extension, contentType }) => defaultType(extension, contentType))
         .join('');
 }
-function contentTypeOverrides(sheetCount, tables, drawingNumbers, commentNumbers, hasSharedStrings, preservedParts, pivots, preservedWorkbookRefs, extensionDefaults, threadedCommentNumbers, hasPersons) {
+function contentTypeOverrides(inputs, extensionDefaults) {
+    const { sheetCount, tables, drawingNumbers, commentNumbers, threadedCommentNumbers, pivots, hasSharedStrings, hasPersons, preservedParts, preservedWorkbookRefs, } = inputs;
     const preservedOverrides = preservedParts
         .filter((part) => part.path !== THEME_PART_PATH)
-        .filter((part) => extensionDefaults.get(extensionOf(part.path).toLowerCase())?.contentType !==
-        part.contentType)
+        .filter((part) => extensionDefaults.get(extensionOf(part.path))?.contentType !== part.contentType)
         .map((part) => override(part.path, part.contentType));
     return [
         override(WORKBOOK_PART, isMacroEnabled(preservedWorkbookRefs) ? CT.macroEnabledWorkbook : CT.workbook),
@@ -94,10 +97,10 @@ function contentTypeOverrides(sheetCount, tables, drawingNumbers, commentNumbers
     ].join('');
 }
 function override(partPath, contentType) {
-    return `<Override PartName="/${partPath}" ContentType="${contentType}"/>`;
+    return `<Override PartName="/${escapeAttr(partPath)}" ContentType="${escapeAttr(contentType)}"/>`;
 }
 function defaultType(extension, contentType) {
-    return `<Default Extension="${extension}" ContentType="${contentType}"/>`;
+    return `<Default Extension="${escapeAttr(extension)}" ContentType="${escapeAttr(contentType)}"/>`;
 }
 export function rootRelsXml(rootRefs) {
     return relationshipsPart([
@@ -107,18 +110,25 @@ export function rootRelsXml(rootRefs) {
         ...rootRefs.map((ref, i) => relationship(`rId${4 + i}`, ref.relType, ref.entryPath)),
     ]);
 }
-export function workbookXml(workbook, preservedRels, pivots) {
+export function workbookXml(workbook, plan, pivots) {
+    const preservedRels = plan.preservedWorkbookRels;
     const sheets = workbook.worksheets;
     const entries = sheets
         .map((sheet, i) => {
+        const relId = plan.sheetRelIds[i];
+        if (relId === undefined) {
+            throw new InternalError(`worksheet ${i + 1} of ${sheets.length} has no relationship id: the plan was drawn for ` +
+                `${plan.sheetRelIds.length} sheet(s)`);
+        }
         const state = sheet.state === 'visible'
             ? ''
             : ` state="${checkedToken(sheet.state, isVisibility, 'sheet visibility')}"`;
-        return `<sheet name="${escapeAttr(sheet.name)}" sheetId="${sheet.id}"${state} r:id="rId${i + 1}"/>`;
+        return `<sheet name="${escapeAttr(sheet.name)}" sheetId="${sheet.id}"${state} r:id="${relId}"/>`;
     })
         .join('');
     return (XML_DECLARATION +
         `<workbook xmlns="${NS.main}" xmlns:r="${NS.docRels}">` +
+        workbookPrXml(workbook) +
         workbookProtectionXml(workbook) +
         bookViewsXml(workbook) +
         `<sheets>${entries}</sheets>` +
@@ -129,6 +139,11 @@ export function workbookXml(workbook, preservedRels, pivots) {
         workbookExtLstXml(preservedRels) +
         '</workbook>');
 }
+function workbookPrXml(workbook) {
+    const attrs = (workbook.dateEpoch === 1904 ? ' date1904="1"' : '') +
+        (workbook.codeName === undefined ? '' : ` codeName="${escapeAttr(workbook.codeName)}"`);
+    return attrs === '' ? '' : `<workbookPr${attrs}/>`;
+}
 function bookViewsXml(workbook) {
     const view = workbook.view;
     const activeTab = workbook.activeTabIndex;
@@ -146,23 +161,23 @@ function bookViewsXml(workbook) {
 function externalReferencesXml(preservedRels) {
     const links = preservedRels
         .filter((ref) => ref.externalReferenceIndex !== undefined)
-        .sort((a, b) => a.externalReferenceIndex - b.externalReferenceIndex);
+        .sort((a, b) => (a.externalReferenceIndex ?? 0) - (b.externalReferenceIndex ?? 0));
     if (links.length === 0)
         return '';
     const entries = links.map((ref) => `<externalReference r:id="${ref.relId}"/>`).join('');
     return `<externalReferences>${entries}</externalReferences>`;
 }
 function workbookExtLstXml(preservedRels) {
-    const caches = preservedRels.filter((ref) => ref.relType.endsWith('/slicerCache'));
+    const caches = preservedRels.filter((ref) => isRelType(ref.relType, 'slicerCache'));
     if (caches.length === 0)
         return '';
     const entries = caches.map((ref) => `<x14:slicerCache r:id="${ref.relId}"/>`).join('');
     return `<extLst>${x14Ext(SLICER_CACHES_EXT_URI, `<x14:slicerCaches>${entries}</x14:slicerCaches>`)}</extLst>`;
 }
 function pivotCachesXml(preservedRels, pivots) {
-    const preserved = preservedRels
-        .filter((ref) => ref.pivotCacheId !== undefined)
-        .map((ref) => `<pivotCache cacheId="${escapeAttr(ref.pivotCacheId)}" r:id="${ref.relId}"/>`);
+    const preserved = preservedRels.flatMap((ref) => ref.pivotCacheId === undefined
+        ? []
+        : [`<pivotCache cacheId="${escapeAttr(ref.pivotCacheId)}" r:id="${ref.relId}"/>`]);
     const generated = pivots.map((pivot) => `<pivotCache cacheId="${escapeAttr(pivot.cacheId)}" r:id="${pivot.workbookRelId}"/>`);
     const entries = [...preserved, ...generated];
     if (entries.length === 0)
@@ -193,12 +208,20 @@ const EXCEL_CALC_ID = '171027';
 function calcPrXml(workbook) {
     return workbook.fullCalcOnLoad ? `<calcPr calcId="${EXCEL_CALC_ID}" fullCalcOnLoad="1"/>` : '';
 }
+function localSheetId(sheets, name, scope) {
+    const wanted = scope.toLowerCase();
+    const index = sheets.findIndex((sheet) => sheet.name.toLowerCase() === wanted);
+    if (index === -1) {
+        throw new AuthoringError(`defined name ${quoted(name)} is scoped to worksheet ${quoted(scope)}, which this workbook does not contain`);
+    }
+    return index;
+}
 function definedNamesXml(workbook) {
     const sheets = workbook.worksheets;
     const userEntries = workbook.definedNames.map((name) => {
         const scopeAttr = name.scope === undefined
             ? ''
-            : ` localSheetId="${sheets.findIndex((sheet) => sheet.name === name.scope)}"`;
+            : ` localSheetId="${localSheetId(sheets, name.name, name.scope)}"`;
         const commentAttr = textAttr('comment', name.comment);
         const hiddenAttr = name.hidden ? ' hidden="1"' : '';
         return (`<definedName name="${escapeAttr(name.name)}"${scopeAttr}${commentAttr}${hiddenAttr}>` +
@@ -219,21 +242,22 @@ function filterDatabaseRefersTo(sheetName, range) {
     const absolute = range.replace(/([A-Z]+)(\d+)/g, '$$$1$$$2');
     return `${quoteSheetName(sheetName)}!${absolute}`;
 }
-export const FIXED_WORKBOOK_REL_COUNT = 2;
-export function workbookRelsXml(sheetCount, hasSharedStrings, personsRelId, preservedRels, pivots) {
+export function workbookRelsXml(plan, pivots) {
+    const { personsRelId } = plan;
+    const preservedRels = plan.preservedWorkbookRels;
     return relationshipsPart([
-        ...Array.from({ length: sheetCount }, (_, i) => relationship(`rId${i + 1}`, REL.worksheet, targetFromWorkbook(worksheetPart(i + 1)))),
-        relationship(`rId${sheetCount + 1}`, REL.styles, 'styles.xml'),
-        relationship(`rId${sheetCount + FIXED_WORKBOOK_REL_COUNT}`, REL.theme, targetFromWorkbook(THEME_PART_PATH)),
-        ...(hasSharedStrings
-            ? [
-                relationship(`rId${sheetCount + FIXED_WORKBOOK_REL_COUNT + 1}`, REL.sharedStrings, targetFromWorkbook(SHARED_STRINGS_PART)),
-            ]
-            : []),
+        ...plan.sheetRelIds.map((relId, i) => relationship(relId, REL.worksheet, targetFromWorkbook(worksheetPart(i + 1)))),
+        relationship(plan.stylesRelId, REL.styles, targetFromWorkbook(STYLES_PART)),
+        relationship(plan.themeRelId, REL.theme, targetFromWorkbook(THEME_PART_PATH)),
+        ...(plan.sharedStringsRelId === null
+            ? []
+            : [
+                relationship(plan.sharedStringsRelId, REL.sharedStrings, targetFromWorkbook(SHARED_STRINGS_PART)),
+            ]),
         ...(personsRelId === null
             ? []
             : [relationship(personsRelId, REL.person, targetFromWorkbook(PERSONS_PART))]),
-        ...preservedRels.map((ref) => relationship(ref.relId, ref.relType, escapeAttr(targetFromWorkbook(ref.entryPath)))),
+        ...preservedRels.map((ref) => relationship(ref.relId, ref.relType, targetFromWorkbook(ref.entryPath))),
         ...pivots.map((pivot) => relationship(pivot.workbookRelId, REL.pivotCacheDefinition, targetFromWorkbook(pivotCacheDefinitionPart(pivot.number)))),
     ]);
 }
@@ -248,10 +272,10 @@ export function corePropsXml(properties) {
     if (properties.lastModifiedBy !== undefined) {
         parts.push(`<cp:lastModifiedBy>${escapeText(properties.lastModifiedBy)}</cp:lastModifiedBy>`);
     }
-    if (properties.created) {
+    if (properties.created !== undefined) {
         parts.push(w3cdtf('created', properties.created));
     }
-    if (properties.modified) {
+    if (properties.modified !== undefined) {
         parts.push(w3cdtf('modified', properties.modified));
     }
     return (XML_DECLARATION +
@@ -261,7 +285,9 @@ export function corePropsXml(properties) {
         '</cp:coreProperties>');
 }
 function w3cdtf(element, date) {
-    return `<dcterms:${element} xsi:type="dcterms:W3CDTF">${date.toISOString()}</dcterms:${element}>`;
+    assertWritableDate(date, `the document property ${quoted(element)}`);
+    const stamp = date.toISOString().replace(/\.\d{3}Z$/, 'Z');
+    return `<dcterms:${element} xsi:type="dcterms:W3CDTF">${stamp}</dcterms:${element}>`;
 }
 export function appPropsXml(properties) {
     const company = properties.company === undefined ? '' : `<Company>${escapeText(properties.company)}</Company>`;

package/dist/io/xlsx/worksheet-xml.d.ts

@@ -1,46 +1,10 @@
-import { type Cell } from '../../core/cell.ts';
-import type { ColumnProperties, RowProperties, Worksheet } from '../../core/worksheet.ts';
+import type { DateEpoch } from '../../core/date.ts';
+import type { Worksheet } from '../../core/worksheet.ts';
 import { type HyperlinkPlan } from './hyperlinks.ts';
-import type { BackgroundPlan, CommentPlan, DrawingPlan, PivotPlan, PreservedReferencePlan, PrinterSettingsPlan, TablePlan, ThreadedCommentPlan } from './package-plan.ts';
-import { type SharedFormulaRole } from './shared-formulas.ts';
+import type { SheetPlan, TablePlan } from './package-plan.ts';
+import { type FlushedSheet } from './row-xml.ts';
 import type { SharedStringTable } from './shared-strings.ts';
 import type { StyleRegistry } from './styles.ts';
-/**
- * The used-cell extent of a sheet: the top-left/bottom-right grid bounds that fold into the
- * `<dimension>`. Rows carrying only formatting (a row height, an outline level) do not extend the
- * used range, matching how Excel records `<dimension>`, so {@link add} ignores them. A fresh extent
- * holds the `Infinity`/`-Infinity` sentinels; {@link isEmpty} reports that no used cell has been seen.
- */
-export declare class Extent {
-    top: number;
-    left: number;
-    bottom: number;
-    right: number;
-    constructor(seed?: Extent);
-    /** Whether no used cell has been folded in yet, in which case the dimension is the lone cell `A1`. */
-    get isEmpty(): boolean;
-    /** Fold a rendered row's used-column span into the extent. `minCol` is `Infinity` when the row
-     * carried no cells (only formatting), which extends nothing. */
-    add(row: number, minCol: number, maxCol: number): void;
-}
-/**
- * A worksheet's eagerly-serialised rows: each row's `<row>` XML tagged with its number (so it merges
- * into ascending order with the sheet's remaining live rows, whatever order it was committed in), plus
- * the used-cell {@link Extent} they span. The buffered pass folds that extent into the sheet's dimension.
- */
-export interface FlushedSheet {
-    readonly rows: ReadonlyArray<{
-        readonly number: number;
-        readonly xml: string;
-    }>;
-    readonly extent: Extent;
-    /**
-     * The deepest row outline level among the flushed rows. Carried across the eviction because
-     * `<sheetFormatPr outlineLevelRow>` is derived from every row on the sheet, and a flushed row's
-     * properties are gone from the model by the time the header is serialised.
-     */
-    readonly maxRowOutlineLevel: number;
-}
 export interface SheetReferences {
     readonly drawingRelId: string | null;
     readonly legacyDrawingRelId: string | null;
@@ -49,38 +13,27 @@ export interface SheetReferences {
     readonly legacyDrawingHFRelId: string | null;
     readonly slicerRelIds: readonly string[];
 }
-export declare function worksheetXml(sheet: Worksheet, tables: readonly TablePlan[], styles: StyleRegistry, references: SheetReferences, hyperlinks: readonly HyperlinkPlan[], sharedStrings: SharedStringTable | null, active: boolean, flushed?: FlushedSheet): string;
 /**
- * A column's style facets are defaults its cells inherit unless they override them; the writer
- * composes each cell's full style up front (cell over row over column, per facet) so a cell that
- * overrides one facet still carries the column's others, rather than silently dropping them. Frozen
- * once by the streaming writer at its first flush so every eagerly-rendered row sees the same defaults.
+ * Everything one worksheet part is rendered from: the sheet itself, the parts of the package plan
+ * that belong to it, and the two registries a sheet pass interns into.
+ *
+ * One object for the reason {@link SheetReferences} is one object, applied to the layer above it: a
+ * run of positional arguments carrying two `readonly …[]`s, two nullable references and a bare
+ * boolean is a run whose order the call site cannot be read against. `active:` is the clearest of
+ * them -- as a positional it needed a comment at the call site to say which boolean it was.
  */
-export declare function buildColumnDefaults(sheet: Worksheet): Map<number, ColumnProperties>;
-/** The whole-sheet context a single row needs to serialise: the column defaults it inherits, the
- * style/string tables it interns into, the shared-formula roles its cells play, and the collapsed
- * outline summaries whose toggle it must stamp. The streaming writer supplies empty shared-formula
- * and collapsed-summary sets, since those are whole-sheet derivations a flushed row cannot join. */
-export interface RowRenderContext {
-    readonly columnDefaults: ReadonlyMap<number, ColumnProperties>;
+export interface WorksheetXmlInputs {
+    readonly sheet: Worksheet;
+    readonly tables: readonly TablePlan[];
     readonly styles: StyleRegistry;
+    readonly references: SheetReferences;
+    readonly hyperlinks: readonly HyperlinkPlan[];
     readonly sharedStrings: SharedStringTable | null;
-    readonly sharedRoles: ReadonlyMap<string, SharedFormulaRole>;
-    readonly collapsedSummaries: ReadonlySet<number>;
+    readonly dateEpoch: DateEpoch;
+    /** Whether this is the workbook's one selected sheet. */
+    readonly active: boolean;
+    /** The rows the streaming writer already serialised and evicted, absent on the buffered path. */
+    readonly flushed?: FlushedSheet | undefined;
 }
-/**
- * Serialise one row to its `<row>` element, or '' when the row has neither data nor its own
- * formatting. Returns the used-column bounds (`Infinity`/`-Infinity` when nothing was rendered) so a
- * caller can fold them into the sheet dimension. Shared by the buffered sheet pass and the streaming
- * writer's eager flush, so both emit byte-identical rows.
- */
-export declare function renderRow(entry: {
-    readonly number: number;
-    readonly cells: readonly Cell[];
-    readonly properties: RowProperties | undefined;
-}, ctx: RowRenderContext): {
-    xml: string;
-    minCol: number;
-    maxCol: number;
-};
-export declare function worksheetRelsXml(tables: readonly TablePlan[], drawing: DrawingPlan | null, comments: CommentPlan | null, threadedComments: ThreadedCommentPlan | null, printerSettings: PrinterSettingsPlan | null, background: BackgroundPlan | null, hyperlinks: readonly HyperlinkPlan[], preservedReferences: readonly PreservedReferencePlan[], pivots: readonly PivotPlan[]): string;
+export declare function worksheetXml(inputs: WorksheetXmlInputs): string;
+export declare function worksheetRelsXml(plan: SheetPlan): string;