@shbernal/ts-xlsx 2.1.0 → 3.1.0

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;

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

@@ -1,56 +1,25 @@
-import { decodeRange, encodeAddress } from '../../core/address.js';
-import { DEFAULT_DATE_NUMFMT, dateToSerial } from '../../core/date.js';
-import { mangleFormula } from '../../core/formula.js';
-import { NAMED_STYLE_ID } from '../../core/internal.js';
-import { CELL_STYLE_FACETS, pickStyleFacets } from '../../core/style.js';
-import { detectValueType, isDataTableFormulaValue, isErrorValue, isFormulaValue, isHyperlinkValue, isRichTextValue, isSharedFormulaValue, } from '../../core/value.js';
-import { AuthoringError, InternalError } from '../../errors.js';
-import { assertWritableNumber, escapeAttr, escapeSpreadsheetText, escapeText, numberText, textAttr, textElement, XML_DECLARATION, } from '../../xml/xml.js';
-import { relativePartPath } from '../opc/part-paths.js';
+import { decodeRange, encodeRect } from '../../core/address.js';
+import { pickStyleFacets } from '../../core/style.js';
+import { AuthoringError, InternalError, quoted } from '../../errors.js';
+import { escapeAttr, numberText, XML_DECLARATION } from '../../xml/xml.js';
 import { relationship, relationshipsPart } from '../opc/rels.js';
-import { conditionalFormattingsExtXml, conditionalFormattingsXml } from './conditional-formatting.js';
+import { conditionalFormattingsExtXml, conditionalFormattingsXml, dataBarExtLinks, } from './conditional-formatting.js';
 import { dataValidationsExtXml, dataValidationsXml } from './data-validation.js';
-import { hyperlinksXml } from './hyperlinks.js';
+import { hyperlinksXml, isExternalHyperlink } from './hyperlinks.js';
 import { SLICER_LIST_EXT_URI } from './namespaces.js';
+import { commentsPart, drawingPart, mediaPart, pivotTablePart, printerSettingsPart, tablePart, targetFromWorksheet, threadedCommentsPart, vmlDrawingPart, } from './part-names.js';
 import { NS, REL } from './relationships.js';
-import { richTextRunsXml } from './rich-text.js';
+import { assertWritableLevel, buildColumnDefaults, Extent, outlineAttr, renderRow, rowOpenTag, } from './row-xml.js';
 import { planSharedFormulas } from './shared-formulas.js';
 import { autoFilterXml, headerFooterXml, pageBreaksXml, pageMarginsXml, pageSetupXml, printOptionsXml, sheetProtectionXml, sheetPrXml, sheetViewsXml, } from './sheet-properties.js';
 import { x14Ext } from './x14-ext.js';
