@svgrid/enterprise 3.0.2 → 3.1.0

package/dist/sheet/xlsx-document.js

@@ -0,0 +1,1849 @@
+import { formatKeyAt } from './format-store.js';
+import { colToLetters, lettersToCol, parseA1 } from './address.js';
+import { emptyOutline, hiddenByOutline, isOutlined, outlineLevel } from './outline.js';
+import { translateFormula } from './refs.js';
+import { isError, typedError } from './ast.js';
+import { listComments, isThreaded } from './comments.js';
+import { isSafeLinkTarget, listLinks, parseLinkTarget } from './links.js';
+import { PROTECTION_PERMISSIONS, newEditRangeId } from './protection.js';
+import { PAPER_SIZES, defaultPageSetup } from './page-setup.js';
+import { cleanIteration, DEFAULT_ITERATION, TEXT_PREFIX } from './workbook.js';
+import { findTableStyle, DEFAULT_TABLE_STYLE, NO_TABLE_STYLE } from './table-styles.js';
+import { drawingPartsFor, objectsFromDrawing, rectOfRef, REL_DRAWING } from './xlsx-drawing.js';
+import { objectId } from './objects.js';
+import { sparklineLines, sparklineId } from './sparklines.js';
+import { autoFilterXlsx, filteredRows, filtersFromXlsx } from './filter-files.js';
+// ---------------------------------------------------------------------------
+// Shared pieces
+// ---------------------------------------------------------------------------
+const XML_ESCAPE = { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&apos;' };
+// eslint-disable-next-line no-control-regex
+const INVALID_XML = /[\x00-\x08\x0B\x0C\x0E-\x1F]/g;
+const esc = (s) => s.replace(INVALID_XML, '').replace(/[&<>"']/g, (c) => XML_ESCAPE[c]);
+const NS_MAIN = 'http://schemas.openxmlformats.org/spreadsheetml/2006/main';
+const NS_REL = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships';
+/** Excel's 2009 extensions, which is where a sparkline lives. */
+const NS_X14 = 'http://schemas.microsoft.com/office/spreadsheetml/2009/9/main';
+const NS_XM = 'http://schemas.microsoft.com/office/excel/2006/main';
+const NS_PKG_REL = 'http://schemas.openxmlformats.org/package/2006/relationships';
+const REL_WORKSHEET = `${NS_REL}/worksheet`;
+const REL_STYLES = `${NS_REL}/styles`;
+const REL_SHARED = `${NS_REL}/sharedStrings`;
+const REL_COMMENTS = `${NS_REL}/comments`;
+const REL_VML = `${NS_REL}/vmlDrawing`;
+const NS_THREADS = 'http://schemas.microsoft.com/office/spreadsheetml/2018/threadedcomments';
+const REL_THREADS = 'http://schemas.microsoft.com/office/2017/10/relationships/threadedComment';
+const REL_PERSONS = 'http://schemas.microsoft.com/office/2017/10/relationships/person';
+const REL_METADATA = `${NS_REL}/sheetMetadata`;
+const REL_HYPERLINK = `${NS_REL}/hyperlink`;
+const REL_TABLE = `${NS_REL}/table`;
+/** What Excel puts in the legacy note of a threaded comment, for readers that predate threads. */
+const THREAD_LEGACY_HEAD = '[Threaded comment]\n\nYour version of Excel allows you to read this threaded comment; however, any edits to it will get removed if the file is opened in a newer version of Excel. Learn more: https://go.microsoft.com/fwlink/?linkid=870924\n\n';
+const XML_HEAD = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n';
+const EXCEL_EPOCH_MS = Date.UTC(1899, 11, 30);
+const DAY_MS = 86400000;
+const ISO_DATE = /^(\d{4})-(\d{2})-(\d{2})$/;
+export const isoToSerial = (iso) => {
+    const m = ISO_DATE.exec(iso);
+    if (!m)
+        return null;
+    return Math.round((Date.UTC(Number(m[1]), Number(m[2]) - 1, Number(m[3])) - EXCEL_EPOCH_MS) / DAY_MS);
+};
+export const serialToIso = (serial) => new Date(EXCEL_EPOCH_MS + Math.round(serial) * DAY_MS).toISOString().slice(0, 10);
+/** `#rrggbb` (or a bare rrggbb) as OOXML ARGB; null for any other colour. */
+function argb(colour) {
+    if (!colour)
+        return null;
+    const m = /^#?([0-9a-f]{6})$/i.exec(colour.trim());
+    if (m)
+        return `FF${m[1].toUpperCase()}`;
+    const short = /^#([0-9a-f]{3})$/i.exec(colour.trim());
+    if (short)
+        return `FF${short[1].split('').map((c) => c + c).join('').toUpperCase()}`;
+    return null;
+}
+const fromArgb = (rgb) => rgb && /^[0-9a-f]{8}$/i.test(rgb) ? `#${rgb.slice(2).toLowerCase()}` : rgb && /^[0-9a-f]{6}$/i.test(rgb) ? `#${rgb.toLowerCase()}` : undefined;
+/** Excel's built-in number formats, the ones a file names by id alone. */
+export const BUILTIN_NUMFMT = {
+    0: 'General', 1: '0', 2: '0.00', 3: '#,##0', 4: '#,##0.00', 9: '0%', 10: '0.00%', 11: '0.00E+00', 12: '# ?/?', 13: '# ??/??',
+    14: 'm/d/yyyy', 15: 'd-mmm-yy', 16: 'd-mmm', 17: 'mmm-yy', 18: 'h:mm AM/PM', 19: 'h:mm:ss AM/PM', 20: 'h:mm', 21: 'h:mm:ss',
+    22: 'm/d/yyyy h:mm', 37: '#,##0 ;(#,##0)', 38: '#,##0 ;[Red](#,##0)', 39: '#,##0.00;(#,##0.00)', 40: '#,##0.00;[Red](#,##0.00)',
+    45: 'mm:ss', 46: '[h]:mm:ss', 47: 'mmss.0', 48: '##0.0E+0', 49: '@',
+};
+/** Is this a date pattern: date tokens outside quotes, no digit placeholders. */
+export function isDateFormat(fmt) {
+    if (!fmt)
+        return false;
+    const bare = fmt.replace(/"[^"]*"/g, '').replace(/\[[^\]]*\]/g, '');
+    return /[ymd]/i.test(bare) && !/[#0?]/.test(bare) && !/^General$/i.test(fmt);
+}
+/**
+ * A date format that shows a day (a year, month or day token), as against
+ * a time alone. The reader turns a whole serial under one of these into the
+ * sheet's yyyy-mm-dd text; under h:mm the fraction stays a number, which
+ * the sheet shows as the time it is.
+ */
+export function isDayFormat(fmt) {
+    if (!isDateFormat(fmt))
+        return false;
+    const bare = fmt.replace(/"[^"]*"/g, '').replace(/\[[^\]]*\]/g, '');
+    if (/[yd]/i.test(bare))
+        return true;
+    // An m beside an h or an s is minutes; any other is a month.
+    return /m/i.test(bare.replace(/h+:m+|m+:s+/gi, ''));
+}
+/** `$A$1:$D$10`, the way a print name spells a rectangle. */
+const absRef = ([r1, c1, r2, c2]) => `$${colToLetters(c1)}$${r1 + 1}:$${colToLetters(c2)}$${r2 + 1}`;
+const rectRef = ([r1, c1, r2, c2]) => r1 === r2 && c1 === c2 ? `${colToLetters(c1)}${r1 + 1}` : `${colToLetters(c1)}${r1 + 1}:${colToLetters(c2)}${r2 + 1}`;
+function refRect(ref) {
+    const [a, b] = ref.split(':');
+    const from = parseA1(a ?? '');
+    if (!from || from.row === null)
+        return null;
+    const to = b ? parseA1(b) : from;
+    if (!to || to.row === null)
+        return null;
+    return [Math.min(from.row, to.row), Math.min(from.col, to.col), Math.max(from.row, to.row), Math.max(from.col, to.col)];
+}
+const sqrefRects = (sqref) => sqref.split(/\s+/).map(refRect).filter((r) => r !== null);
+/** Excel column width units from pixels, and back. Excel's unit is the
+ *  width of a digit in the default font, close to seven pixels. */
+export const pxToWidth = (px) => Math.max(0, Math.round((px / 7) * 100) / 100);
+export const widthToPx = (w) => Math.round(w * 7);
+export const pxToPt = (px) => Math.round(px * 0.75 * 100) / 100;
+export const ptToPx = (pt) => Math.round(pt / 0.75);
+const formatKey = formatKeyAt;
+function splitFormatKey(key) {
+    const gap = key.indexOf(' ');
+    if (gap < 0)
+        return null;
+    const rowId = decodeURIComponent(key.slice(0, gap));
+    const columnId = decodeURIComponent(key.slice(gap + 1));
+    const row = Number(rowId.slice(1));
+    const col = lettersToCol(columnId);
+    return rowId.startsWith('r') && Number.isInteger(row) && col >= 0 ? { row, col } : null;
+}
+// ---------------------------------------------------------------------------
+// Writer
+// ---------------------------------------------------------------------------
+/** The styles part: fonts, fills, borders and cell xfs deduplicated, and
+ *  the differential formats (dxf) conditional formatting points at. */
+function styleRegistry() {
+    const numFmts = new Map();
+    let nextNumFmt = 164;
+    const numFmtId = (code) => {
+        if (!code || /^General$/i.test(code))
+            return 0;
+        const known = Object.entries(BUILTIN_NUMFMT).find(([, c]) => c === code);
+        if (known)
+            return Number(known[0]);
+        let id = numFmts.get(code);
+        if (id === undefined) {
+            id = nextNumFmt++;
+            numFmts.set(code, id);
+        }
+        return id;
+    };
+    const fonts = ['<font><sz val="11"/><name val="Calibri"/></font>'];
+    const fontIds = new Map([[fonts[0], 0]]);
+    const fontXml = (e) => {
+        const colour = argb(e.color);
+        return '<font>'
+            + (e.bold ? '<b/>' : '') + (e.italic ? '<i/>' : '') + (e.underline ? '<u/>' : '') + (e.strike ? '<strike/>' : '')
+            + `<sz val="${e.fontSize ? Math.round(e.fontSize * 0.75 * 100) / 100 : 11}"/>`
+            + (colour ? `<color rgb="${colour}"/>` : '')
+            + `<name val="${esc(e.fontFamily || 'Calibri')}"/>`
+            + '</font>';
+    };
+    const fills = ['<fill><patternFill patternType="none"/></fill>', '<fill><patternFill patternType="gray125"/></fill>'];
+    const fillIds = new Map();
+    const fillId = (colour) => {
+        const c = argb(colour);
+        if (!c)
+            return 0;
+        let id = fillIds.get(c);
+        if (id === undefined) {
+            id = fills.length;
+            fills.push(`<fill><patternFill patternType="solid"><fgColor rgb="${c}"/><bgColor indexed="64"/></patternFill></fill>`);
+            fillIds.set(c, id);
+        }
+        return id;
+    };
+    const borders = ['<border><left/><right/><top/><bottom/><diagonal/></border>'];
+    const borderIds = new Map([[borders[0], 0]]);
+    const side = (name, spec) => {
+        if (!spec)
+            return `<${name}/>`;
+        const style = spec.style === 'dashed' ? 'dashed' : spec.style === 'dotted' ? 'dotted' : spec.style === 'double' ? 'double' : (spec.width ?? 2) >= 3 ? 'thick' : (spec.width ?? 2) >= 2 ? 'medium' : 'thin';
+        const colour = argb(spec.color);
+        return `<${name} style="${style}">${colour ? `<color rgb="${colour}"/>` : ''}</${name}>`;
+    };
+    const borderXml = (b) => b ? `<border>${side('left', b.left)}${side('right', b.right)}${side('top', b.top)}${side('bottom', b.bottom)}<diagonal/></border>` : borders[0];
+    const intern = (list, ids, xml) => {
+        let id = ids.get(xml);
+        if (id === undefined) {
+            id = list.length;
+            list.push(xml);
+            ids.set(xml, id);
+        }
+        return id;
+    };
+    const xfs = ['<xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0"/>'];
+    const xfIds = new Map([[xfs[0], 0]]);
+    const xfId = (e) => {
+        const nf = numFmtId(e.numFmt);
+        const font = intern(fonts, fontIds, fontXml(e));
+        const fill = fillId(e.fill);
+        const border = intern(borders, borderIds, borderXml(e.border));
+        const alignParts = [];
+        if (e.align)
+            alignParts.push(`horizontal="${e.align}"`);
+        if (e.valign)
+            alignParts.push(`vertical="${e.valign}"`);
+        if (e.wrap)
+            alignParts.push('wrapText="1"');
+        if (e.indent)
+            alignParts.push(`indent="${e.indent}"`);
+        const align = alignParts.length ? `<alignment ${alignParts.join(' ')}/>` : '';
+        const protection = e.locked === false ? '<protection locked="0"/>' : '';
+        if (!nf && !font && !fill && !border && !align && !protection)
+            return 0;
+        const xml = `<xf numFmtId="${nf}" fontId="${font}" fillId="${fill}" borderId="${border}" xfId="0"`
+            + (nf ? ' applyNumberFormat="1"' : '') + (font ? ' applyFont="1"' : '') + (fill ? ' applyFill="1"' : '')
+            + (border ? ' applyBorder="1"' : '') + (align ? ' applyAlignment="1"' : '') + (protection ? ' applyProtection="1"' : '')
+            + `>${align}${protection}</xf>`;
+        return intern(xfs, xfIds, xml);
+    };
+    const dxfs = [];
+    const dxfId = (style) => {
+        const colour = argb(style.color);
+        const fill = argb(style.fill);
+        const font = style.bold || style.italic || style.underline || style.strike || colour
+            ? `<font>${style.bold ? '<b/>' : ''}${style.italic ? '<i/>' : ''}${style.underline ? '<u/>' : ''}${style.strike ? '<strike/>' : ''}${colour ? `<color rgb="${colour}"/>` : ''}</font>`
+            : '';
+        const nf = style.numFmt ? `<numFmt numFmtId="${numFmtId(style.numFmt)}" formatCode="${esc(style.numFmt)}"/>` : '';
+        const fillXml = fill ? `<fill><patternFill><bgColor rgb="${fill}"/></patternFill></fill>` : '';
+        dxfs.push(`<dxf>${font}${nf}${fillXml}</dxf>`);
+        return dxfs.length - 1;
+    };
+    const build = () => XML_HEAD + `<styleSheet xmlns="${NS_MAIN}">`
+        + (numFmts.size ? `<numFmts count="${numFmts.size}">${[...numFmts].map(([code, id]) => `<numFmt numFmtId="${id}" formatCode="${esc(code)}"/>`).join('')}</numFmts>` : '')
+        + `<fonts count="${fonts.length}">${fonts.join('')}</fonts>`
+        + `<fills count="${fills.length}">${fills.join('')}</fills>`
+        + `<borders count="${borders.length}">${borders.join('')}</borders>`
+        + '<cellStyleXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0"/></cellStyleXfs>'
+        + `<cellXfs count="${xfs.length}">${xfs.join('')}</cellXfs>`
+        + '<cellStyles count="1"><cellStyle name="Normal" xfId="0" builtinId="0"/></cellStyles>'
+        + `<dxfs count="${dxfs.length}">${dxfs.join('')}</dxfs>`
+        + '</styleSheet>';
+    return { xfId, dxfId, build };
+}
+/** A string cell's text as the workbook stores it. Text that would be read
+ *  back as a number, a date, a boolean or a formula takes Excel's apostrophe,
+ *  which says "this is text" and is not part of the value. */
+export function asText(text) {
+    if (text === '')
+        return '';
+    const upper = text.trim().toUpperCase();
+    const numberish = text.trim() !== '' && Number.isFinite(Number(text));
+    const plain = !numberish && upper !== 'TRUE' && upper !== 'FALSE'
+        && isoToSerial(text.trim()) === null
+        && !text.startsWith('=') && !text.startsWith("'") && !typedError(text.trim());
+    return plain ? text : `'${text}`;
+}
+/** A cell's `<c>` element: a formula with its cached value, or a literal. */
+function cellXml(ref, raw, value, s, spill, inTable) {
+    const sAttr = s ? ` s="${s}"` : '';
+    const text = raw.trim();
+    if (text === '' && spill === 'covered') {
+        // A cell a dynamic array spills into: the value Excel caches there, no formula.
+        if (isError(value))
+            return `<c r="${ref}"${sAttr} t="e"><v>${esc(value.error)}</v></c>`;
+        if (typeof value === 'boolean')
+            return `<c r="${ref}"${sAttr} t="b"><v>${value ? 1 : 0}</v></c>`;
+        if (typeof value === 'number')
+            return `<c r="${ref}"${sAttr}><v>${Number.isFinite(value) ? value : 0}</v></c>`;
+        if (value === '')
+            return s ? `<c r="${ref}"${sAttr}/>` : '';
+        return `<c r="${ref}"${sAttr} t="str"><v>${esc(String(value))}</v></c>`;
+    }
+    if (text === '')
+        return s ? `<c r="${ref}"${sAttr}/>` : '';
+    if (text.startsWith('=')) {
+        // A dynamic array formula is an array formula over its spill with the
+        // metadata flag (`cm`) that tells Excel it spills rather than being an
+        // old-style CSE array.
+        const body = esc(xlsxFormula(text.slice(1), inTable));
+        const f = spill && spill !== 'covered' ? `<f t="array" ref="${spill.ref}">${body}</f>` : `<f>${body}</f>`;
+        const cm = spill && spill !== 'covered' ? ' cm="1"' : '';
+        if (isError(value))
+            return `<c r="${ref}"${sAttr}${cm} t="e">${f}<v>${esc(value.error)}</v></c>`;
+        if (typeof value === 'boolean')
+            return `<c r="${ref}"${sAttr}${cm} t="b">${f}<v>${value ? 1 : 0}</v></c>`;
+        if (typeof value === 'number')
+            return `<c r="${ref}"${sAttr}${cm}>${f}<v>${Number.isFinite(value) ? value : 0}</v></c>`;
+        return `<c r="${ref}"${sAttr}${cm} t="str">${f}<v>${esc(String(value))}</v></c>`;
+    }
+    // Excel's text prefix is not part of the value: '007 is written as the
+    // string 007, which is what the file carries and what Excel shows.
+    if (text.startsWith("'")) {
+        return `<c r="${ref}"${sAttr} t="inlineStr"><is><t xml:space="preserve">${esc(text.slice(1))}</t></is></c>`;
+    }
+    // A typed error code IS the error, as it is in Excel, so it goes out as
+    // one rather than as the text that spells it.
+    if (isError(value) && text.startsWith('#'))
+        return `<c r="${ref}"${sAttr} t="e"><v>${esc(value.error)}</v></c>`;
+    const serial = isoToSerial(text);
+    if (serial !== null)
+        return `<c r="${ref}"${sAttr}><v>${serial}</v></c>`;
+    // A number under a date or time format is a serial to Excel, which shows
+    // it through the format: 0.4375 under h:mm is 10:30 there as here.
+    if (typeof value === 'number')
+        return `<c r="${ref}"${sAttr}><v>${value}</v></c>`;
+    if (typeof value === 'boolean')
+        return `<c r="${ref}"${sAttr} t="b"><v>${value ? 1 : 0}</v></c>`;
+    return `<c r="${ref}"${sAttr} t="inlineStr"><is><t xml:space="preserve">${esc(text)}</t></is></c>`;
+}
+/** A bound or source as the file spells it: no leading `=`, a literal
+ *  string in quotes, a date as its serial. */
+function validationFormula(text, allow) {
+    if (text === undefined || text.trim() === '')
+        return null;
+    const t = text.trim();
+    if (t.startsWith('='))
+        return t.slice(1);
+    if (allow === 'list')
+        return `"${t.replace(/"/g, '""')}"`;
+    if (allow === 'date') {
+        const serial = isoToSerial(t);
+        if (serial !== null)
+            return String(serial);
+    }
+    if (allow === 'custom')
+        return t;
+    return Number.isFinite(Number(t)) ? t : `"${t.replace(/"/g, '""')}"`;
+}
+const VALIDATION_TYPE = {
+    any: null, whole: 'whole', decimal: 'decimal', list: 'list', date: 'date', textLength: 'textLength', custom: 'custom',
+};
+const VALIDATION_OP = {
+    between: 'between', notBetween: 'notBetween', equal: 'equal', notEqual: 'notEqual',
+    greater: 'greaterThan', less: 'lessThan', greaterOrEqual: 'greaterThanOrEqual', lessOrEqual: 'lessThanOrEqual',
+};
+const CF_OP = {
+    greater: 'greaterThan', less: 'lessThan', between: 'between', notBetween: 'notBetween',
+    equal: 'equal', notEqual: 'notEqual', greaterOrEqual: 'greaterThanOrEqual', lessOrEqual: 'lessThanOrEqual',
+};
+const CF_TEXT = { contains: 'containsText', notContains: 'notContainsText', beginsWith: 'beginsWith', endsWith: 'endsWith' };
+const CF_ICONS = { arrows: '3Arrows', traffic: '3TrafficLights1', flags: '3Flags', symbols: '3Symbols2' };
+function cfFormula(text) {
+    const t = text.trim();
+    if (t.startsWith('='))
+        return t.slice(1);
+    return Number.isFinite(Number(t)) && t !== '' ? t : `"${t.replace(/"/g, '""')}"`;
+}
+/**
+ * One `<cfRule>`, or null when the rule is not one this writer can spell.
+ *
+ * Null rather than a half-written element: a rule from a newer schema, or
+ * one a consumer built by hand with an operator that is not Excel's, used to
+ * put the text `undefined` inside `<conditionalFormatting>`, and a file with
+ * that in it is one Excel offers to repair. Skipping the rule loses a colour;
+ * writing it loses the workbook.
+ */
+function cfRuleXml(rule, priority, dxf, anchor) {
+    const stop = rule.stopIfTrue ? ' stopIfTrue="1"' : '';
+    const styled = 'style' in rule ? ` dxfId="${dxf(rule.style)}"` : '';
+    const open = (attrs) => `<cfRule ${attrs}${styled} priority="${priority}"${stop}>`;
+    switch (rule.kind) {
+        case 'cellIs': {
+            if (!CF_OP[rule.operator])
+                return null;
+            const formulas = `<formula>${esc(cfFormula(rule.value1))}</formula>`
+                + (rule.value2 !== undefined && (rule.operator === 'between' || rule.operator === 'notBetween') ? `<formula>${esc(cfFormula(rule.value2))}</formula>` : '');
+            return `${open(`type="cellIs" operator="${CF_OP[rule.operator]}"`)}${formulas}</cfRule>`;
+        }
+        case 'text': {
+            const type = CF_TEXT[rule.match];
+            if (!type)
+                return null;
+            const quoted = `"${rule.value.replace(/"/g, '""')}"`;
+            const search = `SEARCH(${quoted},${anchor})`;
+            const formula = rule.match === 'contains' ? `NOT(ISERROR(${search}))`
+                : rule.match === 'notContains' ? `ISERROR(${search})`
+                    : rule.match === 'beginsWith' ? `LEFT(${anchor},${rule.value.length})=${quoted}`
+                        : `RIGHT(${anchor},${rule.value.length})=${quoted}`;
+            return `${open(`type="${type}" operator="${type}" text="${esc(rule.value)}"`)}<formula>${esc(formula)}</formula></cfRule>`;
+        }
+        case 'duplicates':
+            return `${open(`type="${rule.unique ? 'uniqueValues' : 'duplicateValues'}"`)}</cfRule>`;
+        case 'topBottom':
+            return `${open(`type="top10" rank="${rule.rank}"${rule.top ? '' : ' bottom="1"'}${rule.percent ? ' percent="1"' : ''}`)}</cfRule>`;
+        case 'average':
+            return `${open(`type="aboveAverage"${rule.above ? '' : ' aboveAverage="0"'}`)}</cfRule>`;
+        case 'formula':
+            return `${open('type="expression"')}<formula>${esc(rule.formula.replace(/^=/, ''))}</formula></cfRule>`;
+        case 'dataBar': {
+            // The negative colour is an extension Excel keeps in x14; the plain
+            // part carries the bar colour, and Excel draws negatives in red by
+            // itself, as this reader assumes when the extension is absent.
+            return `${open('type="dataBar"')}<dataBar><cfvo type="min"/><cfvo type="max"/><color rgb="${argb(rule.color) ?? 'FF638EC6'}"/></dataBar></cfRule>`;
+        }
+        case 'colorScale': {
+            const cfvo = rule.colors.length === 3 ? '<cfvo type="min"/><cfvo type="percentile" val="50"/><cfvo type="max"/>' : '<cfvo type="min"/><cfvo type="max"/>';
+            return `${open('type="colorScale"')}<colorScale>${cfvo}${rule.colors.map((c) => `<color rgb="${argb(c) ?? 'FFFFFFFF'}"/>`).join('')}</colorScale></cfRule>`;
+        }
+        case 'iconSet':
+            return CF_ICONS[rule.set]
+                ? `${open('type="iconSet"')}<iconSet iconSet="${CF_ICONS[rule.set]}"><cfvo type="percent" val="0"/><cfvo type="percent" val="33"/><cfvo type="percent" val="67"/></iconSet></cfRule>`
+                : null;
+        default:
+            // A kind this writer does not know: better no rule than a broken file.
+            return null;
+    }
+}
+/** A stable id in the GUID spelling the threaded parts want. */
+function guid(group, n) {
+    return `{${group.toString(16).padStart(8, '0')}-0000-0000-0000-${n.toString(16).padStart(12, '0')}}`.toUpperCase();
+}
+/** An ISO time as Excel spells `dT`: UTC to hundredths, no zone. */
+function threadTime(at) {
+    const ms = at ? Date.parse(at) : NaN;
+    const d = Number.isFinite(ms) ? new Date(ms) : new Date(0);
+    return d.toISOString().replace(/\.(\d{2})\dZ$/, '.$1');
+}
+/** The legacy VML part a comment needs before Excel will show it. */
+function vmlXml(comments) {
+    const shapes = comments.map(({ row, col }, i) => `<v:shape id="_x0000_s${1025 + i}" type="#_x0000_t202" style="position:absolute;margin-left:80pt;margin-top:${Math.max(0, row - 1) * 15}pt;width:108pt;height:60pt;z-index:${i + 1};visibility:hidden" fillcolor="#ffffe1" o:insetmode="auto">`
+        + '<v:fill color2="#ffffe1"/><v:shadow on="t" color="black" obscured="t"/><v:path o:connecttype="none"/><v:textbox style="mso-direction-alt:auto"/>'
+        + `<x:ClientData ObjectType="Note"><x:MoveWithCells/><x:SizeWithCells/><x:Anchor>${col + 1}, 15, ${Math.max(0, row - 1)}, 2, ${col + 3}, 15, ${row + 3}, 16</x:Anchor><x:AutoFill>False</x:AutoFill><x:Row>${row}</x:Row><x:Column>${col}</x:Column></x:ClientData>`
+        + '</v:shape>').join('');
+    return '<xml xmlns:v="urn:schemas-microsoft-com:vml" xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:x="urn:schemas-microsoft-com:office:excel">'
+        + '<o:shapelayout v:ext="edit"><o:idmap v:ext="edit" data="1"/></o:shapelayout>'
+        + '<v:shapetype id="_x0000_t202" coordsize="21600,21600" o:spt="202" path="m,l,21600r21600,l21600,xe"><v:stroke joinstyle="miter"/><v:path gradientshapeok="t" o:connecttype="rect"/></v:shapetype>'
+        + shapes + '</xml>';
+}
+/**
+ * The package parts of an .xlsx holding the whole document, keyed by path,
+ * ready to zip. Pure: nothing here touches the DOM or the network.
+ */
+export function documentToXlsxParts(doc) {
+    const wb = doc.workbook;
+    const styles = styleRegistry();
+    const parts = {};
+    const overrides = [];
+    let hasVml = false;
+    /** Table parts are numbered across the workbook, not per sheet. */
+    let tableCount = 0;
+    /** Drawings, charts and media are numbered across the workbook too. */
+    let drawingCount = 0;
+    let chartCount = 0;
+    let mediaCount = 0;
+    /** The extensions the media written needs declared in [Content_Types]. */
+    const mediaExtensions = new Set();
+    let hasSpills = false;
+    // The people a thread names, one part for the workbook; an entry
+    // without an author is a person with no name.
+    const persons = [];
+    /** Excel's own names for the print area and the title rows, one per sheet that has them. */
+    const printNames = [];
+    const personId = (name) => { let i = persons.indexOf(name); if (i < 0) {
+        i = persons.length;
+        persons.push(name);
+    } return guid(0, i + 1); };
+    const sheetEntries = wb.sheets.map((name, index) => {
+        const n = index + 1;
+        const state = doc.get(name);
+        const formats = state.formats.serialize();
+        const byCell = new Map();
+        for (const [key, entry] of Object.entries(formats)) {
+            const at = splitFormatKey(key);
+            if (at)
+                byCell.set(`${at.row},${at.col}`, entry);
+        }
+        const rows = wb.rowCount(name);
+        const cols = wb.colCount(name);
+        let maxRow = rows - 1;
+        let maxCol = cols - 1;
+        for (const key of byCell.keys()) {
+            const [r, c] = key.split(',').map(Number);
+            maxRow = Math.max(maxRow, r);
+            maxCol = Math.max(maxCol, c);
+        }
+        for (const r of state.heights.keys())
+            maxRow = Math.max(maxRow, r);
+        for (const r of state.hidden.rows)
+            maxRow = Math.max(maxRow, r);
+        // Dynamic arrays: the anchors with their rectangles, and every cell they cover.
+        const spillAt = new Map();
+        for (const spill of wb.spills(name)) {
+            const [r1, c1, r2, c2] = spill.rect;
+            spillAt.set(`${spill.row},${spill.col}`, { ref: rectRef([r1, c1, r2, c2]) });
+            for (let r = r1; r <= r2; r += 1)
+                for (let c = c1; c <= c2; c += 1)
+                    if (r !== spill.row || c !== spill.col)
+                        spillAt.set(`${r},${c}`, 'covered');
+            maxRow = Math.max(maxRow, r2);
+            maxCol = Math.max(maxCol, c2);
+        }
+        if (spillAt.size)
+            hasSpills = true;
+        // <cols>: widths and hidden columns, one element per column that differs.
+        const colXml = [];
+        const widthCols = new Set();
+        for (const letter of Object.keys(state.widths)) {
+            const c = lettersToCol(letter);
+            if (c >= 0)
+                widthCols.add(c);
+        }
+        for (const c of state.hidden.cols)
+            widthCols.add(c);
+        const colOutline = state.outline?.cols ?? emptyOutline();
+        const colFolded = hiddenByOutline(colOutline, OUTLINE_SIDE);
+        for (const c of Object.keys(colOutline.levels))
+            widthCols.add(Number(c));
+        for (const c of colOutline.collapsed)
+            widthCols.add(c);
+        for (const c of colFolded)
+            widthCols.add(c);
+        for (const c of [...widthCols].sort((a, b) => a - b)) {
+            const px = state.widths[colToLetters(c)];
+            const hidden = state.hidden.cols.has(c) || colFolded.has(c);
+            const level = outlineLevel(colOutline, c);
+            const collapsed = colOutline.collapsed.includes(c);
+            colXml.push(`<col min="${c + 1}" max="${c + 1}"${px !== undefined ? ` width="${pxToWidth(px)}" customWidth="1"` : ' width="12.5"'}${hidden ? ' hidden="1"' : ''}${level > 0 ? ` outlineLevel="${level}"` : ''}${collapsed ? ' collapsed="1"' : ''}/>`);
+        }
+        // <sheetData>. The rows the AutoFilter folds away go out hidden, as
+        // Excel writes them, so the file opens in the same view; the criteria
+        // beside the region are what lets Clear Filter bring them back.
+        const filtered = filteredRows(doc, name);
+        const rowOutline = state.outline?.rows ?? emptyOutline();
+        const rowFolded = hiddenByOutline(rowOutline, OUTLINE_SIDE);
+        const rowXml = [];
+        for (let r = 0; r <= Math.max(maxRow, ...filtered); r += 1) {
+            const cells = [];
+            for (let c = 0; c <= maxCol; c += 1) {
+                const raw = wb.getRaw(name, r, c);
+                const entry = byCell.get(`${r},${c}`);
+                const spill = spillAt.get(`${r},${c}`);
+                if (raw === '' && !entry && !spill)
+                    continue;
+                // A date is stored here as its ISO text and goes out as the number
+                // Excel counts. Without a date format on the cell that number is all
+                // Excel has: it shows 46204, and reading the file back hands back
+                // 46204 rather than the date. So a date cell that carries no format
+                // of its own is given Excel's own.
+                const dated = !raw.startsWith(TEXT_PREFIX) && isoToSerial(raw.trim()) !== null && !isDateFormat(entry?.numFmt);
+                const look = dated ? { ...(entry ?? {}), numFmt: BUILTIN_NUMFMT[14] } : entry;
+                const s = look ? styles.xfId(look) : 0;
+                const xml = cellXml(`${colToLetters(c)}${r + 1}`, raw, raw.trim() === '' && !spill ? '' : wb.getValue(name, r, c), s, spill, wb.tables.at(name, r, c)?.name);
+                if (xml)
+                    cells.push(xml);
+            }
+            const height = state.heights.get(r);
+            const hidden = state.hidden.rows.has(r) || filtered.has(r) || rowFolded.has(r);
+            const level = outlineLevel(rowOutline, r);
+            const collapsed = rowOutline.collapsed.includes(r);
+            if (!cells.length && height === undefined && !hidden && level === 0 && !collapsed)
+                continue;
+            rowXml.push(`<row r="${r + 1}"${height !== undefined ? ` ht="${pxToPt(height)}" customHeight="1"` : ''}${hidden ? ' hidden="1"' : ''}${level > 0 ? ` outlineLevel="${level}"` : ''}${collapsed ? ' collapsed="1"' : ''}>${cells.join('')}</row>`);
+        }
+        // Frozen panes.
+        const { rows: fr, cols: fc } = state.freeze;
+        let sheetView = `<sheetView workbookViewId="0"${wb.active === name ? ' tabSelected="1"' : ''}/>`;
+        if (fr > 0 || fc > 0) {
+            const topLeft = `${colToLetters(fc)}${fr + 1}`;
+            const pane = fc > 0 && fr > 0 ? 'bottomRight' : fc > 0 ? 'topRight' : 'bottomLeft';
+            sheetView = `<sheetView workbookViewId="0"${wb.active === name ? ' tabSelected="1"' : ''}>`
+                + `<pane${fc > 0 ? ` xSplit="${fc}"` : ''}${fr > 0 ? ` ySplit="${fr}"` : ''} topLeftCell="${topLeft}" activePane="${pane}" state="frozen"/>`
+                + `<selection pane="${pane}" activeCell="${topLeft}" sqref="${topLeft}"/></sheetView>`;
+        }
+        // The allow list is spelled the file's way round: an attribute is
+        // "locked", so an allowed kind is written as 0 and the rest left to
+        // their default of 1.
+        const allowed = PROTECTION_PERMISSIONS.filter((key) => state.protection.allow[key]).map((key) => ` ${key}="0"`).join('');
+        const protection = state.protected ? `<sheetProtection sheet="1" objects="1" scenarios="1"${allowed}/>` : '';
+        const editRanges = state.protection.ranges.length
+            ? `<protectedRanges>${state.protection.ranges.map((range) => `<protectedRange sqref="${range.rects.map(rectRef).join(' ')}" name="${esc(range.title)}"/>`).join('')}</protectedRanges>`
+            : '';
+        const autoFilter = autoFilterXlsx(doc, name);
+        const merges = state.merges.length
+            ? `<mergeCells count="${state.merges.length}">${state.merges.map((m) => `<mergeCell ref="${rectRef(m)}"/>`).join('')}</mergeCells>`
+            : '';
+        const cf = state.conditionalFormats.map((rule, i) => {
+            if (!rule.rects.length)
+                return '';
+            const anchor = `${colToLetters(rule.rects[0]?.[1] ?? 0)}${(rule.rects[0]?.[0] ?? 0) + 1}`;
+            const body = cfRuleXml(rule, i + 1, styles.dxfId, anchor);
+            // An empty <conditionalFormatting> is as invalid as a broken rule, so
+            // a rule that cannot be written takes its block with it.
+            if (!body)
+                return '';
+            return `<conditionalFormatting sqref="${rule.rects.map(rectRef).join(' ')}">${body}</conditionalFormatting>`;
+        }).join('');
+        const validations = state.validation.filter((rule) => VALIDATION_TYPE[rule.allow] !== null);
+        const dv = validations.length
+            ? `<dataValidations count="${validations.length}">${validations.map((rule) => {
+                const f1 = validationFormula(rule.value1, rule.allow);
+                const f2 = validationFormula(rule.value2, rule.allow);
+                const op = rule.allow === 'list' || rule.allow === 'custom' ? '' : ` operator="${VALIDATION_OP[rule.operator ?? 'between']}"`;
+                const alert = ` errorStyle="${rule.alert.style === 'warning' ? 'warning' : 'stop'}" showErrorMessage="1"`
+                    + (rule.alert.title ? ` errorTitle="${esc(rule.alert.title)}"` : '') + (rule.alert.message ? ` error="${esc(rule.alert.message)}"` : '');
+                const prompt = rule.input
+                    ? ' showInputMessage="1"' + (rule.input.title ? ` promptTitle="${esc(rule.input.title)}"` : '') + (rule.input.message ? ` prompt="${esc(rule.input.message)}"` : '')
+                    : '';
+                const dropdown = rule.allow === 'list' && !rule.inCellDropdown ? ' showDropDown="1"' : '';
+                return `<dataValidation type="${VALIDATION_TYPE[rule.allow]}"${op} allowBlank="${rule.ignoreBlank ? 1 : 0}"${dropdown}${alert}${prompt} sqref="${rule.rects.map(rectRef).join(' ')}">`
+                    + (f1 !== null ? `<formula1>${esc(f1)}</formula1>` : '') + (f2 !== null ? `<formula2>${esc(f2)}</formula2>` : '') + '</dataValidation>';
+            }).join('')}</dataValidations>`
+            : '';
+        // Comments: the legacy part and its VML for every one, and for a
+        // thread the threaded part too, with the legacy text Excel itself
+        // writes for readers that predate threads.
+        const comments = listComments(state.notes);
+        let legacyDrawing = '';
+        /** The sheet's relationships, from the comment parts and the links. */
+        let sheetRels = '';
+        if (comments.length) {
+            hasVml = true;
+            const authors = [''];
+            const authorId = (name) => { let i = authors.indexOf(name); if (i < 0) {
+                i = authors.length;
+                authors.push(name);
+            } return i; };
+            const threaded = comments.filter((c) => isThreaded(c.thread));
+            const threadIds = new Map();
+            const legacy = comments.map((c) => {
+                const ref = `${colToLetters(c.col)}${c.row + 1}`;
+                if (!isThreaded(c.thread))
+                    return `<comment ref="${ref}" authorId="0"><text><t xml:space="preserve">${esc(c.thread.text)}</t></text></comment>`;
+                const id = guid(n, threadIds.size + 1);
+                threadIds.set(ref, id);
+                const text = THREAD_LEGACY_HEAD + `Comment:\n    ${c.thread.text}` + (c.thread.replies ?? []).map((r) => `\nReply:\n    ${r.text}`).join('');
+                return `<comment ref="${ref}" authorId="${authorId(`tc=${id}`)}"><text><t xml:space="preserve">${esc(text)}</t></text></comment>`;
+            }).join('');
+            parts[`xl/comments${n}.xml`] = XML_HEAD + `<comments xmlns="${NS_MAIN}"><authors>${authors.map((a) => `<author>${esc(a)}</author>`).join('')}</authors><commentList>${legacy}</commentList></comments>`;
+            parts[`xl/drawings/vmlDrawing${n}.vml`] = vmlXml(comments);
+            let rels = `<Relationship Id="rId1" Type="${REL_VML}" Target="../drawings/vmlDrawing${n}.vml"/>`
+                + `<Relationship Id="rId2" Type="${REL_COMMENTS}" Target="../comments${n}.xml"/>`;
+            if (threaded.length) {
+                let replyCount = 0;
+                const one = (ref, entry, id, parentId, done) => `<threadedComment ref="${ref}" dT="${threadTime(entry.at)}" personId="${personId(entry.author ?? '')}" id="${id}"${parentId ? ` parentId="${parentId}"` : ''}${done ? ' done="1"' : ''}><text>${esc(entry.text)}</text></threadedComment>`;
+                const xml = threaded.map((c) => {
+                    const ref = `${colToLetters(c.col)}${c.row + 1}`;
+                    const id = threadIds.get(ref);
+                    return one(ref, c.thread, id, null, Boolean(c.thread.resolved))
+                        + (c.thread.replies ?? []).map((r) => one(ref, r, guid(n + 1000, (replyCount += 1)), id, false)).join('');
+                }).join('');
+                parts[`xl/threadedComments/threadedComment${n}.xml`] = XML_HEAD + `<ThreadedComments xmlns="${NS_THREADS}" xmlns:x="${NS_MAIN}">${xml}</ThreadedComments>`;
+                rels += `<Relationship Id="rId3" Type="${REL_THREADS}" Target="../threadedComments/threadedComment${n}.xml"/>`;
+                overrides.push(`<Override PartName="/xl/threadedComments/threadedComment${n}.xml" ContentType="application/vnd.ms-excel.threadedcomments+xml"/>`);
+            }
+            sheetRels = rels;
+            legacyDrawing = '<legacyDrawing r:id="rId1"/>';
+            overrides.push(`<Override PartName="/xl/comments${n}.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml"/>`);
+        }
+        // Hyperlinks. An external one is a relationship with `TargetMode`
+        // External, the way Excel writes it, so the URL lives in the rels part
+        // and the cell carries only its id; an address on this workbook is a
+        // `location` on the element itself and needs no relationship. The ids
+        // start at 4 because the comment parts above take 1 to 3 when they are
+        // there.
+        // Tables: one part each, a relationship from the sheet, and the
+        // `tableParts` list that ties them together. This is what makes Excel
+        // show the block as a table rather than as cells that look like one,
+        // and what makes a structured reference in the file resolve.
+        const sheetTables = (doc.workbook.serialize().tables ?? []).filter((t) => t.sheet.toLowerCase() === name.toLowerCase());
+        let tableParts = '';
+        if (sheetTables.length) {
+            const refs = [];
+            sheetTables.forEach((table, i) => {
+                const id = tableCount + i + 1;
+                const rel = `rIdT${id}`;
+                const last = table.lastRow + (table.hasTotals ? 1 : 0);
+                const ref = `${colToLetters(table.firstCol)}${table.headerRow + 1}:${colToLetters(table.lastCol)}${last + 1}`;
+                const columns = Array.from({ length: table.lastCol - table.firstCol + 1 }, (_, c) => {
+                    const header = (doc.workbook.getRaw(name, table.headerRow, table.firstCol + c) || `Column${c + 1}`).replace(/^=/, '');
+                    return `<tableColumn id="${c + 1}" name="${esc(header)}"/>`;
+                }).join('');
+                parts[`xl/tables/table${id}.xml`] = XML_HEAD
+                    + `<table xmlns="${NS_MAIN}" id="${id}" name="${esc(table.name)}" displayName="${esc(table.name)}" ref="${ref}"`
+                    + ` headerRowCount="1" totalsRowCount="${table.hasTotals ? 1 : 0}">`
+                    + `<autoFilter ref="${colToLetters(table.firstCol)}${table.headerRow + 1}:${colToLetters(table.lastCol)}${table.lastRow + 1}"/>`
+                    + `<tableColumns count="${table.lastCol - table.firstCol + 1}">${columns}</tableColumns>`
+                    // The style by Excel's own name, so the table opens there wearing
+                    // what it wears here. `None` writes no style element at all.
+                    + (table.style === NO_TABLE_STYLE
+                        ? ''
+                        : `<tableStyleInfo name="${esc(findTableStyle(table.style)?.id ?? DEFAULT_TABLE_STYLE)}" showFirstColumn="0" showLastColumn="0" showRowStripes="1" showColumnStripes="0"/>`)
+                    + '</table>';
+                sheetRels += `<Relationship Id="${rel}" Type="${REL_TABLE}" Target="../tables/table${id}.xml"/>`;
+                overrides.push(`<Override PartName="/xl/tables/table${id}.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml"/>`);
+                refs.push(`<tablePart r:id="${rel}"/>`);
+            });
+            tableCount += sheetTables.length;
+            tableParts = `<tableParts count="${refs.length}">${refs.join('')}</tableParts>`;
+        }
+        const links = listLinks(state.links);
+        let hyperlinks = '';
+        if (links.length) {
+            const refs = [];
+            links.forEach(({ row, col, link }, i) => {
+                const ref = `${colToLetters(col)}${row + 1}`;
+                const tip = link.tip ? ` tooltip="${esc(link.tip)}"` : '';
+                const target = parseLinkTarget(link.target);
+                // A target the shell will not follow is not written into the file
+                // either: a workbook that carries one is a workbook that hands it
+                // to whoever opens it next.
+                if (!target)
+                    return;
+                if (target.kind === 'external') {
+                    const id = `rId${4 + i}`;
+                    sheetRels += `<Relationship Id="${id}" Type="${REL_HYPERLINK}" Target="${esc(target.href)}" TargetMode="External"/>`;
+                    refs.push(`<hyperlink ref="${ref}" r:id="${id}"${tip}/>`);
+                }
+                else {
+                    refs.push(`<hyperlink ref="${ref}" location="${esc(link.target)}"${tip}/>`);
+                }
+            });
+            hyperlinks = `<hyperlinks>${refs.join('')}</hyperlinks>`;
+        }
+        // Sparklines, which Excel keeps in the worksheet's extension list
+        // rather than in a part of their own: one group per definition, one
+        // entry per cell, each with the line of numbers it reads.
+        let sparklineExt = '';
+        const groups = state.sparklines ?? [];
+        if (groups.length) {
+            const quotedSheet = /^[A-Za-z_][A-Za-z0-9_.]*$/.test(name) ? name : `'${name.replace(/'/g, "''")}'`;
+            const xml = groups.map((group) => {
+                const lines = sparklineLines(group).map((line) => {
+                    const from = `${colToLetters(line.data[1])}${line.data[0] + 1}`;
+                    const to = `${colToLetters(line.data[3])}${line.data[2] + 1}`;
+                    return `<x14:sparkline><xm:f>${esc(`${quotedSheet}!${from}:${to}`)}</xm:f>`
+                        + `<xm:sqref>${colToLetters(line.col)}${line.row + 1}</xm:sqref></x14:sparkline>`;
+                }).join('');
+                if (!lines)
+                    return '';
+                const type = group.type === 'column' ? ' type="column"' : group.type === 'winloss' ? ' type="stacked"' : '';
+                return `<x14:sparklineGroup${type}${group.sameScale ? ' minAxisType="group" maxAxisType="group"' : ''}${group.markers ? ' markers="1"' : ''} displayEmptyCellsAs="gap">`
+                    + (group.color ? `<x14:colorSeries rgb="${argb(group.color)}"/>` : '')
+                    + (group.negativeColor ? `<x14:colorNegative rgb="${argb(group.negativeColor)}"/>` : '')
+                    + `<x14:sparklines>${lines}</x14:sparklines></x14:sparklineGroup>`;
+            }).join('');
+            if (xml) {
+                sparklineExt = '<extLst><ext uri="{05C60535-1F16-4fd2-B633-F4F36F0B64E0}" xmlns:x14="http://schemas.microsoft.com/office/spreadsheetml/2009/9/main">'
+                    + `<x14:sparklineGroups xmlns:xm="http://schemas.microsoft.com/office/excel/2006/main">${xml}</x14:sparklineGroups>`
+                    + '</ext></extLst>';
+            }
+        }
+        // The objects on this sheet: a picture's bytes in xl/media, a chart's
+        // definition in its own part, both anchored by one drawing part.
+        let drawing = '';
+        const objects = state.objects ?? [];
+        if (objects.length) {
+            drawingCount += 1;
+            const built = drawingPartsFor(objects, {
+                sheet: name,
+                index: drawingCount,
+                chartsSoFar: chartCount,
+                mediaSoFar: mediaCount,
+                valueAt: (row, col) => wb.getValue(name, row, col),
+                textAt: (row, col) => {
+                    const value = wb.getValue(name, row, col);
+                    return isError(value) ? value.error : String(value ?? '');
+                },
+            });
+            if (built.drawingPath) {
+                chartCount += Object.keys(built.parts).filter((path) => path.startsWith('xl/charts/')).length;
+                mediaCount += Object.keys(built.parts).filter((path) => path.startsWith('xl/media/')).length;
+                Object.assign(parts, built.parts);
+                parts[built.drawingPath] = XML_HEAD + built.drawingXml;
+                parts[`xl/drawings/_rels/drawing${drawingCount}.xml.rels`] = XML_HEAD + built.drawingRels;
+                overrides.push(...built.overrides);
+                for (const extension of built.extensions)
+                    mediaExtensions.add(extension);
+                const id = `rIdD${drawingCount}`;
+                sheetRels += `<Relationship Id="${id}" Type="${REL_DRAWING}" Target="../drawings/drawing${drawingCount}.xml"/>`;
+                drawing = `<drawing r:id="${id}"/>`;
+            }
+            else {
+                drawingCount -= 1;
+            }
+        }
+        if (sheetRels) {
+            parts[`xl/worksheets/_rels/sheet${n}.xml.rels`] = XML_HEAD + `<Relationships xmlns="${NS_PKG_REL}">${sheetRels}</Relationships>`;
+        }
+        // Page Layout: what prints and how. `printOptions` only when something is on.
+        const ps = state.pageSetup;
+        const printOptions = ps.gridlines || ps.headings ? `<printOptions${ps.gridlines ? ' gridLines="1"' : ''}${ps.headings ? ' headings="1"' : ''}/>` : '';
+        const m = ps.margins;
+        const pageMargins = `<pageMargins left="${m.left}" right="${m.right}" top="${m.top}" bottom="${m.bottom}" header="${m.header}" footer="${m.footer}"/>`;
+        const pageSetup = `<pageSetup paperSize="${PAPER_SIZES[ps.paper]?.code ?? 9}"${ps.scale !== 100 ? ` scale="${ps.scale}"` : ''} orientation="${ps.orientation}"/>`;
+        const quoted = /^[A-Za-z_][A-Za-z0-9_.]*$/.test(name) ? name : `'${name.replace(/'/g, "''")}'`;
+        if (ps.printArea?.length)
+            printNames.push(`<definedName name="_xlnm.Print_Area" localSheetId="${index}">${esc(ps.printArea.map((r) => `${quoted}!${absRef(r)}`).join(','))}</definedName>`);
+        if (ps.printTitleRows)
+            printNames.push(`<definedName name="_xlnm.Print_Titles" localSheetId="${index}">${esc(`${quoted}!$${ps.printTitleRows[0] + 1}:$${ps.printTitleRows[1] + 1}`)}</definedName>`);
+        parts[`xl/worksheets/sheet${n}.xml`] = XML_HEAD
+            + `<worksheet xmlns="${NS_MAIN}" xmlns:r="${NS_REL}">`
+            + `<sheetViews>${sheetView}</sheetViews><sheetFormatPr defaultRowHeight="15"/>`
+            + (colXml.length ? `<cols>${colXml.join('')}</cols>` : '')
+            + `<sheetData>${rowXml.join('')}</sheetData>`
+            // Order matters in a worksheet: `drawing` comes after the page setup
+            // and before the legacy drawing the comments use.
+            + protection + editRanges + autoFilter + merges + cf + dv + hyperlinks + printOptions + pageMargins + pageSetup + drawing + legacyDrawing + tableParts + sparklineExt
+            + '</worksheet>';
+        overrides.push(`<Override PartName="/xl/worksheets/sheet${n}.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/>`);
+        return { name, n, hidden: state.sheetHidden };
+    });
+    const activeTab = Math.max(0, wb.sheets.indexOf(wb.active));
+    const names = wb.names.list();
+    const iteration = wb.iteration;
+    parts['xl/workbook.xml'] = XML_HEAD
+        + `<workbook xmlns="${NS_MAIN}" xmlns:r="${NS_REL}">`
+        + `<bookViews><workbookView activeTab="${activeTab}"/></bookViews>`
+        + `<sheets>${sheetEntries.map((s) => `<sheet name="${esc(s.name)}" sheetId="${s.n}"${s.hidden ? ' state="hidden"' : ''} r:id="rId${s.n}"/>`).join('')}</sheets>`
+        + (names.length || printNames.length ? `<definedNames>${names.map((d) => `<definedName name="${esc(d.name)}">${esc(d.refersTo.replace(/^=/, ''))}</definedName>`).join('')}${printNames.join('')}</definedNames>` : '')
+        // Iterative calculation, which Excel keeps here rather than per sheet.
+        // Written only when it is on: a file with no calcPr is a file with the
+        // defaults, and that is what an untouched workbook means.
+        + (iteration?.enabled
+            ? `<calcPr calcId="191029" iterate="1" iterateCount="${iteration.maxIterations}" iterateDelta="${iteration.maxChange}"/>`
+            : '')
+        + '</workbook>';
+    parts['xl/_rels/workbook.xml.rels'] = XML_HEAD + `<Relationships xmlns="${NS_PKG_REL}">`
+        + sheetEntries.map((s) => `<Relationship Id="rId${s.n}" Type="${REL_WORKSHEET}" Target="worksheets/sheet${s.n}.xml"/>`).join('')
+        + `<Relationship Id="rId${sheetEntries.length + 1}" Type="${REL_STYLES}" Target="styles.xml"/>`
+        + (persons.length ? `<Relationship Id="rId${sheetEntries.length + 2}" Type="${REL_PERSONS}" Target="persons/person.xml"/>` : '')
+        + (hasSpills ? `<Relationship Id="rId${sheetEntries.length + 3}" Type="${REL_METADATA}" Target="metadata.xml"/>` : '')
+        + '</Relationships>';
+    if (hasSpills) {
+        // The one piece of metadata a dynamic array needs: cell metadata record 1
+        // says "this array formula spills", which is what `cm="1"` points at.
+        parts['xl/metadata.xml'] = XML_HEAD + `<metadata xmlns="${NS_MAIN}" xmlns:xda="http://schemas.microsoft.com/office/spreadsheetml/2017/dynamicarray">`
+            + '<metadataTypes count="1"><metadataType name="XLDAPR" minSupportedVersion="120000" copy="1" pasteAll="1" pasteValues="1" merge="1" splitFirst="1" rowColShift="1" clearFormats="1" clearComments="1" assign="1" coerce="1" cellMeta="1"/></metadataTypes>'
+            + '<futureMetadata name="XLDAPR" count="1"><bk><extLst><ext uri="{bdbb8cdc-fa1e-496e-a857-3c3f30c029c3}"><xda:dynamicArrayProperties fDynamic="1" fCollapsed="0"/></ext></extLst></bk></futureMetadata>'
+            + '<cellMetadata count="1"><bk><rc t="1" v="0"/></bk></cellMetadata></metadata>';
+        overrides.push('<Override PartName="/xl/metadata.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheetMetadata+xml"/>');
+    }
+    if (persons.length) {
+        parts['xl/persons/person.xml'] = XML_HEAD + `<personList xmlns="${NS_THREADS}" xmlns:x="${NS_MAIN}">`
+            + persons.map((name, i) => `<person displayName="${esc(name)}" id="${guid(0, i + 1)}" userId="${esc(name)}" providerId="None"/>`).join('')
+            + '</personList>';
+        overrides.push('<Override PartName="/xl/persons/person.xml" ContentType="application/vnd.ms-excel.person+xml"/>');
+    }
+    parts['xl/styles.xml'] = styles.build();
+    parts['_rels/.rels'] = XML_HEAD + `<Relationships xmlns="${NS_PKG_REL}"><Relationship Id="rId1" Type="${NS_REL}/officeDocument" Target="xl/workbook.xml"/></Relationships>`;
+    parts['[Content_Types].xml'] = XML_HEAD + '<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">'
+        + '<Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>'
+        + '<Default Extension="xml" ContentType="application/xml"/>'
+        + (hasVml ? '<Default Extension="vml" ContentType="application/vnd.openxmlformats-officedocument.vmlDrawing"/>' : '')
+        + [...mediaExtensions].map((extension) => `<Default Extension="${extension}" ContentType="image/${extension === 'jpeg' ? 'jpeg' : extension}"/>`).join('')
+        + '<Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/>'
+        + '<Override PartName="/xl/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"/>'
+        + overrides.join('')
+        + '</Types>';
+    return parts;
+}
+// ---------------------------------------------------------------------------
+// Reader
+// ---------------------------------------------------------------------------
+function parseXml(xml, what) {
+    if (typeof DOMParser === 'undefined')
+        throw new Error(`@svgrid/enterprise: reading an xlsx needs DOMParser, which this environment does not have (${what})`);
+    const doc = new DOMParser().parseFromString(xml.replace(/^/, ''), 'application/xml');
+    if (doc.getElementsByTagName('parsererror').length)
+        throw new Error(`@svgrid/enterprise: ${what} is not well-formed XML`);
+    return doc;
+}
+/** Children by local name, so a namespaced and a bare document read alike. */
+function kids(node, name) {
+    if (!node)
+        return [];
+    const out = [];
+    for (const child of Array.from(node.children))
+        if (child.localName === name)
+            out.push(child);
+    return out;
+}
+const kid = (node, name) => kids(node, name)[0] ?? null;
+const attr = (el, name) => el?.getAttribute(name) ?? null;
+const num = (el, name) => {
+    const v = attr(el, name);
+    if (v === null)
+        return null;
+    const n = Number(v);
+    return Number.isFinite(n) ? n : null;
+};
+const flag = (el, name) => { const v = attr(el, name); return v === '1' || v === 'true'; };
+/** Excel's `dT` (UTC, no zone) as ISO 8601; null when it does not parse. */
+function readThreadTime(dT) {
+    if (!dT)
+        return null;
+    const ms = Date.parse(/[zZ]|[+-]\d\d:\d\d$/.test(dT) ? dT : `${dT}Z`);
+    return Number.isFinite(ms) ? new Date(ms).toISOString() : null;
+}
+/** Every `<t>` under a rich-text element, joined. */
+function textOf(el) {
+    if (!el)
+        return '';
+    let out = '';
+    const walk = (node) => {
+        for (const child of Array.from(node.children)) {
+            if (child.localName === 't')
+                out += child.textContent ?? '';
+            else if (child.localName === 'r' || child.localName === 'rPh')
+                walk(child);
+        }
+    };
+    walk(el);
+    return out;
+}
+/**
+ * A relationship's target EXACTLY as written, for an external hyperlink:
+ * `readRels` resolves a target against the part that holds it, which is
+ * right for a part inside the package and wrong for `https://…`.
+ */
+function rawRelTarget(parts, relsPath, id) {
+    const xml = parts[relsPath];
+    if (!xml)
+        return null;
+    for (const rel of kids(parseXml(xml, relsPath).documentElement, 'Relationship')) {
+        if (rel.getAttribute('Id') === id)
+            return rel.getAttribute('Target');
+    }
+    return null;
+}
+/** Resolve a relationship target against the part that holds the rels. */
+function resolvePath(base, target) {
+    if (target.startsWith('/'))
+        return target.slice(1);
+    const dir = base.split('/').slice(0, -1);
+    for (const piece of target.split('/')) {
+        if (piece === '..')
+            dir.pop();
+        else if (piece !== '.' && piece !== '')
+            dir.push(piece);
+    }
+    return dir.join('/');
+}
+function readRels(parts, relsPath, base) {
+    const out = new Map();
+    const xml = parts[relsPath];
+    if (!xml)
+        return out;
+    for (const rel of kids(parseXml(xml, relsPath).documentElement, 'Relationship')) {
+        const id = attr(rel, 'Id');
+        const type = attr(rel, 'Type');
+        const target = attr(rel, 'Target');
+        if (id && type && target)
+            out.set(id, { type, target: resolvePath(base, target) });
+    }
+    return out;
+}
+function readFontInto(font, into, sizes) {
+    if (!font)
+        return;
+    if (kid(font, 'b'))
+        into.bold = true;
+    if (kid(font, 'i'))
+        into.italic = true;
+    if (kid(font, 'u'))
+        into.underline = true;
+    if (kid(font, 'strike'))
+        into.strike = true;
+    const colour = fromArgb(attr(kid(font, 'color'), 'rgb'));
+    if (colour)
+        into.color = colour;
+    if (sizes) {
+        const entry = into;
+        const sz = num(kid(font, 'sz'), 'val');
+        if (sz !== null && Math.abs(sz - 11) > 0.01)
+            entry.fontSize = Math.round((sz / 0.75) * 100) / 100;
+        const name = attr(kid(font, 'name'), 'val');
+        if (name && name !== 'Calibri')
+            entry.fontFamily = name;
+    }
+}
+function readStyles(xml) {
+    const empty = { xfs: [], dxfs: [], numFmtOf: () => undefined };
+    if (!xml)
+        return empty;
+    const root = parseXml(xml, 'xl/styles.xml').documentElement;
+    const numFmts = new Map();
+    for (const nf of kids(kid(root, 'numFmts'), 'numFmt')) {
+        const id = num(nf, 'numFmtId');
+        const code = attr(nf, 'formatCode');
+        if (id !== null && code)
+            numFmts.set(id, code);
+    }
+    const codeOf = (id) => {
+        if (id === null || id === 0)
+            return undefined;
+        const code = numFmts.get(id) ?? BUILTIN_NUMFMT[id];
+        // LibreOffice writes General as a numbered format of its own. It is the
+        // absence of a format, not a format, and storing it would make every
+        // imported cell look as though someone had chosen one.
+        return code && code.toLowerCase() !== 'general' ? code : undefined;
+    };
+    const fonts = kids(kid(root, 'fonts'), 'font');
+    const fills = kids(kid(root, 'fills'), 'fill').map((fill) => {
+        const pattern = kid(fill, 'patternFill');
+        if (!pattern || attr(pattern, 'patternType') === 'none')
+            return undefined;
+        return fromArgb(attr(kid(pattern, 'fgColor'), 'rgb'));
+    });
+    const borders = kids(kid(root, 'borders'), 'border').map((border) => {
+        const out = {};
+        for (const side of ['left', 'right', 'top', 'bottom']) {
+            const el = kid(border, side);
+            const style = attr(el, 'style');
+            if (!el || !style || style === 'none')
+                continue;
+            const spec = {};
+            if (style === 'dashed' || style === 'mediumDashed' || style === 'dashDot')
+                spec.style = 'dashed';
+            else if (style === 'dotted' || style === 'hair')
+                spec.style = 'dotted';
+            else if (style === 'double')
+                spec.style = 'double';
+            if (style === 'thick')
+                spec.width = 3;
+            else if (style === 'medium' || style.startsWith('medium'))
+                spec.width = 2;
+            else
+                spec.width = 1;
+            const colour = fromArgb(attr(kid(el, 'color'), 'rgb'));
+            if (colour)
+                spec.color = colour;
+            out[side] = spec;
+        }
+        return Object.keys(out).length ? out : undefined;
+    });
+    const xfNumFmt = [];
+    const xfs = kids(kid(root, 'cellXfs'), 'xf').map((xf) => {
+        const entry = {};
+        const nfId = num(xf, 'numFmtId');
+        xfNumFmt.push(nfId);
+        const code = codeOf(nfId);
+        if (code)
+            entry.numFmt = code;
+        readFontInto(fonts[num(xf, 'fontId') ?? 0] ?? null, entry, true);
+        const fill = fills[num(xf, 'fillId') ?? 0];
+        if (fill)
+            entry.fill = fill;
+        const border = borders[num(xf, 'borderId') ?? 0];
+        if (border)
+            entry.border = border;
+        const align = kid(xf, 'alignment');
+        const horizontal = attr(align, 'horizontal');
+        if (horizontal === 'left' || horizontal === 'center' || horizontal === 'right')
+            entry.align = horizontal;
+        const vertical = attr(align, 'vertical');
+        // The middle is the sheet's default, so only top and bottom are kept.
+        if (vertical === 'top' || vertical === 'bottom')
+            entry.valign = vertical;
+        if (flag(align, 'wrapText'))
+            entry.wrap = true;
+        const indent = num(align, 'indent');
+        if (indent)
+            entry.indent = indent;
+        const protection = kid(xf, 'protection');
+        if (protection && attr(protection, 'locked') === '0')
+            entry.locked = false;
+        return entry;
+    });
+    const dxfs = kids(kid(root, 'dxfs'), 'dxf').map((dxf) => {
+        const style = {};
+        readFontInto(kid(dxf, 'font'), style, false);
+        const fill = fromArgb(attr(kid(kid(kid(dxf, 'fill'), 'patternFill'), 'bgColor'), 'rgb'))
+            ?? fromArgb(attr(kid(kid(kid(dxf, 'fill'), 'patternFill'), 'fgColor'), 'rgb'));
+        if (fill)
+            style.fill = fill;
+        const nf = kid(dxf, 'numFmt');
+        const code = attr(nf, 'formatCode') ?? codeOf(num(nf, 'numFmtId'));
+        if (code)
+            style.numFmt = code;
+        return style;
+    });
+    return { xfs, dxfs, numFmtOf: (xf) => codeOf(xfNumFmt[xf] ?? null) };
+}
+function readSharedStrings(xml) {
+    if (!xml)
+        return [];
+    return kids(parseXml(xml, 'xl/sharedStrings.xml').documentElement, 'si').map(textOf);
+}
+/** A formula as the engine spells it: a leading `=`, no `_xlfn.` prefixes. */
+/** Excel's own defaults: the summary line comes after its detail on both
+ *  axes, which is `summaryBelow="1"` and `summaryRight="1"`. */
+const OUTLINE_SIDE = { summaryBelow: true };
+const engineFormula = (text) => `=${text.replace(/_xlfn\./g, '').replace(/_xlws\./g, '')}`;
+/**
+ * Excel's "future functions", which it stores under a prefix.
+ *
+ * Anything added after the file format was frozen is written as
+ * `_xlfn.NAME`, and the ones that only make sense on a worksheet as
+ * `_xlfn._xlws.NAME`. A file that spells them plainly opens in Excel with
+ * `#NAME?` in every one of those cells, which is why this list exists: the
+ * reader already strips the prefixes, and the writer has to put them back.
+ */
+const XLWS_FUNCTIONS = new Set(['FILTER', 'SORT']);
+/**
+ * Future functions this engine does NOT evaluate but still spells the way
+ * the file wants.
+ *
+ * A cell this engine answers with `#NAME?` is one Excel can still work
+ * out, so dropping the prefix on the way back out would turn a formula
+ * that merely looks broken here into one that is broken there too. Keeping
+ * the name here costs nothing and makes the round trip lossless.
+ *
+ * Anything on this list is a candidate for implementing later; nothing
+ * should arrive here by accident, which is what the test that reads it
+ * guards.
+ */
+export const PRESERVED_ONLY = ['RANDARRAY'];
+export const XLFN_FUNCTIONS = new Set([
+    // Excel 365 and the dynamic arrays.
+    'LET', 'LAMBDA', 'MAP', 'BYROW', 'BYCOL', 'REDUCE', 'SCAN', 'MAKEARRAY',
+    'UNIQUE', 'SEQUENCE', 'SORTBY', 'TEXTSPLIT',
+    'TEXTBEFORE', 'TEXTAFTER',
+    'XLOOKUP', 'XMATCH', 'IMAGE',
+    // Excel 2016.
+    'TEXTJOIN', 'CONCAT', 'IFS', 'SWITCH', 'MAXIFS', 'MINIFS', 'FORECAST.LINEAR',
+    // Excel 2013: the reciprocal trigonometry, the bitwise set, and the
+    // handful of others that arrived with them.
+    'ACOT', 'ACOTH', 'COT', 'COTH', 'CSC', 'CSCH', 'SEC', 'SECH',
+    'BITAND', 'BITOR', 'BITXOR', 'BITLSHIFT', 'BITRSHIFT',
+    'CEILING.MATH', 'FLOOR.MATH', 'DAYS', 'XOR', 'NUMBERVALUE',
+    'GAMMA', 'GAUSS', 'PHI', 'PERMUTATIONA', 'SKEW.P', 'UNICHAR', 'UNICODE',
+    // Excel 2010: the statistical family Microsoft renamed with a dot. The
+    // OLD spelling of each (NORMDIST, CHIDIST, TTEST) is NOT a future
+    // function and must stay unprefixed, which is why only the dotted names
+    // are here.
+    'BETA.DIST', 'BETA.INV', 'BINOM.DIST', 'BINOM.INV',
+    'CHISQ.DIST', 'CHISQ.DIST.RT', 'CHISQ.INV', 'CHISQ.INV.RT', 'CHISQ.TEST',
+    'CONFIDENCE.NORM', 'CONFIDENCE.T', 'COVARIANCE.P', 'COVARIANCE.S',
+    'ERF.PRECISE', 'ERFC.PRECISE', 'EXPON.DIST',
+    'F.DIST', 'F.DIST.RT', 'F.INV', 'F.INV.RT', 'F.TEST',
+    'GAMMA.DIST', 'GAMMA.INV', 'GAMMALN.PRECISE', 'HYPGEOM.DIST',
+    'LOGNORM.DIST', 'LOGNORM.INV', 'MODE.SNGL', 'NEGBINOM.DIST',
+    'NORM.DIST', 'NORM.INV', 'NORM.S.DIST', 'NORM.S.INV',
+    'PERCENTILE.EXC', 'PERCENTILE.INC', 'POISSON.DIST',
+    'QUARTILE.EXC', 'QUARTILE.INC', 'STDEV.P', 'STDEV.S',
+    'T.DIST', 'T.DIST.2T', 'T.DIST.RT', 'T.INV', 'T.INV.2T', 'T.TEST',
+    'VAR.P', 'VAR.S', 'WEIBULL.DIST', 'Z.TEST',
+    ...PRESERVED_ONLY,
+]);
+/**
+ * A formula as the FILE spells it: the future functions prefixed.
+ *
+ * Scanned rather than replaced by a regular expression, so that a name
+ * inside a string literal (`="SORT(x)"`) is left alone, and one that is
+ * part of a longer name (`MYSORT(`) is too.
+ */
+export function xlsxFormula(text, inTable) {
+    let out = '';
+    let i = 0;
+    while (i < text.length) {
+        const ch = text[i];
+        if (ch === '"') {
+            const end = text.indexOf('"', i + 1);
+            const close = end < 0 ? text.length : end + 1;
+            out += text.slice(i, close);
+            i = close;
+            continue;
+        }
+        // `[@Amount]` is the shorthand Excel takes in the formula bar; what it
+        // STORES is the long form, naming the table and the specifier. A file
+        // carrying the shorthand is one other readers refuse.
+        if (ch === '[' && text[i + 1] === '@' && inTable) {
+            const end = text.indexOf(']', i);
+            if (end > 0) {
+                const column = text.slice(i + 2, end).trim();
+                out += column === ''
+                    ? `${inTable}[#This Row]`
+                    : `${inTable}[[#This Row],[${column}]]`;
+                i = end + 1;
+                continue;
+            }
+        }
+        if (/[A-Za-z_]/.test(ch)) {
+            let j = i;
+            while (j < text.length && /[A-Za-z0-9_.]/.test(text[j]))
+                j += 1;
+            const word = text.slice(i, j);
+            const isCall = text[j] === '(';
+            const before = i > 0 ? text[i - 1] : '';
+            const upper = word.toUpperCase();
+            if (isCall && before !== '.' && before !== '!' && (XLFN_FUNCTIONS.has(upper) || XLWS_FUNCTIONS.has(upper))) {
+                out += XLWS_FUNCTIONS.has(upper) ? `_xlfn._xlws.${word}` : `_xlfn.${word}`;
+            }
+            else {
+                out += word;
+            }
+            i = j;
+            continue;
+        }
+        out += ch;
+        i += 1;
+    }
+    return out;
+}
+/** A bound as the file spells it, read back as a literal or a formula. */
+function readValidationFormula(text, allow) {
+    if (text === null || text.trim() === '')
+        return undefined;
+    const t = text.trim();
+    const quoted = /^"(.*)"$/s.exec(t);
+    if (quoted)
+        return quoted[1].replace(/""/g, '"');
+    if (allow === 'custom')
+        return engineFormula(t);
+    if (Number.isFinite(Number(t)))
+        return allow === 'date' ? serialToIso(Number(t)) : t;
+    return engineFormula(t);
+}
+const VALIDATION_ALLOW_BACK = { whole: 'whole', decimal: 'decimal', list: 'list', date: 'date', time: 'decimal', textLength: 'textLength', custom: 'custom' };
+const VALIDATION_OP_BACK = Object.fromEntries(Object.entries(VALIDATION_OP).map(([k, v]) => [v, k]));
+const CF_OP_BACK = Object.fromEntries(Object.entries(CF_OP).map(([k, v]) => [v, k]));
+const CF_TEXT_BACK = Object.fromEntries(Object.entries(CF_TEXT).map(([k, v]) => [v, k]));
+function iconSetBack(name) {
+    if (!name)
+        return 'arrows';
+    if (/Traffic/i.test(name))
+        return 'traffic';
+    if (/Flag/i.test(name))
+        return 'flags';
+    if (/Symbol/i.test(name))
+        return 'symbols';
+    return 'arrows';
+}
+function readCfFormula(text) {
+    const t = text.trim();
+    const quoted = /^"(.*)"$/s.exec(t);
+    if (quoted)
+        return quoted[1].replace(/""/g, '"');
+    return Number.isFinite(Number(t)) && t !== '' ? t : engineFormula(t);
+}
+let ruleSeq = 0;
+const nextId = (prefix) => `${prefix}x${(ruleSeq += 1)}`;
+/**
+ * The document a package holds, as a saved state: hand it to
+ * `createSheetDocument({ state })` or a shell's `setState`.
+ */
+export function documentFromXlsxParts(parts) {
+    const workbookXml = parts['xl/workbook.xml'];
+    if (!workbookXml)
+        throw new Error('@svgrid/enterprise: not an xlsx package: xl/workbook.xml is missing');
+    const wbRoot = parseXml(workbookXml, 'xl/workbook.xml').documentElement;
+    const wbRels = readRels(parts, 'xl/_rels/workbook.xml.rels', 'xl/workbook.xml');
+    const stylesPath = [...wbRels.values()].find((r) => r.type === REL_STYLES)?.target ?? 'xl/styles.xml';
+    const sharedPath = [...wbRels.values()].find((r) => r.type === REL_SHARED)?.target ?? 'xl/sharedStrings.xml';
+    const styles = readStyles(parts[stylesPath]);
+    const shared = readSharedStrings(parts[sharedPath]);
+    const personsPath = [...wbRels.values()].find((r) => r.type === REL_PERSONS)?.target;
+    const persons = new Map();
+    if (personsPath && parts[personsPath]) {
+        for (const person of kids(parseXml(parts[personsPath], personsPath).documentElement, 'person')) {
+            const id = attr(person, 'id');
+            if (id)
+                persons.set(id, attr(person, 'displayName') ?? '');
+        }
+    }
+    // <calcPr iterate="1" .../>: Excel's Enable iterative calculation.
+    const calcPr = kid(wbRoot, 'calcPr');
+    const iterateOn = calcPr ? attr(calcPr, 'iterate') === '1' || attr(calcPr, 'iterate') === 'true' : false;
+    const iteration = iterateOn
+        ? cleanIteration({
+            enabled: true,
+            maxIterations: Number(attr(calcPr, 'iterateCount') ?? DEFAULT_ITERATION.maxIterations),
+            maxChange: Number(attr(calcPr, 'iterateDelta') ?? DEFAULT_ITERATION.maxChange),
+        })
+        : null;
+    const sheets = [];
+    const entries = {};
+    /** Tables are workbook-wide, though each part hangs off its own sheet. */
+    const tables = [];
+    const sheetNodes = kids(kid(wbRoot, 'sheets'), 'sheet');
+    sheetNodes.forEach((sheetNode, index) => {
+        const name = attr(sheetNode, 'name') ?? `Sheet${index + 1}`;
+        const rid = sheetNode.getAttributeNS(NS_REL, 'id') ?? attr(sheetNode, 'r:id');
+        const path = (rid && wbRels.get(rid)?.target) ?? `xl/worksheets/sheet${index + 1}.xml`;
+        const xml = parts[path];
+        const cells = [];
+        const entry = {
+            formats: {}, columnWidths: {}, rowHeights: [], hidden: { rows: [], cols: [] }, freeze: { rows: 0, cols: 0 },
+            comments: {}, protected: false, sheetHidden: attr(sheetNode, 'state') === 'hidden' || attr(sheetNode, 'state') === 'veryHidden',
+            merges: [], validation: [], conditionalFormats: [], autoFilter: null,
+        };
+        // Filled from the rows' and columns' `outlineLevel` below, then hung on
+        // the entry once, so an unoutlined sheet carries no `outline` at all.
+        const outlineRows = emptyOutline();
+        const outlineCols = emptyOutline();
+        if (xml) {
+            const root = parseXml(xml, path).documentElement;
+            const put = (r, c, text) => {
+                while (cells.length <= r)
+                    cells.push([]);
+                const line = cells[r];
+                while (line.length <= c)
+                    line.push('');
+                line[c] = text;
+            };
+            for (const col of kids(kid(root, 'cols'), 'col')) {
+                const min = num(col, 'min');
+                const max = num(col, 'max');
+                if (min === null || max === null)
+                    continue;
+                const width = num(col, 'width');
+                const hidden = flag(col, 'hidden');
+                const level = num(col, 'outlineLevel');
+                const collapsedCol = flag(col, 'collapsed');
+                // A run over every column to the sheet's edge is Excel's default
+                // width, not a setting on sixteen thousand columns.
+                const last = Math.min(max, Math.max(min, 256));
+                for (let c = min - 1; c <= last - 1; c += 1) {
+                    if (width !== null && flag(col, 'customWidth'))
+                        entry.columnWidths[colToLetters(c)] = widthToPx(width);
+                    if (level !== null && level > 0)
+                        outlineCols.levels[c] = level;
+                    if (collapsedCol)
+                        outlineCols.collapsed.push(c);
+                    // A line a collapsed group folds is not a hidden line: it comes
+                    // back when the group opens, so recording it as hidden as well
+                    // would leave it behind when it did.
+                    if (hidden && level === null)
+                        entry.hidden.cols.push(c);
+                }
+            }
+            const sharedFormulas = new Map();
+            /** The rectangles of the array formulas seen so far: cells inside them without a formula hold spilled values, not text. */
+            const arrayRects = [];
+            // A row's own `r` is optional in the format: without one the rows are
+            // in order, which is what a streaming writer produces. The same goes
+            // for a cell's, so both fall back to counting.
+            const defaultHeight = num(kid(root, 'sheetFormatPr'), 'defaultRowHeight');
+            let nextRow = 0;
+            for (const row of kids(kid(root, 'sheetData'), 'row')) {
+                const given = num(row, 'r');
+                const r = given === null ? nextRow : given - 1;
+                if (r < 0)
+                    continue;
+                nextRow = r + 1;
+                const ht = num(row, 'ht');
+                // Excel marks a height it was told with `customHeight`; LibreOffice
+                // keeps the height and drops the flag, so a height that differs from
+                // the sheet's default counts either way.
+                const told = ht !== null
+                    && (flag(row, 'customHeight') || defaultHeight === null || Math.abs(ht - defaultHeight) > 0.01);
+                if (told)
+                    entry.rowHeights.push([r, ptToPx(ht)]);
+                const rowLevel = num(row, 'outlineLevel');
+                if (rowLevel !== null && rowLevel > 0)
+                    outlineRows.levels[r] = rowLevel;
+                if (flag(row, 'collapsed'))
+                    outlineRows.collapsed.push(r);
+                if (flag(row, 'hidden') && rowLevel === null)
+                    entry.hidden.rows.push(r);
+                let nextCol = 0;
+                for (const cell of kids(row, 'c')) {
+                    const at = attr(cell, 'r');
+                    const ref = at ? parseA1(at) : { row: r, col: nextCol, rowAbs: false, colAbs: false, sheet: null };
+                    if (!ref || ref.row === null)
+                        continue;
+                    const c = ref.col;
+                    nextCol = c + 1;
+                    const fEl = kid(cell, 'f');
+                    // The cached values under an array formula belong to its spill,
+                    // not to the cells: read the anchor, skip the rest.
+                    if (!fEl && arrayRects.some(([r1, c1, r2, c2]) => ref.row >= r1 && ref.row <= r2 && c >= c1 && c <= c2))
+                        continue;
+                    if (fEl && attr(fEl, 't') === 'array') {
+                        const rect = refRect(attr(fEl, 'ref') ?? '');
+                        if (rect)
+                            arrayRects.push(rect);
+                    }
+                    const s = num(cell, 's');
+                    const type = attr(cell, 't') ?? 'n';
+                    const f = kid(cell, 'f');
+                    const v = kid(cell, 'v')?.textContent ?? null;
+                    const style = s !== null ? styles.xfs[s] : undefined;
+                    if (style && Object.keys(style).length)
+                        entry.formats[formatKey(ref.row, c)] = { ...style, border: style.border ? { ...style.border } : undefined };
+                    if (entry.formats[formatKey(ref.row, c)]?.border === undefined)
+                        delete entry.formats[formatKey(ref.row, c)]?.border;
+                    let text = '';
+                    if (f) {
+                        let body = f.textContent ?? '';
+                        const si = attr(f, 'si');
+                        if (attr(f, 't') === 'shared' && si !== null) {
+                            if (body)
+                                sharedFormulas.set(si, { row: ref.row, col: c, text: body });
+                            else {
+                                const master = sharedFormulas.get(si);
+                                if (master)
+                                    body = String(translateFormula(engineFormula(master.text), ref.row - master.row, c - master.col)).slice(1);
+                            }
+                        }
+                        text = body ? engineFormula(body) : '';
+                    }
+                    if (!text) {
+                        // A string cell holds TEXT even when the text reads as a number,
+                        // which is the whole point of a part number like 007. The
+                        // apostrophe is how the workbook spells that, and without it the
+                        // round trip would hand back the number 7.
+                        if (type === 's')
+                            text = asText(shared[Number(v)] ?? '');
+                        else if (type === 'inlineStr')
+                            text = asText(textOf(kid(cell, 'is')));
+                        else if (type === 'str')
+                            text = asText(v ?? '');
+                        else if (type === 'b')
+                            text = v === '1' || v === 'true' ? 'TRUE' : 'FALSE';
+                        else if (type === 'e')
+                            text = v ?? '';
+                        else if (v !== null && v !== '') {
+                            const n = Number(v);
+                            text = Number.isFinite(n) && isDayFormat(s !== null ? styles.numFmtOf(s) : undefined) && n >= 0 && Number.isInteger(n) ? serialToIso(n) : v;
+                        }
+                    }
+                    if (text !== '')
+                        put(ref.row, c, text);
+                }
+            }
+            const pane = kid(kid(kid(root, 'sheetViews'), 'sheetView'), 'pane');
+            if (pane && attr(pane, 'state') === 'frozen')
+                entry.freeze = { rows: num(pane, 'ySplit') ?? 0, cols: num(pane, 'xSplit') ?? 0 };
+            const printOptions = kid(root, 'printOptions');
+            const pageMargins = kid(root, 'pageMargins');
+            const pageSetupEl = kid(root, 'pageSetup');
+            if (printOptions || pageMargins || pageSetupEl) {
+                const ps = defaultPageSetup();
+                if (flag(printOptions, 'gridLines'))
+                    ps.gridlines = true;
+                if (flag(printOptions, 'headings'))
+                    ps.headings = true;
+                if (pageMargins) {
+                    for (const side of ['left', 'right', 'top', 'bottom', 'header', 'footer']) {
+                        const v = num(pageMargins, side);
+                        if (v !== null)
+                            ps.margins[side] = v;
+                    }
+                }
+                if (attr(pageSetupEl, 'orientation') === 'landscape')
+                    ps.orientation = 'landscape';
+                const code = num(pageSetupEl, 'paperSize');
+                const paper = Object.keys(PAPER_SIZES).find((p) => PAPER_SIZES[p].code === code);
+                if (paper)
+                    ps.paper = paper;
+                const scale = num(pageSetupEl, 'scale');
+                if (scale !== null && scale > 0)
+                    ps.scale = scale;
+                entry.pageSetup = ps;
+            }
+            const sheetProtection = kid(root, 'sheetProtection');
+            if (sheetProtection && flag(sheetProtection, 'sheet')) {
+                entry.protected = true;
+                const allow = {};
+                for (const key of PROTECTION_PERMISSIONS) {
+                    const v = attr(sheetProtection, key);
+                    if (v === '0' || v === 'false')
+                        allow[key] = true;
+                }
+                entry.protection = { allow, ranges: [] };
+            }
+            for (const range of kids(kid(root, 'protectedRanges'), 'protectedRange')) {
+                const rects = (attr(range, 'sqref') ?? '').split(/\s+/).map(refRect).filter((r) => r !== null);
+                if (!rects.length)
+                    continue;
+                entry.protection ?? (entry.protection = { allow: {}, ranges: [] });
+                entry.protection.ranges.push({ id: newEditRangeId(), title: attr(range, 'name') ?? `Range${entry.protection.ranges.length + 1}`, rects });
+            }
+            const afNode = kid(root, 'autoFilter');
+            const af = attr(afNode, 'ref');
+            const afRect = af ? refRect(af) : null;
+            if (afRect && afNode) {
+                // The criteria come back with the region. Excel writes the rows a
+                // filter hides as hidden rows; the document releases the ones its
+                // criteria hide again (see releaseFilteredRows), and the rest stay
+                // hidden by hand, which shows the rows Excel showed.
+                const isDateColumn = (col) => {
+                    let dates = 0;
+                    let filled = 0;
+                    for (let r = afRect[0] + 1; r <= afRect[2]; r += 1) {
+                        const raw = cells[r]?.[col] ?? '';
+                        if (raw === '')
+                            continue;
+                        filled += 1;
+                        if (isoToSerial(raw.trim()) !== null)
+                            dates += 1;
+                    }
+                    return filled > 0 && dates === filled;
+                };
+                entry.autoFilter = { range: afRect, filters: filtersFromXlsx(afNode, afRect, isDateColumn).filters };
+            }
+            for (const merge of kids(kid(root, 'mergeCells'), 'mergeCell')) {
+                const rect = refRect(attr(merge, 'ref') ?? '');
+                if (rect)
+                    entry.merges.push([rect[0], rect[1], rect[2], rect[3]]);
+            }
+            for (const block of kids(root, 'conditionalFormatting')) {
+                const rects = sqrefRects(attr(block, 'sqref') ?? '');
+                if (!rects.length)
+                    continue;
+                const ruleNodes = kids(block, 'cfRule').map((node) => ({ node, priority: num(node, 'priority') ?? 0 }));
+                for (const { node, priority } of ruleNodes) {
+                    const type = attr(node, 'type');
+                    const dxf = num(node, 'dxfId');
+                    const style = dxf !== null ? { ...(styles.dxfs[dxf] ?? {}) } : {};
+                    const formulas = kids(node, 'formula').map((f) => f.textContent ?? '');
+                    const base = { id: nextId('cf'), rects, ...(flag(node, 'stopIfTrue') ? { stopIfTrue: true } : {}) };
+                    let rule = null;
+                    if (type === 'cellIs') {
+                        const operator = CF_OP_BACK[attr(node, 'operator') ?? ''] ?? 'equal';
+                        rule = { ...base, kind: 'cellIs', operator, value1: readCfFormula(formulas[0] ?? '0'), ...(formulas[1] !== undefined ? { value2: readCfFormula(formulas[1]) } : {}), style };
+                    }
+                    else if (type && CF_TEXT_BACK[type]) {
+                        rule = { ...base, kind: 'text', match: CF_TEXT_BACK[type], value: attr(node, 'text') ?? '', style };
+                    }
+                    else if (type === 'duplicateValues' || type === 'uniqueValues') {
+                        rule = { ...base, kind: 'duplicates', ...(type === 'uniqueValues' ? { unique: true } : {}), style };
+                    }
+                    else if (type === 'top10') {
+                        rule = { ...base, kind: 'topBottom', top: !flag(node, 'bottom'), rank: num(node, 'rank') ?? 10, ...(flag(node, 'percent') ? { percent: true } : {}), style };
+                    }
+                    else if (type === 'aboveAverage') {
+                        rule = { ...base, kind: 'average', above: attr(node, 'aboveAverage') !== '0', style };
+                    }
+                    else if (type === 'expression') {
+                        rule = { ...base, kind: 'formula', formula: engineFormula(formulas[0] ?? 'FALSE'), style };
+                    }
+                    else if (type === 'dataBar') {
+                        rule = { ...base, kind: 'dataBar', color: fromArgb(attr(kid(kid(node, 'dataBar'), 'color'), 'rgb')) ?? '#638ec6' };
+                    }
+                    else if (type === 'colorScale') {
+                        const colours = kids(kid(node, 'colorScale'), 'color').map((c) => fromArgb(attr(c, 'rgb')) ?? '#ffffff');
+                        if (colours.length >= 3)
+                            rule = { ...base, kind: 'colorScale', colors: [colours[0], colours[1], colours[2]] };
+                        else if (colours.length === 2)
+                            rule = { ...base, kind: 'colorScale', colors: [colours[0], colours[1]] };
+                    }
+                    else if (type === 'iconSet') {
+                        rule = { ...base, kind: 'iconSet', set: iconSetBack(attr(kid(node, 'iconSet'), 'iconSet')) };
+                    }
+                    if (rule)
+                        entry.conditionalFormats.push(Object.assign(rule, { priority }));
+                }
+            }
+            // Excel orders rules by priority across the blocks; ours by position.
+            entry.conditionalFormats.sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
+            for (const rule of entry.conditionalFormats)
+                delete rule.priority;
+            for (const dv of kids(kid(root, 'dataValidations'), 'dataValidation')) {
+                const allow = VALIDATION_ALLOW_BACK[attr(dv, 'type') ?? ''] ?? 'any';
+                const rects = sqrefRects(attr(dv, 'sqref') ?? '');
+                if (!rects.length || allow === 'any')
+                    continue;
+                const errorStyle = attr(dv, 'errorStyle');
+                const rule = {
+                    id: nextId('v'),
+                    rects,
+                    allow,
+                    ignoreBlank: attr(dv, 'allowBlank') === null ? true : flag(dv, 'allowBlank'),
+                    inCellDropdown: allow === 'list' && !flag(dv, 'showDropDown'),
+                    alert: { style: errorStyle === 'warning' || errorStyle === 'information' ? 'warning' : 'stop' },
+                };
+                const title = attr(dv, 'errorTitle');
+                const message = attr(dv, 'error');
+                if (title)
+                    rule.alert.title = title;
+                if (message)
+                    rule.alert.message = message;
+                const promptTitle = attr(dv, 'promptTitle');
+                const prompt = attr(dv, 'prompt');
+                if (promptTitle || prompt)
+                    rule.input = { ...(promptTitle ? { title: promptTitle } : {}), ...(prompt ? { message: prompt } : {}) };
+                if (allow !== 'list' && allow !== 'custom')
+                    rule.operator = VALIDATION_OP_BACK[attr(dv, 'operator') ?? 'between'] ?? 'between';
+                const f1 = readValidationFormula(kid(dv, 'formula1')?.textContent ?? null, allow);
+                const f2 = readValidationFormula(kid(dv, 'formula2')?.textContent ?? null, allow);
+                if (f1 !== undefined)
+                    rule.value1 = f1;
+                if (f2 !== undefined)
+                    rule.value2 = f2;
+                entry.validation.push(rule);
+            }
+            // Comments, through the sheet's relationships: a threaded part wins
+            // over the legacy note that stands in for it.
+            const relsPath = path.replace(/worksheets\/([^/]+)$/, 'worksheets/_rels/$1.rels');
+            const rels = readRels(parts, relsPath, path);
+            // Sparklines, out of the worksheet's extension list.
+            const sparklineGroups = [];
+            for (const group of root.getElementsByTagNameNS(NS_X14, 'sparklineGroup')) {
+                const cells = [];
+                for (const one of group.getElementsByTagNameNS(NS_X14, 'sparkline')) {
+                    const formula = one.getElementsByTagNameNS(NS_XM, 'f')[0]?.textContent ?? '';
+                    const at = one.getElementsByTagNameNS(NS_XM, 'sqref')[0]?.textContent ?? '';
+                    const data = rectOfRef(formula);
+                    const cell = parseA1(at.replace(/\$/g, '').trim());
+                    if (!data || !cell || cell.row === null)
+                        continue;
+                    cells.push({ row: cell.row, col: cell.col, data: data.rect });
+                }
+                if (!cells.length)
+                    continue;
+                // One group covers a run of cells and the block they read; both come
+                // back as the outer rectangle of the entries, which is how the group
+                // was written.
+                const location = cells.reduce((box, c) => [Math.min(box[0], c.row), Math.min(box[1], c.col), Math.max(box[2], c.row), Math.max(box[3], c.col)], [cells[0].row, cells[0].col, cells[0].row, cells[0].col]);
+                const data = cells.reduce((box, c) => [Math.min(box[0], c.data[0]), Math.min(box[1], c.data[1]), Math.max(box[2], c.data[2]), Math.max(box[3], c.data[3])], cells[0].data);
+                const kind = attr(group, 'type');
+                const colour = fromArgb(attr(group.getElementsByTagNameNS(NS_X14, 'colorSeries')[0] ?? null, 'rgb'));
+                const negative = fromArgb(attr(group.getElementsByTagNameNS(NS_X14, 'colorNegative')[0] ?? null, 'rgb'));
+                sparklineGroups.push({
+                    id: sparklineId(),
+                    location,
+                    data,
+                    type: kind === 'column' ? 'column' : kind === 'stacked' ? 'winloss' : 'line',
+                    ...(colour ? { color: colour } : {}),
+                    ...(negative ? { negativeColor: negative } : {}),
+                    ...(attr(group, 'minAxisType') === 'group' ? { sameScale: true } : {}),
+                    ...(attr(group, 'markers') === '1' ? { markers: true } : {}),
+                });
+            }
+            if (sparklineGroups.length)
+                entry.sparklines = sparklineGroups;
+            // The drawing, through the same relationships: the pictures and the
+            // charts anchored over this sheet.
+            const drawingId = kid(root, 'drawing')?.getAttribute('r:id') ?? kid(root, 'drawing')?.getAttributeNS(NS_REL, 'id');
+            const drawingPath = drawingId ? rels.get(drawingId)?.target : undefined;
+            const drawingXml = drawingPath ? parts[drawingPath] : undefined;
+            if (drawingXml && drawingPath) {
+                const objects = objectsFromDrawing(drawingXml, {
+                    parse: parseXml,
+                    rels: readRels(parts, drawingPath.replace(/drawings\/([^/]+)$/, 'drawings/_rels/$1.rels'), drawingPath),
+                    parts,
+                    newId: objectId,
+                    columnWidth: (col) => entry.columnWidths[colToLetters(col)] ?? 64,
+                });
+                if (objects.length)
+                    entry.objects = objects;
+            }
+            // Tables, through the sheet's relationships: the part carries the
+            // range, the header count and whether there is a totals row.
+            for (const part of kids(kid(root, 'tableParts'), 'tablePart')) {
+                const id = part.getAttribute('r:id') ?? part.getAttributeNS(NS_REL, 'id');
+                const target = id ? rels.get(id)?.target : undefined;
+                const xml = target ? parts[target] : undefined;
+                if (!xml)
+                    continue;
+                const table = parseXml(xml, target).documentElement;
+                const ref = attr(table, 'ref') ?? '';
+                const [fromText, toText] = ref.split(':');
+                const from = parseA1(fromText ?? '');
+                const to = parseA1(toText ?? fromText ?? '');
+                if (!from || from.row === null || !to || to.row === null)
+                    continue;
+                const totals = num(table, 'totalsRowCount') ?? 0;
+                tables.push({
+                    name: attr(table, 'displayName') || attr(table, 'name') || `Table${tables.length + 1}`,
+                    sheet: name,
+                    headerRow: from.row,
+                    firstCol: from.col,
+                    lastCol: to.col,
+                    lastRow: to.row - (totals > 0 ? 1 : 0),
+                    hasTotals: totals > 0,
+                    // A style Excel knows keeps its name; one it does not, or none at
+                    // all, reads as no style rather than as a guess.
+                    style: findTableStyle(attr(kid(table, 'tableStyleInfo'), 'name') ?? undefined)?.id ?? NO_TABLE_STYLE,
+                });
+                // A filtered table keeps its filter inside the table part, which is
+                // where LibreOffice leaves it. Without this the arrows are lost on
+                // the way in, though the table itself survives.
+                if (!entry.autoFilter) {
+                    const range = refRect(attr(kid(table, 'autoFilter'), 'ref') ?? '');
+                    if (range)
+                        entry.autoFilter = { range, filters: {} };
+                }
+            }
+            // Hyperlinks: an external one points at a relationship whose target is
+            // the URL, an internal one carries its address as `location`.
+            for (const link of kids(kid(root, 'hyperlinks'), 'hyperlink')) {
+                const at = parseA1(attr(link, 'ref')?.split(':')[0] ?? '');
+                if (!at || at.row === null)
+                    continue;
+                const id = link.getAttribute('r:id') ?? link.getAttributeNS(NS_REL, 'id');
+                const target = id ? rawRelTarget(parts, relsPath, id) : attr(link, 'location');
+                // A file is the easiest way to hand someone a link they did not
+                // write. One carrying a scheme the shell will not follow is dropped
+                // on the way in, so it is not in the document to be followed, shown
+                // or written out again.
+                if (!target || !isSafeLinkTarget(target))
+                    continue;
+                const tip = attr(link, 'tooltip');
+                entry.links ?? (entry.links = {});
+                const rowId = `r${at.row}`;
+                entry.links[rowId] = { ...(entry.links[rowId] ?? {}), [colToLetters(at.col)]: { target, ...(tip ? { tip } : {}) } };
+            }
+            const threadsPath = [...rels.values()].find((r) => r.type === REL_THREADS)?.target;
+            const threadsXml = threadsPath ? parts[threadsPath] : undefined;
+            const threaded = new Set();
+            if (threadsXml) {
+                const roots = new Map();
+                for (const tc of kids(parseXml(threadsXml, threadsPath).documentElement, 'threadedComment')) {
+                    const ref = parseA1(attr(tc, 'ref') ?? '');
+                    const id = attr(tc, 'id');
+                    if (!ref || ref.row === null || !id)
+                        continue;
+                    const at = readThreadTime(attr(tc, 'dT'));
+                    const author = persons.get(attr(tc, 'personId') ?? '');
+                    const item = { text: kid(tc, 'text')?.textContent ?? '', ...(author ? { author } : {}), ...(at ? { at } : {}) };
+                    const parentId = attr(tc, 'parentId');
+                    const parent = parentId ? roots.get(parentId) : undefined;
+                    if (parent) {
+                        parent.thread.replies = [...(parent.thread.replies ?? []), item];
+                    }
+                    else {
+                        roots.set(id, { row: ref.row, col: ref.col, thread: { ...item, ...(flag(tc, 'done') ? { resolved: true } : {}) } });
+                    }
+                }
+                for (const { row, col, thread } of roots.values()) {
+                    const rowId = `r${row}`;
+                    entry.comments[rowId] = { ...(entry.comments[rowId] ?? {}), [colToLetters(col)]: thread };
+                    threaded.add(`${row},${col}`);
+                }
+            }
+            const commentsPath = [...rels.values()].find((r) => r.type === REL_COMMENTS)?.target;
+            const commentsXml = commentsPath ? parts[commentsPath] : undefined;
+            if (commentsXml) {
+                for (const comment of kids(kid(parseXml(commentsXml, commentsPath).documentElement, 'commentList'), 'comment')) {
+                    const ref = parseA1(attr(comment, 'ref') ?? '');
+                    if (!ref || ref.row === null || threaded.has(`${ref.row},${ref.col}`))
+                        continue;
+                    const text = textOf(kid(comment, 'text'));
+                    if (!text)
+                        continue;
+                    const rowId = `r${ref.row}`;
+                    entry.comments[rowId] = { ...(entry.comments[rowId] ?? {}), [colToLetters(ref.col)]: text };
+                }
+            }
+        }
+        if (isOutlined(outlineRows) || isOutlined(outlineCols)) {
+            entry.outline = { rows: outlineRows, cols: outlineCols };
+        }
+        sheets.push({ name, cells });
+        entries[name] = entry;
+    });
+    const names = {};
+    for (const dn of kids(kid(wbRoot, 'definedNames'), 'definedName')) {
+        const name = attr(dn, 'name');
+        const refersTo = dn.textContent?.trim();
+        if (!name || !refersTo)
+            continue;
+        // Excel's own names: the print area and the title rows go to their
+        // sheet's page setup; the rest of the underscored ones stay where they were.
+        if (name === '_xlnm.Print_Area' || name === '_xlnm.Print_Titles') {
+            const sheetName = sheets[num(dn, 'localSheetId') ?? -1]?.name;
+            const entry = sheetName ? entries[sheetName] : undefined;
+            if (!entry)
+                continue;
+            entry.pageSetup ?? (entry.pageSetup = defaultPageSetup());
+            const areas = refersTo.split(',').map((piece) => piece.slice(piece.lastIndexOf('!') + 1).replace(/\$/g, ''));
+            if (name === '_xlnm.Print_Area') {
+                const rects = areas.map(refRect).filter((r) => r !== null);
+                if (rects.length)
+                    entry.pageSetup.printArea = rects;
+            }
+            else {
+                const rows = /^(\d+):(\d+)$/.exec(areas[0] ?? '');
+                if (rows)
+                    entry.pageSetup.printTitleRows = [Number(rows[1]) - 1, Number(rows[2]) - 1];
+            }
+            continue;
+        }
+        if (!name.startsWith('_xlnm.'))
+            names[name] = refersTo;
+    }
+    const activeTab = num(kid(kid(wbRoot, 'bookViews'), 'workbookView'), 'activeTab') ?? 0;
+    const active = sheets[activeTab]?.name ?? sheets[0]?.name ?? 'Sheet1';
+    if (!sheets.length)
+        sheets.push({ name: 'Sheet1', cells: [] });
+    return {
+        version: 1,
+        workbook: { sheets, active, names, ...(tables.length ? { tables } : {}), ...(iteration ? { iteration } : {}) },
+        sheets: entries,
+    };
+}
+/**
+ * A picture's bytes travel through the parts map as the `data:` URL the
+ * document holds, because everything else in the package is text and a map
+ * of strings is what the tests read. The zip is where they become bytes
+ * again, and the only place that has to know.
+ */
+const MEDIA_PREFIX = 'xl/media/';
+/** The media type a media part's extension stands for. */
+function mediaTypeOf(path) {
+    const extension = path.slice(path.lastIndexOf('.') + 1).toLowerCase();
+    return extension === 'jpg' || extension === 'jpeg' ? 'image/jpeg' : `image/${extension || 'png'}`;
+}
+let zipPromise = null;
+/** The jszip a caller gave, the one on the page, or the optional peer. */
+export async function loadZip(given) {
+    if (given)
+        return given;
+    const g = globalThis;
+    if (g.JSZip)
+        return g.JSZip;
+    if (!zipPromise) {
+        zipPromise = (async () => {
+            let mod;
+            try {
+                // @ts-ignore - "jszip" is an optional peerDependency
+                mod = await import('jszip');
+            }
+            catch {
+                throw new Error('@svgrid/enterprise: reading and writing .xlsx and .ods needs the "jszip" peer dependency. Install it with: pnpm add jszip');
+            }
+            return (mod.default ?? mod);
+        })();
+    }
+    return zipPromise;
+}
+/** The document as an .xlsx Blob. */
+export async function documentToXlsx(doc, JSZip) {
+    const Zip = await loadZip(JSZip);
+    const zip = new Zip();
+    for (const [path, content] of Object.entries(documentToXlsxParts(doc))) {
+        if (path.startsWith(MEDIA_PREFIX)) {
+            const comma = content.indexOf(',');
+            zip.file(path, comma >= 0 ? content.slice(comma + 1) : content, { base64: true });
+        }
+        else {
+            zip.file(path, content);
+        }
+    }
+    return zip.generateAsync({ type: 'blob', mimeType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' });
+}
+/** The document an .xlsx file holds, as a saved state. */
+export async function documentFromXlsx(file, JSZip) {
+    const Zip = await loadZip(JSZip);
+    const zip = await Zip.loadAsync(file);
+    const parts = {};
+    const pending = [];
+    zip.forEach((path, entry) => {
+        if (entry.dir)
+            return;
+        const clean = path.replace(/^\//, '');
+        // A picture comes back as the data URL an image object holds, so the
+        // rest of the reader never has to think about bytes.
+        if (clean.startsWith(MEDIA_PREFIX)) {
+            pending.push(entry.async('base64').then((base64) => { parts[clean] = `data:${mediaTypeOf(clean)};base64,${base64}`; }));
+            return;
+        }
+        if (!/\.(xml|rels|vml)$/i.test(path))
+            return;
+        pending.push(entry.async('string').then((text) => { parts[clean] = text; }));
+    });
+    await Promise.all(pending);
+    return documentFromXlsxParts(parts);
+}