@shbernal/ts-xlsx 2.1.0 → 3.1.0

package/dist/io/xlsx/hyperlinks.js

@@ -1,23 +1,32 @@
 import { tryDecodeRange } from '../../core/address.js';
 import { isHyperlinkValue, isRichTextValue } from '../../core/value.js';
-import { localName, parseXml } from '../../xml/xml-read.js';
+import {} from '../../xml/xml-read.js';
+import { localName } from '../../xml/xml-scan.js';
 import { escapeAttr, textAttr } from '../../xml/xml.js';
-export function collectHyperlinks(sheet) {
+import { relAttr } from '../opc/namespaces.js';
+export function collectHyperlinks(cells) {
     const links = [];
-    for (const { cells } of sheet.rows()) {
-        for (const cell of cells) {
-            const value = cell.value;
-            if (isHyperlinkValue(value)) {
-                links.push({
-                    ref: value.range ?? cell.address,
-                    target: value.hyperlink,
-                    ...(value.tooltip !== undefined ? { tooltip: value.tooltip } : {}),
-                });
-            }
+    for (const cell of cells) {
+        const value = cell.value;
+        if (isHyperlinkValue(value)) {
+            links.push({
+                ref: value.range ?? cell.address,
+                row: cell.row,
+                col: cell.col,
+                target: value.hyperlink,
+                ...(value.tooltip !== undefined ? { tooltip: value.tooltip } : {}),
+            });
         }
     }
     return links;
 }
+export function* liveCells(sheet) {
+    for (const { cells } of sheet.rows())
+        yield* cells;
+}
+export function isExternalHyperlink(link) {
+    return link.relId !== undefined && link.target !== undefined;
+}
 export function planHyperlinks(links, rels) {
     return links.map((link) => {
         const tooltip = link.tooltip !== undefined ? { tooltip: link.tooltip } : {};
@@ -40,24 +49,27 @@ export function hyperlinksXml(links) {
         .join('');
     return `<hyperlinks>${items}</hyperlinks>`;
 }
-export function parseSheetHyperlinks(xml) {
+export function sheetHyperlinkPass() {
     const links = [];
-    parseXml(xml, {
-        onOpen(name, attrs) {
-            if (localName(name) !== 'hyperlink')
-                return;
-            const ref = attrs.ref;
-            if (ref === undefined)
-                return;
-            links.push({
-                ref,
-                ...(attrs['r:id'] !== undefined ? { rid: attrs['r:id'] } : {}),
-                ...(attrs.location !== undefined ? { location: attrs.location } : {}),
-                ...(attrs.tooltip !== undefined ? { tooltip: attrs.tooltip } : {}),
-            });
+    return {
+        handlers: {
+            onOpen(name, attrs, _selfClosing, scope) {
+                if (localName(name) !== 'hyperlink')
+                    return;
+                const ref = attrs.ref;
+                if (ref === undefined)
+                    return;
+                const rid = relAttr(scope, attrs, 'id');
+                links.push({
+                    ref,
+                    ...(rid !== undefined ? { rid } : {}),
+                    ...(attrs.location !== undefined ? { location: attrs.location } : {}),
+                    ...(attrs.tooltip !== undefined ? { tooltip: attrs.tooltip } : {}),
+                });
+            },
         },
-    });
-    return links;
+        result: () => links,
+    };
 }
 export function applyHyperlinks(sheet, links, targetOf) {
     for (const link of links) {

package/dist/io/xlsx/images.js

@@ -1,25 +1,27 @@
 import { isImageEditAs, isOneCellAnchor, } from '../../core/image.js';
-import { enumToken, localName, numFinite, parseXml, TextCapture } from '../../xml/xml-read.js';
+import { enumToken, numFinite } from '../../xml/xml-attrs.js';
+import { openElements, parseXml, TextCapture } from '../../xml/xml-read.js';
+import { localName } from '../../xml/xml-scan.js';
 import { checkedToken, numAttr, numberText, XML_DECLARATION } from '../../xml/xml.js';
-import { RELATIONSHIPS_NS } from '../opc/namespaces.js';
+import { relAttr, RELATIONSHIPS_NS } from '../opc/namespaces.js';
 import { relationship, relationshipsPart } from '../opc/rels.js';
 import { DRAWINGML_NS, XDR_NS } from './namespaces.js';
 const IMAGE_REL_TYPE = `${RELATIONSHIPS_NS}/image`;
-const IMAGE_CONTENT_TYPES = {
-    png: 'image/png',
-    jpg: 'image/jpeg',
-    jpeg: 'image/jpeg',
-    gif: 'image/gif',
-    bmp: 'image/bmp',
-    tif: 'image/tiff',
-    tiff: 'image/tiff',
-    emf: 'image/x-emf',
-    wmf: 'image/x-wmf',
-    svg: 'image/svg+xml',
-};
+const IMAGE_CONTENT_TYPES = new Map([
+    ['png', 'image/png'],
+    ['jpg', 'image/jpeg'],
+    ['jpeg', 'image/jpeg'],
+    ['gif', 'image/gif'],
+    ['bmp', 'image/bmp'],
+    ['tif', 'image/tiff'],
+    ['tiff', 'image/tiff'],
+    ['emf', 'image/x-emf'],
+    ['wmf', 'image/x-wmf'],
+    ['svg', 'image/svg+xml'],
+]);
 export function imageContentType(extension) {
     const ext = extension.toLowerCase();
-    return IMAGE_CONTENT_TYPES[ext] ?? `image/${ext}`;
+    return IMAGE_CONTENT_TYPES.get(ext) ?? `image/${ext}`;
 }
 export function drawingXml(images) {
     const anchors = images.map((image, i) => anchorXml(image, i + 1)).join('');
@@ -84,7 +86,7 @@ export function parseDrawing(xml) {
     let picDepth = 0;
     const coord = new TextCapture(COORDINATES);
     parseXml(xml, {
-        onOpen(name, attrs, selfClosing) {
+        onOpen(name, attrs, selfClosing, scope) {
             const local = localName(name);
             if (local === 'twoCellAnchor' || local === 'oneCellAnchor') {
                 from = blankPoint();
@@ -115,7 +117,7 @@ export function parseDrawing(xml) {
                     ext = { cx, cy };
             }
             else if (local === 'blip') {
-                const value = attrs['r:embed'] ?? attrs.embed;
+                const value = relAttr(scope, attrs, 'embed');
                 if (value !== undefined)
                     embed = value;
             }
@@ -161,14 +163,11 @@ export function parseDrawing(xml) {
 }
 const UNMODELED_DRAWING_CONTENT = new Set(['graphicFrame', 'sp', 'cxnSp', 'grpSp']);
 export function drawingHasUnmodeledContent(xml) {
-    let found = false;
-    parseXml(xml, {
-        onOpen(name) {
-            if (!found && UNMODELED_DRAWING_CONTENT.has(localName(name)))
-                found = true;
-        },
-    });
-    return found;
+    for (const { local } of openElements(xml)) {
+        if (UNMODELED_DRAWING_CONTENT.has(local))
+            return true;
+    }
+    return false;
 }
 const COORDINATES = new Set(['col', 'colOff', 'row', 'rowOff']);
 function setCoordinate(point, coord, value) {

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

@@ -9,6 +9,7 @@
  * The package-level URIs (`.rels`, content types, the relationship vocabulary) describe the
  * container rather than the spreadsheet inside it, and live in `../opc/namespaces.ts`.
  */
+import type { NamespaceScope } from '../../xml/xml-namespaces.ts';
 /**
  * SpreadsheetML main namespace: the default `xmlns` of the workbook,
  * worksheet, styles, sharedStrings, comments, table and pivot parts.
@@ -53,3 +54,18 @@ export declare const DATABAR_LINK_EXT_URI = "{B025F937-C7B1-47D3-B67F-A62EFF666E
 export declare const DATA_VALIDATION_EXT_URI = "{CCE6A557-97BC-4b89-ADB6-D9C93CAAB3DF}";
 export declare const SLICER_LIST_EXT_URI = "{A8765BA9-456A-4dab-B4F3-ACF838C121DE}";
 export declare const SLICER_CACHES_EXT_URI = "{BBE1A952-AA13-448e-AADC-164F8A28A991}";
+/**
+ * Whether an element belongs to the standard SpreadsheetML vocabulary rather than to an extension.
+ *
+ * This used to be spelled `!name.includes(':')`, on the assumption that only extension elements carry
+ * a prefix. A worksheet may bind the *main* namespace to a prefix instead, which is legal and which
+ * real toolchains emit, and then every element has a colon in it: such a file had every one of its
+ * data validations and conditional formats read as an unknown extension and dropped, silently.
+ *
+ * An unprefixed element counts even when the part declares no default namespace. A part with no
+ * `xmlns` at all is not conforming OOXML, but this scanner does not reject it, such parts were read
+ * before, and a fix that gains files by resolving namespaces should not lose files that have none.
+ */
+export declare function isMainNamespaceElement(scope: NamespaceScope, name: string): boolean;
+/** The complement of {@link isMainNamespaceElement}: an element of one of the extension vocabularies. */
+export declare function isExtensionElement(scope: NamespaceScope, name: string): boolean;

package/dist/io/xlsx/namespaces.js

@@ -11,3 +11,10 @@ export const DATABAR_LINK_EXT_URI = '{B025F937-C7B1-47D3-B67F-A62EFF666E3E}';
 export const DATA_VALIDATION_EXT_URI = '{CCE6A557-97BC-4b89-ADB6-D9C93CAAB3DF}';
 export const SLICER_LIST_EXT_URI = '{A8765BA9-456A-4dab-B4F3-ACF838C121DE}';
 export const SLICER_CACHES_EXT_URI = '{BBE1A952-AA13-448e-AADC-164F8A28A991}';
+export function isMainNamespaceElement(scope, name) {
+    const namespace = scope.elementNamespace(name);
+    return namespace === SPREADSHEETML_NS || (namespace === undefined && !name.includes(':'));
+}
+export function isExtensionElement(scope, name) {
+    return !isMainNamespaceElement(scope, name);
+}

package/dist/io/xlsx/package-plan.d.ts

@@ -1,11 +1,13 @@
 import type { CommentThread } from '../../core/comment-thread.ts';
+import type { WorkbookImage } from '../../core/image.ts';
 import type { PivotTable } from '../../core/pivot-table.ts';
 import type { Table } from '../../core/table.ts';
 import type { Workbook } from '../../core/workbook.ts';
 import type { Worksheet } from '../../core/worksheet.ts';
 import type { CommentCell } from './comments.ts';
+import type { HyperlinkPlan } from './hyperlinks.ts';
 import type { DrawingImage } from './images.ts';
-export declare class SheetRelIds {
+export declare class RelIdAllocator {
     #private;
     /** The next relationship id (`rId1`, `rId2`, …), advancing the counter. */
     next(): string;
@@ -94,10 +96,28 @@ export interface MediaPart {
     readonly extension: string;
     readonly data: Uint8Array;
 }
+export interface ResolvedMedia {
+    readonly number: number;
+    readonly image: WorkbookImage;
+}
 export interface MediaPlan {
     readonly parts: readonly MediaPart[];
-    readonly numberById: ReadonlyMap<number, number>;
     readonly extensions: readonly string[];
+    /** The media part number and registered image for a referenced id. Total over the ids
+     * {@link planMedia} saw on the sheets it planned, because planning already threw on any it could
+     * not resolve; an id from anywhere else is a caller bug and is reported as one. */
+    resolve(id: number): ResolvedMedia;
 }
 export declare function planMedia(workbook: Workbook, sheets: readonly Worksheet[]): MediaPlan;
-export declare function planPreservedParts(workbook: Workbook, generatedDrawingCount: number, generatedMediaCount: number): PreservedPlan;
+export declare function planPreservedParts(workbook: Workbook, generatedDrawingCount: number, generatedMediaCount: number, generatedPivotCount: number): PreservedPlan;
+export interface SheetPlan {
+    readonly tables: TablePlan[];
+    readonly drawing: DrawingPlan | null;
+    readonly comments: CommentPlan | null;
+    readonly threadedComments: ThreadedCommentPlan | null;
+    readonly printerSettings: PrinterSettingsPlan | null;
+    readonly hyperlinks: HyperlinkPlan[];
+    readonly background: BackgroundPlan | null;
+    readonly preservedRefs: PreservedReferencePlan[];
+    readonly pivots: PivotPlan[];
+}

package/dist/io/xlsx/package-plan.js

@@ -1,49 +1,65 @@
-import { AuthoringError } from '../../errors.js';
+import { AuthoringError, InternalError, quoted } from '../../errors.js';
 import { extensionOf, relativePartPath, relsPathFor, THEME_PART_PATH } from '../opc/part-paths.js';
-import { preservedRelsXml } from '../opc/rels.js';
+import { relsPartXml } from '../opc/rels.js';
+import { drawingPart, mediaPart, pivotCacheDefinitionPart, pivotCacheRecordsPart, pivotTablePart, vmlDrawingPart, } from './part-names.js';
 import { applyThemeOverrides } from './theme-xml.js';
-export class SheetRelIds {
+export class RelIdAllocator {
     #next = 1;
     next() {
         return `rId${this.#next++}`;
     }
 }
 export function planMedia(workbook, sheets) {
-    const usedIds = [];
+    const uses = [];
     const seen = new Set();
-    const use = (id) => {
+    const use = (id, sheetName, role) => {
         if (!seen.has(id)) {
             seen.add(id);
-            usedIds.push(id);
+            uses.push({ id, sheetName, role });
         }
     };
     for (const sheet of sheets) {
         for (const image of sheet.images)
-            use(image.imageId);
-        if (sheet.backgroundImageId !== undefined)
-            use(sheet.backgroundImageId);
+            use(image.imageId, sheet.name, 'anchor');
+        if (sheet.backgroundImageId !== undefined) {
+            use(sheet.backgroundImageId, sheet.name, 'background');
+        }
     }
     const parts = [];
-    const numberById = new Map();
+    const byId = new Map();
     const extensions = new Set();
-    usedIds.forEach((id, i) => {
+    uses.forEach(({ id, sheetName, role }, i) => {
         const image = workbook.getImage(id);
         if (image === undefined) {
-            throw new AuthoringError(`a worksheet anchors image id ${id}, which is not registered on the workbook`);
+            const reference = role === 'anchor' ? `anchors image id ${id}` : `sets background image id ${id}`;
+            throw new AuthoringError(`sheet ${quoted(sheetName)} ${reference}, which is not registered on the workbook`);
         }
         const number = i + 1;
         parts.push({ number, extension: image.extension, data: image.data });
-        numberById.set(id, number);
+        byId.set(id, { number, image });
         extensions.add(image.extension);
     });
-    return { parts, numberById, extensions: [...extensions] };
+    return {
+        parts,
+        extensions: [...extensions],
+        resolve(id) {
+            const resolved = byId.get(id);
+            if (resolved === undefined) {
+                throw new AuthoringError(`image id ${id} was not planned into this workbook's media`);
+            }
+            return resolved;
+        },
+    };
 }
-export function planPreservedParts(workbook, generatedDrawingCount, generatedMediaCount) {
+export function planPreservedParts(workbook, generatedDrawingCount, generatedMediaCount, generatedPivotCount) {
     const sheets = workbook.worksheets;
     const numbering = {
         drawing: generatedDrawingCount,
         vml: sheets.length,
         media: generatedMediaCount,
+        pivotTable: generatedPivotCount,
+        pivotCacheDefinition: generatedPivotCount,
+        pivotCacheRecords: generatedPivotCount,
     };
     const remap = new Map();
     const theme = workbook.themePart;
@@ -64,7 +80,7 @@ export function planPreservedParts(workbook, generatedDrawingCount, generatedMed
     const emitted = new Map();
     for (const reference of allReferences) {
         for (const part of reference.parts) {
-            const newPath = remap.get(part.path);
+            const newPath = resolveRemapped(remap, part.path);
             if (emitted.has(newPath))
                 continue;
             const rels = part.rels.flatMap((rel) => {
@@ -84,24 +100,24 @@ export function planPreservedParts(workbook, generatedDrawingCount, generatedMed
                     : new TextEncoder().encode(applyThemeOverrides(new TextDecoder().decode(part.bytes), overrides)),
                 contentType: part.contentType,
                 relsPath: rels.length === 0 ? null : relsPathFor(newPath),
-                relsXml: rels.length === 0 ? null : preservedRelsXml(rels),
+                relsXml: rels.length === 0 ? null : relsPartXml(rels),
             });
         }
     }
     const perSheet = sheets.map((sheet) => sheet.preservedReferences.map((reference) => ({
         element: reference.element,
         relType: reference.relType,
-        entryPath: remap.get(reference.entryPath),
+        entryPath: resolveRemapped(remap, reference.entryPath),
     })));
     const workbookRefs = workbook.preservedReferences.map((reference) => ({
         relType: reference.relType,
-        entryPath: remap.get(reference.entryPath),
+        entryPath: resolveRemapped(remap, reference.entryPath),
         pivotCacheId: reference.pivotCacheId,
         externalReferenceIndex: reference.externalReferenceIndex,
     }));
     const rootRefs = workbook.preservedRootReferences.map((reference) => ({
         relType: reference.relType,
-        entryPath: remap.get(reference.entryPath),
+        entryPath: resolveRemapped(remap, reference.entryPath),
     }));
     return {
         perSheet,
@@ -111,14 +127,39 @@ export function planPreservedParts(workbook, generatedDrawingCount, generatedMed
         themeEmitted: theme !== undefined,
     };
 }
+function resolveRemapped(remap, path) {
+    const resolved = remap.get(path);
+    if (resolved === undefined) {
+        throw new InternalError(`preserved part ${quoted(path)} was never assigned a new path`);
+    }
+    return resolved;
+}
 function preservedPartPath(originalPath, numbering) {
     const ext = extensionOf(originalPath);
-    if (ext.toLowerCase() === 'vml')
-        return `xl/drawings/vmlDrawing${++numbering.vml}.vml`;
+    if (ext === 'vml')
+        return vmlDrawingPart(++numbering.vml);
     if (originalPath.startsWith('xl/media/'))
-        return `xl/media/image${++numbering.media}.${ext}`;
-    if (originalPath.startsWith('xl/drawings/') && ext.toLowerCase() === 'xml') {
-        return `xl/drawings/drawing${++numbering.drawing}.xml`;
+        return mediaPart(++numbering.media, ext);
+    if (originalPath.startsWith('xl/drawings/') && ext === 'xml') {
+        return drawingPart(++numbering.drawing);
+    }
+    if (isNumberedPart(originalPath, PIVOT_TABLE_PREFIX)) {
+        return pivotTablePart(++numbering.pivotTable);
+    }
+    if (isNumberedPart(originalPath, PIVOT_CACHE_DEFINITION_PREFIX)) {
+        return pivotCacheDefinitionPart(++numbering.pivotCacheDefinition);
+    }
+    if (isNumberedPart(originalPath, PIVOT_CACHE_RECORDS_PREFIX)) {
+        return pivotCacheRecordsPart(++numbering.pivotCacheRecords);
     }
     return originalPath;
 }
+const PIVOT_TABLE_PREFIX = numberedPartPrefix(pivotTablePart);
+const PIVOT_CACHE_DEFINITION_PREFIX = numberedPartPrefix(pivotCacheDefinitionPart);
+const PIVOT_CACHE_RECORDS_PREFIX = numberedPartPrefix(pivotCacheRecordsPart);
+function numberedPartPrefix(part) {
+    return part(1).slice(0, -'1.xml'.length);
+}
+function isNumberedPart(path, prefix) {
+    return path.startsWith(prefix) && /^\d+\.xml$/.test(path.slice(prefix.length));
+}

package/dist/io/xlsx/part-names.d.ts

@@ -0,0 +1,41 @@
+/** The office document part: the workbook every other part hangs off. */
+export declare const WORKBOOK_PART = "xl/workbook.xml";
+export declare const STYLES_PART = "xl/styles.xml";
+export declare const SHARED_STRINGS_PART = "xl/sharedStrings.xml";
+/** Singular and unnumbered, unlike the per-sheet thread parts: one identity registry serves the
+ * whole workbook's threaded comments. */
+export declare const PERSONS_PART = "xl/persons/person.xml";
+export declare const CORE_PROPS_PART = "docProps/core.xml";
+export declare const APP_PROPS_PART = "docProps/app.xml";
+/** `xl/worksheets/sheet{n}.xml`, numbered by the sheet's position in the workbook (1-based). */
+export declare function worksheetPart(number: number): string;
+/** `xl/tables/table{n}.xml`, numbered across the whole workbook rather than per sheet. */
+export declare function tablePart(number: number): string;
+/** `xl/media/image{n}.{ext}`: the one part name that carries the source file's own extension, since
+ * the `<Default>` content type is registered per extension. */
+export declare function mediaPart(number: number, extension: string): string;
+/** `xl/drawings/drawing{n}.xml`: the DrawingML anchors for one sheet's images. */
+export declare function drawingPart(number: number): string;
+/** `xl/drawings/vmlDrawing{n}.vml`: the legacy shape a note's box is drawn as. Numbered with the
+ * comments part it accompanies, not with the DrawingML drawings it shares a directory with. */
+export declare function vmlDrawingPart(number: number): string;
+/** `xl/comments{n}.xml`: directly under `xl/`, unlike every other numbered part. */
+export declare function commentsPart(number: number): string;
+/** `xl/threadedComments/threadedComment{n}.xml`: one sheet's modern conversations. */
+export declare function threadedCommentsPart(number: number): string;
+/** `xl/printerSettings/printerSettings{n}.bin`: an opaque blob carried through verbatim. */
+export declare function printerSettingsPart(number: number): string;
+/** `xl/pivotTables/pivotTable{n}.xml`: the pivot as its host sheet reaches it. */
+export declare function pivotTablePart(number: number): string;
+/** `xl/pivotCache/pivotCacheDefinition{n}.xml`: the field catalogue and source reference. */
+export declare function pivotCacheDefinitionPart(number: number): string;
+/** `xl/pivotCache/pivotCacheRecords{n}.xml`: the cached rows the definition points at. */
+export declare function pivotCacheRecordsPart(number: number): string;
+/**
+ * A part named as a Target of a relationship carried by a *worksheet*. Every worksheet part lives in
+ * `xl/worksheets/`, so one sheet's view of a target is every sheet's, and the sheet number the
+ * arithmetic runs against does not matter.
+ */
+export declare function targetFromWorksheet(partPath: string): string;
+/** A part named as a Target of a relationship carried by the workbook part. */
+export declare function targetFromWorkbook(partPath: string): string;

package/dist/io/xlsx/part-names.js

@@ -0,0 +1,46 @@
+import { relativePartPath } from '../opc/part-paths.js';
+export const WORKBOOK_PART = 'xl/workbook.xml';
+export const STYLES_PART = 'xl/styles.xml';
+export const SHARED_STRINGS_PART = 'xl/sharedStrings.xml';
+export const PERSONS_PART = 'xl/persons/person.xml';
+export const CORE_PROPS_PART = 'docProps/core.xml';
+export const APP_PROPS_PART = 'docProps/app.xml';
+export function worksheetPart(number) {
+    return `xl/worksheets/sheet${number}.xml`;
+}
+export function tablePart(number) {
+    return `xl/tables/table${number}.xml`;
+}
+export function mediaPart(number, extension) {
+    return `xl/media/image${number}.${extension}`;
+}
+export function drawingPart(number) {
+    return `xl/drawings/drawing${number}.xml`;
+}
+export function vmlDrawingPart(number) {
+    return `xl/drawings/vmlDrawing${number}.vml`;
+}
+export function commentsPart(number) {
+    return `xl/comments${number}.xml`;
+}
+export function threadedCommentsPart(number) {
+    return `xl/threadedComments/threadedComment${number}.xml`;
+}
+export function printerSettingsPart(number) {
+    return `xl/printerSettings/printerSettings${number}.bin`;
+}
+export function pivotTablePart(number) {
+    return `xl/pivotTables/pivotTable${number}.xml`;
+}
+export function pivotCacheDefinitionPart(number) {
+    return `xl/pivotCache/pivotCacheDefinition${number}.xml`;
+}
+export function pivotCacheRecordsPart(number) {
+    return `xl/pivotCache/pivotCacheRecords${number}.xml`;
+}
+export function targetFromWorksheet(partPath) {
+    return relativePartPath(worksheetPart(1), partPath);
+}
+export function targetFromWorkbook(partPath) {
+    return relativePartPath(WORKBOOK_PART, partPath);
+}

package/dist/io/xlsx/pivot.js

@@ -1,5 +1,5 @@
 import { encodeAddress } from '../../core/address.js';
-import { escapeAttr, XML_DECLARATION } from '../../xml/xml.js';
+import { boolAttr, escapeAttr, numberText, XML_DECLARATION } from '../../xml/xml.js';
 import { RELATIONSHIPS_NS } from '../opc/namespaces.js';
 import { SPREADSHEETML_NS } from './namespaces.js';
 const METRIC_CAPTIONS = {
@@ -30,9 +30,10 @@ export function pivotCacheDefinitionXml(table) {
         const numeric = field.numeric;
         const descriptor = numeric === null
             ? `<sharedItems${blank}/>`
-            : `<sharedItems containsSemiMixedTypes="0" containsString="0" containsNumber="1" ` +
-                `containsInteger="${numeric.allInteger ? 1 : 0}"${blank} ` +
-                `minValue="${numeric.min}" maxValue="${numeric.max}"/>`;
+            : `<sharedItems containsSemiMixedTypes="0" containsString="0" containsNumber="1"` +
+                boolAttr('containsInteger', numeric.allInteger) +
+                blank +
+                ` minValue="${numberText(numeric.min)}" maxValue="${numberText(numeric.max)}"/>`;
         return `<cacheField name="${escapeAttr(field.name)}" numFmtId="0">${descriptor}</cacheField>`;
     })
         .join('');
@@ -56,8 +57,8 @@ export function pivotCacheRecordsXml(table) {
         `</pivotCacheRecords>`);
 }
 export function pivotTableXml(table, name, cacheId) {
-    const rowField = table.rowFields[0];
-    const columnField = table.columnFields[0];
+    const rowField = table.rowFields[0] ?? 0;
+    const columnField = table.columnFields[0] ?? 0;
     const rowGroups = table.cacheFields[rowField]?.sharedItems?.length ?? 1;
     const columnGroups = table.cacheFields[columnField]?.sharedItems?.length ?? 1;
     const location = `A1:${encodeAddress(2 + columnGroups, 3 + rowGroups)}`;
@@ -107,7 +108,7 @@ function sharedItemXml(item) {
         case 'string':
             return `<s v="${escapeAttr(item.value)}"/>`;
         case 'number':
-            return `<n v="${item.value}"/>`;
+            return `<n v="${numberText(item.value)}"/>`;
         case 'blank':
             return '<m/>';
     }

package/dist/io/xlsx/read-parts.d.ts

@@ -0,0 +1,59 @@
+import type { CommentThread } from '../../core/comment-thread.ts';
+import { Workbook } from '../../core/workbook.ts';
+import type { Worksheet } from '../../core/worksheet.ts';
+import type { CollectingPass } from '../../xml/xml-read.ts';
+import { type PackageAccessors, type PartRelationships } from '../opc/read-opc.ts';
+import { type ParsedComment } from './comments.ts';
+/**
+ * What every part reader in one package read shares: the inflated package, the model being built, the
+ * content-type resolver a preserved part's closure is captured through, and the interning map that
+ * makes one workbook image per media part however many places point at it.
+ *
+ * None of the four varies within a read, and threading them positionally is what let `internImage`
+ * end up taking the same three in a different order from both of its callers. What genuinely varies
+ * -- a part's relationships, the sheet being filled -- stays a positional argument, and the sheet's
+ * rels in particular are deliberately *not* in here: they are per sheet, and a stale copy of them
+ * would send every sheet's parts to the first sheet's.
+ */
+export interface PackageReadContext {
+    readonly pkg: PackageAccessors;
+    readonly workbook: Workbook;
+    readonly contentTypeOf: (path: string) => string;
+    readonly imageIdByMediaPath: Map<string, number>;
+}
+export declare function readSheetComments(sheetRels: PartRelationships): Map<string, ParsedComment> | undefined;
+export declare function readWorkbookPersons({ workbook }: PackageReadContext, workbookRels: PartRelationships): void;
+export declare function readWorkbookTheme(context: PackageReadContext, workbookRels: PartRelationships): void;
+export declare function readSheetCommentThreads({ workbook }: PackageReadContext, sheetRels: PartRelationships): CommentThread[];
+export declare function readSheetPrinterSettings(sheetRels: PartRelationships): Uint8Array | undefined;
+export declare function readSheetImages(context: PackageReadContext, sheetRels: PartRelationships, sheet: Worksheet): void;
+export declare function readSheetBackground(context: PackageReadContext, sheetRels: PartRelationships, sheet: Worksheet): void;
+export declare function readSheetPreservedReferences(context: PackageReadContext, sheetRels: PartRelationships, referenceRelIds: WorksheetReferenceRelIds, sheet: Worksheet): void;
+export declare function readWorkbookPreservedReferences(context: PackageReadContext, workbookRels: PartRelationships, registrations: WorkbookRegistrations): void;
+export declare function readRootPreservedReferences(context: PackageReadContext): void;
+/** The two `<pivotCaches>`/`<externalReferences>` registries a preserved reference is wired by,
+ * gathered from the workbook part's own scan rather than from two more of it. */
+export interface WorkbookRegistrations {
+    readonly cacheIdByRelId: ReadonlyMap<string, string>;
+    readonly externalIndexByRelId: ReadonlyMap<string, number>;
+}
+export declare function pivotCacheRegistrationsPass(): CollectingPass<ReadonlyMap<string, string>>;
+export declare function externalReferenceRegistrationsPass(): CollectingPass<ReadonlyMap<string, number>>;
+/** The `r:id` each of the two element-wired references carries, or `undefined` where absent. */
+export type WorksheetReferenceRelIds = Readonly<Partial<Record<'drawing' | 'legacyDrawingHF', string>>>;
+/**
+ * A pass gathering the `r:id` of the first `<drawing>` and `<legacyDrawingHF>` in a worksheet.
+ *
+ * These two references live in the worksheet body rather than being distinguishable by relationship
+ * Type, since a header/footer VML and a comment VML share the `vmlDrawing` type, so the specific
+ * relationship is found by reading the element's own `r:id`.
+ *
+ * A pass rather than its own scan, because the sheet part is the largest in a package by a wide
+ * margin and this ran a full extra scan of it, once or twice per sheet, for two attributes.
+ * `readSheet` already builds a multi-pass single parse of it whose own comment records that five
+ * separate scans "spent 45% of a large file's read on four scans that matched no element"; this was
+ * the sixth scan, added later, that the same argument covers.
+ */
+export declare function worksheetReferencePass(): CollectingPass<WorksheetReferenceRelIds>;
+export declare function readSheetTables({ pkg }: PackageReadContext, sheetRels: PartRelationships, sheet: Worksheet): void;
+export declare function readSheetPivotTables({ pkg }: PackageReadContext, sheetRels: PartRelationships, sheet: Worksheet): void;