@shbernal/ts-xlsx 2.0.0 → 3.0.0

package/dist/io/xlsx/read.js

@@ -3,51 +3,45 @@ 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 { boolStrict, localName, numInteger, openElements, parseXml } from '../../xml/xml-read.js';
+import { isVisibility } from '../../core/worksheet.js';
+import { capturedText, openElements, parseXml, parseXmlPasses } from '../../xml/xml-read.js';
+import { boolStrict, enumToken, localName, numInteger } from '../../xml/xml-scan.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 { extensionOf, resolveRelativePart } from '../opc/part-paths.js';
+import { capturePartClosure, contentTypeResolver, openSpreadsheetPackage, parseRelationshipRecords, readPartRelationships, } from '../opc/read-opc.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 { conditionalFormattingPass } from './conditional-formatting.js';
+import { applyDataValidations, dataValidationPass, extendedDataValidationPass, } from './data-validation.js';
+import { applyHyperlinks, sheetHyperlinkPass } from './hyperlinks.js';
 import { drawingHasUnmodeledContent, parseDrawing } from './images.js';
 import { parsePivotTable } from './read-pivot.js';
 import { parseSharedStrings } from './read-shared-strings.js';
-import { parseIndexedColors, parseMruColors, parseStyleTable, parseTableStyles, } from './read-styles.js';
-import { parseWorksheet } from './read-worksheet.js';
+import { parseStyleTable } from './read-styles.js';
+import { worksheetPass } 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';
 export { parseStyleTable } from './read-styles.js';
 export function readXlsx(data, options = {}) {
-    const cap = options.maxUncompressedBytes ?? DEFAULT_MAX_UNCOMPRESSED;
-    const files = inflateSpreadsheetPackage(data, cap);
-    const pkg = packageAccessors(files);
+    const { files, pkg, workbookXml } = openSpreadsheetPackage(data, options.maxUncompressedBytes);
     const { partText } = pkg;
-    const workbookXml = partText('xl/workbook.xml');
     if (workbookXml === undefined) {
         if (files[XLSB_WORKBOOK_PART] !== undefined)
             return readXlsbPackage(files);
         throw new UnsupportedFormatError('unknown');
     }
     const contentTypeOf = contentTypeResolver(partText('[Content_Types].xml') ?? '');
-    const workbookRelsXml = partText('xl/_rels/workbook.xml.rels') ?? '';
-    const rels = parseRelationships(workbookRelsXml);
+    const workbookRels = readPartRelationships('xl/workbook.xml', partText);
     const sharedStrings = parseSharedStrings(partText('xl/sharedStrings.xml') ?? '');
     const stylesXml = partText('xl/styles.xml') ?? '';
-    const { cellXfs: xfStyles, namedStyles, defaultFont } = parseStyleTable(stylesXml);
+    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);
+    workbook[INTERNAL].restoreDifferentialStyles([...preserved.dxfs]);
+    workbook[INTERNAL].restoreIndexedColors([...preserved.indexedColors]);
+    workbook[INTERNAL].restoreMruColors([...preserved.mruColors]);
+    workbook[INTERNAL].restoreTableStyles(preserved.tableStyles);
+    readWorkbookTheme(workbookRels, pkg, contentTypeOf, workbook);
     if (namedStyles.length > 1)
         workbook[INTERNAL].restoreNamedStyles(namedStyles);
     workbook[INTERNAL].restoreDefaultFont(defaultFont);
@@ -59,53 +53,72 @@ export function readXlsx(data, options = {}) {
         applyAppProperties(workbook, app);
     workbook.protection = parseWorkbookProtection(workbookXml);
     applyWorkbookView(workbook.view, workbookXml);
-    readWorkbookPersons(workbookRelsXml, pkg, workbook);
-    const imageIdByMediaPath = new Map();
+    readWorkbookPersons(workbookRels, pkg, workbook);
+    const context = {
+        pkg,
+        workbook,
+        contentTypeOf,
+        sharedStrings,
+        xfStyles,
+        imageIdByMediaPath: new Map(),
+    };
     const sheetOrder = [];
     for (const { name, relId, state } of parseWorkbookSheets(workbookXml)) {
-        const target = rels.get(relId);
+        const target = workbookRels.byId(relId)?.target;
         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;
-        }
+        readSheet(sheet, target === undefined ? undefined : workbookRels.pathOf(target), context);
     }
