@shbernal/ts-xlsx 2.1.0 → 3.1.0

package/dist/io/xlsx/read.js

@@ -1,54 +1,49 @@
-import { decodeRange } from '../../core/address.js';
-import { unmangleFunctions } from '../../core/formula.js';
 import { INTERNAL } from '../../core/internal.js';
-import { WORKBOOK_PROTECTION_CREDENTIAL_ATTRS, } from '../../core/workbook-protection.js';
 import { Workbook } from '../../core/workbook.js';
-import { isVisibility } from '../../core/worksheet.js';
-import { boolStrict, capturedText, enumToken, localName, numInteger, openElements, parseXml, } from '../../xml/xml-read.js';
+import { parseXmlPasses } from '../../xml/xml-read.js';
 import { UnsupportedFormatError } from '../opc/errors.js';
-import { extensionOf } from '../opc/part-paths.js';
-import { capturePartClosure, contentTypeResolver, packageAccessors, parseRelationshipRecords, parseRelationships, readPartRelationships, relationshipTargetByType, resolveRelativePart, resolveWorkbookPart, } from '../opc/read-opc.js';
-import { DEFAULT_MAX_UNCOMPRESSED } from '../opc/read-options.js';
-import { inflateSpreadsheetPackage } from '../opc/sniff-format.js';
-import { readXlsbPackage, XLSB_WORKBOOK_PART } from '../xlsb/read.js';
-import { applyNotes, parseComments } from './comments.js';
-import { parseConditionalFormattings, parseDxfs } from './conditional-formatting.js';
-import { applyDataValidations, parseDataValidations, parseExtendedDataValidations, } from './data-validation.js';
-import { applyHyperlinks, parseSheetHyperlinks } from './hyperlinks.js';
-import { drawingHasUnmodeledContent, parseDrawing } from './images.js';
-import { parsePivotTable } from './read-pivot.js';
+import { contentTypeResolver, openSpreadsheetPackage, readPartRelationships, } from '../opc/read-opc.js';
+import { readXlsbPackage } from '../xlsb/read.js';
+import { applyNotes } from './comments.js';
+import { conditionalFormattingPass } from './conditional-formatting.js';
+import { applyDataValidations, dataValidationPass, extendedDataValidationPass, } from './data-validation.js';
+import { applyHyperlinks, sheetHyperlinkPass } from './hyperlinks.js';
+import { SHARED_STRINGS_PART, STYLES_PART } from './part-names.js';
+import { readRootPreservedReferences, readSheetBackground, readSheetComments, readSheetCommentThreads, readSheetImages, readSheetPivotTables, readSheetPreservedReferences, readSheetPrinterSettings, readSheetTables, readWorkbookPersons, externalReferenceRegistrationsPass, pivotCacheRegistrationsPass, readWorkbookPreservedReferences, readWorkbookTheme, worksheetReferencePass, } from './read-parts.js';
+import { admitting, repairSheetName } from './read-repair.js';
 import { parseSharedStrings } from './read-shared-strings.js';
-import { parseIndexedColors, parseMruColors, parseStyleTable, parseTableStyles, } from './read-styles.js';
-import { parseWorksheet } from './read-worksheet.js';
-import { parseTable } from './tables.js';
-import { parseThemeColorScheme, parseThemeFontScheme } from './theme-xml.js';
-import { buildCommentThreads, parsePersons, parseThreadedComments } from './threaded-comments.js';
-export { parseRelationships, resolveWorkbookPart } from '../opc/read-opc.js';
-export { DEFAULT_MAX_UNCOMPRESSED } from '../opc/read-options.js';
+import { parseStyleTable } from './read-styles.js';
+import { applyAppProperties, applyCoreProperties, definedNamesPass, workbookPropertiesPass, workbookProtectionPass, workbookSheetsPass, workbookViewPass, } from './read-workbook-xml.js';
+import { worksheetPass } from './read-worksheet.js';
 export { parseStyleTable } from './read-styles.js';
