@shbernal/ts-xlsx 1.3.1 → 2.1.0

package/dist/io/xlsx/read.js

@@ -1,12 +1,13 @@
 import { decodeRange } from '../../core/address.js';
 import { unmangleFunctions } from '../../core/formula.js';
 import { INTERNAL } from '../../core/internal.js';
-import { Workbook } from '../../core/workbook.js';
 import { WORKBOOK_PROTECTION_CREDENTIAL_ATTRS, } from '../../core/workbook-protection.js';
-import { boolStrict, localName, openElements, parseXml } from '../../xml/xml-read.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 { UnsupportedFormatError } from '../opc/errors.js';
-import { extensionOf, relsPathFor } from '../opc/part-paths.js';
-import { capturePartClosure, contentTypeResolver, packageAccessors, parseRelationshipRecords, parseRelationships, relationshipTargetByType, relationshipTargetsByType, resolveRelativePart, resolveWorkbookPart, sheetRelTarget, } from '../opc/read-opc.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';
@@ -20,6 +21,7 @@ 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';
@@ -70,9 +72,9 @@ export function readXlsx(data, options = {}) {
         if (sheetXml !== undefined)
             parseWorksheet(sheetXml, sheet, sharedStrings, xfStyles);
         if (path !== undefined) {
+            const sheetRels = readPartRelationships(path, partText);
             if (sheetXml !== undefined) {
-                const sheetRels = parseRelationships(partText(relsPathFor(path)) ?? '');
-                applyHyperlinks(sheet, parseSheetHyperlinks(sheetXml), sheetRels);
+                applyHyperlinks(sheet, parseSheetHyperlinks(sheetXml), (id) => sheetRels.byId(id)?.target);
                 applyDataValidations(sheet, [
                     ...parseDataValidations(sheetXml),
                     ...parseExtendedDataValidations(sheetXml),
@@ -80,20 +82,20 @@ export function readXlsx(data, options = {}) {
                 for (const cf of parseConditionalFormattings(sheetXml))
                     sheet.addConditionalFormatting(cf);
             }
-            const threads = readSheetCommentThreads(path, pkg, workbook);
+            const threads = readSheetCommentThreads(sheetRels, pkg, workbook);
             if (threads.length > 0)
                 sheet[INTERNAL].restoreCommentThreads(threads);
-            const comments = readSheetComments(path, pkg);
+            const comments = readSheetComments(sheetRels, pkg);
             if (comments !== undefined)
                 applyNotes(sheet, comments);
-            readSheetImages(path, pkg, workbook, sheet, imageIdByMediaPath);
-            readSheetBackground(path, pkg, workbook, sheet, imageIdByMediaPath);
+            readSheetImages(sheetRels, pkg, workbook, sheet, imageIdByMediaPath);
+            readSheetBackground(sheetRels, pkg, workbook, sheet, imageIdByMediaPath);
             if (sheetXml !== undefined) {
-                readSheetPreservedReferences(path, sheetXml, pkg, contentTypeOf, sheet);
+                readSheetPreservedReferences(sheetRels, sheetXml, pkg, contentTypeOf, sheet);
             }
-            readSheetTables(path, pkg, sheet);
-            readSheetPivotTables(path, pkg, sheet);
-            const printerSettings = readSheetPrinterSettings(path, pkg);
+            readSheetTables(sheetRels, pkg, sheet);
+            readSheetPivotTables(sheetRels, pkg, sheet);
+            const printerSettings = readSheetPrinterSettings(sheetRels, pkg);
             if (printerSettings !== undefined)
                 sheet.pageSetup.printerSettings = printerSettings;
         }
@@ -105,8 +107,8 @@ export function readXlsx(data, options = {}) {
     }
     return workbook;
 }
-function readSheetComments(sheetPath, pkg) {
-    const commentsPath = sheetRelTarget(sheetPath, pkg.partText, 'comments');
+function readSheetComments(sheetRels, pkg) {
+    const commentsPath = sheetRels.targetPath('comments');
     if (commentsPath === undefined)
         return undefined;
     const commentsXml = pkg.partText(commentsPath);
@@ -126,23 +128,36 @@ function readWorkbookTheme(workbookRelsXml, pkg, contentTypeOf, workbook) {
         return;
     const entryPath = resolveWorkbookPart(target);
     const parts = capturePartClosure(entryPath, pkg.partText, pkg.partBytes, contentTypeOf);
-    if (parts !== undefined)
-        workbook[INTERNAL].restoreThemePart({ entryPath, parts });
+    if (parts === undefined)
+        return;
+    const xml = pkg.partText(entryPath) ?? '';
+    workbook[INTERNAL].restoreThemePart({ entryPath, parts }, { colors: parseThemeColorScheme(xml), fonts: parseThemeFontScheme(xml) });
 }
-function readSheetCommentThreads(sheetPath, pkg, workbook) {
-    const path = sheetRelTarget(sheetPath, pkg.partText, 'threadedComment');
+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(sheetPath, pkg) {
-    const path = sheetRelTarget(sheetPath, pkg.partText, 'printerSettings');
+function readSheetPrinterSettings(sheetRels, pkg) {
+    const path = sheetRels.targetPath('printerSettings');
     return path === undefined ? undefined : pkg.partBytes(path);
 }
-function readSheetImages(sheetPath, pkg, workbook, sheet, imageIdByMediaPath) {
-    const { partText, partBytes } = pkg;
-    const drawingPath = sheetRelTarget(sheetPath, partText, 'drawing');
+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);
@@ -150,20 +165,15 @@ function readSheetImages(sheetPath, pkg, workbook, sheet, imageIdByMediaPath) {
         return;
     if (drawingHasUnmodeledContent(drawingXml))
         return;
-    const drawingRels = parseRelationships(partText(relsPathFor(drawingPath)) ?? '');
+    const drawingRels = readPartRelationships(drawingPath, partText);
     for (const anchor of parseDrawing(drawingXml)) {
-        const target = drawingRels.get(anchor.embed);
-        if (target === undefined)
+        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 mediaPath = resolveRelativePart(drawingPath, 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 rot = anchor.rotation !== undefined ? { rotation: anchor.rotation } : {};
         if (anchor.to !== undefined) {
             const mode = anchor.editAs !== undefined ? { editAs: anchor.editAs } : {};
@@ -174,29 +184,18 @@ function readSheetImages(sheetPath, pkg, workbook, sheet, imageIdByMediaPath) {
         }
     }
 }
-function readSheetBackground(sheetPath, pkg, workbook, sheet, imageIdByMediaPath) {
-    const mediaPath = sheetRelTarget(sheetPath, pkg.partText, 'image');
+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(sheetPath, sheetXml, pkg, contentTypeOf, sheet) {
+function readSheetPreservedReferences(sheetRels, sheetXml, pkg, contentTypeOf, sheet) {
     const { partText, partBytes } = pkg;
-    const relsXml = partText(relsPathFor(sheetPath));
-    if (relsXml === undefined)
-        return;
-    const records = parseRelationshipRecords(relsXml);
-    const recordById = new Map(records.map((record) => [record.id, record]));
     const capture = (element, relType, target) => {
-        const entryPath = resolveRelativePart(sheetPath, target);
+        const entryPath = sheetRels.pathOf(target);
         const parts = capturePartClosure(entryPath, partText, partBytes, contentTypeOf);
         if (parts !== undefined)
             sheet[INTERNAL].addPreservedReference({ element, relType, entryPath, parts });
@@ -204,11 +203,11 @@ function readSheetPreservedReferences(sheetPath, sheetXml, pkg, contentTypeOf, s
     const referenceElements = sheet.images.length === 0 ? ['drawing', 'legacyDrawingHF'] : ['legacyDrawingHF'];
     for (const element of referenceElements) {
         const relId = worksheetReferenceRelId(sheetXml, element);
-        const record = relId === undefined ? undefined : recordById.get(relId);
+        const record = relId === undefined ? undefined : sheetRels.byId(relId);
         if (record !== undefined && !record.external)
             capture(element, record.type, record.target);
     }
-    for (const record of records) {
+    for (const record of sheetRels.records) {
         if (record.external)
             continue;
         if (isPreservedSheetRelType(record.type))
@@ -294,12 +293,9 @@ function worksheetReferenceRelId(sheetXml, element) {
     }
     return undefined;
 }
-function readSheetTables(sheetPath, pkg, sheet) {
-    const relsXml = pkg.partText(relsPathFor(sheetPath));
-    if (relsXml === undefined)
-        return;
-    for (const target of relationshipTargetsByType(relsXml, 'table')) {
-        const tableXml = pkg.partText(resolveRelativePart(sheetPath, target));
+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);
@@ -308,20 +304,14 @@ function readSheetTables(sheetPath, pkg, sheet) {
     }
     dropMergesInsideTables(sheet);
 }
-function readSheetPivotTables(sheetPath, pkg, sheet) {
+function readSheetPivotTables(sheetRels, pkg, sheet) {
     const { partText } = pkg;
-    const relsXml = partText(relsPathFor(sheetPath));
-    if (relsXml === undefined)
-        return;
-    for (const target of relationshipTargetsByType(relsXml, 'pivotTable')) {
-        const tablePath = resolveRelativePart(sheetPath, target);
+    for (const tablePath of sheetRels.targetPaths('pivotTable')) {
         const tableXml = partText(tablePath);
         if (tableXml === undefined)
             continue;
-        const cacheTarget = relationshipTargetByType(partText(relsPathFor(tablePath)) ?? '', 'pivotCacheDefinition');
-        const cacheXml = cacheTarget === undefined
-            ? ''
-            : (partText(resolveRelativePart(tablePath, cacheTarget)) ?? '');
+        const cachePath = readPartRelationships(tablePath, partText).targetPath('pivotCacheDefinition');
+        const cacheXml = cachePath === undefined ? '' : (partText(cachePath) ?? '');
         sheet[INTERNAL].addLoadedPivotTable(parsePivotTable(tableXml, cacheXml));
     }
 }
@@ -348,13 +338,14 @@ 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;
 }
-export function parseWorkbookProtection(xml) {
+function parseWorkbookProtection(xml) {
     let result;
     parseXml(xml, {
         onOpen(name, attrs) {
@@ -382,26 +373,29 @@ export function parseWorkbookProtection(xml) {
 }
 export function applyWorkbookView(view, xml) {
     for (const { attrs } of openElements(xml, 'workbookView')) {
-        applyViewNumber(attrs.xWindow, (value) => (view.x = value));
-        applyViewNumber(attrs.yWindow, (value) => (view.y = value));
-        applyViewNumber(attrs.windowWidth, (value) => (view.width = value));
-        applyViewNumber(attrs.windowHeight, (value) => (view.height = value));
-        applyViewNumber(attrs.activeTab, (value) => (view.activeTab = value));
-        if (attrs.visibility === 'hidden' || attrs.visibility === 'veryHidden') {
-            view.visibility = attrs.visibility;
-        }
+        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;
         return;
     }
 }
-function applyViewNumber(raw, assign) {
-    if (raw === undefined)
-        return;
-    const value = Number(raw);
-    if (Number.isFinite(value))
-        assign(Math.trunc(value));
-}
 function parseWorkbookDefinedNames(xml, sheetOrder) {
     const names = [];
     let capture = false;
@@ -415,7 +409,7 @@ function parseWorkbookDefinedNames(xml, sheetOrder) {
                 return;
             capture = true;
             refersTo = '';
-            const scopeIndex = attrs.localSheetId === undefined ? -1 : Number(attrs.localSheetId);
+            const scopeIndex = numInteger(attrs.localSheetId, 0) ?? -1;
             const scope = sheetOrder[scopeIndex];
             pending = { name: attrs.name };
             if (scope !== undefined)
@@ -447,57 +441,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-read.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;
-    reset(): 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,107 @@
+import { decodeSpreadsheetText, TextCapture } from '../../xml/xml-read.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;
-    reset() {
-        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/rich-text.d.ts

@@ -1,7 +1,7 @@
 import type { RichTextRun } from '../../core/value.ts';
 /**
  * Serialise a rich-text value's runs as the inner content of an `<is>` element. A zero-length run
- * is dropped: an empty `<t/>` is schema-invalid — Excel flags the file as corrupt — and an empty
+ * is dropped: an empty `<t/>` is schema-invalid (Excel flags the file as corrupt) and an empty
  * run contributes nothing to the rendered text, so omitting it is loss-free.
  */
 export declare function richTextRunsXml(runs: readonly RichTextRun[]): string;

package/dist/io/xlsx/shared-strings.d.ts

@@ -3,14 +3,14 @@ import type { RichTextValue } from '../../core/value.ts';
  * Interns cell string values into the shared-strings pool. {@link intern} returns the index a
  * `t="s"` cell writes as its `<v>`; identical entries collapse to one, so `count` (total references)
  * and `uniqueCount` (distinct entries) diverge exactly as Excel records them. Each entry is stored as
- * its rendered `<si>` inner XML, which is also its dedup key — a plain string (`<t>…`) and rich runs
+ * its rendered `<si>` inner XML, which is also its dedup key: a plain string (`<t>…`) and rich runs
  * (`<r>…`) render to distinct markup, so the two kinds never collide in the pool.
  */
 export declare class SharedStringTable {
     #private;
     /** Intern a plain or rich string and return its `<si>` index, reusing the entry when it repeats. */
     intern(value: string | RichTextValue): number;
-    /** Whether no string has been interned — the writer omits the part entirely when so. */
+    /** Whether no string has been interned; the writer omits the part entirely when so. */
     get isEmpty(): boolean;
     /** Serialise the pool as the `xl/sharedStrings.xml` part. */
     toXml(): string;

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;