-export class Extent {
-    top = Infinity;
-    left = Infinity;
-    bottom = -Infinity;
-    right = -Infinity;
-    constructor(seed) {
-        if (seed) {
-            this.top = seed.top;
-            this.left = seed.left;
-            this.bottom = seed.bottom;
-            this.right = seed.right;
-        }
-    }
-    get isEmpty() {
-        return this.bottom === -Infinity;
-    }
-    add(row, minCol, maxCol) {
-        if (minCol === Infinity)
-            return;
-        if (row < this.top)
-            this.top = row;
-        if (row > this.bottom)
-            this.bottom = row;
-        if (minCol < this.left)
-            this.left = minCol;
-        if (maxCol > this.right)
-            this.right = maxCol;
-    }
-}
-export function worksheetXml(sheet, tables, styles, references, hyperlinks, sharedStrings, active, flushed) {
+export function worksheetXml(inputs) {
+    const { sheet, tables, styles, references, hyperlinks, sharedStrings, dateEpoch, active, flushed } = inputs;
     validateMerges(sheet);
     const columnDefaults = buildColumnDefaults(sheet);
     const sharedRoles = planSharedFormulas(sheet);
-    const rowOutline = scanRowOutline(sheet);
+    const extLinks = dataBarExtLinks(sheet.conditionalFormattings);
+    const rowOutline = scanRowOutline(sheet, flushed);
     const collapsedSummaries = rowOutline.collapsedSummaries;
     const context = {
         columnDefaults,
@@ -58,6 +27,7 @@ export function worksheetXml(sheet, tables, styles, references, hyperlinks, shar
         sharedStrings,
         sharedRoles,
         collapsedSummaries,
+        dateEpoch,
     };
     const liveRows = [];
     const extent = new Extent(flushed?.extent);
@@ -68,11 +38,9 @@ export function worksheetXml(sheet, tables, styles, references, hyperlinks, shar
         liveRows.push({ number: entry.number, xml });
         extent.add(entry.number, minCol, maxCol);
     }
-    const dimensionRef = extent.isEmpty
-        ? 'A1'
-        : `${encodeAddress(extent.left, extent.top)}:${encodeAddress(extent.right, extent.bottom)}`;
+    const dimensionRef = extent.isEmpty ? 'A1' : encodeRect(extent);
     const orderedRows = flushed
-        ? [...flushed.rows, ...liveRows].sort((a, b) => a.number - b.number)
+        ? [...flushed.rows.map((row) => completeCollapsed(row, collapsedSummaries)), ...liveRows].sort((a, b) => a.number - b.number)
         : liveRows;
     const bodyXml = orderedRows.map((row) => row.xml).join('');
     const sheetData = bodyXml === '' ? '<sheetData/>' : `<sheetData>${bodyXml}</sheetData>`;
@@ -83,14 +51,14 @@ export function worksheetXml(sheet, tables, styles, references, hyperlinks, shar
         sheetViewsXml(sheet.view, active) +
         sheetFormatPr(sheet.properties, {
             col: maxColumnOutlineLevel(sheet),
-            row: Math.max(rowOutline.maxLevel, flushed?.maxRowOutlineLevel ?? 0),
+            row: rowOutline.maxLevel,
         }) +
         colsXml(sheet, styles) +
         sheetData +
         sheetProtectionXml(sheet.protection) +
         autoFilterXml(sheet.autoFilter) +
         mergeCellsXml(sheet.merges) +
-        conditionalFormattingsXml(sheet.conditionalFormattings, styles) +
+        conditionalFormattingsXml(sheet.conditionalFormattings, styles, extLinks) +
         dataValidationsXml(sheet.dataValidations) +
         hyperlinksXml(hyperlinks) +
         printOptionsXml(sheet.printOptions) +
@@ -104,57 +72,12 @@ export function worksheetXml(sheet, tables, styles, references, hyperlinks, shar
         refElement('legacyDrawingHF', references.legacyDrawingHFRelId) +
         refElement('picture', references.backgroundRelId) +
         tablePartsXml(tables) +
-        worksheetExtLstXml(sheet, references.slicerRelIds) +
+        worksheetExtLstXml(sheet, references.slicerRelIds, extLinks) +
         '</worksheet>');
 }
-export function buildColumnDefaults(sheet) {
-    const columnDefaults = new Map();
-    for (const { index, properties } of sheet.columns())
-        columnDefaults.set(index, properties ?? {});
-    return columnDefaults;
-}
-export function renderRow(entry, ctx) {
-    const { number, cells, properties } = entry;
-    const rendered = cells.filter((cell) => cell.value !== null || hasOwnStyle(cell));
-    const attrs = rowAttrs(properties, ctx.styles, ctx.collapsedSummaries.has(number));
-    if (rendered.length === 0 && attrs === '')
-        return { xml: '', minCol: Infinity, maxCol: -Infinity };
-    const rowFill = properties?.fill;
-    const cellsXml = rendered
-        .map((cell) => {
-        const style = ctx.styles.styleId(composeCellStyle(cell, rowFill, ctx.columnDefaults.get(cell.col)));
-        return cellXml(cell, style, ctx.sharedRoles.get(cell.address), ctx.sharedStrings);
-    })
-        .join('');
-    let minCol = Infinity;
-    let maxCol = -Infinity;
-    for (const cell of rendered) {
-        if (cell.col < minCol)
-            minCol = cell.col;
-        if (cell.col > maxCol)
-            maxCol = cell.col;
-    }
-    return { xml: `<row r="${number}"${attrs}>${cellsXml}</row>`, minCol, maxCol };
-}
-function composeCellStyle(cell, rowFill, colDef) {
-    const style = {};
-    for (const facet of CELL_STYLE_FACETS)
-        inheritFacet(style, facet, cell, colDef);
-    style.fill = cell.fill ?? rowFill ?? colDef?.fill;
-    style.numFmt = cell.numFmt ?? colDef?.numFmt ?? dateDefaultNumFmt(cell.value);
-    if (cell.quotePrefix !== undefined)
-        style.quotePrefix = cell.quotePrefix;
-    const xfId = cell[NAMED_STYLE_ID];
-    if (xfId !== undefined)
-        style.xfId = xfId;
-    return style;
-}
-function inheritFacet(target, key, cell, colDef) {
-    target[key] = cell[key] ?? colDef?.[key];
-}
-function worksheetExtLstXml(sheet, slicerRelIds) {
+function worksheetExtLstXml(sheet, slicerRelIds, extLinks) {
     const exts = [
-        conditionalFormattingsExtXml(sheet.conditionalFormattings),
+        conditionalFormattingsExtXml(sheet.conditionalFormattings, extLinks),
         dataValidationsExtXml(sheet.dataValidations),
         slicerListExtXml(slicerRelIds),
     ].filter((ext) => ext !== '');
@@ -180,7 +103,7 @@ function validateMerges(sheet) {
                 top <= region.bottom &&
                 bottom >= region.top;
             if (overlaps) {
-                throw new AuthoringError(`merged range ${merge} overlaps table "${table.name}" (${table.range}): Excel forbids a merge inside a table`);
+                throw new AuthoringError(`merged range ${merge} overlaps table ${quoted(table.name)} (${table.range}): Excel forbids a merge inside a table`);
             }
         }
     }
@@ -202,40 +125,41 @@ function tablePartsXml(tables) {
     const parts = tables.map(({ relId }) => `<tablePart r:id="${relId}"/>`).join('');
     return `<tableParts count="${tables.length}">${parts}</tableParts>`;
 }
-export function worksheetRelsXml(tables, drawing, comments, threadedComments, printerSettings, background, hyperlinks, preservedReferences, pivots) {
+export function worksheetRelsXml(plan) {
+    const { tables, drawing, comments, threadedComments, printerSettings, background, hyperlinks, preservedRefs: preservedReferences, pivots, } = plan;
     const rels = [
-        ...tables.map(({ relId, number }) => relationship(relId, REL.table, `../tables/table${number}.xml`)),
-        ...pivots.map((pivot) => relationship(pivot.sheetRelId, REL.pivotTable, `../pivotTables/pivotTable${pivot.number}.xml`)),
+        ...tables.map(({ relId, number }) => relationship(relId, REL.table, targetFromWorksheet(tablePart(number)))),
+        ...pivots.map((pivot) => relationship(pivot.sheetRelId, REL.pivotTable, targetFromWorksheet(pivotTablePart(pivot.number)))),
         ...(drawing === null
             ? []
-            : [relationship(drawing.relId, REL.drawing, `../drawings/drawing${drawing.number}.xml`)]),
+            : [
+                relationship(drawing.relId, REL.drawing, targetFromWorksheet(drawingPart(drawing.number))),
+            ]),
         ...(comments === null
             ? []
             : [
-                relationship(comments.vmlRelId, REL.vmlDrawing, `../drawings/vmlDrawing${comments.number}.vml`),
-                relationship(comments.commentsRelId, REL.comments, `../comments${comments.number}.xml`),
+                relationship(comments.vmlRelId, REL.vmlDrawing, targetFromWorksheet(vmlDrawingPart(comments.number))),
+                relationship(comments.commentsRelId, REL.comments, targetFromWorksheet(commentsPart(comments.number))),
             ]),
         ...(threadedComments === null
             ? []
             : [
-                relationship(threadedComments.relId, REL.threadedComment, `../threadedComments/threadedComment${threadedComments.number}.xml`),
+                relationship(threadedComments.relId, REL.threadedComment, targetFromWorksheet(threadedCommentsPart(threadedComments.number))),
             ]),
         ...(printerSettings === null
             ? []
             : [
-                relationship(printerSettings.relId, REL.printerSettings, `../printerSettings/printerSettings${printerSettings.number}.bin`),
+                relationship(printerSettings.relId, REL.printerSettings, targetFromWorksheet(printerSettingsPart(printerSettings.number))),
             ]),
         ...(background === null
             ? []
             : [
-                relationship(background.relId, REL.image, `../media/image${background.mediaNumber}.${background.extension}`),
+                relationship(background.relId, REL.image, targetFromWorksheet(mediaPart(background.mediaNumber, background.extension))),
             ]),
-        ...preservedReferences.map((reference) => relationship(reference.relId, reference.relType, escapeAttr(relativePartPath('xl/worksheets/sheet1.xml', reference.entryPath)))),
+        ...preservedReferences.map((reference) => relationship(reference.relId, reference.relType, targetFromWorksheet(reference.entryPath))),
         ...hyperlinks
-            .filter((link) => link.relId !== undefined && link.target !== undefined)
-            .map((link) => relationship(link.relId, REL.hyperlink, link.target, {
-            external: true,
-        })),
+            .filter(isExternalHyperlink)
+            .map((link) => relationship(link.relId, REL.hyperlink, link.target, { external: true })),
     ];
     return relationshipsPart(rels);
 }
@@ -252,12 +176,6 @@ function sheetFormatPr(properties, outlineLevel) {
     attrs += outlineAttr('outlineLevelRow', outlineLevel.row);
     return `<sheetFormatPr${attrs}/>`;
 }
-function outlineAttr(name, level) {
-    if (level === undefined)
-        return '';
-    const text = numberText(level);
-    return level > 0 ? ` ${name}="${text}"` : '';
-}
 function maxColumnOutlineLevel(sheet) {
     let max = 0;
     for (const column of sheet.columns())
@@ -310,33 +228,35 @@ function colBody(properties, styles) {
     }
     return meaningful ? attrs : null;
 }
-function rowAttrs(properties, styles, collapsedSummary) {
-    if (properties === undefined)
-        return collapsedSummary ? ' collapsed="1"' : '';
-    let attrs = '';
-    if (properties.height !== undefined)
-        attrs += ` ht="${numberText(properties.height)}" customHeight="1"`;
-    if (properties.hidden)
-        attrs += ' hidden="1"';
-    attrs += outlineAttr('outlineLevel', properties.outlineLevel);
-    if (properties.collapsed || collapsedSummary)
-        attrs += ' collapsed="1"';
-    const style = styles.styleId({ fill: properties.fill });
-    if (style !== 0)
-        attrs += ` s="${style}" customFormat="1"`;
-    return attrs;
+function completeCollapsed(row, collapsedSummaries) {
+    if (!collapsedSummaries.has(row.number) || row.attrs.includes(' collapsed="1"')) {
+        return { number: row.number, xml: row.xml };
+    }
+    const open = rowOpenTag(row.number);
+    if (!row.xml.startsWith(open)) {
+        throw new InternalError(`flushed row ${row.number} does not open with ${quoted(open)}`);
+    }
+    return {
+        number: row.number,
+        xml: `${open} collapsed="1"${row.xml.slice(open.length)}`,
+    };
 }
-function scanRowOutline(sheet) {
+function scanRowOutline(sheet, flushed) {
     const level = new Map();
     const hidden = new Map();
     let maxLevel = 0;
-    for (const { number, properties } of sheet.rows()) {
-        const rowLevel = properties?.outlineLevel ?? 0;
-        assertWritableNumber(rowLevel);
+    const note = (number, rowLevel, rowHidden) => {
+        assertWritableLevel(`row ${number} outlineLevel`, rowLevel);
         level.set(number, rowLevel);
-        hidden.set(number, properties?.hidden ?? false);
+        hidden.set(number, rowHidden);
         if (rowLevel > maxLevel)
             maxLevel = rowLevel;
+    };
+    for (const [number, entry] of flushed?.rowOutline ?? []) {
+        note(number, entry.outlineLevel, entry.hidden);
+    }
+    for (const { number, properties } of sheet.rows()) {
+        note(number, properties?.outlineLevel ?? 0, properties?.hidden ?? false);
     }
     const levelOf = (row) => level.get(row) ?? 0;
     const step = sheet.outline.summaryBelow === false ? 1 : -1;
@@ -345,7 +265,7 @@ function scanRowOutline(sheet) {
         let detail = summary + step;
         let sawDetail = false;
         let allHidden = true;
-        while (levelOf(detail) > summaryLevel) {
+        while (level.get(detail) !== undefined && levelOf(detail) > summaryLevel) {
             sawDetail = true;
             if (!hidden.get(detail))
                 allHidden = false;
@@ -356,106 +276,3 @@ function scanRowOutline(sheet) {
     }
     return { collapsedSummaries, maxLevel };
 }
-function dateDefaultNumFmt(value) {
-    const date = value instanceof Date
-        ? value
-        : (isFormulaValue(value) || isSharedFormulaValue(value)) && value.result instanceof Date
-            ? value.result
-            : undefined;
-    return date !== undefined && !Number.isNaN(date.getTime()) ? DEFAULT_DATE_NUMFMT : undefined;
-}
-function cellXml(cell, style, shared, sharedStrings) {
-    const ref = cell.address;
-    const value = cell.value;
-    const s = style !== 0 ? ` s="${style}"` : '';
-    const formula = cellFormulaXml(ref, s, value, shared);
-    if (formula !== undefined)
-        return formula;
-    if (value instanceof Date) {
-        if (Number.isNaN(value.getTime()))
-            return `<c r="${ref}"${s}/>`;
-        return `<c r="${ref}"${s}><v>${numberText(dateToSerial(value))}</v></c>`;
-    }
-    if (typeof value === 'number') {
-        if (!Number.isFinite(value))
-            return `<c r="${ref}"${s}/>`;
-        return `<c r="${ref}"${s}><v>${numberText(value)}</v></c>`;
-    }
-    if (typeof value === 'boolean') {
-        return `<c r="${ref}"${s} t="b"><v>${value ? 1 : 0}</v></c>`;
-    }
-    if (typeof value === 'string') {
-        if (sharedStrings !== null) {
-            return `<c r="${ref}"${s} t="s"><v>${sharedStrings.intern(value)}</v></c>`;
-        }
-        return `<c r="${ref}"${s} t="inlineStr"><is>${textElement(value)}</is></c>`;
-    }
-    if (isRichTextValue(value)) {
-        if (sharedStrings !== null) {
-            return `<c r="${ref}"${s} t="s"><v>${sharedStrings.intern(value)}</v></c>`;
-        }
-        return `<c r="${ref}"${s} t="inlineStr"><is>${richTextRunsXml(value.richText)}</is></c>`;
-    }
-    if (isHyperlinkValue(value)) {
-        const label = typeof value.text === 'string'
-            ? textElement(value.text)
-            : richTextRunsXml(value.text.richText);
-        return `<c r="${ref}"${s} t="inlineStr"><is>${label}</is></c>`;
-    }
-    if (isErrorValue(value)) {
-        return `<c r="${ref}"${s} t="e"><v>${value.error}</v></c>`;
-    }
-    if (value === null)
-        return `<c r="${ref}"${s}/>`;
-    throw new InternalError(`writing a ${detectValueType(value)} cell value has no arm: every CellValue kind is handled above`);
-}
-function hasOwnStyle(cell) {
-    return (CELL_STYLE_FACETS.some((facet) => cell[facet] !== undefined) ||
-        cell.quotePrefix === true ||
-        cell[NAMED_STYLE_ID] !== undefined);
-}
-function cellFormulaXml(ref, s, value, shared) {
-    if (shared !== undefined) {
-        if (shared.ref !== undefined && isFormulaValue(value)) {
-            const f = `<f t="shared" ref="${shared.ref}" si="${shared.si}">${escapeText(mangleFormula(value.formula))}</f>`;
-            return formulaBodyXml(ref, s, f, value.result);
-        }
-        const result = isSharedFormulaValue(value) ? value.result : undefined;
-        return formulaBodyXml(ref, s, `<f t="shared" si="${shared.si}"/>`, result);
-    }
-    if (isDataTableFormulaValue(value)) {
-        const attrs = `ref="${escapeAttr(value.ref)}"` +
-            ` dt2D="${value.dataTable2D ? 1 : 0}"` +
-            ` dtr="${value.dataTableRow ? 1 : 0}"` +
-            textAttr('r1', value.r1) +
-            textAttr('r2', value.r2);
-        return formulaBodyXml(ref, s, `<f t="dataTable" ${attrs}/>`, value.result);
-    }
-    if (isFormulaValue(value)) {
-        return formulaBodyXml(ref, s, `<f>${escapeText(mangleFormula(value.formula))}</f>`, value.result);
-    }
-    return undefined;
-}
-function formulaBodyXml(ref, s, f, result) {
-    if (result === undefined || (typeof result === 'number' && !Number.isFinite(result))) {
-        return `<c r="${ref}"${s}>${f}</c>`;
-    }
-    if (typeof result === 'number') {
-        return `<c r="${ref}"${s}>${f}<v>${numberText(result)}</v></c>`;
-    }
-    if (typeof result === 'boolean') {
-        return `<c r="${ref}"${s} t="b">${f}<v>${result ? 1 : 0}</v></c>`;
-    }
-    if (typeof result === 'string') {
-        return `<c r="${ref}"${s} t="str">${f}<v>${escapeSpreadsheetText(result)}</v></c>`;
-    }
-    if (isErrorValue(result)) {
-        return `<c r="${ref}"${s} t="e">${f}<v>${result.error}</v></c>`;
-    }
-    if (result instanceof Date) {
-        if (Number.isNaN(result.getTime()))
-            return `<c r="${ref}"${s}>${f}</c>`;
-        return `<c r="${ref}"${s}>${f}<v>${numberText(dateToSerial(result))}</v></c>`;
-    }
-    throw new InternalError('writing a non-primitive formula result has no arm: every FormulaResult kind is handled above');
-}