+export { workbookPropertiesPass, workbookSheetsPass, workbookViewPass, } from './read-workbook-xml.js';
 export function readXlsx(data, options = {}) {
-    const cap = options.maxUncompressedBytes ?? DEFAULT_MAX_UNCOMPRESSED;
-    const files = inflateSpreadsheetPackage(data, cap);
-    const pkg = packageAccessors(files);
-    const { partText } = pkg;
-    const workbookXml = partText('xl/workbook.xml');
+    const { files, pkg, documentPath, workbookXml } = openSpreadsheetPackage(data, options.maxUncompressedBytes);
+    const { partText, partBytes } = pkg;
     if (workbookXml === undefined) {
-        if (files[XLSB_WORKBOOK_PART] !== undefined)
-            return readXlsbPackage(files);
+        if (partBytes(documentPath) !== undefined)
+            return readXlsbPackage(files, documentPath);
         throw new UnsupportedFormatError('unknown');
     }
     const contentTypeOf = contentTypeResolver(partText('[Content_Types].xml') ?? '');
-    const workbookRelsXml = partText('xl/_rels/workbook.xml.rels') ?? '';
-    const rels = parseRelationships(workbookRelsXml);
-    const sharedStrings = parseSharedStrings(partText('xl/sharedStrings.xml') ?? '');
-    const stylesXml = partText('xl/styles.xml') ?? '';
-    const { cellXfs: xfStyles, namedStyles, defaultFont } = parseStyleTable(stylesXml);
+    const workbookRels = readPartRelationships(documentPath, partText);
+    const sharedStrings = parseSharedStrings(workbookRels.relatedTextOrPath('sharedStrings', SHARED_STRINGS_PART));
+    const stylesXml = workbookRels.relatedTextOrPath('styles', STYLES_PART);
+    const { cellXfs: xfStyles, namedStyles, defaultFont, preserved } = parseStyleTable(stylesXml);
     const workbook = new Workbook();
-    workbook[INTERNAL].restoreDifferentialStyles(parseDxfs(stylesXml));
-    workbook[INTERNAL].restoreIndexedColors(parseIndexedColors(stylesXml));
-    workbook[INTERNAL].restoreMruColors(parseMruColors(stylesXml));
-    workbook[INTERNAL].restoreTableStyles(parseTableStyles(stylesXml));
-    readWorkbookTheme(workbookRelsXml, pkg, contentTypeOf, workbook);
+    const context = {
+        pkg,
+        workbook,
+        contentTypeOf,
+        sharedStrings,
+        xfStyles,
+        imageIdByMediaPath: new Map(),
+    };
+    workbook[INTERNAL].restoreDifferentialStyles([...preserved.dxfs]);
+    workbook[INTERNAL].restoreIndexedColors([...preserved.indexedColors]);
+    workbook[INTERNAL].restoreMruColors([...preserved.mruColors]);
+    workbook[INTERNAL].restoreTableStyles(preserved.tableStyles);
+    readWorkbookTheme(context, workbookRels);
     if (namedStyles.length > 1)
         workbook[INTERNAL].restoreNamedStyles(namedStyles);
     workbook[INTERNAL].restoreDefaultFont(defaultFont);
@@ -58,408 +53,88 @@ export function readXlsx(data, options = {}) {
     const app = partText('docProps/app.xml');
     if (app !== undefined)
         applyAppProperties(workbook, app);
-    workbook.protection = parseWorkbookProtection(workbookXml);
-    applyWorkbookView(workbook.view, workbookXml);
-    readWorkbookPersons(workbookRelsXml, pkg, workbook);
-    const imageIdByMediaPath = new Map();
+    const protection = workbookProtectionPass();
+    const sheets = workbookSheetsPass();
+    const definedNames = definedNamesPass();
+    const pivotCaches = pivotCacheRegistrationsPass();
+    const externalReferences = externalReferenceRegistrationsPass();
+    parseXmlPasses(workbookXml, [
+        protection,
+        workbookPropertiesPass(workbook),
+        workbookViewPass(workbook.view),
+        sheets,
+        definedNames,
+        pivotCaches,
+        externalReferences,
+    ]);
+    workbook.protection = protection.result();
+    readWorkbookPersons(context, workbookRels);
     const sheetOrder = [];
-    for (const { name, relId, state } of parseWorkbookSheets(workbookXml)) {
-        const target = rels.get(relId);
-        const sheet = workbook.addWorksheet(name, state === undefined ? undefined : { state });
-        sheetOrder.push(name);
-        const path = target === undefined ? undefined : resolveWorkbookPart(target);
-        const sheetXml = path === undefined ? undefined : partText(path);
-        if (sheetXml !== undefined)
-            parseWorksheet(sheetXml, sheet, sharedStrings, xfStyles);
-        if (path !== undefined) {
-            const sheetRels = readPartRelationships(path, partText);
-            if (sheetXml !== undefined) {
-                applyHyperlinks(sheet, parseSheetHyperlinks(sheetXml), (id) => sheetRels.byId(id)?.target);
-                applyDataValidations(sheet, [
-                    ...parseDataValidations(sheetXml),
-                    ...parseExtendedDataValidations(sheetXml),
-                ]);
-                for (const cf of parseConditionalFormattings(sheetXml))
-                    sheet.addConditionalFormatting(cf);
-            }
-            const threads = readSheetCommentThreads(sheetRels, pkg, workbook);
-            if (threads.length > 0)
-                sheet[INTERNAL].restoreCommentThreads(threads);
-            const comments = readSheetComments(sheetRels, pkg);
-            if (comments !== undefined)
-                applyNotes(sheet, comments);
-            readSheetImages(sheetRels, pkg, workbook, sheet, imageIdByMediaPath);
-            readSheetBackground(sheetRels, pkg, workbook, sheet, imageIdByMediaPath);
-            if (sheetXml !== undefined) {
-                readSheetPreservedReferences(sheetRels, sheetXml, pkg, contentTypeOf, sheet);
-            }
-            readSheetTables(sheetRels, pkg, sheet);
-            readSheetPivotTables(sheetRels, pkg, sheet);
-            const printerSettings = readSheetPrinterSettings(sheetRels, pkg);
-            if (printerSettings !== undefined)
-                sheet.pageSetup.printerSettings = printerSettings;
-        }
-    }
-    readWorkbookPreservedReferences(workbookXml, pkg, contentTypeOf, workbook);
-    readRootPreservedReferences(pkg, contentTypeOf, workbook);
-    for (const name of parseWorkbookDefinedNames(workbookXml, sheetOrder)) {
-        workbook.defineName(name);
-    }
-    return workbook;
-}
-function readSheetComments(sheetRels, pkg) {
-    const commentsPath = sheetRels.targetPath('comments');
-    if (commentsPath === undefined)
-        return undefined;
-    const commentsXml = pkg.partText(commentsPath);
-    if (commentsXml === undefined)
-        return undefined;
-    return parseComments(commentsXml);
-}
-function readWorkbookPersons(workbookRelsXml, pkg, workbook) {
-    const target = relationshipTargetByType(workbookRelsXml, 'person');
-    const xml = target === undefined ? undefined : pkg.partText(resolveWorkbookPart(target));
-    if (xml !== undefined)
-        workbook[INTERNAL].restorePersons(parsePersons(xml));
-}
-function readWorkbookTheme(workbookRelsXml, pkg, contentTypeOf, workbook) {
-    const target = relationshipTargetByType(workbookRelsXml, 'theme');
-    if (target === undefined)
-        return;
-    const entryPath = resolveWorkbookPart(target);
-    const parts = capturePartClosure(entryPath, pkg.partText, pkg.partBytes, contentTypeOf);
-    if (parts === undefined)
-        return;
-    const xml = pkg.partText(entryPath) ?? '';
-    workbook[INTERNAL].restoreThemePart({ entryPath, parts }, { colors: parseThemeColorScheme(xml), fonts: parseThemeFontScheme(xml) });
-}
-function readSheetCommentThreads(sheetRels, pkg, workbook) {
-    const path = sheetRels.targetPath('threadedComment');
-    const xml = path === undefined ? undefined : pkg.partText(path);
-    if (xml === undefined)
-        return [];
-    return buildCommentThreads(parseThreadedComments(xml), (id) => workbook.getPerson(id));
-}
-function readSheetPrinterSettings(sheetRels, pkg) {
-    const path = sheetRels.targetPath('printerSettings');
-    return path === undefined ? undefined : pkg.partBytes(path);
-}
-function internImage(workbook, pkg, imageIdByMediaPath, mediaPath) {
-    const known = imageIdByMediaPath.get(mediaPath);
-    if (known !== undefined)
-        return known;
-    const bytes = pkg.partBytes(mediaPath);
-    if (bytes === undefined)
-        return undefined;
-    const id = workbook.addImage({ buffer: bytes, extension: extensionOf(mediaPath) });
-    imageIdByMediaPath.set(mediaPath, id);
-    return id;
-}
-function readSheetImages(sheetRels, pkg, workbook, sheet, imageIdByMediaPath) {
-    const { partText } = pkg;
-    const drawingPath = sheetRels.targetPath('drawing');
-    if (drawingPath === undefined)
-        return;
-    const drawingXml = partText(drawingPath);
-    if (drawingXml === undefined)
-        return;
-    if (drawingHasUnmodeledContent(drawingXml))
-        return;
-    const drawingRels = readPartRelationships(drawingPath, partText);
-    for (const anchor of parseDrawing(drawingXml)) {
-        const embedded = drawingRels.byId(anchor.embed);
-        if (embedded === undefined)
-            continue;
-        const mediaPath = drawingRels.pathOf(embedded.target);
-        const id = internImage(workbook, pkg, imageIdByMediaPath, mediaPath);
-        if (id === undefined)
-            continue;
-        const rot = anchor.rotation !== undefined ? { rotation: anchor.rotation } : {};
-        if (anchor.to !== undefined) {
-            const mode = anchor.editAs !== undefined ? { editAs: anchor.editAs } : {};
-            sheet.addImageAnchor(id, { from: anchor.from, to: anchor.to, ...mode, ...rot });
-        }
-        else if (anchor.ext !== undefined) {
-            sheet.addImageAnchor(id, { from: anchor.from, ext: anchor.ext, ...rot });
-        }
-    }
-}
-function readSheetBackground(sheetRels, pkg, workbook, sheet, imageIdByMediaPath) {
-    const mediaPath = sheetRels.targetPath('image');
-    if (mediaPath === undefined)
-        return;
-    const id = internImage(workbook, pkg, imageIdByMediaPath, mediaPath);
-    if (id !== undefined)
-        sheet.addBackgroundImage(id);
-}
-function readSheetPreservedReferences(sheetRels, sheetXml, pkg, contentTypeOf, sheet) {
-    const { partText, partBytes } = pkg;
-    const capture = (element, relType, target) => {
-        const entryPath = sheetRels.pathOf(target);
-        const parts = capturePartClosure(entryPath, partText, partBytes, contentTypeOf);
-        if (parts !== undefined)
-            sheet[INTERNAL].addPreservedReference({ element, relType, entryPath, parts });
-    };
-    const referenceElements = sheet.images.length === 0 ? ['drawing', 'legacyDrawingHF'] : ['legacyDrawingHF'];
-    for (const element of referenceElements) {
-        const relId = worksheetReferenceRelId(sheetXml, element);
-        const record = relId === undefined ? undefined : sheetRels.byId(relId);
-        if (record !== undefined && !record.external)
-            capture(element, record.type, record.target);
-    }
-    for (const record of sheetRels.records) {
-        if (record.external)
-            continue;
-        if (isPreservedSheetRelType(record.type))
-            capture(undefined, record.type, record.target);
-    }
-}
-function isPreservedSheetRelType(type) {
-    return type.endsWith('/pivotTable') || type.endsWith('/slicer');
-}
-function readWorkbookPreservedReferences(workbookXml, pkg, contentTypeOf, workbook) {
-    const { partText, partBytes } = pkg;
-    const relsXml = partText('xl/_rels/workbook.xml.rels');
-    if (relsXml === undefined)
-        return;
-    const cacheIdByRelId = parsePivotCacheRegistrations(workbookXml);
-    const externalIndexByRelId = parseExternalReferenceRegistrations(workbookXml);
-    for (const record of parseRelationshipRecords(relsXml)) {
-        if (record.external || !isPreservedWorkbookRelType(record.type))
-            continue;
-        const entryPath = resolveWorkbookPart(record.target);
-        const parts = capturePartClosure(entryPath, partText, partBytes, contentTypeOf);
-        if (parts === undefined)
-            continue;
-        const cacheId = cacheIdByRelId.get(record.id);
-        const externalReferenceIndex = externalIndexByRelId.get(record.id);
-        workbook[INTERNAL].addPreservedReference({
-            relType: record.type,
-            entryPath,
-            parts,
-            ...(cacheId !== undefined ? { pivotCacheId: cacheId } : {}),
-            ...(externalReferenceIndex !== undefined ? { externalReferenceIndex } : {}),
+    const takenSheetNames = new Set();
+    for (const { name, relId, state } of sheets.result()) {
+        const target = workbookRels.byId(relId)?.target;
+        const sheet = workbook.addWorksheet(repairSheetName(name, takenSheetNames), state === undefined ? undefined : { state });
+        takenSheetNames.add(sheet.name.toLowerCase());
+        sheetOrder.push(sheet.name);
+        readSheet(sheet, target === undefined ? undefined : workbookRels.pathOf(target), context);
+    }
+    readWorkbookPreservedReferences(context, workbookRels, {
+        cacheIdByRelId: pivotCaches.result(),
+        externalIndexByRelId: externalReferences.result(),
+    });
+    readRootPreservedReferences(context);
+    for (const name of definedNames.result(sheetOrder)) {
+        admitting(() => {
+            workbook.defineName(name);
         });
     }
+    return workbook;
 }
-function readRootPreservedReferences(pkg, contentTypeOf, workbook) {
-    const { partText, partBytes } = pkg;
-    const relsXml = partText('_rels/.rels');
-    if (relsXml === undefined)
-        return;
-    for (const record of parseRelationshipRecords(relsXml)) {
-        if (record.external || isRegeneratedRootRelType(record.type))
-            continue;
-        const entryPath = resolveRelativePart('', record.target);
-        const parts = capturePartClosure(entryPath, partText, partBytes, contentTypeOf);
-        if (parts === undefined)
-            continue;
-        workbook[INTERNAL].addPreservedRootReference({ relType: record.type, entryPath, parts });
-    }
-}
-function isRegeneratedRootRelType(type) {
-    return (type.endsWith('/officeDocument') ||
-        type.endsWith('/core-properties') ||
-        type.endsWith('/extended-properties'));
-}
-function isPreservedWorkbookRelType(type) {
-    return (type.endsWith('/pivotCacheDefinition') ||
-        type.endsWith('/slicerCache') ||
-        type.endsWith('/vbaProject') ||
-        type.endsWith('/externalLink'));
-}
-function parsePivotCacheRegistrations(workbookXml) {
-    const byRelId = new Map();
-    for (const { attrs } of openElements(workbookXml, 'pivotCache')) {
-        if (attrs['r:id'] !== undefined && attrs.cacheId !== undefined) {
-            byRelId.set(attrs['r:id'], attrs.cacheId);
-        }
-    }
-    return byRelId;
-}
-function parseExternalReferenceRegistrations(workbookXml) {
-    const byRelId = new Map();
-    let index = 0;
-    for (const { attrs } of openElements(workbookXml, 'externalReference')) {
-        if (attrs['r:id'] !== undefined)
-            byRelId.set(attrs['r:id'], index++);
-    }
-    return byRelId;
-}
-function worksheetReferenceRelId(sheetXml, element) {
-    for (const { attrs } of openElements(sheetXml, element)) {
-        if (attrs['r:id'] !== undefined)
-            return attrs['r:id'];
-    }
-    return undefined;
-}
-function readSheetTables(sheetRels, pkg, sheet) {
-    for (const tablePath of sheetRels.targetPaths('table')) {
-        const tableXml = pkg.partText(tablePath);
-        if (tableXml === undefined)
-            continue;
-        const options = parseTable(tableXml);
-        if (options !== undefined)
-            sheet.addTable(options);
-    }
-    dropMergesInsideTables(sheet);
-}
-function readSheetPivotTables(sheetRels, pkg, sheet) {
+function readSheet(sheet, path, context) {
+    const { pkg, workbook, sharedStrings, xfStyles } = context;
     const { partText } = pkg;
-    for (const tablePath of sheetRels.targetPaths('pivotTable')) {
-        const tableXml = partText(tablePath);
-        if (tableXml === undefined)
-            continue;
-        const cachePath = readPartRelationships(tablePath, partText).targetPath('pivotCacheDefinition');
-        const cacheXml = cachePath === undefined ? '' : (partText(cachePath) ?? '');
-        sheet[INTERNAL].addLoadedPivotTable(parsePivotTable(tableXml, cacheXml));
-    }
-}
-function dropMergesInsideTables(sheet) {
-    const regions = sheet.tables.map((table) => table.region);
-    if (regions.length === 0)
-        return;
-    for (const range of [...sheet.merges]) {
-        const { top, left, bottom, right } = decodeRange(range);
-        if (top === undefined || left === undefined || bottom === undefined || right === undefined)
-            continue;
-        const overlaps = regions.some((region) => left <= region.right &&
-            right >= region.left &&
-            top <= region.bottom &&
-            bottom >= region.top);
-        if (overlaps)
-            sheet.unmergeCells(range);
-    }
-}
-export function parseWorkbookSheets(xml) {
-    const sheets = [];
-    for (const { attrs } of openElements(xml, 'sheet')) {
-        const entry = {
-            name: attrs.name ?? '',
-            relId: attrs['r:id'] ?? '',
-        };
-        const state = enumToken(attrs.state, isVisibility);
-        if (state !== undefined && state !== 'visible')
-            entry.state = state;
-        sheets.push(entry);
-    }
-    return sheets;
-}
-function parseWorkbookProtection(xml) {
-    let result;
-    parseXml(xml, {
-        onOpen(name, attrs) {
-            if (localName(name) !== 'workbookProtection')
-                return;
-            const protection = {};
-            if (boolStrict(attrs.lockStructure))
-                protection.lockStructure = true;
-            if (boolStrict(attrs.lockWindows))
-                protection.lockWindows = true;
-            if (boolStrict(attrs.lockRevision))
-                protection.lockRevision = true;
-            const credentials = {};
-            for (const key of WORKBOOK_PROTECTION_CREDENTIAL_ATTRS) {
-                const value = attrs[key];
-                if (value !== undefined)
-                    credentials[key] = value;
-            }
-            if (Object.keys(credentials).length > 0)
-                protection.credentials = credentials;
-            result = protection;
-        },
-    });
-    return result;
-}
-export function applyWorkbookView(view, xml) {
-    for (const { attrs } of openElements(xml, 'workbookView')) {
-        const x = numInteger(attrs.xWindow);
-        if (x !== undefined)
-            view.x = x;
-        const y = numInteger(attrs.yWindow);
-        if (y !== undefined)
-            view.y = y;
-        const width = numInteger(attrs.windowWidth, 0);
-        if (width !== undefined)
-            view.width = width;
-        const height = numInteger(attrs.windowHeight, 0);
-        if (height !== undefined)
-            view.height = height;
-        const activeTab = numInteger(attrs.activeTab, 0);
-        if (activeTab !== undefined)
-            view.activeTab = activeTab;
-        const visibility = enumToken(attrs.visibility, isVisibility);
-        if (visibility !== undefined && visibility !== 'visible')
-            view.visibility = visibility;
-        if (boolStrict(attrs.minimized))
-            view.minimized = true;
+    const sheetXml = path === undefined ? undefined : partText(path);
+    const hyperlinks = sheetHyperlinkPass();
+    const validations = dataValidationPass();
+    const extendedValidations = extendedDataValidationPass();
+    const formattings = conditionalFormattingPass();
+    const references = worksheetReferencePass();
+    if (sheetXml !== undefined) {
+        parseXmlPasses(sheetXml, [
+            worksheetPass(sheet, sharedStrings, xfStyles, workbook.dateEpoch),
+            hyperlinks,
+            validations,
+            extendedValidations,
+            formattings,
+            references,
+        ]);
+    }
+    if (path === undefined)
         return;
-    }
-}
-function parseWorkbookDefinedNames(xml, sheetOrder) {
-    const names = [];
-    let capture = false;
-    let refersTo = '';
-    let pending;
-    parseXml(xml, {
-        onOpen(name, attrs) {
-            if (localName(name) !== 'definedName' || attrs.name === undefined)
-                return;
-            if (attrs.name === '_xlnm._FilterDatabase')
-                return;
-            capture = true;
-            refersTo = '';
-            const scopeIndex = numInteger(attrs.localSheetId, 0) ?? -1;
-            const scope = sheetOrder[scopeIndex];
-            pending = { name: attrs.name };
-            if (scope !== undefined)
-                pending.scope = scope;
-            if (attrs.comment !== undefined)
-                pending.comment = attrs.comment;
-            if (boolStrict(attrs.hidden))
-                pending.hidden = true;
-        },
-        onText(chunk) {
-            if (capture)
-                refersTo += chunk;
-        },
-        onClose(name) {
-            if (localName(name) !== 'definedName' || pending === undefined)
-                return;
-            names.push({ ...pending, refersTo: unmangleFunctions(refersTo) });
-            capture = false;
-            pending = undefined;
-        },
-    });
-    return names;
-}
-const CORE_PROPERTY_LOCAL_NAMES = new Set([
-    'title',
-    'creator',
-    'lastModifiedBy',
-    'created',
-    'modified',
-]);
-function applyCoreProperties(workbook, xml) {
-    for (const { local, text } of capturedText(xml, CORE_PROPERTY_LOCAL_NAMES)) {
-        if (local === 'title')
-            workbook.properties.title = text;
-        else if (local === 'creator')
-            workbook.properties.creator = text;
-        else if (local === 'lastModifiedBy')
-            workbook.properties.lastModifiedBy = text;
-        else {
-            const date = new Date(text);
-            if (!Number.isNaN(date.getTime())) {
-                if (local === 'created')
-                    workbook.properties.created = date;
-                else
-                    workbook.properties.modified = date;
-            }
+    const sheetRels = readPartRelationships(path, partText, pkg.partBytes);
+    if (sheetXml !== undefined) {
+        applyHyperlinks(sheet, hyperlinks.result(), (id) => sheetRels.byId(id)?.target);
+        applyDataValidations(sheet, [...validations.result(), ...extendedValidations.result()]);
+        for (const cf of formattings.result()) {
+            admitting(() => {
+                sheet.addConditionalFormatting(cf);
+            });
         }
     }
-}
-function applyAppProperties(workbook, xml) {
-    for (const { text } of capturedText(xml, 'Company'))
-        workbook.properties.company = text;
+    const threads = readSheetCommentThreads(context, sheetRels);
+    if (threads.length > 0)
+        sheet[INTERNAL].restoreCommentThreads(threads);
+    const comments = readSheetComments(sheetRels);
+    if (comments !== undefined)
+        applyNotes(sheet, comments);
+    readSheetImages(context, sheetRels, sheet);
+    readSheetBackground(context, sheetRels, sheet);
+    if (sheetXml !== undefined) {
+        readSheetPreservedReferences(context, sheetRels, references.result(), sheet);
+    }
+    readSheetTables(context, sheetRels, sheet);
+    readSheetPivotTables(context, sheetRels, sheet);
+    const printerSettings = readSheetPrinterSettings(sheetRels);
+    if (printerSettings !== undefined)
+        sheet.pageSetup.printerSettings = printerSettings;
 }

package/dist/io/xlsx/rich-text.js

@@ -1,5 +1,5 @@
 import { textElement } from '../../xml/xml.js';
-import { fontXml } from './styles.js';
+import { fontXml } from './font-xml.js';
 export function richTextRunsXml(runs) {
     return runs
         .filter((run) => run.text !== '')

package/dist/io/xlsx/row-position.d.ts

@@ -0,0 +1,18 @@
+import { type XmlAttributes } from '../../xml/xml-scan.ts';
+/** One `<row>`, as the reader that opened it needs to see it. */
+export interface RowPosition {
+    /** The row's 1-based number, inferred from position when the element declares no `r`. */
+    readonly number: number;
+    /**
+     * Whether that number names a row the grid has. A row past the ceiling is dropped whole by both
+     * readers rather than clamped: an `r` names one row, so there is nothing to fold it onto, and
+     * clamping would silently move its formatting to the last row of the sheet.
+     */
+    readonly inGrid: boolean;
+}
+/** Tracks where the reader is in `<sheetData>`, so a `<row>` with no `r` still has a number. */
+export declare class RowPositionTracker {
+    #private;
+    /** Open the next `<row>`. A declared `r` wins and re-anchors the count, exactly as position does. */
+    open(attrs: XmlAttributes): RowPosition;
+}

package/dist/io/xlsx/row-position.js

@@ -0,0 +1,11 @@
+import { MAX_ROW } from '../../core/address.js';
+import { numInteger } from '../../xml/xml-attrs.js';
+import {} from '../../xml/xml-scan.js';
+export class RowPositionTracker {
+    #last = 0;
+    open(attrs) {
+        const number = numInteger(attrs.r, 1) ?? this.#last + 1;
+        this.#last = number;
+        return { number, inGrid: number <= MAX_ROW };
+    }
+}