-    readWorkbookPreservedReferences(workbookXml, pkg, contentTypeOf, workbook);
+    readWorkbookPreservedReferences(workbookXml, workbookRels, pkg, contentTypeOf, workbook);
     readRootPreservedReferences(pkg, contentTypeOf, workbook);
     for (const name of parseWorkbookDefinedNames(workbookXml, sheetOrder)) {
         workbook.defineName(name);
     }
     return workbook;
 }
+function readSheet(sheet, path, context) {
+    const { pkg, workbook, contentTypeOf, sharedStrings, xfStyles, imageIdByMediaPath } = context;
+    const { partText } = pkg;
+    const sheetXml = path === undefined ? undefined : partText(path);
+    const hyperlinks = sheetHyperlinkPass();
+    const validations = dataValidationPass();
+    const extendedValidations = extendedDataValidationPass();
+    const formattings = conditionalFormattingPass();
+    if (sheetXml !== undefined) {
+        parseXmlPasses(sheetXml, [
+            worksheetPass(sheet, sharedStrings, xfStyles),
+            hyperlinks,
+            validations,
+            extendedValidations,
+            formattings,
+        ]);
+    }
+    if (path === undefined)
+        return;
+    const sheetRels = readPartRelationships(path, partText);
+    if (sheetXml !== undefined) {
+        applyHyperlinks(sheet, hyperlinks.result(), (id) => sheetRels.byId(id)?.target);
+        applyDataValidations(sheet, [...validations.result(), ...extendedValidations.result()]);
+        for (const cf of formattings.result())
+            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;
+}
 function readSheetComments(sheetRels, pkg) {
     const commentsPath = sheetRels.targetPath('comments');
     if (commentsPath === undefined)
@@ -115,17 +128,16 @@ function readSheetComments(sheetRels, pkg) {
         return undefined;
     return parseComments(commentsXml);
 }
-function readWorkbookPersons(workbookRelsXml, pkg, workbook) {
-    const target = relationshipTargetByType(workbookRelsXml, 'person');
-    const xml = target === undefined ? undefined : pkg.partText(resolveWorkbookPart(target));
+function readWorkbookPersons(workbookRels, pkg, workbook) {
+    const path = workbookRels.targetPath('person');
+    const xml = path === undefined ? undefined : pkg.partText(path);
     if (xml !== undefined)
         workbook[INTERNAL].restorePersons(parsePersons(xml));
 }
-function readWorkbookTheme(workbookRelsXml, pkg, contentTypeOf, workbook) {
-    const target = relationshipTargetByType(workbookRelsXml, 'theme');
-    if (target === undefined)
+function readWorkbookTheme(workbookRels, pkg, contentTypeOf, workbook) {
+    const entryPath = workbookRels.targetPath('theme');
+    if (entryPath === undefined)
         return;
-    const entryPath = resolveWorkbookPart(target);
     const parts = capturePartClosure(entryPath, pkg.partText, pkg.partBytes, contentTypeOf);
     if (parts === undefined)
         return;
@@ -143,8 +155,19 @@ 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, partBytes } = pkg;
+    const { partText } = pkg;
     const drawingPath = sheetRels.targetPath('drawing');
     if (drawingPath === undefined)
         return;
@@ -159,14 +182,9 @@ function readSheetImages(sheetRels, pkg, workbook, sheet, imageIdByMediaPath) {
         if (embedded === undefined)
             continue;
         const mediaPath = drawingRels.pathOf(embedded.target);
-        let id = imageIdByMediaPath.get(mediaPath);
-        if (id === undefined) {
-            const bytes = partBytes(mediaPath);
-            if (bytes === undefined)
-                continue;
-            id = workbook.addImage({ buffer: bytes, extension: extensionOf(mediaPath) });
-            imageIdByMediaPath.set(mediaPath, id);
-        }
+        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 } : {};
@@ -181,15 +199,9 @@ function readSheetBackground(sheetRels, pkg, workbook, sheet, imageIdByMediaPath
     const mediaPath = sheetRels.targetPath('image');
     if (mediaPath === undefined)
         return;
-    let id = imageIdByMediaPath.get(mediaPath);
-    if (id === undefined) {
-        const bytes = pkg.partBytes(mediaPath);
-        if (bytes === undefined)
-            return;
-        id = workbook.addImage({ buffer: bytes, extension: extensionOf(mediaPath) });
-        imageIdByMediaPath.set(mediaPath, id);
-    }
-    sheet.addBackgroundImage(id);
+    const id = internImage(workbook, pkg, imageIdByMediaPath, mediaPath);
+    if (id !== undefined)
+        sheet.addBackgroundImage(id);
 }
 function readSheetPreservedReferences(sheetRels, sheetXml, pkg, contentTypeOf, sheet) {
     const { partText, partBytes } = pkg;
@@ -216,17 +228,14 @@ function readSheetPreservedReferences(sheetRels, sheetXml, pkg, contentTypeOf, s
 function isPreservedSheetRelType(type) {
     return type.endsWith('/pivotTable') || type.endsWith('/slicer');
 }
-function readWorkbookPreservedReferences(workbookXml, pkg, contentTypeOf, workbook) {
+function readWorkbookPreservedReferences(workbookXml, workbookRels, 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)) {
+    for (const record of workbookRels.records) {
         if (record.external || !isPreservedWorkbookRelType(record.type))
             continue;
-        const entryPath = resolveWorkbookPart(record.target);
+        const entryPath = workbookRels.pathOf(record.target);
         const parts = capturePartClosure(entryPath, partText, partBytes, contentTypeOf);
         if (parts === undefined)
             continue;
@@ -337,8 +346,9 @@ export function parseWorkbookSheets(xml) {
             name: attrs.name ?? '',
             relId: attrs['r:id'] ?? '',
         };
-        if (attrs.state === 'hidden' || attrs.state === 'veryHidden')
-            entry.state = attrs.state;
+        const state = enumToken(attrs.state, isVisibility);
+        if (state !== undefined && state !== 'visible')
+            entry.state = state;
         sheets.push(entry);
     }
     return sheets;
@@ -386,9 +396,9 @@ export function applyWorkbookView(view, xml) {
         const activeTab = numInteger(attrs.activeTab, 0);
         if (activeTab !== undefined)
             view.activeTab = activeTab;
-        if (attrs.visibility === 'hidden' || attrs.visibility === 'veryHidden') {
-            view.visibility = attrs.visibility;
-        }
+        const visibility = enumToken(attrs.visibility, isVisibility);
+        if (visibility !== undefined && visibility !== 'visible')
+            view.visibility = visibility;
         if (boolStrict(attrs.minimized))
             view.minimized = true;
         return;
@@ -439,57 +449,25 @@ const CORE_PROPERTY_LOCAL_NAMES = new Set([
     'modified',
 ]);
 function applyCoreProperties(workbook, xml) {
-    let capture = '';
-    let text = '';
-    parseXml(xml, {
-        onOpen(name) {
-            const local = localName(name);
-            capture = CORE_PROPERTY_LOCAL_NAMES.has(local) ? local : '';
-            text = '';
-        },
-        onText(chunk) {
-            if (capture !== '')
-                text += chunk;
-        },
-        onClose(name) {
-            if (capture === '' || localName(name) !== capture)
-                return;
-            if (capture === 'title')
-                workbook.properties.title = text;
-            else if (capture === 'creator')
-                workbook.properties.creator = text;
-            else if (capture === 'lastModifiedBy')
-                workbook.properties.lastModifiedBy = text;
-            else {
-                const date = new Date(text);
-                if (!Number.isNaN(date.getTime())) {
-                    if (capture === 'created')
-                        workbook.properties.created = date;
-                    else
-                        workbook.properties.modified = date;
-                }
+    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;
             }
-            capture = '';
-        },
-    });
+        }
+    }
 }
 function applyAppProperties(workbook, xml) {
-    let capture = false;
-    let text = '';
-    parseXml(xml, {
-        onOpen(name) {
-            capture = localName(name) === 'Company';
-            text = '';
-        },
-        onText(chunk) {
-            if (capture)
-                text += chunk;
-        },
-        onClose(name) {
-            if (!capture || localName(name) !== 'Company')
-                return;
-            workbook.properties.company = text;
-            capture = false;
-        },
-    });
+    for (const { text } of capturedText(xml, 'Company'))
+        workbook.properties.company = text;
 }

package/dist/io/xlsx/rich-runs.d.ts

@@ -1,13 +1,47 @@
 import type { RichTextRun } from '../../core/value.ts';
-import type { XmlAttributes } from '../../xml/xml-read.ts';
+import { type XmlAttributes } from '../../xml/xml-scan.ts';
+/**
+ * What {@link RunAccumulator.close} did with an element: `'container'` means the `<si>`/`<is>` itself
+ * closed and the caller should commit whatever it makes of the gathered runs, the one step the two
+ * readers do differently; `'claimed'` means the machine handled it; `'other'` leaves it to the caller.
+ *
+ * Three values rather than a boolean because both callers need to tell "the machine dealt with it"
+ * from "your string is complete", and a boolean would mean something different to each of them.
+ */
+export type RunClose = 'claimed' | 'container' | 'other';
 export declare class RunAccumulator {
     #private;
-    beginContainer(): void;
+    /**
+     * @param options.container the element that opens one string: `'si'` for the shared-string pool,
+     * `'is'` for an inline string in a worksheet body.
+     * @param options.readRuns whether `<r>`/`<rPr>` open a rich-text run. The buffered readers read
+     * them; the row stream deliberately does not, and with runs off every `<t>` falls through to
+     * {@link plainText}, which is exactly the documented flattening.
+     */
+    constructor(options: {
+        readonly container: 'si' | 'is';
+        readonly readRuns: boolean;
+    });
     /** The runs gathered so far. */
     get runs(): RichTextRun[];
-    beginRun(): void;
-    beginProperties(): void;
-    applyProperty(local: string, attrs: XmlAttributes): void;
-    appendText(text: string): boolean;
-    endRun(): void;
+    /** Whether the container held at least one `<r>`: what decides rich text from a plain string. */
+    get isRich(): boolean;
+    /** The container's own text: every `<t>` no run claimed, concatenated and already unescaped. */
+    get plainText(): string;
+    /**
+     * Open a string container by discarding whatever the last one gathered. Called for the machine's
+     * own container automatically; a caller whose own element may *hold* one (a `<c>` around an
+     * `<is>`) calls it too, or that container inherits the previous one's runs, which is the one way
+     * this accumulator can be misused.
+     *
+     * A new array is installed rather than the existing one emptied, so a value already built from the
+     * last container's runs keeps its own array.
+     */
+    beginContainer(): void;
+    /** Drive one element open, and return whether it was one of this machine's own. */
+    open(local: string, attrs: XmlAttributes, selfClosing: boolean): boolean;
+    /** Feed one run of character data. Ignored unless a `<t>` is open. */
+    text(chunk: string): void;
+    /** Drive one element close. See {@link RunClose}. */
+    close(local: string): RunClose;
 }

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

@@ -1,43 +1,108 @@
+import { TextCapture } from '../../xml/xml-read.js';
+import { decodeSpreadsheetText } from '../../xml/xml-scan.js';
 import { applyFontChild } from './read-styles.js';
 export class RunAccumulator {
+    #container;
+    #readRuns;
+    #capture = new TextCapture('t');
     #runs = [];
     #font = null;
-    #text = '';
+    #inProperties = false;
+    #runText = '';
+    #plain = '';
     #inRun = false;
-    beginContainer() {
-        this.#runs = [];
-        this.#font = null;
-        this.#inRun = false;
+    #isRich = false;
+    #inContainer = false;
+    constructor(options) {
+        this.#container = options.container;
+        this.#readRuns = options.readRuns;
     }
     get runs() {
         return this.#runs;
     }
-    beginRun() {
-        this.#inRun = true;
+    get isRich() {
+        return this.#isRich;
+    }
+    get plainText() {
+        return this.#plain;
+    }
+    beginContainer() {
+        this.#runs = [];
         this.#font = null;
-        this.#text = '';
-    }
-    beginProperties() {
-        if (this.#inRun)
-            this.#font = {};
-    }
-    applyProperty(local, attrs) {
-        if (this.#font !== null)
-            applyFontChild(this.#font, local, attrs);
-    }
-    appendText(text) {
-        if (!this.#inRun)
-            return false;
-        this.#text += text;
-        return true;
-    }
-    endRun() {
-        if (!this.#inRun)
-            return;
-        const run = { text: this.#text };
-        if (this.#font !== null && Object.keys(this.#font).length > 0)
-            run.font = this.#font;
-        this.#runs.push(run);
+        this.#inProperties = false;
+        this.#runText = '';
+        this.#plain = '';
         this.#inRun = false;
+        this.#isRich = false;
+    }
+    open(local, attrs, selfClosing) {
+        switch (local) {
+            case this.#container:
+                this.#inContainer = true;
+                this.beginContainer();
+                return true;
+            case 'r':
+                if (!this.#readRuns || !this.#inContainer)
+                    return false;
+                this.#isRich = true;
+                this.#inRun = true;
+                this.#font = null;
+                this.#inProperties = false;
+                this.#runText = '';
+                return true;
+            case 'rPr':
+                if (!this.#readRuns || !this.#inRun)
+                    return false;
+                this.#font = {};
+                this.#inProperties = true;
+                return true;
+            case 't':
+                this.#capture.open(local, selfClosing);
+                return true;
+            default:
+                if (!this.#inProperties || this.#font === null)
+                    return false;
+                applyFontChild(this.#font, local, attrs);
+                return true;
+        }
+    }
+    text(chunk) {
+        this.#capture.text(chunk);
+    }
+    close(local) {
+        switch (local) {
+            case 't': {
+                const text = this.#capture.close(local);
+                if (text !== undefined) {
+                    const decoded = decodeSpreadsheetText(text);
+                    if (this.#inRun)
+                        this.#runText += decoded;
+                    else if (this.#inContainer)
+                        this.#plain += decoded;
+                }
+                return 'claimed';
+            }
+            case 'rPr':
+                if (!this.#readRuns || !this.#inProperties)
+                    return 'other';
+                this.#inProperties = false;
+                return 'claimed';
+            case 'r': {
+                if (!this.#readRuns || !this.#inRun)
+                    return 'other';
+                this.#inProperties = false;
+                const run = { text: this.#runText };
+                if (this.#font !== null && Object.keys(this.#font).length > 0)
+                    run.font = this.#font;
+                this.#runs.push(run);
+                this.#inRun = false;
+                return 'claimed';
+            }
+            case this.#container:
+                this.#inContainer = false;
+                return 'container';
+            default:
+                return 'other';
+        }
     }
 }

package/dist/io/xlsx/sheet-properties.d.ts

@@ -1,5 +1,5 @@
 import type { AutoFilter } from '../../core/autofilter.ts';
-import type { HeaderFooter, PageBreak, PageMargins, PageSetup, PrintOptions } from '../../core/page-setup.ts';
+import { type HeaderFooter, type PageBreak, type PageMargins, type PageSetup, type PrintOptions } from '../../core/page-setup.ts';
 import { type SheetProtection } from '../../core/protection.ts';
 import type { SheetView, Worksheet } from '../../core/worksheet.ts';
 export declare function sheetViewsXml(view: SheetView, active: boolean): string;