@shbernal/ts-xlsx 2.1.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-read.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,6 +1,8 @@
 import { encodeAddress, tryDecodeCellRef } from '../../core/address.js';
 import { MENTION_OFFSET_MAX, } from '../../core/comment-thread.js';
-import { boolStrict, decodeSpreadsheetText, localName, numInteger, parseXml, TextCapture, } from '../../xml/xml-read.js';
+import { decodeSpreadsheetText, numInteger } from '../../xml/xml-attrs.js';
+import { parseXml, TextCapture } from '../../xml/xml-read.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,11 +1,14 @@
 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 { extensionOf, relativePartPath, THEME_PART_PATH } from '../opc/part-paths.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';
 import { SLICER_CACHES_EXT_URI } from './namespaces.js';
+import { APP_PROPS_PART, commentsPart, CORE_PROPS_PART, drawingPart, PERSONS_PART, pivotCacheDefinitionPart, pivotCacheRecordsPart, pivotTablePart, SHARED_STRINGS_PART, STYLES_PART, tablePart, targetFromWorkbook, threadedCommentsPart, WORKBOOK_PART, worksheetPart, } from './part-names.js';
 import { NS, REL } from './relationships.js';
 import { x14Ext } from './x14-ext.js';
 const CT = {
@@ -28,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();
@@ -53,71 +57,78 @@ 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)
-        .map((part) => override(`/${part.path}`, part.contentType));
+        .filter((part) => extensionDefaults.get(extensionOf(part.path))?.contentType !== part.contentType)
+        .map((part) => override(part.path, part.contentType));
     return [
-        override('/xl/workbook.xml', isMacroEnabled(preservedWorkbookRefs) ? CT.macroEnabledWorkbook : CT.workbook),
-        ...Array.from({ length: sheetCount }, (_, i) => override(`/xl/worksheets/sheet${i + 1}.xml`, CT.worksheet)),
-        ...tables.map(({ number }) => override(`/xl/tables/table${number}.xml`, CT.table)),
-        ...drawingNumbers.map((number) => override(`/xl/drawings/drawing${number}.xml`, CT.drawing)),
-        ...commentNumbers.map((number) => override(`/xl/comments${number}.xml`, CT.comments)),
-        ...threadedCommentNumbers.map((number) => override(`/xl/threadedComments/threadedComment${number}.xml`, CT.threadedComments)),
-        ...pivots.map(({ number }) => override(`/xl/pivotTables/pivotTable${number}.xml`, CT.pivotTable)),
-        ...pivots.map(({ number }) => override(`/xl/pivotCache/pivotCacheDefinition${number}.xml`, CT.pivotCacheDefinition)),
-        ...pivots.map(({ number }) => override(`/xl/pivotCache/pivotCacheRecords${number}.xml`, CT.pivotCacheRecords)),
-        override(`/${THEME_PART_PATH}`, CT.theme),
-        override('/xl/styles.xml', CT.styles),
-        ...(hasSharedStrings ? [override('/xl/sharedStrings.xml', CT.sharedStrings)] : []),
-        ...(hasPersons ? [override('/xl/persons/person.xml', CT.person)] : []),
-        override('/docProps/core.xml', CT.core),
-        override('/docProps/app.xml', CT.app),
+        override(WORKBOOK_PART, isMacroEnabled(preservedWorkbookRefs) ? CT.macroEnabledWorkbook : CT.workbook),
+        ...Array.from({ length: sheetCount }, (_, i) => override(worksheetPart(i + 1), CT.worksheet)),
+        ...tables.map(({ number }) => override(tablePart(number), CT.table)),
+        ...drawingNumbers.map((number) => override(drawingPart(number), CT.drawing)),
+        ...commentNumbers.map((number) => override(commentsPart(number), CT.comments)),
+        ...threadedCommentNumbers.map((number) => override(threadedCommentsPart(number), CT.threadedComments)),
+        ...pivots.map(({ number }) => override(pivotTablePart(number), CT.pivotTable)),
+        ...pivots.map(({ number }) => override(pivotCacheDefinitionPart(number), CT.pivotCacheDefinition)),
+        ...pivots.map(({ number }) => override(pivotCacheRecordsPart(number), CT.pivotCacheRecords)),
+        override(THEME_PART_PATH, CT.theme),
+        override(STYLES_PART, CT.styles),
+        ...(hasSharedStrings ? [override(SHARED_STRINGS_PART, CT.sharedStrings)] : []),
+        ...(hasPersons ? [override(PERSONS_PART, CT.person)] : []),
+        override(CORE_PROPS_PART, CT.core),
+        override(APP_PROPS_PART, CT.app),
         ...preservedOverrides,
     ].join('');
 }
-function override(partName, contentType) {
-    return `<Override PartName="${partName}" ContentType="${contentType}"/>`;
+function override(partPath, 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([
-        relationship('rId1', REL.officeDocument, 'xl/workbook.xml'),
-        relationship('rId2', REL.coreProps, 'docProps/core.xml'),
-        relationship('rId3', REL.extProps, 'docProps/app.xml'),
+        relationship('rId1', REL.officeDocument, WORKBOOK_PART),
+        relationship('rId2', REL.coreProps, CORE_PROPS_PART),
+        relationship('rId3', REL.extProps, APP_PROPS_PART),
         ...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>` +
@@ -128,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;
@@ -145,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)
@@ -192,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}>` +
@@ -218,22 +242,23 @@ 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, `worksheets/sheet${i + 1}.xml`)),
-        relationship(`rId${sheetCount + 1}`, REL.styles, 'styles.xml'),
-        relationship(`rId${sheetCount + FIXED_WORKBOOK_REL_COUNT}`, REL.theme, relativePartPath('xl/workbook.xml', THEME_PART_PATH)),
-        ...(hasSharedStrings
-            ? [
-                relationship(`rId${sheetCount + FIXED_WORKBOOK_REL_COUNT + 1}`, REL.sharedStrings, 'sharedStrings.xml'),
-            ]
-            : []),
+        ...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, 'persons/person.xml')]),
-        ...preservedRels.map((ref) => relationship(ref.relId, ref.relType, escapeAttr(relativePartPath('xl/workbook.xml', ref.entryPath)))),
-        ...pivots.map((pivot) => relationship(pivot.workbookRelId, REL.pivotCacheDefinition, `pivotCache/pivotCacheDefinition${pivot.number}.xml`)),
+            : [relationship(personsRelId, REL.person, targetFromWorkbook(PERSONS_PART))]),
+        ...preservedRels.map((ref) => relationship(ref.relId, ref.relType, targetFromWorkbook(ref.entryPath))),
+        ...pivots.map((pivot) => relationship(pivot.workbookRelId, REL.pivotCacheDefinition, targetFromWorkbook(pivotCacheDefinitionPart(pivot.number)))),
     ]);
 }
 export function corePropsXml(properties) {
@@ -247,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 +
@@ -260,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>`;