@xlsxflow/core 1.1.3 → 1.1.4

package/dist/index.cjs

@@ -1,8 +1,367 @@
 'use strict';
 
+const CRC_TABLE = (() => {
+    const t = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+        let c = n;
+        for (let k = 0; k < 8; k++)
+            c = (c & 1) ? (c >>> 1) ^ 0xedb88320 : c >>> 1;
+        t[n] = c >>> 0;
+    }
+    return t;
+})();
+function crc32(bytes) {
+    return (crc32Update(0xffffffff, bytes) ^ 0xffffffff) >>> 0;
+}
+// Running CRC-32 over chunks: start at 0xffffffff, finish with (crc ^ 0xffffffff) >>> 0
+function crc32Update(crc, bytes) {
+    for (let i = 0; i < bytes.length; i++)
+        crc = CRC_TABLE[(crc ^ bytes[i]) & 0xff] ^ (crc >>> 8);
+    return crc;
+}
+const MAX_U32 = 0xffffffff;
+// General-purpose flag bit 11: the entry name is UTF-8 (set only when it isn't plain ASCII)
+const utf8Flag = (name) => name.some(b => b > 0x7f) ? 0x0800 : 0;
+// No ZIP64 support: fail loudly instead of writing a corrupt archive.
+function assertNoZip64(value, what) {
+    if (value > MAX_U32)
+        throw new Error(`ZIP64 not supported: ${what} exceeds 4 GiB.`);
+}
+// A true Single-Pass Streaming ZIP Writer
+class ZipStreamWriter {
+    cdEntries = [];
+    offset = 0;
+    streamController;
+    waiting = [];
+    cancelled = false;
+    stream;
+    textEncoder = new TextEncoder();
+    constructor(highWaterMarkBytes = 1 << 20) {
+        this.stream = new ReadableStream({
+            start: (controller) => {
+                this.streamController = controller;
+            },
+            pull: () => this.wake(),
+            // Consumer gone: unblock any pending write so the producer can see the error.
+            cancel: () => {
+                this.cancelled = true;
+                this.wake();
+            }
+        }, new ByteLengthQueuingStrategy({ highWaterMark: highWaterMarkBytes }));
+    }
+    // Adds a file to the zip. `inputStream` MUST be raw uncompressed data.
+    async addFile(filenameStr, inputStream) {
+        const filename = this.textEncoder.encode(filenameStr);
+        const flags = 0x0008 | utf8Flag(filename);
+        const startOffset = this.offset;
+        await this.pushChunk(this.localHeader(filename, flags, 8, 0, 0, 0));
+        // Stream data, tracking sizes and CRC32
+        let uncompressedSize = 0;
+        let crc = 0xffffffff;
+        const crcStream = new TransformStream({
+            // CompressionStream takes every write at once, so the input is held back here instead,
+            // while nobody reads the output
+            transform: async (chunk, controller) => {
+                await this.roomInQueue();
+                uncompressedSize += chunk.length;
+                crc = crc32Update(crc, chunk);
+                controller.enqueue(chunk);
+            }
+        });
+        let compressedSize = 0;
+        const reader = inputStream
+            .pipeThrough(crcStream)
+            .pipeThrough(new CompressionStream('deflate-raw'))
+            .getReader();
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                compressedSize += value.length;
+                await this.pushChunk(value);
+            }
+        }
+        catch (err) {
+            // Stop the source too (a row generator's finally runs, a database cursor closes)
+            await reader.cancel(err).catch(() => { });
+            throw err;
+        }
+        crc = (crc ^ 0xffffffff) >>> 0;
+        assertNoZip64(uncompressedSize, filenameStr);
+        assertNoZip64(compressedSize, filenameStr);
+        // Data Descriptor
+        const desc = new Uint8Array(16);
+        const descView = new DataView(desc.buffer);
+        descView.setUint32(0, 0x08074b50, true);
+        descView.setUint32(4, crc, true);
+        descView.setUint32(8, compressedSize, true);
+        descView.setUint32(12, uncompressedSize, true);
+        await this.pushChunk(desc);
+        this.cdEntries.push({ filename, offset: startOffset, uncompressedSize, compressedSize, crc, flags, method: 8 });
+    }
+    // Adds a file that is ALREADY compressed (pass-through for the Editor)
+    async addCompressedFile(filenameStr, compressedStream, uncompressedSize, compressedSize, crc, method = 8) {
+        const filename = this.textEncoder.encode(filenameStr);
+        const flags = utf8Flag(filename);
+        const startOffset = this.offset;
+        await this.pushChunk(this.localHeader(filename, flags, method, crc, compressedSize, uncompressedSize));
+        const reader = compressedStream.getReader();
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            await this.pushChunk(value);
+        }
+        this.cdEntries.push({ filename, offset: startOffset, uncompressedSize, compressedSize, crc, flags, method });
+    }
+    async close() {
+        // 0xFFFF in the end record means "see the ZIP64 record", which readers then look for
+        if (this.cdEntries.length >= 0xffff)
+            throw new Error('ZIP64 not supported: 65535 entries or more.');
+        const cdStartOffset = this.offset;
+        for (const entry of this.cdEntries) {
+            const cd = new Uint8Array(46 + entry.filename.length);
+            const view = new DataView(cd.buffer);
+            view.setUint32(0, 0x02014b50, true);
+            view.setUint16(4, 20, true); // version made by
+            view.setUint16(6, 20, true); // version needed
+            view.setUint16(8, entry.flags, true);
+            view.setUint16(10, entry.method, true);
+            view.setUint32(16, entry.crc, true);
+            view.setUint32(20, entry.compressedSize, true);
+            view.setUint32(24, entry.uncompressedSize, true);
+            view.setUint16(28, entry.filename.length, true);
+            view.setUint32(42, entry.offset, true);
+            cd.set(entry.filename, 46);
+            await this.pushChunk(cd);
+        }
+        const cdSize = this.offset - cdStartOffset;
+        assertNoZip64(this.offset, 'archive');
+        const eocd = new Uint8Array(22);
+        const eocdView = new DataView(eocd.buffer);
+        eocdView.setUint32(0, 0x06054b50, true);
+        eocdView.setUint16(8, this.cdEntries.length, true);
+        eocdView.setUint16(10, this.cdEntries.length, true);
+        eocdView.setUint32(12, cdSize, true);
+        eocdView.setUint32(16, cdStartOffset, true);
+        await this.pushChunk(eocd);
+        this.streamController.close();
+    }
+    // Propagate a producer failure to whoever is reading `stream`.
+    error(err) {
+        try {
+            this.streamController.error(err);
+        }
+        catch { /* already closed/errored */ }
+    }
+    localHeader(filename, flags, method, crc, compressedSize, uncompressedSize) {
+        assertNoZip64(this.offset, 'archive');
+        const header = new Uint8Array(30 + filename.length);
+        const view = new DataView(header.buffer);
+        view.setUint32(0, 0x04034b50, true);
+        view.setUint16(4, 20, true);
+        view.setUint16(6, flags, true);
+        view.setUint16(8, method, true);
+        view.setUint32(14, crc, true);
+        view.setUint32(18, compressedSize, true);
+        view.setUint32(22, uncompressedSize, true);
+        view.setUint16(26, filename.length, true);
+        header.set(filename, 30);
+        return header;
+    }
+    // Enqueue and wait while the consumer's queue is full, so memory stays bounded.
+    async pushChunk(chunk) {
+        if (this.cancelled)
+            throw new Error('ZIP stream cancelled by consumer.');
+        this.streamController.enqueue(chunk);
+        this.offset += chunk.length;
+        await this.roomInQueue();
+    }
+    async roomInQueue() {
+        while ((this.streamController.desiredSize ?? 1) <= 0) {
+            if (this.cancelled)
+                throw new Error('ZIP stream cancelled by consumer.');
+            await new Promise(resolve => this.waiting.push(resolve));
+        }
+        if (this.cancelled)
+            throw new Error('ZIP stream cancelled by consumer.');
+    }
+    wake() {
+        const waiting = this.waiting;
+        this.waiting = [];
+        for (const resolve of waiting)
+            resolve();
+    }
+}
+
+// Reader for Compound File Binary files [MS-CFB]: the container of .xls workbooks and of
+// password-protected .xlsx files. Streams are read from an in-memory copy of the file.
+const SIGNATURE = [0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1];
+const END_OF_CHAIN = 0xfffffffe;
+const MAX_REGULAR_SECTOR = 0xfffffffa;
+function isCfb(bytes) {
+    return bytes.length >= 8 && SIGNATURE.every((b, i) => bytes[i] === b);
+}
+const corrupt$1 = (why) => new Error(`Corrupt compound file: ${why}`);
+class CfbReader {
+    bytes;
+    view;
+    sectorSize;
+    miniSectorSize;
+    miniCutoff;
+    fat;
+    miniFat;
+    miniStream;
+    dir;
+    byPath = new Map();
+    constructor(bytes) {
+        this.bytes = bytes;
+        if (!isCfb(bytes))
+            throw new Error('Not a compound file (no D0CF11E0 signature)');
+        if (bytes.length < 512)
+            throw corrupt$1(`only ${bytes.length} bytes, shorter than its 512-byte header`);
+        this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        const u16 = (o) => this.view.getUint16(o, true);
+        const u32 = (o) => this.view.getUint32(o, true);
+        const sectorShift = u16(0x1e);
+        if (sectorShift !== 9 && sectorShift !== 12)
+            throw corrupt$1(`sector shift ${sectorShift}`);
+        this.sectorSize = 1 << sectorShift;
+        const miniShift = u16(0x20);
+        if (miniShift !== 6)
+            throw corrupt$1(`mini sector shift ${miniShift}`);
+        this.miniSectorSize = 1 << miniShift;
+        this.miniCutoff = u32(0x38);
+        // The FAT's own sectors are listed in the header (109 slots) and then in a chain of DIFAT sectors
+        const numFatSectors = u32(0x2c);
+        const sectorCount = Math.ceil(bytes.length / this.sectorSize) - 1;
+        if (numFatSectors > sectorCount)
+            throw corrupt$1(`${numFatSectors} FAT sectors in a ${bytes.length}-byte file`);
+        const fatSectors = [];
+        for (let i = 0; i < 109 && fatSectors.length < numFatSectors; i++)
+            fatSectors.push(u32(0x4c + i * 4));
+        const perDifat = this.sectorSize / 4 - 1;
+        for (let s = u32(0x44), hops = 0; fatSectors.length < numFatSectors; hops++) {
+            if (s > MAX_REGULAR_SECTOR || hops > sectorCount)
+                throw corrupt$1('DIFAT chain ends early');
+            const at = this.sectorOffset(s);
+            for (let i = 0; i < perDifat && fatSectors.length < numFatSectors; i++)
+                fatSectors.push(u32(at + i * 4));
+            s = u32(at + perDifat * 4);
+        }
+        const perSector = this.sectorSize / 4;
+        this.fat = new Uint32Array(numFatSectors * perSector);
+        fatSectors.forEach((s, i) => {
+            const at = this.sectorOffset(s);
+            for (let j = 0; j < perSector; j++)
+                this.fat[i * perSector + j] = u32(at + j * 4);
+        });
+        // Directory: 128-byte entries in the chain starting at the header's first directory sector
+        const dirBytes = this.readChain(u32(0x30), Infinity);
+        this.dir = [];
+        for (let at = 0; at + 128 <= dirBytes.length; at += 128) {
+            const d = new DataView(dirBytes.buffer, dirBytes.byteOffset + at, 128);
+            const nameLen = Math.min(d.getUint16(64, true), 64);
+            let name = '';
+            for (let i = 0; i + 2 < nameLen; i += 2)
+                name += String.fromCharCode(d.getUint16(i, true));
+            // Version 3 files may leave garbage in the size's high half
+            const size = sectorShift === 9 ? d.getUint32(120, true) : d.getUint32(120, true) + d.getUint32(124, true) * 2 ** 32;
+            this.dir.push({ name, type: d.getUint8(66), left: d.getUint32(68, true), right: d.getUint32(72, true),
+                child: d.getUint32(76, true), start: d.getUint32(116, true), size });
+        }
+        if (this.dir[0]?.type !== 5)
+            throw corrupt$1('no root entry');
+        this.walk(this.dir[0].child, '');
+    }
+    // Start of a sector, checked to hold `need` bytes (the last sector of a file may be cut short)
+    sectorOffset(sector, need = this.sectorSize) {
+        const at = (sector + 1) * this.sectorSize;
+        if (sector > MAX_REGULAR_SECTOR || at + need > this.bytes.length) {
+            throw corrupt$1(`sector ${sector} is outside the file`);
+        }
+        return at;
+    }
+    // Sibling entries form a red-black tree; children of a storage hang off its `child`
+    walk(root, prefix) {
+        const stack = [root];
+        const seen = new Set();
+        while (stack.length) {
+            const id = stack.pop();
+            if (id > MAX_REGULAR_SECTOR)
+                continue; // NOSTREAM
+            if (seen.has(id) || !this.dir[id])
+                throw corrupt$1('directory tree loops or points outside the directory');
+            seen.add(id);
+            const e = this.dir[id];
+            stack.push(e.left, e.right);
+            if (e.type !== 1 && e.type !== 2)
+                continue;
+            const path = prefix + e.name;
+            this.byPath.set(path.toLowerCase(), { ...e, path });
+            if (e.type === 1)
+                this.walk(e.child, path + '/');
+        }
+    }
+    readChain(start, size, mini = false) {
+        const table = mini ? this.miniFat : this.fat;
+        const unit = mini ? this.miniSectorSize : this.sectorSize;
+        const source = mini ? this.miniStream : this.bytes;
+        const sectors = [];
+        for (let s = start; s !== END_OF_CHAIN && sectors.length * unit < size; s = table[s]) {
+            if (s >= table.length || sectors.length > table.length)
+                throw corrupt$1(`${mini ? 'mini ' : ''}sector chain is broken or loops`);
+            sectors.push(s);
+        }
+        const total = Math.min(size, sectors.length * unit);
+        if (size !== Infinity && total < size)
+            throw corrupt$1(`stream is shorter (${total} bytes) than its stated ${size}`);
+        const out = new Uint8Array(total);
+        sectors.forEach((s, i) => {
+            const len = Math.min(unit, total - i * unit);
+            const at = mini ? s * unit : this.sectorOffset(s, len);
+            if (at + len > source.length)
+                throw corrupt$1(`mini sector ${s} is outside the mini stream`);
+            out.set(source.subarray(at, at + len), i * unit);
+        });
+        return out;
+    }
+    entries() {
+        return [...this.byPath.values()].map(e => ({ path: e.path, type: e.type === 1 ? 'storage' : 'stream', size: e.size }));
+    }
+    has(path) {
+        return this.byPath.get(path.toLowerCase())?.type === 2;
+    }
+    // A stream's bytes, by path (case-insensitive, as in the format); undefined if there is none
+    read(path) {
+        const e = this.byPath.get(path.toLowerCase());
+        if (!e || e.type !== 2)
+            return undefined;
+        if (e.size >= this.miniCutoff) {
+            if (e.size > this.bytes.length)
+                throw corrupt$1(`stream ${e.path} is larger than the file`);
+            return this.readChain(e.start, e.size);
+        }
+        if (!this.miniStream) {
+            const root = this.dir[0];
+            this.miniStream = this.readChain(root.start, root.size);
+            const view = new DataView(this.bytes.buffer, this.bytes.byteOffset, this.bytes.byteLength);
+            const miniFatBytes = this.readChain(view.getUint32(0x3c, true), view.getUint32(0x40, true) * this.sectorSize);
+            this.miniFat = new Uint32Array(miniFatBytes.length / 4);
+            const mv = new DataView(miniFatBytes.buffer, miniFatBytes.byteOffset, miniFatBytes.byteLength);
+            for (let i = 0; i < this.miniFat.length; i++)
+                this.miniFat[i] = mv.getUint32(i * 4, true);
+        }
+        return this.readChain(e.start, e.size, true);
+    }
+}
+
 class ZipRandomAccessParser {
     reader;
     records = new Map();
+    // Part names are case-insensitive in OPC: a rels target "Sheet1.xml" finds "sheet1.xml"
+    lowerCase = new Map();
     constructor(reader) {
         this.reader = reader;
     }
@@ -15,15 +374,24 @@ class ZipRandomAccessParser {
         const searchStart = size - searchSize;
         const buffer = await this.reader.read(searchStart, searchSize);
         const dataView = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-        // Search backwards for the EOCD signature (0x06054b50)
+        // Search backwards for the EOCD signature (0x06054b50). The real record's comment reaches the end
+        // of the file, so the signature bytes inside a comment are skipped; failing that (junk appended
+        // after the archive), the last signature is used.
         let eocdOffset = -1;
         for (let i = buffer.length - 22; i >= 0; i--) {
-            if (dataView.getUint32(i, true) === 0x06054b50) {
+            if (dataView.getUint32(i, true) !== 0x06054b50)
+                continue;
+            if (eocdOffset === -1)
+                eocdOffset = i;
+            if (i + 22 + dataView.getUint16(i + 20, true) === buffer.length) {
                 eocdOffset = i;
                 break;
             }
         }
         if (eocdOffset === -1) {
+            if (isCfb(buffer.subarray(0, 8)) || searchStart > 0 && isCfb(await this.reader.read(0, 8))) {
+                throw new Error('This file is a compound file, not a ZIP: an .xls, or a workbook saved with a password. Decrypt it first with decryptWorkbook from @xlsxflow/pro.');
+            }
             throw new Error("End of Central Directory (EOCD) not found. This may not be a valid ZIP file.");
         }
         const totalRecords = dataView.getUint16(eocdOffset + 10, true);
@@ -60,14 +428,10 @@ class ZipRandomAccessParser {
             if (filename.includes('../') || filename.includes('..\\')) {
                 throw new Error(`Security Exception: Path traversal detected in ZIP filename: ${filename}`);
             }
-            this.records.set(filename, {
-                filename,
-                compressionMethod,
-                crc,
-                compressedSize,
-                uncompressedSize,
-                localHeaderOffset
-            });
+            const record = { filename, compressionMethod, crc, compressedSize, uncompressedSize, localHeaderOffset };
+            this.records.set(filename, record);
+            if (!this.lowerCase.has(filename.toLowerCase()))
+                this.lowerCase.set(filename.toLowerCase(), record);
             offset += 46 + filenameLength + extraFieldLength + fileCommentLength;
         }
         // Entries must not share bytes: aliased names would let one small deflated entry be inflated many times
@@ -80,13 +444,13 @@ class ZipRandomAccessParser {
         }
     }
     has(filename) {
-        return this.records.has(filename);
+        return this.records.has(filename) || this.lowerCase.has(filename.toLowerCase());
     }
     getFiles() {
         return Array.from(this.records.keys());
     }
     getRecord(filename) {
-        const record = this.records.get(filename);
+        const record = this.records.get(filename) ?? this.lowerCase.get(filename.toLowerCase());
         if (!record)
             throw new Error(`File ${filename} not found in ZIP.`);
         return record;
@@ -118,17 +482,24 @@ class ZipRandomAccessParser {
             throw new Error(`Unsupported compression method ${record.compressionMethod} for ${filename}`);
         }
         const stream = await this.extractRawStream(filename);
-        if (record.compressionMethod === 0)
-            return stream;
+        const data = record.compressionMethod === 0 ? stream
+            : stream.pipeThrough(new DecompressionStream('deflate-raw'));
         // Node reports bad deflate data as a bare TypeError; name the entry instead
-        const inflated = stream.pipeThrough(new DecompressionStream('deflate-raw')).getReader();
+        const inflated = data.getReader();
         let total = 0;
+        let crc = 0xffffffff;
         return new ReadableStream({
             async pull(controller) {
                 try {
                     const { done, value } = await inflated.read();
-                    if (done)
+                    if (done) {
+                        // Changed bytes must fail, not read as different data
+                        if (total !== record.uncompressedSize || ((crc ^ 0xffffffff) >>> 0) !== record.crc) {
+                            return controller.error(new Error(`Corrupt ZIP entry ${filename}: its data does not match the size and CRC-32 in the directory`));
+                        }
                         return controller.close();
+                    }
+                    crc = crc32Update(crc, value);
                     // The directory states each entry's size; inflating past it means a crafted entry (a zip bomb)
                     total += value.length;
                     if (total > record.uncompressedSize) {
@@ -181,7 +552,7 @@ function stripNamespace(name) {
 // Emits one array of tokens per input chunk. Per-token stream chunks cost a promise round-trip
 // each (~5 per cell), which dominated read time; batching removes that overhead.
 function createXmlBatchParser() {
-    const decoder = new TextDecoder();
+    let decoder;
     let buffer = '';
     let isFirstChunk = true;
     // When a construct spans chunks, remember how far it was already scanned (and the quote state
@@ -192,6 +563,8 @@ function createXmlBatchParser() {
     let pendingQuote = '';
     return new TransformStream({
         transform(chunk, controller) {
+            // XML parsers must read UTF-16 as well as UTF-8; a UTF-16 part starts with its byte-order mark
+            decoder ??= new TextDecoder(chunk[0] === 0xff && chunk[1] === 0xfe ? 'utf-16le' : chunk[0] === 0xfe && chunk[1] === 0xff ? 'utf-16be' : 'utf-8');
             buffer += decoder.decode(chunk, { stream: true });
             if (isFirstChunk) {
                 if (buffer.charCodeAt(0) === 0xFEFF) {
@@ -290,7 +663,7 @@ function createXmlBatchParser() {
                 controller.enqueue(out);
         },
         flush(controller) {
-            buffer += decoder.decode();
+            buffer += decoder?.decode() ?? '';
             // Handle trailing text if any
             if (buffer.length > 0 && pending !== 'tag' && pending !== 'cdata' && pending !== 'comment') {
                 controller.enqueue([{ type: 'text', value: unescapeXml$1(normalizeEol(buffer)) }]);
@@ -362,6 +735,17 @@ async function sheetToJson(parseResult, headerRowIndex = 0) {
             });
             continue;
         }
+        // Values right of the header row get their own column name, as blank headers do
+        for (let i = headers.length; i < row.cells.length; i++) {
+            if (row.cells[i] === null || row.cells[i] === undefined)
+                continue;
+            let name = `Column${i + 1}`;
+            for (let n = 2; headers.includes(name); n++)
+                name = `Column${i + 1}_${n}`;
+            while (headers.length < i)
+                headers.push(`Column${headers.length + 1}`);
+            headers.push(name);
+        }
         const obj = {};
         for (let i = 0; i < headers.length; i++) {
             const value = row.cells[i] ?? null;
@@ -386,9 +770,13 @@ function escapeCsv(val) {
 }
 async function streamToCsv(parseResult) {
     const rows = [];
+    let last = 0;
     for await (const row of parseResult) {
-        const csvRow = row.cells.map(escapeCsv).join(',');
-        rows.push(csvRow);
+        // Rows missing between rows are blank lines, as in Excel's CSV export, so nothing shifts up
+        for (let gap = last ? row.rowNumber - last - 1 : 0; gap > 0; gap--)
+            rows.push('');
+        last = row.rowNumber;
+        rows.push(row.cells.map(escapeCsv).join(','));
     }
     return rows.join('\n');
 }
@@ -434,15 +822,18 @@ async function resolveWorkbookParts(readText) {
     const workbookXml = await readText(workbookPath);
     const rels = parseRels(await readText(relsPathOf(workbookPath)), dirOf(workbookPath));
     const sheets = new Map();
+    const chartsheets = new Set();
     for (const [tag] of workbookXml.matchAll(/<(?:\w+:)?sheet\b[^>]*>/g)) {
         const name = attr(tag, 'name');
         const rId = attr(tag, 'r:id') ?? attr(tag, '\\w+:id');
         const rel = rId ? rels.find(r => r.id === rId && !r.external) : undefined;
         if (name && rel)
             sheets.set(name, rel.path);
+        if (rel?.type.endsWith('/chartsheet'))
+            chartsheets.add(rel.path);
     }
     return {
-        workbookPath, workbookXml, sheets,
+        workbookPath, workbookXml, sheets, chartsheets,
         sharedStrings: byType(rels, '/sharedStrings'), styles: byType(rels, '/styles'), theme: byType(rels, '/theme'),
     };
 }
@@ -519,16 +910,23 @@ function mapFormulaRefs(formula, mapCol, mapRow) {
             if (isEnd)
                 sheet = prevSheet;
             else if (before.endsWith('!')) {
-                sheet = /([A-Za-z0-9_.\u00C0-\uFFFF]+)!$/.exec(before)?.[1]
-                    ?? (offset === 1 && i > 0 && parts[i - 1].startsWith("'") ? unquoteSheet(parts[i - 1]) : undefined);
+                // [1]Sheet!A1 points into another workbook: "[" can't be in a sheet name, so no sheet matches it
+                const plain = /(\]?)([A-Za-z0-9_.\u00C0-\uFFFF]+)!$/.exec(before);
+                sheet = plain ? (plain[1] ? `[external]${plain[2]}` : plain[2])
+                    : offset === 1 && i > 0 && parts[i - 1].startsWith("'") ? unquoteSheet(parts[i - 1]) : undefined;
             }
             const role = isEnd ? 'end' : part[offset + m.length] === ':' ? 'start' : 'single';
+            // The end of a range pushed past the sheet's edge stays at the edge, as in Excel (SUM(B1:B1048576))
             const col = (abs, letters, r) => {
-                const c = mapCol(colIndex(letters), !!abs, r, sheet);
+                let c = mapCol(colIndex(letters), !!abs, r, sheet);
+                if (c !== null && c >= MAX_COLUMNS$1 && r === 'end' && colIndex(letters) < MAX_COLUMNS$1)
+                    c = MAX_COLUMNS$1 - 1;
                 return c !== null && c >= 0 && c < MAX_COLUMNS$1 ? abs + colLetter(c) : null;
             };
             const row = (abs, digits, r) => {
-                const n = mapRow(parseInt(digits, 10), !!abs, r, sheet);
+                let n = mapRow(parseInt(digits, 10), !!abs, r, sheet);
+                if (n !== null && n > MAX_ROWS$1 && r === 'end' && parseInt(digits, 10) <= MAX_ROWS$1)
+                    n = MAX_ROWS$1;
                 return n !== null && n >= 1 && n <= MAX_ROWS$1 ? n : null;
             };
             prevEnd = offset + m.length;
@@ -576,7 +974,7 @@ function dateToSerial(d) {
 function encodeXString(s) {
     return s
         .replace(/_(?=x[0-9A-Fa-f]{4}_)/g, '_x005F_')
-        .replace(/[\x00-\x08\x0B\x0C\r\x0E-\x1F]/g, c => `_x${c.charCodeAt(0).toString(16).toUpperCase().padStart(4, '0')}_`);
+        .replace(/[\x00-\x08\x0B\x0C\r\x0E-\x1F\uFFFE\uFFFF]/g, c => `_x${c.charCodeAt(0).toString(16).toUpperCase().padStart(4, '0')}_`);
 }
 // The format SheetWriter gives a date without one: the time only when there is one
 const defaultDateFormat = (d) => d.getTime() % 86400000 === 0 ? 'yyyy-mm-dd' : 'yyyy-mm-dd hh:mm:ss';
@@ -620,15 +1018,18 @@ async function recalcOnOpen(readText, parts, workbookXml = parts.workbookXml) {
 }
 // Excel refuses to open a workbook that breaks these rules
 function validateSheetName(name, existing) {
-    if (!name || name.length > 31 || /[\\/?*:[\]]/.test(name) || name.startsWith("'") || name.endsWith("'")) {
-        throw new Error(`Invalid sheet name "${name}": 1-31 characters, none of \\ / ? * : [ ], and no leading or trailing apostrophe.`);
+    if (!name || name.length > 31 || /[\\/?*:[\]\x00-\x1F\uFFFE\uFFFF]/.test(name) || name.startsWith("'") || name.endsWith("'")) {
+        throw new Error(`Invalid sheet name "${name}": 1-31 characters, none of \\ / ? * : [ ] or control characters, and no leading or trailing apostrophe.`);
     }
     for (const other of existing) {
         if (other.toLowerCase() === name.toLowerCase())
             throw new Error(`Duplicate sheet name "${name}".`);
     }
 }
-const escapeXml$5 = (val) => val.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+// Characters XML 1.0 can't carry at all. Text that allows _xHHHH_ escapes keeps them through
+// encodeXString first; anywhere else (names, properties, formulas) they are dropped.
+const INVALID_XML_CHARS = /[\x00-\x08\x0B\x0C\x0E-\x1F\uFFFE\uFFFF]/g;
+const escapeXml$4 = (val) => val.replace(INVALID_XML_CHARS, '').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
 const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 // Out-of-range references (&#x110000;) stay as written instead of throwing
 const fromCodePoint = (cp, m) => (cp <= 0x10ffff ? String.fromCodePoint(cp) : m);
@@ -1284,6 +1685,13 @@ class ParseResult {
         return this.comments();
     }
 }
+// "2026-10-08T14:05:00" or "2026-10-08" (a t="d" cell, no zone: UTC) as an ISO string; undefined when unreadable
+function isoDateCell(text) {
+    const t = text.trim();
+    const zoned = /(?:Z|[+-]\d\d:?\d\d)$/.test(t) ? t : t.includes('T') ? t + 'Z' : t + 'T00:00:00Z';
+    const d = new Date(zoned);
+    return isNaN(d.getTime()) ? undefined : d.toISOString();
+}
 function parseWorksheet(xmlTokenStream, sharedStrings, styles, is1904 = false, options = {}) {
     let resolveMeta;
     let rejectMeta;
@@ -1319,12 +1727,14 @@ function parseWorksheet(xmlTokenStream, sharedStrings, styles, is1904 = false, o
         let rowStyles;
         let rowRichText;
         let rowFormatted;
+        let rowErrors;
         let rawNumber; // a date cell's serial, for formatted text
         const runs = options.richText ? new RichTextCollector(options.richText) : undefined;
         let skipDepth = 0;
         // Shared formula anchors by si: the text and the cell it was written for
         const sharedFormulas = new Map();
         let currentRowNumber = 0;
+        let openedWorksheet = false, closedWorksheet = false;
         let currentColIndex = 0;
         let currentCellCol = 0;
         try {
@@ -1345,18 +1755,17 @@ function parseWorksheet(xmlTokenStream, sharedStrings, styles, is1904 = false, o
                             }
                             continue;
                         }
+                        if (token.name === 'worksheet')
+                            openedWorksheet = true;
                         if (token.name === 'row') {
                             inRow = true;
                             currentRow = [];
                             rowFormulas = rowStyles = rowRichText = rowFormatted = undefined;
+                            rowErrors = undefined;
                             currentColIndex = 0;
-                            const r = token.attributes['r'];
-                            if (r) {
-                                currentRowNumber = parseInt(r, 10);
-                            }
-                            else {
-                                currentRowNumber++;
-                            }
+                            // A missing or unusable r ("abc", "0") means the row after the previous one
+                            const r = Number(token.attributes['r']);
+                            currentRowNumber = Number.isInteger(r) && r >= 1 ? r : currentRowNumber + 1;
                             if (token.attributes['hidden'] === '1' || token.attributes['hidden'] === 'true') {
                                 hiddenRows.push(currentRowNumber);
                             }
@@ -1446,6 +1855,8 @@ function parseWorksheet(xmlTokenStream, sharedStrings, styles, is1904 = false, o
                         }
                         if (skipDepth > 0)
                             continue;
+                        if (token.name === 'worksheet')
+                            closedWorksheet = true;
                         if (token.name === 'row') {
                             const row = { rowNumber: currentRowNumber, cells: currentRow };
                             if (rowFormulas)
@@ -1456,6 +1867,8 @@ function parseWorksheet(xmlTokenStream, sharedStrings, styles, is1904 = false, o
                                 row.richText = rowRichText;
                             if (rowFormatted)
                                 row.formatted = rowFormatted;
+                            if (rowErrors)
+                                row.errors = rowErrors;
                             yield row;
                             inRow = false;
                         }
@@ -1484,11 +1897,19 @@ function parseWorksheet(xmlTokenStream, sharedStrings, styles, is1904 = false, o
                                 }
                                 else if (currentCellType === 'e') {
                                     resolvedValue = currentCellValue;
+                                    if (options.errors)
+                                        (rowErrors ??= [])[currentCellCol] = true;
                                 }
                                 else {
                                     const num = Number(currentCellValue);
-                                    if (isNaN(num)) {
-                                        resolvedValue = currentCellValue; // e.g. t="d" ISO dates
+                                    const iso = currentCellType === 'd' ? isoDateCell(currentCellValue) : undefined;
+                                    if (iso) {
+                                        // t="d": ISO text without a zone, read as UTC like serial dates
+                                        rawNumber = dateToSerial(new Date(iso)) - (is1904 ? 1462 : 0);
+                                        resolvedValue = iso;
+                                    }
+                                    else if (isNaN(num)) {
+                                        resolvedValue = currentCellValue;
                                     }
                                     else if (currentStyleId !== null && styles.get(currentStyleId) === 14) {
                                         rawNumber = num;
@@ -1551,6 +1972,9 @@ function parseWorksheet(xmlTokenStream, sharedStrings, styles, is1904 = false, o
                     }
                 }
             }
+            // A part cut off inside a row (an intact zip around a truncated sheet) must not read as a shorter sheet
+            if (inRow || inCell || openedWorksheet && !closedWorksheet)
+                throw new Error('Worksheet XML is cut off: the sheet ends before its closing tags.');
             const hiddenCols = [];
             hiddenColMarks.forEach((hidden, c) => { if (hidden)
                 hiddenCols.push(c); });
@@ -1570,6 +1994,13 @@ function parseWorksheet(xmlTokenStream, sharedStrings, styles, is1904 = false, o
 const EMU_PER_PX = 9525;
 // Format and pixel size from the file header
 function imageInfo(b) {
+    const info = headerInfo(b);
+    // A truncated header reads past the end of the bytes and gives NaN (or 0) sizes
+    if (!(info.width > 0 && info.height > 0))
+        throw new Error(`The ${info.ext.toUpperCase()} image is truncated or has no size.`);
+    return info;
+}
+function headerInfo(b) {
     const be16 = (i) => (b[i] << 8) | b[i + 1];
     const be32 = (i) => ((b[i] << 24) | (b[i + 1] << 16) | (b[i + 2] << 8) | b[i + 3]) >>> 0;
     if (b[0] === 0x89 && b[1] === 0x50 && b[2] === 0x4e && b[3] === 0x47) {
@@ -1648,7 +2079,6 @@ async function readSheetImages(readText, readBytes, sheetPath) {
     }
     return images;
 }
-const escapeXml$4 = (s) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
 const cellPos = (ref) => {
     const m = /^\$?([A-Za-z]{1,3})\$?(\d+)$/.exec(ref.trim());
     const col = m ? colIndex(m[1]) : -1, row = m ? parseInt(m[2], 10) - 1 : -1;
@@ -1664,6 +2094,9 @@ const DRAWING_NS = 'xmlns:xdr="http://schemas.openxmlformats.org/drawingml/2006/
 // none; a missing side keeps its aspect ratio. `attrs` lands on the anchor element, e.g. DRAWING_NS
 // when the anchor is added to a drawing that declares other prefixes.
 function anchorXml(place, natural, body, attrs = '') {
+    if (!place || typeof place.range !== 'string' && typeof place.at !== 'string') {
+        throw new Error('A picture or chart needs a placement: "at" (a cell) or "range".');
+    }
     if ('range' in place) {
         const [from, to = from] = place.range.split(':');
         const a = cellPos(from), b = cellPos(to);
@@ -1675,6 +2108,9 @@ function anchorXml(place, natural, body, attrs = '') {
     const { width: w, height: h } = natural;
     const width = place.width ?? (place.height ? w * place.height / h : w);
     const height = place.height ?? h * width / w;
+    if (!(width > 0 && height > 0 && isFinite(width) && isFinite(height))) {
+        throw new Error(`Invalid size ${place.width ?? ''}x${place.height ?? ''} at ${place.at}: width and height must be positive numbers.`);
+    }
     return `<xdr:oneCellAnchor${attrs}>${marker('from', cellPos(place.at))}<xdr:ext cx="${Math.round(width * EMU_PER_PX)}" cy="${Math.round(height * EMU_PER_PX)}"/>${body}<xdr:clientData/></xdr:oneCellAnchor>`;
 }
 const drawingPartXml = (anchors) => `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<xdr:wsDr ${DRAWING_NS}>${anchors}</xdr:wsDr>`;
@@ -1686,166 +2122,6 @@ function drawingXml(images, infos, rIds) {
         `<xdr:spPr><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></xdr:spPr></xdr:pic>`)).join(''));
 }
 
-// Reader for Compound File Binary files [MS-CFB]: the container of .xls workbooks and of
-// password-protected .xlsx files. Streams are read from an in-memory copy of the file.
-const SIGNATURE = [0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1];
-const END_OF_CHAIN = 0xfffffffe;
-const MAX_REGULAR_SECTOR = 0xfffffffa;
-function isCfb(bytes) {
-    return bytes.length >= 8 && SIGNATURE.every((b, i) => bytes[i] === b);
-}
-const corrupt$1 = (why) => new Error(`Corrupt compound file: ${why}`);
-class CfbReader {
-    bytes;
-    view;
-    sectorSize;
-    miniSectorSize;
-    miniCutoff;
-    fat;
-    miniFat;
-    miniStream;
-    dir;
-    byPath = new Map();
-    constructor(bytes) {
-        this.bytes = bytes;
-        if (!isCfb(bytes) || bytes.length < 512)
-            throw new Error('Not a compound file (no D0CF11E0 signature)');
-        this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-        const u16 = (o) => this.view.getUint16(o, true);
-        const u32 = (o) => this.view.getUint32(o, true);
-        const sectorShift = u16(0x1e);
-        if (sectorShift !== 9 && sectorShift !== 12)
-            throw corrupt$1(`sector shift ${sectorShift}`);
-        this.sectorSize = 1 << sectorShift;
-        const miniShift = u16(0x20);
-        if (miniShift !== 6)
-            throw corrupt$1(`mini sector shift ${miniShift}`);
-        this.miniSectorSize = 1 << miniShift;
-        this.miniCutoff = u32(0x38);
-        // The FAT's own sectors are listed in the header (109 slots) and then in a chain of DIFAT sectors
-        const numFatSectors = u32(0x2c);
-        const sectorCount = Math.ceil(bytes.length / this.sectorSize) - 1;
-        if (numFatSectors > sectorCount)
-            throw corrupt$1(`${numFatSectors} FAT sectors in a ${bytes.length}-byte file`);
-        const fatSectors = [];
-        for (let i = 0; i < 109 && fatSectors.length < numFatSectors; i++)
-            fatSectors.push(u32(0x4c + i * 4));
-        const perDifat = this.sectorSize / 4 - 1;
-        for (let s = u32(0x44), hops = 0; fatSectors.length < numFatSectors; hops++) {
-            if (s > MAX_REGULAR_SECTOR || hops > sectorCount)
-                throw corrupt$1('DIFAT chain ends early');
-            const at = this.sectorOffset(s);
-            for (let i = 0; i < perDifat && fatSectors.length < numFatSectors; i++)
-                fatSectors.push(u32(at + i * 4));
-            s = u32(at + perDifat * 4);
-        }
-        const perSector = this.sectorSize / 4;
-        this.fat = new Uint32Array(numFatSectors * perSector);
-        fatSectors.forEach((s, i) => {
-            const at = this.sectorOffset(s);
-            for (let j = 0; j < perSector; j++)
-                this.fat[i * perSector + j] = u32(at + j * 4);
-        });
-        // Directory: 128-byte entries in the chain starting at the header's first directory sector
-        const dirBytes = this.readChain(u32(0x30), Infinity);
-        this.dir = [];
-        for (let at = 0; at + 128 <= dirBytes.length; at += 128) {
-            const d = new DataView(dirBytes.buffer, dirBytes.byteOffset + at, 128);
-            const nameLen = Math.min(d.getUint16(64, true), 64);
-            let name = '';
-            for (let i = 0; i + 2 < nameLen; i += 2)
-                name += String.fromCharCode(d.getUint16(i, true));
-            // Version 3 files may leave garbage in the size's high half
-            const size = sectorShift === 9 ? d.getUint32(120, true) : d.getUint32(120, true) + d.getUint32(124, true) * 2 ** 32;
-            this.dir.push({ name, type: d.getUint8(66), left: d.getUint32(68, true), right: d.getUint32(72, true),
-                child: d.getUint32(76, true), start: d.getUint32(116, true), size });
-        }
-        if (this.dir[0]?.type !== 5)
-            throw corrupt$1('no root entry');
-        this.walk(this.dir[0].child, '');
-    }
-    // Start of a sector, checked to hold `need` bytes (the last sector of a file may be cut short)
-    sectorOffset(sector, need = this.sectorSize) {
-        const at = (sector + 1) * this.sectorSize;
-        if (sector > MAX_REGULAR_SECTOR || at + need > this.bytes.length) {
-            throw corrupt$1(`sector ${sector} is outside the file`);
-        }
-        return at;
-    }
-    // Sibling entries form a red-black tree; children of a storage hang off its `child`
-    walk(root, prefix) {
-        const stack = [root];
-        const seen = new Set();
-        while (stack.length) {
-            const id = stack.pop();
-            if (id > MAX_REGULAR_SECTOR)
-                continue; // NOSTREAM
-            if (seen.has(id) || !this.dir[id])
-                throw corrupt$1('directory tree loops or points outside the directory');
-            seen.add(id);
-            const e = this.dir[id];
-            stack.push(e.left, e.right);
-            if (e.type !== 1 && e.type !== 2)
-                continue;
-            const path = prefix + e.name;
-            this.byPath.set(path.toLowerCase(), { ...e, path });
-            if (e.type === 1)
-                this.walk(e.child, path + '/');
-        }
-    }
-    readChain(start, size, mini = false) {
-        const table = mini ? this.miniFat : this.fat;
-        const unit = mini ? this.miniSectorSize : this.sectorSize;
-        const source = mini ? this.miniStream : this.bytes;
-        const sectors = [];
-        for (let s = start; s !== END_OF_CHAIN && sectors.length * unit < size; s = table[s]) {
-            if (s >= table.length || sectors.length > table.length)
-                throw corrupt$1(`${mini ? 'mini ' : ''}sector chain is broken or loops`);
-            sectors.push(s);
-        }
-        const total = Math.min(size, sectors.length * unit);
-        if (size !== Infinity && total < size)
-            throw corrupt$1(`stream is shorter (${total} bytes) than its stated ${size}`);
-        const out = new Uint8Array(total);
-        sectors.forEach((s, i) => {
-            const len = Math.min(unit, total - i * unit);
-            const at = mini ? s * unit : this.sectorOffset(s, len);
-            if (at + len > source.length)
-                throw corrupt$1(`mini sector ${s} is outside the mini stream`);
-            out.set(source.subarray(at, at + len), i * unit);
-        });
-        return out;
-    }
-    entries() {
-        return [...this.byPath.values()].map(e => ({ path: e.path, type: e.type === 1 ? 'storage' : 'stream', size: e.size }));
-    }
-    has(path) {
-        return this.byPath.get(path.toLowerCase())?.type === 2;
-    }
-    // A stream's bytes, by path (case-insensitive, as in the format); undefined if there is none
-    read(path) {
-        const e = this.byPath.get(path.toLowerCase());
-        if (!e || e.type !== 2)
-            return undefined;
-        if (e.size >= this.miniCutoff) {
-            if (e.size > this.bytes.length)
-                throw corrupt$1(`stream ${e.path} is larger than the file`);
-            return this.readChain(e.start, e.size);
-        }
-        if (!this.miniStream) {
-            const root = this.dir[0];
-            this.miniStream = this.readChain(root.start, root.size);
-            const view = new DataView(this.bytes.buffer, this.bytes.byteOffset, this.bytes.byteLength);
-            const miniFatBytes = this.readChain(view.getUint32(0x3c, true), view.getUint32(0x40, true) * this.sectorSize);
-            this.miniFat = new Uint32Array(miniFatBytes.length / 4);
-            const mv = new DataView(miniFatBytes.buffer, miniFatBytes.byteOffset, miniFatBytes.byteLength);
-            for (let i = 0; i < this.miniFat.length; i++)
-                this.miniFat[i] = mv.getUint32(i * 4, true);
-        }
-        return this.readChain(e.start, e.size, true);
-    }
-}
-
 // Reader for Excel 97-2003 workbooks (.xls, BIFF8 records in a compound file) [MS-XLS].
 // Returns the same rows and metadata as the .xlsx reader. The file is held in memory; .xls sheets
 // are limited to 65,536 rows, so that stays modest.
@@ -2390,8 +2666,10 @@ async function readOdsWorkbook(content, readText) {
     if (!properties.creator && text('dc:creator'))
         properties.creator = text('dc:creator');
     const created = text('meta:creation-date');
-    if (created && !isNaN(Date.parse(created)))
-        properties.created = new Date(created);
+    // Without a zone the time is UTC, as written by OdsWriter (and stored by Excel)
+    const createdAt = created && new Date(/(?:Z|[+-]\d\d:?\d\d)$/.test(created) ? created : created + 'Z');
+    if (createdAt && !isNaN(createdAt.getTime()))
+        properties.created = createdAt;
     return { sheets, definedNames, properties };
 }
 // Frozen panes are view settings, kept in settings.xml per sheet
@@ -2640,9 +2918,7 @@ function parseOds(content, readText, options) {
     return new ParseResult(rows, metadata, async () => [], async () => { await finished; return comments; });
 }
 
-function escapeXml$3(val) {
-    return String(val).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
-}
+const escapeXml$3 = (val) => escapeXml$4(String(val));
 // Child elements of a <font> (styles) or, with nameTag "rFont", of a rich text run's <rPr>
 function fontXml(font, nameTag = 'name') {
     let xml = '';
@@ -2837,9 +3113,7 @@ ${this.dxfs.size ? `<dxfs count="${this.dxfs.size}">${[...this.dxfs.keys()].map(
     }
 }
 
-function escapeXml$2(val) {
-    return String(val).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
-}
+const escapeXml$2 = (val) => escapeXml$4(String(val));
 const color = (rgb) => `<color rgb="${argb(rgb)}"/>`;
 const bound = (type, value) => value === undefined ? `<cfvo type="${type}"/>` : `<cfvo type="num" val="${escapeXml$2(value)}"/>`;
 const formula = (f) => `<formula>${escapeXml$2(String(f).replace(/^=/, ''))}</formula>`;
@@ -2911,10 +3185,32 @@ class ConditionalFormatter {
     }
 }
 
+// An Excel error value (#DIV/0!, #VALUE!), kept apart from text that happens to start with "#"
+class FormulaError {
+    code;
+    constructor(code) {
+        this.code = code;
+    }
+}
+// Syntax or functions this engine doesn't know: no cached value, Excel computes it on open
+class Unsupported extends Error {
+}
+// A formula that reads its own cell, directly or through others
+class Circular extends Error {
+}
+const DIV0 = new FormulaError('#DIV/0!');
+const VALUE = new FormulaError('#VALUE!');
+// Numbers turned into text keep Excel's 15 significant digits ("0.333333333333333", 1E+21)
+function numberText(n) {
+    return String(Number(n.toPrecision(15))).replace('e', 'E');
+}
 class FormulaEngine {
     cells = new Map();
+    results = new Map();
+    evaluating = new Set();
     clear() {
         this.cells.clear();
+        this.results.clear();
     }
     loadData(data, startRow = 1) {
         data.forEach((row, ri) => {
@@ -2924,25 +3220,73 @@ class FormulaEngine {
             });
         });
     }
+    // Errors come back as their code ("#DIV/0!")
     evaluate(formula) {
+        const v = this.evaluateRaw(formula);
+        return v instanceof FormulaError ? v.code : v;
+    }
+    // Like evaluate, but errors stay FormulaError so text such as "#1 pick" is told apart from them
+    evaluateRaw(formula) {
+        try {
+            return this.run(formula);
+        }
+        catch (err) {
+            // A circular reference is stored as 0, as Excel does
+            if (err instanceof Circular)
+                return 0;
+            return null;
+        }
+    }
+    // The value of a loaded cell, computing its formula (and the formulas it reads) when it has one
+    cellValue(ref) {
         try {
-            const clean = formula.replace(/^=/, '').trim();
-            if (!clean)
-                return null;
-            const tokens = this.tokenize(clean);
-            const ast = this.parse(tokens);
-            return this.evaluateAst(ast);
+            return this.lookup(ref.toUpperCase());
+        }
+        catch (err) {
+            if (err instanceof Circular)
+                return 0;
+            return null;
+        }
+    }
+    run(formula) {
+        const clean = formula.replace(/^=/, '').trim();
+        if (!clean)
+            return null;
+        // A formula is never blank: =A1 over an empty cell is 0
+        return this.scalar(this.parse(this.tokenize(clean))) ?? 0;
+    }
+    lookup(ref) {
+        const cell = this.cells.get(ref);
+        if (cell === null || typeof cell !== 'object')
+            return cell ?? null;
+        if (this.results.has(ref)) {
+            const known = this.results.get(ref);
+            if (known === undefined)
+                throw new Unsupported();
+            return known;
+        }
+        if (this.evaluating.has(ref))
+            throw new Circular();
+        this.evaluating.add(ref);
+        try {
+            const v = this.run(cell.formula);
+            this.results.set(ref, v);
+            return v;
+        }
+        catch (err) {
+            if (!(err instanceof Circular))
+                this.results.set(ref, undefined);
+            throw err;
         }
-        catch {
-            // Unsupported syntax (other sheets, names, unknown functions): no cached value; Excel computes it on open
-            return null;
+        finally {
+            this.evaluating.delete(ref);
         }
     }
     tokenize(expr) {
         const tokens = [];
         let i = 0;
         while (i < expr.length) {
-            let char = expr[i];
+            const char = expr[i];
             if (/\s/.test(char)) {
                 i++;
                 continue;
@@ -2962,7 +3306,7 @@ class FormulaEngine {
                 i++;
                 continue;
             }
-            if (/[+\-*/^<>=]/.test(char)) {
+            if (/[+\-*/^<>=%&]/.test(char)) {
                 let op = char;
                 if (char === '<' || char === '>') {
                     if (expr[i + 1] === '=') {
@@ -2978,29 +3322,34 @@ class FormulaEngine {
                 i++;
                 continue;
             }
-            if (char === '"' || char === "'") {
-                const quote = char;
+            if (char === '"') {
+                // "" inside a string is one quote
                 let str = '';
                 i++;
-                while (i < expr.length && expr[i] !== quote) {
+                for (;;) {
+                    if (i >= expr.length)
+                        throw new Unsupported();
+                    if (expr[i] === '"') {
+                        if (expr[i + 1] !== '"')
+                            break;
+                        i++;
+                    }
                     str += expr[i++];
                 }
                 i++;
                 tokens.push({ type: 'STRING', value: str });
                 continue;
             }
-            if (/[0-9.]/.test(char)) {
-                let num = '';
-                while (i < expr.length && /[0-9.]/.test(expr[i])) {
-                    num += expr[i++];
-                }
-                tokens.push({ type: 'NUMBER', value: num });
+            const num = /^(?:\d+\.?\d*|\.\d+)(?:[Ee][+-]?\d+)?/.exec(expr.slice(i));
+            if (num) {
+                tokens.push({ type: 'NUMBER', value: num[0] });
+                i += num[0].length;
                 continue;
             }
             if (/[A-Za-z$]/.test(char)) {
                 // "$" only pins a reference when copied; it does not change what it points at
                 let id = '';
-                while (i < expr.length && /[A-Za-z0-9$]/.test(expr[i])) {
+                while (i < expr.length && /[A-Za-z0-9$_.]/.test(expr[i])) {
                     id += expr[i++];
                 }
                 id = id.replace(/\$/g, '');
@@ -3011,9 +3360,11 @@ class FormulaEngine {
                         endId += expr[i++];
                     }
                     endId = endId.replace(/\$/g, '');
+                    if (!/^[A-Z]{1,3}\d+$/i.test(id) || !/^[A-Z]{1,3}\d+$/i.test(endId))
+                        throw new Unsupported();
                     tokens.push({ type: 'RANGE', value: id.toUpperCase() + ':' + endId.toUpperCase() });
                 }
-                else if (/^[A-Z]+\d+$/i.test(id)) {
+                else if (/^[A-Z]{1,3}\d+$/i.test(id)) {
                     tokens.push({ type: 'CELL', value: id.toUpperCase() });
                 }
                 else {
@@ -3021,16 +3372,23 @@ class FormulaEngine {
                 }
                 continue;
             }
-            throw new Error(`Unknown character at ${i}: ${char}`);
+            // Sheet references ('Q1'!A1, Data!A1), arrays, error literals and the rest
+            throw new Unsupported();
         }
         return tokens;
     }
     parse(tokens) {
         let pos = 0;
-        const parsePrimary = () => {
+        const isOp = (...ops) => pos < tokens.length && tokens[pos].type === 'OP' && ops.includes(tokens[pos].value);
+        const expect = (type) => {
+            if (tokens[pos]?.type !== type)
+                throw new Unsupported();
+            pos++;
+        };
+        const parseAtom = () => {
             const token = tokens[pos];
             if (!token)
-                throw new Error('Unexpected end of input');
+                throw new Unsupported();
             if (token.type === 'NUMBER') {
                 pos++;
                 return { type: 'NUMBER', value: parseFloat(token.value) };
@@ -3050,146 +3408,188 @@ class FormulaEngine {
             if (token.type === 'IDENTIFIER') {
                 const name = token.value;
                 pos++;
-                if (pos < tokens.length && tokens[pos].type === 'PAREN_L') {
-                    pos++; // skip '('
+                if (tokens[pos]?.type === 'PAREN_L') {
+                    pos++;
                     const args = [];
-                    if (tokens[pos].type !== 'PAREN_R') {
+                    if (tokens[pos]?.type !== 'PAREN_R') {
                         args.push(parseExpression());
-                        while (pos < tokens.length && tokens[pos].type === 'COMMA') {
+                        while (tokens[pos]?.type === 'COMMA') {
                             pos++;
                             args.push(parseExpression());
                         }
                     }
-                    if (tokens[pos].type !== 'PAREN_R')
-                        throw new Error('Expected )');
-                    pos++;
+                    expect('PAREN_R');
                     return { type: 'CALL', name, args };
                 }
-                // Handle true/false constants
                 if (name === 'TRUE')
-                    return { type: 'NUMBER', value: true };
+                    return { type: 'BOOL', value: true };
                 if (name === 'FALSE')
-                    return { type: 'NUMBER', value: false };
-                throw new Error(`Unknown identifier ${name}`);
+                    return { type: 'BOOL', value: false };
+                throw new Unsupported(); // defined names
             }
             if (token.type === 'PAREN_L') {
                 pos++;
                 const node = parseExpression();
-                if (tokens[pos].type !== 'PAREN_R')
-                    throw new Error('Expected )');
-                pos++;
+                expect('PAREN_R');
                 return node;
             }
-            throw new Error(`Unexpected token ${token.value}`);
+            throw new Unsupported();
         };
-        const parsePower = () => {
-            let node = parsePrimary();
-            while (pos < tokens.length && tokens[pos].value === '^') {
-                const op = tokens[pos].value;
+        // Unary minus binds tighter than ^ in Excel (-2^2 is 4); % divides by 100
+        const parseUnary = () => {
+            if (isOp('-')) {
                 pos++;
-                node = { type: 'BINARY', operator: op, left: node, right: parsePrimary() };
+                return { type: 'NEG', left: parseUnary() };
             }
-            return node;
-        };
-        const parseFactor = () => {
-            let node = parsePower();
-            while (pos < tokens.length && (tokens[pos].value === '*' || tokens[pos].value === '/')) {
-                const op = tokens[pos].value;
+            if (isOp('+')) {
                 pos++;
-                node = { type: 'BINARY', operator: op, left: node, right: parsePower() };
+                return parseUnary();
             }
-            return node;
-        };
-        const parseTerm = () => {
-            let node = parseFactor();
-            while (pos < tokens.length && (tokens[pos].value === '+' || tokens[pos].value === '-')) {
-                const op = tokens[pos].value;
+            let node = parseAtom();
+            while (isOp('%')) {
                 pos++;
-                node = { type: 'BINARY', operator: op, left: node, right: parseFactor() };
+                node = { type: 'PERCENT', left: node };
             }
             return node;
         };
-        const parseComparison = () => {
-            let node = parseTerm();
-            while (pos < tokens.length && ['=', '<>', '<', '>', '<=', '>='].includes(tokens[pos].value)) {
-                const op = tokens[pos].value;
-                pos++;
-                node = { type: 'BINARY', operator: op, left: node, right: parseTerm() };
+        const binary = (next, ...ops) => () => {
+            let node = next();
+            while (isOp(...ops)) {
+                const operator = tokens[pos++].value;
+                node = { type: 'BINARY', operator, left: node, right: next() };
             }
             return node;
         };
-        const parseExpression = () => {
-            return parseComparison();
-        };
-        return parseExpression();
+        // Excel's ^ is left-associative: 2^3^2 is 64
+        const parsePower = binary(parseUnary, '^');
+        const parseFactor = binary(parsePower, '*', '/');
+        const parseTerm = binary(parseFactor, '+', '-');
+        const parseConcat = binary(parseTerm, '&');
+        const parseExpression = binary(parseConcat, '=', '<>', '<', '>', '<=', '>=');
+        const ast = parseExpression();
+        if (pos !== tokens.length)
+            throw new Unsupported();
+        return ast;
+    }
+    // A single value: a range used where one value is expected is not supported (implicit intersection)
+    scalar(node) {
+        const v = this.evaluateAst(node);
+        if (Array.isArray(v))
+            throw new Unsupported();
+        return v;
     }
     evaluateAst(node) {
-        if (node.type === 'NUMBER')
-            return node.value;
-        if (node.type === 'STRING')
-            return node.value;
-        if (node.type === 'CELL')
-            return this.cells.get(node.value) ?? 0;
-        if (node.type === 'RANGE')
-            return this.getRangeValues(node.value);
-        if (node.type === 'BINARY') {
-            const left = this.evaluateAst(node.left);
-            const right = this.evaluateAst(node.right);
-            const lNum = Number(left);
-            const rNum = Number(right);
-            switch (node.operator) {
-                case '+': return lNum + rNum;
-                case '-': return lNum - rNum;
-                case '*': return lNum * rNum;
-                case '/': return rNum === 0 ? '#DIV/0!' : lNum / rNum;
-                case '^': return Math.pow(lNum, rNum);
-                case '=': return left === right;
-                case '<>': return left !== right;
-                case '>': return lNum > rNum;
-                case '<': return lNum < rNum;
-                case '>=': return lNum >= rNum;
-                case '<=': return lNum <= rNum;
+        switch (node.type) {
+            case 'NUMBER':
+            case 'STRING':
+            case 'BOOL': return node.value;
+            case 'CELL': return this.lookup(node.value);
+            case 'RANGE': return this.getRangeValues(node.value);
+            case 'NEG': {
+                const n = toNumber(this.scalar(node.left));
+                return n instanceof FormulaError ? n : -n;
+            }
+            case 'PERCENT': {
+                const n = toNumber(this.scalar(node.left));
+                return n instanceof FormulaError ? n : n / 100;
+            }
+            case 'BINARY': return this.binary(node.operator, this.scalar(node.left), this.scalar(node.right));
+            case 'CALL': return this.call(node.name, node.args);
+        }
+        throw new Unsupported();
+    }
+    binary(op, left, right) {
+        if (left instanceof FormulaError)
+            return left;
+        if (right instanceof FormulaError)
+            return right;
+        if (op === '&')
+            return toText(left) + toText(right);
+        if (['=', '<>', '<', '>', '<=', '>='].includes(op)) {
+            const c = compare(left, right);
+            return op === '=' ? c === 0 : op === '<>' ? c !== 0 : op === '<' ? c < 0 : op === '>' ? c > 0 : op === '<=' ? c <= 0 : c >= 0;
+        }
+        const l = toNumber(left), r = toNumber(right);
+        if (l instanceof FormulaError)
+            return l;
+        if (r instanceof FormulaError)
+            return r;
+        switch (op) {
+            case '+': return l + r;
+            case '-': return l - r;
+            case '*': return l * r;
+            case '/': return r === 0 ? DIV0 : l / r;
+            case '^': {
+                const p = Math.pow(l, r);
+                return isFinite(p) ? p : new FormulaError('#NUM!');
             }
         }
-        if (node.type === 'CALL') {
-            const args = node.args.map(a => this.evaluateAst(a));
-            switch (node.name) {
-                case 'SUM': return this.numbers(args).reduce((a, b) => a + b, 0);
-                case 'AVERAGE': {
-                    const nums = this.numbers(args);
-                    return nums.length ? nums.reduce((a, b) => a + b, 0) / nums.length : '#DIV/0!';
-                }
-                case 'COUNT': return this.numbers(args).length;
-                case 'MAX': {
-                    const nums = this.numbers(args);
-                    return nums.length ? nums.reduce((a, b) => a > b ? a : b) : 0;
+        throw new Unsupported();
+    }
+    call(name, argNodes) {
+        if (name === 'IF') {
+            if (argNodes.length < 1 || argNodes.length > 3)
+                throw new Unsupported();
+            const cond = toBool(this.scalar(argNodes[0]));
+            if (cond instanceof FormulaError)
+                return cond;
+            if (cond)
+                return argNodes.length > 1 ? this.scalar(argNodes[1]) ?? 0 : true;
+            return argNodes.length > 2 ? this.scalar(argNodes[2]) ?? 0 : false;
+        }
+        if (name === 'CONCATENATE') {
+            let out = '';
+            for (const a of argNodes) {
+                const v = this.scalar(a);
+                if (v instanceof FormulaError)
+                    return v;
+                out += toText(v);
+            }
+            return out;
+        }
+        if (!['SUM', 'AVERAGE', 'COUNT', 'MAX', 'MIN'].includes(name))
+            throw new Unsupported();
+        // Values typed into the call count (TRUE as 1, "3" as 3); in referenced cells only numbers do
+        const nums = [];
+        for (const a of argNodes) {
+            const v = this.evaluateAst(a);
+            const referenced = a.type === 'CELL' || a.type === 'RANGE';
+            for (const x of Array.isArray(v) ? v : [v]) {
+                if (x instanceof FormulaError) {
+                    if (name === 'COUNT')
+                        continue;
+                    return x;
                 }
-                case 'MIN': {
-                    const nums = this.numbers(args);
-                    return nums.length ? nums.reduce((a, b) => a < b ? a : b) : 0;
+                if (typeof x === 'number')
+                    nums.push(x);
+                else if (!referenced && x !== null) {
+                    const n = toNumber(x);
+                    if (n instanceof FormulaError) {
+                        if (name === 'COUNT')
+                            continue;
+                        return n;
+                    }
+                    nums.push(n);
                 }
-                case 'IF': return args[0] ? args[1] : args[2];
-                case 'CONCATENATE': return this.flatten(args).join('');
             }
         }
-        return null;
-    }
-    // Like Excel aggregates: only numeric values count; text, booleans and blanks are skipped.
-    numbers(args) {
-        return this.flatten(args).filter((v) => typeof v === 'number' && !isNaN(v));
-    }
-    flatten(arr) {
-        return arr.flat(Infinity);
+        switch (name) {
+            case 'SUM': return nums.reduce((a, b) => a + b, 0);
+            case 'COUNT': return nums.length;
+            case 'AVERAGE': return nums.length ? nums.reduce((a, b) => a + b, 0) / nums.length : DIV0;
+            case 'MAX': return nums.length ? Math.max(...nums) : 0;
+            default: return nums.length ? Math.min(...nums) : 0;
+        }
     }
     getRangeValues(range) {
         const [startRef, endRef] = range.split(':');
-        const [startCol, startRow] = this.parseRef(startRef);
-        const [endCol, endRow] = this.parseRef(endRef);
+        const [c1, r1] = this.parseRef(startRef);
+        const [c2, r2] = this.parseRef(endRef);
         const values = [];
-        for (let r = startRow; r <= endRow; r++) {
-            for (let c = startCol; c <= endCol; c++) {
-                const ref = this.toRef(r, c - 1);
-                values.push(this.cells.get(ref) ?? null);
+        // A3:A1 is the same range as A1:A3
+        for (let r = Math.min(r1, r2); r <= Math.max(r1, r2); r++) {
+            for (let c = Math.min(c1, c2); c <= Math.max(c1, c2); c++) {
+                values.push(this.lookup(this.toRef(r, c - 1)));
             }
         }
         return values;
@@ -3210,185 +3610,72 @@ class FormulaEngine {
         return `${col}${row}`;
     }
 }
-
-const CRC_TABLE = (() => {
-    const t = new Uint32Array(256);
-    for (let n = 0; n < 256; n++) {
-        let c = n;
-        for (let k = 0; k < 8; k++)
-            c = (c & 1) ? (c >>> 1) ^ 0xedb88320 : c >>> 1;
-        t[n] = c >>> 0;
-    }
-    return t;
-})();
-function crc32(bytes) {
-    let crc = 0xffffffff;
-    for (let i = 0; i < bytes.length; i++)
-        crc = CRC_TABLE[(crc ^ bytes[i]) & 0xff] ^ (crc >>> 8);
-    return (crc ^ 0xffffffff) >>> 0;
-}
-const MAX_U32 = 0xffffffff;
-// No ZIP64 support: fail loudly instead of writing a corrupt archive.
-function assertNoZip64(value, what) {
-    if (value > MAX_U32)
-        throw new Error(`ZIP64 not supported: ${what} exceeds 4 GiB.`);
-}
-// A true Single-Pass Streaming ZIP Writer
-class ZipStreamWriter {
-    cdEntries = [];
-    offset = 0;
-    streamController;
-    resumePull = null;
-    cancelled = false;
-    stream;
-    textEncoder = new TextEncoder();
-    constructor(highWaterMarkBytes = 1 << 20) {
-        this.stream = new ReadableStream({
-            start: (controller) => {
-                this.streamController = controller;
-            },
-            pull: () => {
-                this.resumePull?.();
-                this.resumePull = null;
-            },
-            // Consumer gone: unblock any pending write so the producer can see the error.
-            cancel: () => {
-                this.cancelled = true;
-                this.resumePull?.();
-                this.resumePull = null;
-            }
-        }, new ByteLengthQueuingStrategy({ highWaterMark: highWaterMarkBytes }));
-    }
-    // Adds a file to the zip. `inputStream` MUST be raw uncompressed data.
-    async addFile(filenameStr, inputStream) {
-        const filename = this.textEncoder.encode(filenameStr);
-        const startOffset = this.offset;
-        await this.pushChunk(this.localHeader(filename, 0x0008, 8, 0, 0, 0));
-        // Stream data, tracking sizes and CRC32
-        let uncompressedSize = 0;
-        let crc = 0xffffffff;
-        const crcStream = new TransformStream({
-            transform: (chunk, controller) => {
-                uncompressedSize += chunk.length;
-                for (let i = 0; i < chunk.length; i++) {
-                    crc = CRC_TABLE[(crc ^ chunk[i]) & 0xff] ^ (crc >>> 8);
-                }
-                controller.enqueue(chunk);
-            }
-        });
-        let compressedSize = 0;
-        const reader = inputStream
-            .pipeThrough(crcStream)
-            .pipeThrough(new CompressionStream('deflate-raw'))
-            .getReader();
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            compressedSize += value.length;
-            await this.pushChunk(value);
-        }
-        crc = (crc ^ 0xffffffff) >>> 0;
-        assertNoZip64(uncompressedSize, filenameStr);
-        assertNoZip64(compressedSize, filenameStr);
-        // Data Descriptor
-        const desc = new Uint8Array(16);
-        const descView = new DataView(desc.buffer);
-        descView.setUint32(0, 0x08074b50, true);
-        descView.setUint32(4, crc, true);
-        descView.setUint32(8, compressedSize, true);
-        descView.setUint32(12, uncompressedSize, true);
-        await this.pushChunk(desc);
-        this.cdEntries.push({ filename, offset: startOffset, uncompressedSize, compressedSize, crc, flags: 0x0008, method: 8 });
-    }
-    // Adds a file that is ALREADY compressed (pass-through for the Editor)
-    async addCompressedFile(filenameStr, compressedStream, uncompressedSize, compressedSize, crc, method = 8) {
-        const filename = this.textEncoder.encode(filenameStr);
-        const startOffset = this.offset;
-        await this.pushChunk(this.localHeader(filename, 0, method, crc, compressedSize, uncompressedSize));
-        const reader = compressedStream.getReader();
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            await this.pushChunk(value);
-        }
-        this.cdEntries.push({ filename, offset: startOffset, uncompressedSize, compressedSize, crc, flags: 0, method });
-    }
-    async close() {
-        if (this.cdEntries.length > 0xffff)
-            throw new Error('ZIP64 not supported: more than 65535 entries.');
-        const cdStartOffset = this.offset;
-        for (const entry of this.cdEntries) {
-            const cd = new Uint8Array(46 + entry.filename.length);
-            const view = new DataView(cd.buffer);
-            view.setUint32(0, 0x02014b50, true);
-            view.setUint16(4, 20, true); // version made by
-            view.setUint16(6, 20, true); // version needed
-            view.setUint16(8, entry.flags, true);
-            view.setUint16(10, entry.method, true);
-            view.setUint32(16, entry.crc, true);
-            view.setUint32(20, entry.compressedSize, true);
-            view.setUint32(24, entry.uncompressedSize, true);
-            view.setUint16(28, entry.filename.length, true);
-            view.setUint32(42, entry.offset, true);
-            cd.set(entry.filename, 46);
-            await this.pushChunk(cd);
-        }
-        const cdSize = this.offset - cdStartOffset;
-        assertNoZip64(this.offset, 'archive');
-        const eocd = new Uint8Array(22);
-        const eocdView = new DataView(eocd.buffer);
-        eocdView.setUint32(0, 0x06054b50, true);
-        eocdView.setUint16(8, this.cdEntries.length, true);
-        eocdView.setUint16(10, this.cdEntries.length, true);
-        eocdView.setUint32(12, cdSize, true);
-        eocdView.setUint32(16, cdStartOffset, true);
-        await this.pushChunk(eocd);
-        this.streamController.close();
-    }
-    // Propagate a producer failure to whoever is reading `stream`.
-    error(err) {
-        try {
-            this.streamController.error(err);
-        }
-        catch { /* already closed/errored */ }
-    }
-    localHeader(filename, flags, method, crc, compressedSize, uncompressedSize) {
-        assertNoZip64(this.offset, 'archive');
-        const header = new Uint8Array(30 + filename.length);
-        const view = new DataView(header.buffer);
-        view.setUint32(0, 0x04034b50, true);
-        view.setUint16(4, 20, true);
-        view.setUint16(6, flags, true);
-        view.setUint16(8, method, true);
-        view.setUint32(14, crc, true);
-        view.setUint32(18, compressedSize, true);
-        view.setUint32(22, uncompressedSize, true);
-        view.setUint16(26, filename.length, true);
-        header.set(filename, 30);
-        return header;
-    }
-    // Enqueue and wait while the consumer's queue is full, so memory stays bounded.
-    async pushChunk(chunk) {
-        this.streamController.enqueue(chunk);
-        this.offset += chunk.length;
-        while ((this.streamController.desiredSize ?? 1) <= 0) {
-            if (this.cancelled)
-                throw new Error('ZIP stream cancelled by consumer.');
-            await new Promise(resolve => { this.resumePull = resolve; });
-        }
-    }
+// Excel's conversions: blank is 0 / "" / FALSE, booleans are 1 and 0, text must read as a number
+function toNumber(v) {
+    if (v instanceof FormulaError)
+        return v;
+    if (v === null)
+        return 0;
+    if (typeof v === 'boolean')
+        return v ? 1 : 0;
+    if (typeof v === 'number')
+        return v;
+    const t = v.trim();
+    const n = t === '' ? NaN : Number(t);
+    return isFinite(n) ? n : VALUE;
+}
+function toText(v) {
+    if (v === null)
+        return '';
+    if (typeof v === 'boolean')
+        return v ? 'TRUE' : 'FALSE';
+    if (typeof v === 'number')
+        return numberText(v);
+    return String(v);
+}
+function toBool(v) {
+    if (v instanceof FormulaError)
+        return v;
+    if (v === null)
+        return false;
+    if (typeof v === 'boolean')
+        return v;
+    if (typeof v === 'number')
+        return v !== 0;
+    const t = v.toUpperCase();
+    return t === 'TRUE' ? true : t === 'FALSE' ? false : VALUE;
+}
+// Excel orders numbers < text < booleans; text compares without case. A blank takes the other side's type.
+function compare(a, b) {
+    if (a === null)
+        a = typeof b === 'string' ? '' : typeof b === 'boolean' ? false : 0;
+    if (b === null)
+        b = typeof a === 'string' ? '' : typeof a === 'boolean' ? false : 0;
+    const rank = (v) => typeof v === 'number' ? 0 : typeof v === 'string' ? 1 : 2;
+    if (rank(a) !== rank(b))
+        return rank(a) - rank(b);
+    if (typeof a === 'string') {
+        const x = a.toLowerCase(), y = b.toLowerCase();
+        return x < y ? -1 : x > y ? 1 : 0;
+    }
+    const x = Number(a), y = Number(b);
+    return x < y ? -1 : x > y ? 1 : 0;
 }
 
-function escapeXml$1(val) {
-    return String(val)
-        .replace(/&/g, '&amp;')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&apos;');
+const escapeXml$1 = (val) => escapeXml$4(String(val)).replace(/'/g, '&apos;');
+// "A1:B2" (or one cell) -> 0-based corners, checked against Excel's sheet size
+function parseRange$1(ref, what) {
+    const m = /^\$?([A-Za-z]{1,3})\$?(\d+)(?::\$?([A-Za-z]{1,3})\$?(\d+))?$/.exec(String(ref).trim());
+    const box = m && {
+        c1: colIndex(m[1]), r1: parseInt(m[2], 10) - 1,
+        c2: colIndex(m[3] ?? m[1]), r2: parseInt(m[4] ?? m[2], 10) - 1,
+    };
+    if (!box || [box.c1, box.c2].some(c => c >= MAX_COLUMNS$1) || [box.r1, box.r2].some(r => r < 0 || r >= MAX_ROWS$1)) {
+        throw new Error(`Invalid ${what} "${ref}".`);
+    }
+    return { c1: Math.min(box.c1, box.c2), r1: Math.min(box.r1, box.r2), c2: Math.max(box.c1, box.c2), r2: Math.max(box.r1, box.r2) };
 }
+const overlaps = (a, b) => a.c1 <= b.c2 && b.c1 <= a.c2 && a.r1 <= b.r2 && b.r1 <= a.r2;
 function isStyledCell$1(v) {
     return typeof v === 'object' && v !== null && 'value' in v;
 }
@@ -3429,7 +3716,7 @@ function appPropsXml(p) {
 }
 // A name Excel accepts: letters, digits, _ . and \, not a cell reference (A1, R1C1) and not reserved
 function validateDefinedName(name) {
-    if (!/^[A-Za-z_\\][A-Za-z0-9_.\\]*$/.test(name) || /^[A-Za-z]{1,3}\d+$/.test(name) || /^([Rr]\d*)?([Cc]\d*)?$/.test(name) || /^_xlnm\./i.test(name)) {
+    if (!/^[A-Za-z_\\][A-Za-z0-9_.\\]*$/.test(name) || name.length > 255 || /^[A-Za-z]{1,3}\d+$/.test(name) || /^([Rr]\d*)?([Cc]\d*)?$/.test(name) || /^_xlnm\./i.test(name)) {
         throw new Error(`Invalid defined name "${name}"`);
     }
 }
@@ -3504,6 +3791,8 @@ class SheetWriter {
                     this.formulaEngine.clear();
                     if (Array.isArray(sheet.rows)) {
                         this.formulaEngine.loadData(sheet.rows.map(row => row.map(cell => {
+                            if (isStyledCell$1(cell) && cell.formula)
+                                return { formula: cell.formula };
                             const v = !isStyledCell$1(cell) ? cell : cell.richText && cell.value == null ? cell.richText.map(r => r.text).join('') : cell.value;
                             return v instanceof Date ? dateToSerial(v) : v;
                         })));
@@ -3512,7 +3801,7 @@ class SheetWriter {
                     }
                     const parts = { links: [], comments: [] };
                     const sheetTables = tables.filter(t => t.sheet === i);
-                    await zip.addFile(`xl/worksheets/sheet${i + 1}.xml`, this.buildWorksheetXmlStream(sheet.rows, sheet.options, parts, sheetTables.length));
+                    await zip.addFile(`xl/worksheets/sheet${i + 1}.xml`, this.buildWorksheetXmlStream(sheet.rows, sheet.options, parts, sheetTables.length, Array.isArray(sheet.rows)));
                     const images = sheet.options.images ?? [];
                     const drawing = images.length ? ++drawings : 0;
                     const rels = this.buildSheetRels(parts.links, drawing, parts.comments.length ? i + 1 : 0, sheetTables.map(t => t.id));
@@ -3550,14 +3839,26 @@ class SheetWriter {
         const plan = [];
         const names = new Set();
         this.sheets.forEach((sheet, i) => {
+            const boxes = [];
             for (const table of sheet.options.tables ?? []) {
-                if (!/^[A-Za-z_\\][A-Za-z0-9_.]*$/.test(table.name) || names.has(table.name.toLowerCase())) {
-                    throw new Error(`Invalid or duplicate table name "${table.name}".`);
+                // Table names follow the defined-name rules: no "AB12", "R1C1" or "C"
+                let valid = !names.has(String(table.name).toLowerCase());
+                try {
+                    validateDefinedName(table.name);
                 }
+                catch {
+                    valid = false;
+                }
+                if (!valid)
+                    throw new Error(`Invalid or duplicate table name "${table.name}".`);
                 names.add(table.name.toLowerCase());
                 const m = /^([A-Za-z]{1,3})(\d+):([A-Za-z]{1,3})(\d+)$/.exec(table.ref.replace(/\$/g, ''));
                 if (!m)
                     throw new Error(`Invalid table range "${table.ref}".`);
+                const box = parseRange$1(table.ref, 'table range');
+                if (boxes.some(b => overlaps(b, box)))
+                    throw new Error(`Table "${table.name}" overlaps another table on sheet "${sheet.name}".`);
+                boxes.push(box);
                 const first = colIndex(m[1]);
                 const width = colIndex(m[3]) - first + 1;
                 let columns = table.columns;
@@ -3623,9 +3924,9 @@ class SheetWriter {
         await zip.addFile(filename, stream);
     }
     // Pull-based so rows are only generated as fast as the ZIP consumer drains them.
-    buildWorksheetXmlStream(rows, options, parts, tables) {
+    buildWorksheetXmlStream(rows, options, parts, tables, evaluate) {
         const encoder = new TextEncoder();
-        const chunks = this.worksheetXmlChunks(rows, options, parts, tables);
+        const chunks = this.worksheetXmlChunks(rows, options, parts, tables, evaluate);
         return new ReadableStream({
             async pull(controller) {
                 const { done, value } = await chunks.next();
@@ -3640,7 +3941,8 @@ class SheetWriter {
         });
     }
     // Hyperlink targets and comments are collected in `parts` for the parts written after the sheet
-    async *worksheetXmlChunks(rows, options, parts, tables) {
+    // `evaluate`: the rows are an array loaded into the formula engine, so formulas get cached results
+    async *worksheetXmlChunks(rows, options, parts, tables, evaluate) {
         const links = parts.links;
         const hyperlinks = [];
         const colCount = Math.max(options.columnWidths?.length ?? 0, options.columns?.length ?? 0);
@@ -3653,7 +3955,12 @@ class SheetWriter {
             colWidths += `<col min="${i + 1}" max="${i + 1}"${width !== undefined ? ` width="${escapeXml$1(width)}" customWidth="1"` : ''}` +
                 `${c.hidden ? ' hidden="1"' : ''}${c.outlineLevel ? ` outlineLevel="${escapeXml$1(c.outlineLevel)}"` : ''}/>`;
         }
-        const rowOptions = Object.entries(options.rows ?? {}).map(([r, o]) => [parseInt(r, 10), o]).sort((a, b) => a[0] - b[0]);
+        const rowOptions = Object.entries(options.rows ?? {}).map(([r, o]) => {
+            const n = Number(r);
+            if (!Number.isInteger(n) || n < 1 || n > MAX_ROWS$1)
+                throw new Error(`Row options for "${r}": rows are numbered 1 to ${MAX_ROWS$1}.`);
+            return [n, o];
+        }).sort((a, b) => a[0] - b[0]);
         const rowAttrs = new Map(rowOptions.map(([r, o]) => [r, `${o.height !== undefined ? ` ht="${escapeXml$1(o.height)}" customHeight="1"` : ''}${o.hidden ? ' hidden="1"' : ''}${o.outlineLevel ? ` outlineLevel="${escapeXml$1(o.outlineLevel)}"` : ''}`]));
         let nextRowOption = 0;
         // Rows that only exist for their options (height, hidden, outline) and hold no cells
@@ -3702,97 +4009,108 @@ class SheetWriter {
             : (async function* () { for (const r of rows)
                 yield r; })();
         let chunkStr = '';
-        while (true) {
-            const { done, value: row } = await iterator.next();
-            if (done)
-                break;
-            const rowNum = ri + 1;
-            // Past Excel's sheet size the file is damaged, so refuse it instead
-            if (rowNum > MAX_ROWS$1)
-                throw new Error(`Row ${rowNum} is past Excel's last row (${MAX_ROWS$1}).`);
-            if (row.length > MAX_COLUMNS$1)
-                throw new Error(`Row ${rowNum} has ${row.length} cells, more than Excel's ${MAX_COLUMNS$1} columns.`);
-            chunkStr += optionRowsBefore(rowNum);
-            if (rowOptions[nextRowOption]?.[0] === rowNum)
-                nextRowOption++;
-            const cellsXml = row.map((cell, ci) => {
-                const colRef = colLetter(ci) + rowNum;
-                const styledCell = isStyledCell$1(cell) ? cell : { value: cell };
-                const val = styledCell.value;
-                let cellStyle = styledCell.style;
-                if (val instanceof Date && !cellStyle?.numFmt) {
-                    // A date needs a date format, or Excel shows the bare serial number
-                    cellStyle = { ...cellStyle, numFmt: defaultDateFormat(val) };
-                }
-                const style = cellStyle ? this.styleEngine.registerStyle(cellStyle) : 0;
-                const sAttr = style > 0 ? ` s="${style}"` : '';
-                if (styledCell.comment !== undefined) {
-                    const comment = typeof styledCell.comment === 'string' ? { text: styledCell.comment } : styledCell.comment;
-                    parts.comments.push({ ref: colRef, row: rowNum - 1, col: ci, comment });
-                }
-                if (styledCell.hyperlink) {
-                    if (styledCell.hyperlink.startsWith('#')) {
-                        hyperlinks.push(`<hyperlink ref="${colRef}" location="${escapeXml$1(styledCell.hyperlink.slice(1))}"/>`);
+        // Ends the caller's row source when the output is cancelled or fails (its finally blocks run)
+        try {
+            while (true) {
+                const { done, value: row } = await iterator.next();
+                if (done)
+                    break;
+                const rowNum = ri + 1;
+                // Past Excel's sheet size the file is damaged, so refuse it instead
+                if (rowNum > MAX_ROWS$1)
+                    throw new Error(`Row ${rowNum} is past Excel's last row (${MAX_ROWS$1}).`);
+                if (row.length > MAX_COLUMNS$1)
+                    throw new Error(`Row ${rowNum} has ${row.length} cells, more than Excel's ${MAX_COLUMNS$1} columns.`);
+                chunkStr += optionRowsBefore(rowNum);
+                if (rowOptions[nextRowOption]?.[0] === rowNum)
+                    nextRowOption++;
+                const cellsXml = row.map((cell, ci) => {
+                    const colRef = colLetter(ci) + rowNum;
+                    const styledCell = isStyledCell$1(cell) ? cell : { value: cell };
+                    const val = styledCell.value;
+                    let cellStyle = styledCell.style;
+                    if (val instanceof Date && !cellStyle?.numFmt) {
+                        // A date needs a date format, or Excel shows the bare serial number
+                        cellStyle = { ...cellStyle, numFmt: defaultDateFormat(val) };
                     }
-                    else {
-                        links.push(styledCell.hyperlink);
-                        hyperlinks.push(`<hyperlink ref="${colRef}" r:id="rId${links.length}"/>`);
+                    const style = cellStyle ? this.styleEngine.registerStyle(cellStyle) : 0;
+                    const sAttr = style > 0 ? ` s="${style}"` : '';
+                    if (styledCell.comment !== undefined) {
+                        const comment = typeof styledCell.comment === 'string' ? { text: styledCell.comment } : styledCell.comment;
+                        parts.comments.push({ ref: colRef, row: rowNum - 1, col: ci, comment });
                     }
-                }
-                if (styledCell.formula) {
-                    const result = this.formulaEngine.evaluate(styledCell.formula);
-                    let tAttr = '';
-                    let cachedVal = '';
-                    if (typeof result === 'number' && isFinite(result))
-                        cachedVal = `<v>${result}</v>`;
-                    else if (typeof result === 'boolean') {
-                        tAttr = ' t="b"';
-                        cachedVal = `<v>${result ? 1 : 0}</v>`;
+                    if (styledCell.hyperlink) {
+                        if (styledCell.hyperlink.startsWith('#')) {
+                            hyperlinks.push(`<hyperlink ref="${colRef}" location="${escapeXml$1(styledCell.hyperlink.slice(1))}"/>`);
+                        }
+                        else {
+                            links.push(styledCell.hyperlink);
+                            hyperlinks.push(`<hyperlink ref="${colRef}" r:id="rId${links.length}"/>`);
+                        }
                     }
-                    else if (typeof result === 'string') {
-                        tAttr = result.startsWith('#') ? ' t="e"' : ' t="str"';
-                        cachedVal = `<v>${escapeXml$1(encodeXString(result))}</v>`;
+                    if (styledCell.formula) {
+                        // Streamed rows aren't in the engine, so their formulas get no (made-up) cached value
+                        const result = evaluate ? this.formulaEngine.cellValue(colRef) : null;
+                        let tAttr = '';
+                        let cachedVal = '';
+                        if (typeof result === 'number' && isFinite(result))
+                            cachedVal = `<v>${result}</v>`;
+                        else if (typeof result === 'boolean') {
+                            tAttr = ' t="b"';
+                            cachedVal = `<v>${result ? 1 : 0}</v>`;
+                        }
+                        else if (result instanceof FormulaError) {
+                            tAttr = ' t="e"';
+                            cachedVal = `<v>${escapeXml$1(result.code)}</v>`;
+                        }
+                        else if (typeof result === 'string') {
+                            tAttr = ' t="str"';
+                            cachedVal = `<v>${escapeXml$1(encodeXString(result))}</v>`;
+                        }
+                        return `<c r="${colRef}"${tAttr}${sAttr}><f>${escapeXml$1(styledCell.formula.replace(/^=/, ''))}</f>${cachedVal}</c>`;
                     }
-                    return `<c r="${colRef}"${tAttr}${sAttr}><f>${escapeXml$1(styledCell.formula.replace(/^=/, ''))}</f>${cachedVal}</c>`;
-                }
-                if (styledCell.richText) {
-                    // Rich text is always inline, even with sharedStrings on
-                    return `<c r="${colRef}" t="inlineStr"${sAttr}><is>${runsXml(styledCell.richText)}</is></c>`;
-                }
-                if (val === null || val === undefined)
-                    return `<c r="${colRef}"${sAttr}/>`;
-                if (typeof val === 'boolean')
-                    return `<c r="${colRef}" t="b"${sAttr}><v>${val ? 1 : 0}</v></c>`;
-                if (typeof val === 'number') {
-                    // NaN/Infinity have no representation in a cell
-                    return isFinite(val) ? `<c r="${colRef}"${sAttr}><v>${val}</v></c>` : `<c r="${colRef}" t="e"${sAttr}><v>#NUM!</v></c>`;
-                }
-                if (val instanceof Date) {
-                    if (isNaN(val.getTime()))
-                        throw new Error(`Invalid Date in cell ${colRef}`);
-                    return `<c r="${colRef}"${sAttr}><v>${dateToSerial(val)}</v></c>`;
-                }
-                if (typeof val === 'string') {
-                    checkCellText(val, colRef);
-                    if (this.writerOptions.sharedStrings) {
-                        let index = this.sharedStrings.get(val);
-                        if (index === undefined)
-                            this.sharedStrings.set(val, index = this.sharedStrings.size);
-                        this.sharedStringRefs++;
-                        return `<c r="${colRef}" t="s"${sAttr}><v>${index}</v></c>`;
+                    if (styledCell.richText) {
+                        // Rich text is always inline, even with sharedStrings on
+                        return `<c r="${colRef}" t="inlineStr"${sAttr}><is>${runsXml(styledCell.richText)}</is></c>`;
+                    }
+                    if (val === null || val === undefined)
+                        return `<c r="${colRef}"${sAttr}/>`;
+                    if (typeof val === 'boolean')
+                        return `<c r="${colRef}" t="b"${sAttr}><v>${val ? 1 : 0}</v></c>`;
+                    if (typeof val === 'number') {
+                        // NaN/Infinity have no representation in a cell
+                        return isFinite(val) ? `<c r="${colRef}"${sAttr}><v>${val}</v></c>` : `<c r="${colRef}" t="e"${sAttr}><v>#NUM!</v></c>`;
+                    }
+                    if (val instanceof Date) {
+                        if (isNaN(val.getTime()))
+                            throw new Error(`Invalid Date in cell ${colRef}`);
+                        return `<c r="${colRef}"${sAttr}><v>${dateToSerial(val)}</v></c>`;
                     }
-                    return `<c r="${colRef}" t="inlineStr"${sAttr}><is>${stringXml(val)}</is></c>`;
+                    if (typeof val === 'string') {
+                        checkCellText(val, colRef);
+                        if (this.writerOptions.sharedStrings) {
+                            let index = this.sharedStrings.get(val);
+                            if (index === undefined)
+                                this.sharedStrings.set(val, index = this.sharedStrings.size);
+                            this.sharedStringRefs++;
+                            return `<c r="${colRef}" t="s"${sAttr}><v>${index}</v></c>`;
+                        }
+                        return `<c r="${colRef}" t="inlineStr"${sAttr}><is>${stringXml(val)}</is></c>`;
+                    }
+                    return `<c r="${colRef}"${sAttr}/>`;
+                }).join('');
+                chunkStr += `    <row r="${rowNum}"${rowAttrs.get(rowNum) ?? ''}>${cellsXml}</row>\n`;
+                ri++;
+                // Flush every ~64KB of string data to keep O(1) memory while avoiding chunk overhead
+                if (chunkStr.length > 65536) {
+                    yield chunkStr;
+                    chunkStr = '';
                 }
-                return `<c r="${colRef}"${sAttr}/>`;
-            }).join('');
-            chunkStr += `    <row r="${rowNum}"${rowAttrs.get(rowNum) ?? ''}>${cellsXml}</row>\n`;
-            ri++;
-            // Flush every ~64KB of string data to keep O(1) memory while avoiding chunk overhead
-            if (chunkStr.length > 65536) {
-                yield chunkStr;
-                chunkStr = '';
             }
         }
+        finally {
+            await iterator.return?.();
+        }
         chunkStr += optionRowsBefore(Infinity);
         if (chunkStr.length > 0) {
             yield chunkStr;
@@ -3808,6 +4126,14 @@ class SheetWriter {
         if (options.autoFilter)
             footer += `  <autoFilter ref="${escapeXml$1(options.autoFilter)}"/>\n`;
         if (options.mergeCells && options.mergeCells.length > 0) {
+            // Overlapping or malformed merges make Excel repair the file
+            const boxes = [];
+            for (const ref of options.mergeCells) {
+                const box = parseRange$1(ref, 'merge range');
+                if (boxes.some(b => overlaps(b, box)))
+                    throw new Error(`Merge "${ref}" overlaps another merge.`);
+                boxes.push(box);
+            }
             const merges = options.mergeCells.map(ref => `<mergeCell ref="${escapeXml$1(ref)}"/>`).join('');
             footer += `  <mergeCells count="${options.mergeCells.length}">${merges}</mergeCells>\n`;
         }
@@ -3835,11 +4161,16 @@ class SheetWriter {
                     if (dv[k])
                         attr += ` ${k}="${escapeXml$1(dv[k])}"`;
                 }
+                // The file stores formulas without "="; a typed list ("a,b,c") holds at most 255 characters
+                const f1 = dv.formula1?.replace(/^=/, ''), f2 = dv.formula2?.replace(/^=/, '');
+                if (dv.type === 'list' && f1?.startsWith('"') && f1.length - 2 > 255) {
+                    throw new Error(`List validation for ${dv.sqref} has ${f1.length - 2} characters; Excel allows 255. Put the items in cells and refer to the range.`);
+                }
                 let inner = '';
-                if (dv.formula1)
-                    inner += `<formula1>${escapeXml$1(dv.formula1)}</formula1>`;
-                if (dv.formula2)
-                    inner += `<formula2>${escapeXml$1(dv.formula2)}</formula2>`;
+                if (f1)
+                    inner += `<formula1>${escapeXml$1(f1)}</formula1>`;
+                if (f2)
+                    inner += `<formula2>${escapeXml$1(f2)}</formula2>`;
                 return `<dataValidation ${attr}>${inner}</dataValidation>`;
             }).join('');
             footer += `  <dataValidations count="${options.dataValidations.length}">${dvs}</dataValidations>\n`;
@@ -3893,8 +4224,10 @@ class SheetWriter {
             : '').join('') + this.sheets.map((s, i) => {
             const page = s.options.pageSetup;
             let names = '';
-            if (page?.printArea)
-                names += `<definedName name="_xlnm.Print_Area" localSheetId="${i}">${escapeXml$1(`${quoteSheet(s.name)}!${absoluteRef(page.printArea)}`)}</definedName>`;
+            // Every range of a multi-range print area names its sheet
+            const area = page?.printArea?.split(',').map(r => `${quoteSheet(s.name)}!${absoluteRef(r.trim())}`).join(',');
+            if (area)
+                names += `<definedName name="_xlnm.Print_Area" localSheetId="${i}">${escapeXml$1(area)}</definedName>`;
             if (page?.printTitleRows) {
                 const rows = page.printTitleRows.replace(/\$/g, '').split(':').map(r => `$${r}`).join(':');
                 names += `<definedName name="_xlnm.Print_Titles" localSheetId="${i}">${escapeXml$1(`${quoteSheet(s.name)}!${rows.includes(':') ? rows : `${rows}:${rows}`}`)}</definedName>`;
@@ -4072,7 +4405,7 @@ var randomAccess = /*#__PURE__*/Object.freeze({
     createFileReader: createFileReader
 });
 
-const escapeAttr = (s) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/"/g, '&quot;');
+const escapeAttr = escapeXml$4;
 const FONT_TAGS = [
     ['bold', 'b'], ['italic', 'i'], ['underline', 'u'], ['size', 'sz'], ['color', 'color'], ['name', 'name'],
 ];
@@ -4103,7 +4436,7 @@ class StylePatcher {
         this.xml = xml;
         this.p = /<((?:\w+:)?)styleSheet\b/.exec(xml)?.[1] ?? '';
         this.fonts = this.items('fonts', 'font');
-        this.fills = this.items('fills', 'fill').length;
+        this.fills = this.items('fills', 'fill');
         this.borders = this.items('borders', 'border');
         this.xfs = this.items('cellXfs', 'xf');
         for (const tag of this.items('numFmts', 'numFmt')) {
@@ -4125,12 +4458,13 @@ class StylePatcher {
         if (id !== undefined)
             return id;
         const p = this.p;
-        const xf = this.xfs[base] ?? this.xfs[0] ?? `<${p}xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0"/>`;
+        // `base` may be a format added earlier in this edit (a date format, then a style)
+        const xf = this.at('cellXfs', base) ?? this.xfs[0] ?? `<${p}xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0"/>`;
         let open = /^<[^>]*>/.exec(xf)[0];
         let inner = open.endsWith('/>') ? '' : xf.slice(open.length, xf.lastIndexOf('<'));
         open = open.replace(/\s*\/>$/, '>');
         if (style.font) {
-            const old = this.fonts[parseInt(attr(open, 'fontId') ?? '0', 10)] ?? '';
+            const old = this.at('fonts', parseInt(attr(open, 'fontId') ?? '0', 10)) ?? '';
             let font = old.endsWith('/>') ? '' : old.replace(/^<[^>]*>/, '').replace(/<\/[^>]*>$/, '');
             for (const [key, tag] of FONT_TAGS) {
                 if (!(key in style.font))
@@ -4147,7 +4481,7 @@ class StylePatcher {
             open = setAttr(setAttr(open, 'fillId', String(this.add('fills', this.prefix(fillXml(style.fill))))), 'applyFill', '1');
         }
         if (style.border) {
-            const old = this.borders[parseInt(attr(open, 'borderId') ?? '0', 10)] ?? `<${p}border/>`;
+            const old = this.at('borders', parseInt(attr(open, 'borderId') ?? '0', 10)) ?? `<${p}border/>`;
             const element = (tag) => new RegExp(`<${p}${tag}\\b[^>]*?(?:/>|>[\\s\\S]*?</${p}${tag}>)`).exec(old)?.[0];
             const sides = SIDES.map(side => side in style.border
                 ? this.prefix(borderSideXml(side, style.border[side])) : element(side) ?? `<${p}${side}/>`);
@@ -4182,7 +4516,7 @@ class StylePatcher {
     // The format for date `d` in a cell of format `base`: `base` when it already shows dates, otherwise
     // `base` with a date format, since a date in a General cell shows as its serial number
     dateFormat(base, d) {
-        const xf = this.xfs[base] ?? this.added.cellXfs[base - this.xfs.length] ?? '';
+        const xf = this.at('cellXfs', base) ?? '';
         const id = parseInt(attr(/^<[^>]*>/.exec(xf)?.[0] ?? '', 'numFmtId') ?? '0', 10);
         const code = [...this.numFmts].find(([, v]) => v === id)?.[0];
         if (isBuiltinDateFormat(id) || (code !== undefined && isDateFormatCode(code)))
@@ -4218,14 +4552,28 @@ class StylePatcher {
         return xml;
     }
     existing(section) {
-        return section === 'fonts' ? this.fonts.length : section === 'fills' ? this.fills
-            : section === 'borders' ? this.borders.length : section === 'cellXfs' ? this.xfs.length
-                : this.items('numFmts', 'numFmt').length;
+        return section === 'numFmts' ? this.items('numFmts', 'numFmt').length : this.list(section).length;
     }
-    // Appends an element to a section, returning its index
+    list(section) {
+        return section === 'fonts' ? this.fonts : section === 'fills' ? this.fills : section === 'borders' ? this.borders : this.xfs;
+    }
+    // Item `i` of a section, counting the ones added in this edit after the file's own
+    at(section, i) {
+        const own = this.list(section);
+        return i < own.length ? own[i] : this.added[section][i - own.length];
+    }
+    // The index of `element` in a section, appending it unless an identical one is already there:
+    // repeating the same restyle on an edited file reuses the formats the first run added
     add(section, element) {
+        const own = this.list(section);
+        const found = own.indexOf(element);
+        if (found >= 0)
+            return found;
+        const added = this.added[section].indexOf(element);
+        if (added >= 0)
+            return own.length + added;
         this.added[section].push(element);
-        return this.existing(section) + this.added[section].length - 1;
+        return own.length + this.added[section].length - 1;
     }
     items(section, tag) {
         const p = this.p;
@@ -4366,12 +4714,12 @@ function mapSheetXml(xml, sheet, maps) {
             if (child)
                 inner = inner.replace(child[0], `<${child[1]}sqref>${mapped}</${child[1]}sqref>`);
         }
-        inner = inner.replace(/<((?:\w+:)?)(formula1|formula2|formula|f)>([^<]*)<\/\1\2>/g, (_m, fp, ftag, f) => `<${fp}${ftag}>${escapeXml$5(mapFormula(unescapeXml(f), sheet, maps, anchor))}</${fp}${ftag}>`);
+        inner = inner.replace(/<((?:\w+:)?)(formula1|formula2|formula|f)>([^<]*)<\/\1\2>/g, (_m, fp, ftag, f) => `<${fp}${ftag}>${escapeXml$4(mapFormula(unescapeXml(f), sheet, maps, anchor))}</${fp}${ftag}>`);
         return whole.endsWith('/>') && !inner ? `<${p}${tag}${attrs}/>` : `<${p}${tag}${attrs}>${inner}</${p}${tag}>`;
     });
     xml = recount(xml, 'dataValidations', 'dataValidation');
     // Sparklines (x14): the data range follows its cells; a sparkline whose own cell is deleted goes
-    const mapF = (s) => s.replace(/<((?:\w+:)?)f>([^<]*)<\/\1f>/g, (_m, p, f) => `<${p}f>${escapeXml$5(mapFormula(unescapeXml(f), sheet, maps))}</${p}f>`);
+    const mapF = (s) => s.replace(/<((?:\w+:)?)f>([^<]*)<\/\1f>/g, (_m, p, f) => `<${p}f>${escapeXml$4(mapFormula(unescapeXml(f), sheet, maps))}</${p}f>`);
     xml = xml.replace(/<((?:\w+:)?)sparklineGroup\b([^>]*)>([\s\S]*?)<\/\1sparklineGroup>/g, (whole, p, attrs, inner) => {
         const list = /<((?:\w+:)?)sparklines>([\s\S]*?)<\/\1sparklines>/.exec(inner);
         if (!list)
@@ -4500,12 +4848,17 @@ function createShiftTransform(sheet, maps) {
                     const expand = !!own || mapped !== text;
                     shared.set(si, { text, row: r, col: c, expand });
                     if (expand)
-                        xml = `<${p}f>${escapeXml$5(mapped)}</${p}f>`;
+                        xml = `<${p}f>${escapeXml$4(mapped)}</${p}f>`;
                 }
                 else {
                     const a = shared.get(si);
-                    if (a?.expand)
-                        xml = `<${p}f>${escapeXml$5(mapF(shiftFormula(a.text, r - a.row, c - a.col)))}</${p}f>`;
+                    if (a) {
+                        // Even when the anchor's own references stay, this cell's may point into moved rows
+                        const own = shiftFormula(a.text, r - a.row, c - a.col);
+                        const mapped = mapF(own);
+                        if (a.expand || mapped !== own)
+                            xml = `<${p}f>${escapeXml$4(mapped)}</${p}f>`;
+                    }
                 }
             }
             else if (kind === 'dataTable') {
@@ -4514,7 +4867,7 @@ function createShiftTransform(sheet, maps) {
                 const range = attr(fAttrs, 'ref');
                 if (own && range)
                     fAttrs = fAttrs.replace(/\sref="[^"]*"/, ` ref="${mapArea(range, own) ?? range}"`);
-                fAttrs = fAttrs.replace(/\s(r1|r2)="([^"]*)"/g, (_m, name, ref) => ` ${name}="${escapeXml$5(mapF(unescapeXml(ref)))}"`);
+                fAttrs = fAttrs.replace(/\s(r1|r2)="([^"]*)"/g, (_m, name, ref) => ` ${name}="${escapeXml$4(mapF(unescapeXml(ref)))}"`);
                 xml = f[0].replace(f[1], () => fAttrs);
             }
             else if (text) {
@@ -4522,7 +4875,7 @@ function createShiftTransform(sheet, maps) {
                 const range = attr(fAttrs, 'ref');
                 if (own && range)
                     fAttrs = fAttrs.replace(/\sref="[^"]*"/, ` ref="${mapArea(range, own) ?? range}"`);
-                xml = `<${p}f${fAttrs}>${escapeXml$5(mapF(text))}</${p}f>`;
+                xml = `<${p}f${fAttrs}>${escapeXml$4(mapF(text))}</${p}f>`;
             }
             return xml === undefined ? cell : cell.replace(f[0], () => xml);
         });
@@ -4682,7 +5035,7 @@ function mapTable(xml, sheet, maps) {
         }
         xml = mapAutoFilter(xml, own).replace(/(<(?:\w+:)?(?:table|sortState|sortCondition)\b[^>]*?\sref=")([^"]*)"/g, (_m, pre, area) => `${pre}${mapArea(area, own) ?? area}"`);
     }
-    xml = xml.replace(/<((?:\w+:)?)(calculatedColumnFormula|totalsRowFormula)\b([^>]*)>([^<]*)<\/\1\2>/g, (_m, p, tag, attrs, f) => `<${p}${tag}${attrs}>${escapeXml$5(mapFormula(unescapeXml(f), sheet, maps))}</${p}${tag}>`);
+    xml = xml.replace(/<((?:\w+:)?)(calculatedColumnFormula|totalsRowFormula)\b([^>]*)>([^<]*)<\/\1\2>/g, (_m, p, tag, attrs, f) => `<${p}${tag}${attrs}>${escapeXml$4(mapFormula(unescapeXml(f), sheet, maps))}</${p}${tag}>`);
     return { xml, headers };
 }
 // Chart series follow the cells they plot. Cached values are dropped when a series moves, and Excel
@@ -4694,10 +5047,14 @@ function mapChart(xml, maps) {
         if (mapped === unescapeXml(f))
             return whole;
         changed = true;
-        return open + escapeXml$5(mapped) + close;
+        return open + escapeXml$4(mapped) + close;
     });
     return changed ? out.replace(/<((?:\w+:)?)(numCache|strCache)\b[\s\S]*?<\/\1\2>/g, '') : xml;
 }
+// A pivot table on a sheet whose rows or columns move is drawn where its cells went
+function mapPivotTable(xml, s) {
+    return xml.replace(/(<(?:\w+:)?location\b[^>]*?\sref=")([^"]*)"/, (_m, pre, ref) => `${pre}${mapArea(ref, s) ?? ref}"`);
+}
 // A pivot cache over moved cells reads the new range and refreshes when the file opens
 function mapPivotCache(xml, maps) {
     let changed = false;
@@ -4716,7 +5073,7 @@ function mapPivotCache(xml, maps) {
 }
 // Workbook defined names (print areas, named ranges) follow the cells they point at
 function mapDefinedNames(wb, maps) {
-    return wb.replace(/(<(?:\w+:)?definedName\b[^>]*>)([^<]*)(<\/(?:\w+:)?definedName>)/g, (_m, open, f, close) => open + escapeXml$5(mapFormula(unescapeXml(f), '', maps)) + close);
+    return wb.replace(/(<(?:\w+:)?definedName\b[^>]*>)([^<]*)(<\/(?:\w+:)?definedName>)/g, (_m, open, f, close) => open + escapeXml$4(mapFormula(unescapeXml(f), '', maps)) + close);
 }
 
 const KEEP = Symbol('keep');
@@ -4743,12 +5100,12 @@ function editedCell(p, ref, attrs, edit) {
         return `<${p}c r="${ref}"${attrs}><${p}v>${dateToSerial(edit)}</${p}v></${p}c>`;
     }
     if (typeof edit === 'object')
-        return `<${p}c r="${ref}"${attrs}><${p}f>${escapeXml$5(edit.formula.replace(/^=/, ''))}</${p}f></${p}c>`;
-    const text = escapeXml$5(encodeXString(checkCellText(edit, ref)));
+        return `<${p}c r="${ref}"${attrs}><${p}f>${escapeXml$4(edit.formula.replace(/^=/, ''))}</${p}f></${p}c>`;
+    const text = escapeXml$4(encodeXString(checkCellText(edit, ref)));
     const t = /^\s|\s$/.test(edit) ? `<${p}t xml:space="preserve">${text}</${p}t>` : `<${p}t>${text}</${p}t>`;
     return `<${p}c r="${ref}"${attrs} t="inlineStr"><${p}is>${t}</${p}is></${p}c>`;
 }
-// The cells of a new sheet, as edits of an empty one
+// The cells of new rows (a new sheet, or rows appended to one) as edits, rows numbered from 1
 function rowsToEdits(name, rows) {
     const edits = new Map();
     rows.forEach((row, ri) => {
@@ -4761,7 +5118,7 @@ function rowsToEdits(name, rows) {
                 return;
             }
             if (cell.hyperlink !== undefined || cell.comment !== undefined) {
-                throw new Error(`Sheet "${name}": SheetEditor.addSheet does not write hyperlinks or notes; use SheetWriter.`);
+                throw new Error(`Sheet "${name}": SheetEditor does not write hyperlinks or notes in new rows; use SheetWriter.`);
             }
             // Rich text is written as plain text here
             const value = cell.richText && cell.value == null ? cell.richText.map(r => r.text).join('') : cell.value;
@@ -4777,14 +5134,19 @@ const WORKSHEET_CONTENT = 'application/vnd.openxmlformats-officedocument.spreads
 // An element in the shape of a regex match: [whole, attributes, body], body undefined when self-closing
 const asMatch = (el) => [el.whole, el.attrs, el.whole.endsWith('/>') ? undefined : el.body];
 class SheetEditor {
-    modifications = new Map();
+    appends = new Map();
     cellEdits = new Map();
     additions = new Map();
     deletions = new Set();
     shiftOps = new Map();
-    // Appends `rows` after the last existing row of sheet `sheetName`.
-    appendSheet(sheetName, rows, options = {}) {
-        this.modifications.set(sheetName, { rows, options });
+    // Appends `rows` after the last existing row of sheet `sheetName`. Cells take values, formulas and
+    // styles, as in addSheet. Called again for the same sheet, the rows go after the earlier ones.
+    appendSheet(sheetName, rows, _options = {}) {
+        let batches = this.appends.get(sheetName);
+        if (!batches)
+            this.appends.set(sheetName, batches = []);
+        batches.push(rows);
+        return this;
     }
     // Sets cells of an existing sheet by address, e.g. { B2: 42, C2: { formula: 'B2*2' } }. A cell
     // keeps its style, so a date written over a date-formatted cell shows as a date. Formulas are
@@ -4884,8 +5246,8 @@ class SheetEditor {
                     return path;
                 };
                 const appendByPath = new Map();
-                for (const [sheetName, mod] of this.modifications)
-                    appendByPath.set(pathOf(sheetName), mod.rows);
+                for (const [sheetName, batches] of this.appends)
+                    appendByPath.set(pathOf(sheetName), rowsToEdits(sheetName, batches.flat()));
                 const editsByPath = new Map();
                 for (const [sheetName, rows] of this.cellEdits)
                     editsByPath.set(pathOf(sheetName), rows);
@@ -4953,6 +5315,8 @@ class SheetEditor {
                                 await update(rel.path, xml => mapVml(xml, map));
                             if (type === '/drawing')
                                 await update(rel.path, xml => mapDrawing(xml, map));
+                            if (type === '/pivotTable')
+                                await update(rel.path, xml => mapPivotTable(xml, map));
                         }
                     }
                     // Charts on any sheet can plot the moved rows, and so can pivot tables
@@ -4972,7 +5336,7 @@ class SheetEditor {
                     }
                 }
                 // Edited cells invalidate cached formula results
-                if (editsByPath.size || added.size || this.deletions.size || rowMaps.size) {
+                if (editsByPath.size || added.size || appendByPath.size || this.deletions.size || rowMaps.size) {
                     const { replace, drop } = await recalcOnOpen(read, parts, await read(parts.workbookPath));
                     for (const [path, xml] of replace)
                         overlay.set(path, xml);
@@ -4981,10 +5345,10 @@ class SheetEditor {
                 }
                 // Styles gain the formats of restyled cells as the sheets stream, so they are written last
                 let patcher;
-                const styled = [...editsByPath.values(), ...added.values()]
+                const styled = [...editsByPath.values(), ...added.values(), ...appendByPath.values()]
                     .some(rows => [...rows.values()].some(cells => [...cells.values()].some(e => styleOf(e))));
                 // Dates may need a date format added to their cells
-                const dated = [...editsByPath.values(), ...added.values()]
+                const dated = [...editsByPath.values(), ...added.values(), ...appendByPath.values()]
                     .some(rows => [...rows.values()].some(cells => [...cells.values()].some(e => contentOf(e) instanceof Date)));
                 if (styled || (dated && parts.styles)) {
                     if (!parts.styles)
@@ -5004,7 +5368,7 @@ class SheetEditor {
                     // A new sheet uses the workbook's namespace (Transitional or Strict)
                     const root = /<((?:\w+:)?)workbook\b[^>]*>/.exec(await read(parts.workbookPath));
                     const ns = (root && attr(root[0], root[1] ? `xmlns:${root[1].slice(0, -1)}` : 'xmlns')) ?? 'http://schemas.openxmlformats.org/spreadsheetml/2006/main';
-                    const empty = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<worksheet xmlns="${escapeXml$5(ns)}"><sheetData/></worksheet>`;
+                    const empty = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<worksheet xmlns="${escapeXml$4(ns)}"><sheetData/></worksheet>`;
                     for (const [path, edits] of added) {
                         await zipOut.addFile(path, encode(decode(new Response(empty).body).pipeThrough(this.createEditTransform(edits, patcher))));
                     }
@@ -5012,18 +5376,16 @@ class SheetEditor {
                 for (const filename of zipIn.getFiles()) {
                     if (written.has(filename))
                         continue;
-                    const rows = appendByPath.get(filename);
+                    const append = appendByPath.get(filename);
                     const edits = editsByPath.get(filename);
                     const shift = shiftByPath.get(filename);
-                    if (rows || edits || shift !== undefined) {
+                    if (append || edits || shift !== undefined) {
                         checkSize(filename, options?.maxUncompressedBytes ?? Infinity);
                         let text = decode(await zipIn.extractStream(filename));
                         if (shift !== undefined)
                             text = text.pipeThrough(createShiftTransform(shift, rowMaps));
-                        if (edits)
-                            text = text.pipeThrough(this.createEditTransform(edits, patcher));
-                        if (rows)
-                            text = text.pipeThrough(this.createInjectTransform(rows));
+                        if (edits || append)
+                            text = text.pipeThrough(this.createEditTransform(edits ?? new Map(), patcher, append));
                         await zipOut.addFile(filename, encode(text));
                     }
                     else {
@@ -5043,10 +5405,12 @@ class SheetEditor {
         return zipOut.stream;
     }
     // Streams a worksheet, rewriting edited cells as their rows pass by and adding rows and cells
-    // that did not exist. Only one row at a time is held in memory.
-    createEditTransform(edits, patcher) {
+    // that did not exist. `append` rows (numbered from 1) go after the last row. Only one row at a
+    // time is held in memory.
+    createEditTransform(edits, patcher, append) {
         const pending = [...edits.keys()].sort((a, b) => a - b);
         let next = 0;
+        let lastRow = 0; // number of the last row read, for rows without an r attribute
         let buffer = '';
         let p = ''; // namespace prefix of the sheet's elements
         let state = 'head';
@@ -5073,8 +5437,8 @@ class SheetEditor {
             // Keeps the style; drops the type and the metadata of rich values and dynamic arrays
             return editedCell(p, ref, attrs.replace(/\s(?:t|vm|cm)="[^"]*"/g, ''), content);
         };
-        const newRow = (r) => {
-            const cells = [...edits.get(r).entries()].sort((a, b) => a[0] - b[0])
+        const newRow = (r, rowEdits = edits.get(r)) => {
+            const cells = [...rowEdits.entries()].sort((a, b) => a[0] - b[0])
                 .map(([c, e]) => cellXml(colLetter(c) + r, e)).join('');
             return `<${p}row r="${r}">${cells}</${p}row>`;
         };
@@ -5084,6 +5448,19 @@ class SheetEditor {
                 xml += newRow(pending[next]);
             return xml;
         };
+        // The rows still to come at the end of sheetData: new edited rows, then the appended rows
+        const lastRows = () => {
+            let xml = rowsBefore(Infinity);
+            if (!append?.size)
+                return xml;
+            const base = Math.max(lastRow, pending[pending.length - 1] ?? 0);
+            const last = base + Math.max(...append.keys());
+            if (last > MAX_ROWS$1)
+                throw new Error(`Appending rows would reach row ${last}, past Excel's last row (${MAX_ROWS$1}).`);
+            for (const [r, cells] of [...append].sort((a, b) => a[0] - b[0]))
+                xml += newRow(base + r, cells);
+            return xml;
+        };
         const rewriteRow = (open, inner, r) => {
             // A copy: the edits stay intact for another edit() call
             const rowEdits = edits.has(r) ? new Map(edits.get(r)) : undefined;
@@ -5115,7 +5492,7 @@ class SheetEditor {
                     if (brokenShared.has(si)) {
                         const a = sharedAnchors.get(si);
                         if (a) {
-                            xml = xml.replace(f[0], `<${p}f>${escapeXml$5(shiftFormula(a.text, r - a.row, col - a.col))}</${p}f>`);
+                            xml = xml.replace(f[0], `<${p}f>${escapeXml$4(shiftFormula(a.text, r - a.row, col - a.col))}</${p}f>`);
                             changed = true;
                         }
                     }
@@ -5142,7 +5519,7 @@ class SheetEditor {
                         p = m[1];
                         if (m[2]) {
                             // Empty sheet: <sheetData/> becomes a pair holding the new rows
-                            out += buffer.slice(0, m.index) + `<${p}sheetData>${rowsBefore(Infinity)}</${p}sheetData>`;
+                            out += buffer.slice(0, m.index) + `<${p}sheetData>${lastRows()}</${p}sheetData>`;
                             buffer = buffer.slice(m.index + m[0].length);
                             state = 'tail';
                         }
@@ -5169,11 +5546,14 @@ class SheetEditor {
                         if (!m)
                             break;
                         if (m[0].trimStart().startsWith(`</${p}sheetData`)) {
-                            out += rowsBefore(Infinity) + m[0];
+                            out += lastRows() + m[0];
                             state = 'tail';
                         }
                         else {
-                            const r = parseInt(/\sr="(\d+)"/.exec(m[1])?.[1] ?? '0', 10);
+                            // A row without r is the one after the previous row, as the reader counts it
+                            const rAttr = /\sr="(\d+)"/.exec(m[1])?.[1];
+                            const r = rAttr ? parseInt(rAttr, 10) : lastRow + 1;
+                            lastRow = Math.max(lastRow, r);
                             out += rowsBefore(r);
                             const open = m[0].slice(0, m[0].indexOf('>') + 1);
                             // Rows are only parsed when they have edits or take part in a shared formula
@@ -5200,72 +5580,6 @@ class SheetEditor {
             },
         });
     }
-    createInjectTransform(rows) {
-        let buffer = '';
-        let maxRow = 0;
-        let done = false;
-        const rowsXml = () => rows.map((row, ri) => {
-            const rowNum = maxRow + ri + 1;
-            const cellsXml = row.map((cell, ci) => {
-                const colRef = colLetter(ci) + rowNum;
-                const val = typeof cell === 'object' && cell !== null && 'value' in cell ? cell.value : cell;
-                if (val === null || val === undefined)
-                    return `<c r="${colRef}"/>`;
-                if (typeof val === 'boolean')
-                    return `<c r="${colRef}" t="b"><v>${val ? 1 : 0}</v></c>`;
-                if (typeof val === 'number')
-                    return `<c r="${colRef}"><v>${val}</v></c>`;
-                if (typeof val === 'string') {
-                    return `<c r="${colRef}" t="inlineStr"><is><t xml:space="preserve">${escapeXml$5(encodeXString(checkCellText(val, colRef)))}</t></is></c>`;
-                }
-                return `<c r="${colRef}"/>`;
-            }).join('');
-            return `<row r="${rowNum}">${cellsXml}</row>`;
-        }).join('');
-        return new TransformStream({
-            transform(chunk, controller) {
-                if (done) {
-                    controller.enqueue(chunk);
-                    return;
-                }
-                buffer += chunk;
-                for (const m of buffer.matchAll(/<(?:\w+:)?row\b[^>]*?\sr="(\d+)"/g)) {
-                    const r = parseInt(m[1], 10);
-                    if (r > maxRow)
-                        maxRow = r;
-                }
-                const close = /<\/(?:\w+:)?sheetData>|<((?:\w+:)?sheetData)\b[^>]*\/>/.exec(buffer);
-                if (close) {
-                    const before = buffer.slice(0, close.index);
-                    const after = buffer.slice(close.index + close[0].length);
-                    // Self-closing <sheetData/> (empty sheet) becomes an open/close pair
-                    const tagName = close[1];
-                    const inject = tagName
-                        ? `${close[0].slice(0, -2)}>${rowsXml()}</${tagName}>`
-                        : `${rowsXml()}${close[0]}`;
-                    controller.enqueue(before + inject + after);
-                    buffer = '';
-                    done = true;
-                }
-                else {
-                    // Hold back from the last '<' so a split tag is never emitted half-scanned
-                    const cut = buffer.lastIndexOf('<');
-                    if (cut > 0) {
-                        controller.enqueue(buffer.slice(0, cut));
-                        buffer = buffer.slice(cut);
-                    }
-                }
-            },
-            flush(controller) {
-                if (!done) {
-                    controller.error(new Error('Worksheet has no <sheetData> element.'));
-                    return;
-                }
-                if (buffer.length > 0)
-                    controller.enqueue(buffer);
-            }
-        });
-    }
     async readStreamToString(stream) {
         const reader = stream.pipeThrough(new TextDecoderStream()).getReader();
         let result = '';
@@ -5306,7 +5620,7 @@ async function removeSheet(name, parts, read, overlay, dropped) {
         let mapped = formula.replace(quoted, '#REF!');
         if (plain)
             mapped = mapped.replace(plain, '$1#REF!');
-        return mapped === formula ? whole : whole.replace(`>${text}<`, `>${escapeXml$5(mapped)}<`);
+        return mapped === formula ? whole : whole.replace(`>${text}<`, `>${escapeXml$4(mapped)}<`);
     });
     wb = wb.replace(/<(?:\w+:)?workbookView\b[^>]*>/g, view => view.replace(/\s(activeTab|firstSheet)="(\d+)"/g, (_m, a, v) => {
         const n = parseInt(v, 10);
@@ -5346,7 +5660,7 @@ async function insertSheet(name, parts, read, overlay, free) {
     overlay.set(relsPath, rels);
     const sheetId = Math.max(0, ...tags.map(t => parseInt(attr(t, 'sheetId') ?? '0', 10))) + 1;
     const rPrefix = /<(?:\w+:)?sheet\b[^>]*?\s(\w+):id="/.exec(wb)?.[1] ?? 'r';
-    wb = wb.replace(/<\/((?:\w+:)?)sheets>/, (close, p) => `<${p}sheet name="${escapeXml$5(name)}" sheetId="${sheetId}" ${rPrefix}:id="rId${k}"/>${close}`);
+    wb = wb.replace(/<\/((?:\w+:)?)sheets>/, (close, p) => `<${p}sheet name="${escapeXml$4(name)}" sheetId="${sheetId}" ${rPrefix}:id="rId${k}"/>${close}`);
     overlay.set(parts.workbookPath, wb);
     const types = await read('[Content_Types].xml');
     const contentType = sheetRel && /ContentType="([^"]*)"/.exec(overrideTag(types, sheetRel.path) ?? '')?.[1];
@@ -5417,17 +5731,18 @@ class SheetReader {
             const name = attr(tag, 'name');
             const state = attr(tag, 'state');
             if (name !== null)
-                sheets.push({ name: unescapeXml(name), state: state === 'hidden' || state === 'veryHidden' ? state : 'visible' });
+                sheets.push({ name, state: state === 'hidden' || state === 'veryHidden' ? state : 'visible' });
         }
         const definedNames = [];
         for (const { attrs: open, body: text } of xmlElements(parts.workbookXml, 'definedName')) {
             const local = attr(open, 'localSheetId');
             const comment = attr(open, 'comment');
-            const name = { name: unescapeXml(attr(open, 'name') ?? ''), ref: unescapeXml(text) };
+            // attr() has already unescaped attribute values; only element text is still escaped
+            const name = { name: attr(open, 'name') ?? '', ref: unescapeXml(text) };
             if (local !== null && sheets[+local])
                 name.sheet = sheets[+local].name;
             if (comment !== null)
-                name.comment = unescapeXml(comment);
+                name.comment = comment;
             if (/^(?:1|true)$/.test(attr(open, 'hidden') ?? ''))
                 name.hidden = true;
             definedNames.push(name);
@@ -5475,7 +5790,8 @@ class SheetReader {
                 throw new Error(`Sheet with name "${options.sheetName}" not found in workbook.`);
         }
         else {
-            worksheetZipPath = parts.sheets.values().next().value
+            // The first tab with cells: a chart sheet first in the tab order is skipped, as the .xls reader does
+            worksheetZipPath = [...parts.sheets.values()].find(path => !parts.chartsheets.has(path))
                 ?? zip.getFiles().find(f => /^xl\/worksheets\/[^/]+\.xml$/.test(f));
             if (!worksheetZipPath)
                 throw new Error("No worksheets found in ZIP.");
@@ -5507,6 +5823,7 @@ class SheetReader {
             .pipeThrough(createXmlBatchParser());
         return parseWorksheet(xmlStream, sharedStrings, styles, is1904, {
             formulas: options?.formulas,
+            errors: options?.errors,
             cellStyles: options?.styles ? cellStyles : undefined,
             numFmts: options?.formatted ? formats : undefined,
             richText: options?.richText ? color : undefined,
@@ -5807,7 +6124,8 @@ const NUMBER = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
 function convertField(s) {
     if (s === '')
         return null;
-    if (NUMBER.test(s))
+    // "1e400" overflows a double: keep the text rather than lose it to Infinity
+    if (NUMBER.test(s) && isFinite(Number(s)))
         return Number(s);
     const upper = s.toUpperCase();
     return upper === 'TRUE' ? true : upper === 'FALSE' ? false : s;
@@ -5911,14 +6229,11 @@ async function* parseCsv(input, options = {}) {
 // Writer for OpenDocument spreadsheets (.ods). Rows stream into content.xml one at a time.
 // Writes values, formulas, dates, merged cells, column widths, frozen panes, hidden sheets and
 // document properties; styles and the other .xlsx sheet options are left out.
-function escapeXml(val) {
-    // XML 1.0 cannot hold most control characters at all, so they are dropped
-    return String(val).replace(/[\x00-\x08\x0B\x0C\x0E-\x1F￾￿]/g, '')
-        .replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
-}
+const escapeXml = (val) => escapeXml$4(String(val));
 const isStyledCell = (v) => v !== null && typeof v === 'object' && !(v instanceof Date);
 // Excel syntax to OpenFormula: "SUM(A1:B2,Sheet2!C3)" -> "of:=SUM([.A1:.B2];[$Sheet2.C3])"
-const REF = /((?:'(?:[^']|'')+'|[A-Za-z_][\w.]*)!)?(\$?[A-Za-z]{1,3}\$?\d+)(?::(\$?[A-Za-z]{1,3}\$?\d+))?(?![\w(!])/y;
+// Cell references and ranges, then whole columns (C:C) and whole rows (1:3)
+const REF = /((?:'(?:[^']|'')+'|[A-Za-z_][\w.]*)!)?(\$?[A-Za-z]{1,3}\$?\d+(?::\$?[A-Za-z]{1,3}\$?\d+)?|\$?[A-Za-z]{1,3}:\$?[A-Za-z]{1,3}|\$?\d+:\$?\d+)(?![\w(!:])/y;
 function toOpenFormula(formula) {
     const f = formula.replace(/^=/, '');
     let out = '';
@@ -5943,7 +6258,7 @@ function toOpenFormula(formula) {
             const m = REF.exec(f);
             if (m) {
                 const sheet = m[1] ? `$${m[1].slice(0, -1)}` : '';
-                out += `[${sheet}.${m[2]}${m[3] ? `:${sheet}.${m[3]}` : ''}]`;
+                out += `[${m[2].split(':').map(part => `${sheet}.${part}`).join(':')}]`;
                 i = REF.lastIndex;
                 continue;
             }
@@ -5959,8 +6274,10 @@ function textXml(s) {
         .replace(/\t/g, '<text:tab/>')
         .replace(/^ | {2,}/g, m => m === ' ' ? '<text:s/>' : ` <text:s text:c="${m.length - 1}"/>`)}</text:p>`).join('');
 }
-const dateValue = (d) => d.toISOString().slice(0, 19); // UTC, like SheetWriter
+// UTC, like SheetWriter; milliseconds only when there are some
+const dateValue = (d) => d.toISOString().slice(0, d.getUTCMilliseconds() ? 23 : 19);
 const hasTime = (d) => d.getTime() % 86400000 !== 0;
+// `evaluate` gives the formula's result, or null when it isn't known (streamed rows, errors)
 function cellXml(cell, span, covered, evaluate) {
     if (covered)
         return '<table:covered-table-cell/>';
@@ -5968,7 +6285,7 @@ function cellXml(cell, span, covered, evaluate) {
     const formula = isStyledCell(cell) && cell.formula ? ` table:formula="${escapeXml(toOpenFormula(cell.formula))}"` : '';
     // A formula without a value gets its result stored, as SheetWriter does, for readers that don't recalculate
     if (formula && value == null)
-        value = evaluate(cell.formula);
+        value = evaluate();
     if (value === null || value === undefined || (typeof value === 'number' && !isFinite(value))) {
         return formula || span ? `<table:table-cell${formula}${span}/>` : '<table:table-cell/>';
     }
@@ -6065,11 +6382,18 @@ class OdsWriter {
                 const engine = new FormulaEngine();
                 if (Array.isArray(sheet.rows)) {
                     engine.loadData(sheet.rows.map(row => row.map(cell => {
+                        if (isStyledCell(cell) && cell.formula)
+                            return { formula: cell.formula };
                         const v = isStyledCell(cell) ? cell.value : cell;
                         return v instanceof Date ? dateToSerial(v) : v ?? null;
                     })));
                 }
-                const evaluate = (f) => engine.evaluate(f);
+                const evaluate = (ref) => {
+                    if (!Array.isArray(sheet.rows))
+                        return null;
+                    const v = engine.cellValue(ref);
+                    return v instanceof FormulaError ? v.code : v;
+                };
                 const covered = (r, c) => merges.some(m => r >= m.r1 && r <= m.r2 && c >= m.c1 && c <= m.c2 && (r !== m.r1 || c !== m.c1));
                 let r = 0, batch = '';
                 const writeRow = (row) => {
@@ -6078,7 +6402,7 @@ class OdsWriter {
                     for (let c = 0; c < width; c++) {
                         const m = mergeAt(r, c);
                         const span = m ? ` table:number-columns-spanned="${m.c2 - m.c1 + 1}" table:number-rows-spanned="${m.r2 - m.r1 + 1}"` : '';
-                        xml += cellXml(row[c], span, covered(r, c), evaluate);
+                        xml += cellXml(row[c], span, covered(r, c), () => evaluate(colLetter(c) + (r + 1)));
                     }
                     r++;
                     return xml + (width ? '' : '<table:table-cell/>') + '</table:table-row>';
@@ -6152,11 +6476,28 @@ const XlsxFlow = {
         const { SheetReader } = await Promise.resolve().then(function () { return index; });
         const reader = new SheetReader();
         const fileReader = await createFileReader(filePath);
-        // All random reads happen inside parse(); the row stream opens its own handle.
+        // Comments, images and .ods content are read after parse() returns, when the handle is closed:
+        // those reads open a short-lived handle of their own
+        let closed = false;
+        const lateRead = async (offset, length) => {
+            const late = await createFileReader(filePath);
+            try {
+                return await late.read(offset, length);
+            }
+            finally {
+                await late.close();
+            }
+        };
         try {
-            return await reader.parse(fileReader, options);
+            return await reader.parse({
+                size: fileReader.size,
+                read: (offset, length) => closed ? lateRead(offset, length) : fileReader.read(offset, length),
+                stream: (offset, length) => fileReader.stream(offset, length),
+                close: async () => { },
+            }, options);
         }
         finally {
+            closed = true;
             await fileReader.close();
         }
     }