@shbernal/ts-xlsx 3.0.0 → 3.2.0

package/dist/io/xlsx/cell-metadata.d.ts

@@ -0,0 +1,39 @@
+import type { ErrorCode } from '../../core/value.ts';
+import { type CellMetadataIndex, type WorkbookMetadata } from '../cell-metadata/metadata.ts';
+import type { PartRelationships } from '../opc/read-opc.ts';
+/**
+ * What every `cm` and `vm` in the workbook resolves to: the metadata part and the two rich-value parts,
+ * each found through the workbook's relationships by type. Both worksheet readers resolve their cells
+ * through this one answer.
+ */
+export declare function readCellMetadata(workbookRels: PartRelationships): CellMetadataIndex;
+/** Read `xl/metadata.xml` as far as a cell's `cm` and `vm` reach into it. */
+export declare function parseMetadataPart(xml: string): WorkbookMetadata;
+/**
+ * Records what the cells written so far point into, so the metadata part and the rich-value parts are
+ * emitted only for a workbook that needs them. Filled during the sheet pass, as the shared-strings table
+ * is, because the streaming writer renders a row long before the package around it is assembled.
+ */
+export declare class WorkbookMetadataTable {
+    #private;
+    /** The `cm` a dynamic-array formula's cell is written with. Every such cell shares the one block. */
+    markDynamicArray(): number;
+    /**
+     * The `vm` a cell holding `error` is written with, beside a `<v>` of `#VALUE!`, or `undefined` for
+     * an error Excel reads literally, which needs no metadata.
+     */
+    markRichValueError(error: ErrorCode): number | undefined;
+    /** Whether no cell points into the metadata part; the writer omits it entirely when so. */
+    get isEmpty(): boolean;
+    /** Whether a cell points at a rich value, so the rich-value parts are emitted beside the metadata. */
+    get hasRichValues(): boolean;
+    /** Serialise the `xl/metadata.xml` part, in the form Excel saves it. */
+    toXml(): string;
+    /**
+     * Serialise `xl/richData/rdrichvalue.xml`: one rich value per error, in the order the `vm`s were handed
+     * out, each naming its `errorType` and the unknown sub-type, 0.
+     */
+    richValuesXml(): string;
+}
+/** `xl/richData/rdrichvaluestructure.xml`: the one structure every rich value the writer emits has. */
+export declare const RICH_VALUE_STRUCTURES_XML: string;

package/dist/io/xlsx/cell-metadata.js

@@ -0,0 +1,162 @@
+import { numInteger } from '../../xml/xml-attrs.js';
+import { parseXml } from '../../xml/xml-read.js';
+import { boolStrict, localName } from '../../xml/xml-scan.js';
+import { XML_DECLARATION } from '../../xml/xml.js';
+import { DYNAMIC_ARRAY_TYPE, indexCellMetadata, RICH_VALUE_TYPE, } from '../cell-metadata/metadata.js';
+import { ERROR_STRUCTURE, parseRichValueErrors, RICH_VALUE_ERROR_TYPES, } from '../cell-metadata/rich-values.js';
+import { DYNAMIC_ARRAY_NS, DYNAMIC_ARRAY_PROPERTIES_EXT_URI, RICH_DATA_NS, RICH_VALUE_BLOCK_EXT_URI, SPREADSHEETML_NS, } from './namespaces.js';
+export function readCellMetadata(workbookRels) {
+    return indexCellMetadata(parseMetadataPart(workbookRels.relatedText('sheetMetadata') ?? ''), parseRichValueErrors(workbookRels.relatedText('rdRichValueStructure') ?? '', workbookRels.relatedText('rdRichValue') ?? ''));
+}
+export function parseMetadataPart(xml) {
+    const typeNames = [];
+    const dynamicArrayBlocks = [];
+    const richValueBlocks = [];
+    const cellBlocks = [];
+    const valueBlocks = [];
+    let container;
+    const records = () => container === 'cells'
+        ? cellBlocks.at(-1)
+        : container === 'values'
+            ? valueBlocks.at(-1)
+            : undefined;
+    if (xml === '')
+        return { typeNames, dynamicArrayBlocks, richValueBlocks, cellBlocks, valueBlocks };
+    parseXml(xml, {
+        onOpen(name, attrs, selfClosing) {
+            switch (localName(name)) {
+                case 'metadataType':
+                    typeNames.push(attrs.name ?? '');
+                    break;
+                case 'futureMetadata':
+                    container = selfClosing
+                        ? undefined
+                        : attrs.name === DYNAMIC_ARRAY_TYPE
+                            ? 'dynamicArrays'
+                            : attrs.name === RICH_VALUE_TYPE
+                                ? 'richValues'
+                                : undefined;
+                    break;
+                case 'cellMetadata':
+                    container = selfClosing ? undefined : 'cells';
+                    break;
+                case 'valueMetadata':
+                    container = selfClosing ? undefined : 'values';
+                    break;
+                case 'bk':
+                    if (container === 'dynamicArrays')
+                        dynamicArrayBlocks.push(false);
+                    else if (container === 'richValues')
+                        richValueBlocks.push(-1);
+                    else if (container === 'cells')
+                        cellBlocks.push([]);
+                    else if (container === 'values')
+                        valueBlocks.push([]);
+                    break;
+                case 'dynamicArrayProperties':
+                    if (container === 'dynamicArrays' && dynamicArrayBlocks.length > 0) {
+                        dynamicArrayBlocks[dynamicArrayBlocks.length - 1] = boolStrict(attrs.fDynamic);
+                    }
+                    break;
+                case 'rvb':
+                    if (container === 'richValues' && richValueBlocks.length > 0) {
+                        richValueBlocks[richValueBlocks.length - 1] = numInteger(attrs.i, 0) ?? -1;
+                    }
+                    break;
+                case 'rc': {
+                    const block = records();
+                    const type = numInteger(attrs.t, 1);
+                    const value = numInteger(attrs.v, 0);
+                    if (block !== undefined && type !== undefined && value !== undefined) {
+                        block.push({ type, value });
+                    }
+                    break;
+                }
+                default:
+                    break;
+            }
+        },
+        onClose(name) {
+            const local = localName(name);
+            if (local === 'futureMetadata' || local === 'cellMetadata' || local === 'valueMetadata') {
+                container = undefined;
+            }
+        },
+    });
+    return { typeNames, dynamicArrayBlocks, richValueBlocks, cellBlocks, valueBlocks };
+}
+const METADATA_TYPE_FLAGS = 'minSupportedVersion="120000" copy="1" pasteAll="1" pasteValues="1" merge="1" splitFirst="1" ' +
+    'rowColShift="1" clearFormats="1" clearComments="1" assign="1" coerce="1"';
+export class WorkbookMetadataTable {
+    #dynamicArrays = false;
+    #errors = new Map();
+    markDynamicArray() {
+        this.#dynamicArrays = true;
+        return 1;
+    }
+    markRichValueError(error) {
+        if (!RICH_VALUE_ERROR_TYPES.has(error))
+            return undefined;
+        const known = this.#errors.get(error);
+        if (known !== undefined)
+            return known;
+        const vm = this.#errors.size + 1;
+        this.#errors.set(error, vm);
+        return vm;
+    }
+    get isEmpty() {
+        return !this.#dynamicArrays && this.#errors.size === 0;
+    }
+    get hasRichValues() {
+        return this.#errors.size > 0;
+    }
+    toXml() {
+        const dynamic = this.#dynamicArrays;
+        const errorCount = this.#errors.size;
+        const types = [
+            ...(dynamic
+                ? [`<metadataType name="${DYNAMIC_ARRAY_TYPE}" ${METADATA_TYPE_FLAGS} cellMeta="1"/>`]
+                : []),
+            ...(errorCount > 0
+                ? [`<metadataType name="${RICH_VALUE_TYPE}" ${METADATA_TYPE_FLAGS}/>`]
+                : []),
+        ];
+        const richValueType = types.length;
+        const indices = Array.from({ length: errorCount }, (_, index) => index);
+        return (XML_DECLARATION +
+            `<metadata xmlns="${SPREADSHEETML_NS}"` +
+            (errorCount > 0 ? ` xmlns:xlrd="${RICH_DATA_NS}"` : '') +
+            (dynamic ? ` xmlns:xda="${DYNAMIC_ARRAY_NS}"` : '') +
+            '>' +
+            `<metadataTypes count="${types.length}">${types.join('')}</metadataTypes>` +
+            (dynamic
+                ? `<futureMetadata name="${DYNAMIC_ARRAY_TYPE}" count="1"><bk><extLst>` +
+                    `<ext uri="${DYNAMIC_ARRAY_PROPERTIES_EXT_URI}">` +
+                    '<xda:dynamicArrayProperties fDynamic="1" fCollapsed="0"/>' +
+                    '</ext></extLst></bk></futureMetadata>'
+                : '') +
+            (errorCount > 0
+                ? `<futureMetadata name="${RICH_VALUE_TYPE}" count="${errorCount}">` +
+                    indices
+                        .map((index) => `<bk><extLst><ext uri="${RICH_VALUE_BLOCK_EXT_URI}"><xlrd:rvb i="${index}"/></ext></extLst></bk>`)
+                        .join('') +
+                    '</futureMetadata>'
+                : '') +
+            (dynamic ? '<cellMetadata count="1"><bk><rc t="1" v="0"/></bk></cellMetadata>' : '') +
+            (errorCount > 0
+                ? `<valueMetadata count="${errorCount}">` +
+                    indices.map((index) => `<bk><rc t="${richValueType}" v="${index}"/></bk>`).join('') +
+                    '</valueMetadata>'
+                : '') +
+            '</metadata>');
+    }
+    richValuesXml() {
+        const values = [...this.#errors.keys()].map((error) => `<rv s="0"><v>${RICH_VALUE_ERROR_TYPES.get(error)}</v><v>0</v></rv>`);
+        return (XML_DECLARATION +
+            `<rvData xmlns="${RICH_DATA_NS}" count="${values.length}">${values.join('')}</rvData>`);
+    }
+}
+export const RICH_VALUE_STRUCTURES_XML = XML_DECLARATION +
+    `<rvStructures xmlns="${RICH_DATA_NS}" count="1">` +
+    `<s t="${ERROR_STRUCTURE}"><k n="errorType" t="i"/><k n="subType" t="i"/></s>` +
+    '</rvStructures>';

package/dist/io/xlsx/cell-value.d.ts

@@ -1,4 +1,5 @@
-import { type CellValue, type FormulaResult, type RichTextRun, type RichTextValue } from '../../core/value.ts';
+import { type DateEpoch } from '../../core/date.ts';
+import { type CellValue, type ErrorCode, type FormulaResult, type RichTextRun, type RichTextValue } from '../../core/value.ts';
 /**
  * One entry of the shared-strings pool. A `<si>` built from a bare `<t>` is a plain string; a `<si>`
  * built from `<r>` runs is rich text, so a `t="s"` cell can resolve to either kind, and rich text
@@ -11,8 +12,17 @@ export interface RawCell {
     readonly type: string;
     readonly hasFormula: boolean;
     readonly formula: string;
+    /** The range an `<f t="array">` fills when it starts at this cell, as Excel spells a `ref`. */
+    readonly arrayRef?: string | undefined;
+    /** Whether the cell's `cm` points at cell metadata marking a dynamic array. */
+    readonly dynamicArray?: boolean;
+    /** The error the cell's `vm` names through a rich value, which is the error a `t="e"` cell holds. */
+    readonly valueError?: ErrorCode | undefined;
+    /** Whether a `<v>` was present, `<v/>` included. */
     readonly hasValue: boolean;
     readonly valueText: string;
+    /** Whether an `<is>` was present, `<is/>` included. */
+    readonly hasInlineString: boolean;
     readonly inlineText: string;
     /** The formatted runs of a rich inline string, when the `<is>` held `<r>` elements rather than a
      * bare `<t>`. Absent (or empty) for a plain inline string, which decodes to `inlineText`. */
@@ -20,13 +30,17 @@ export interface RawCell {
 }
 /**
  * Decode a gathered cell into its model value. A formula cell becomes a `{formula, result?}`
- * object (the on-disk `_xlfn.`/`_xlpm.` mangling stripped back to the readable name); a plain
+ * object (the on-disk `_xlfn.`/`_xlpm.` mangling stripped back to the readable name), or an array
+ * formula over its range, dynamic when the cell's metadata says so; a plain
  * numeric cell under a date number format becomes a {@link Date}; everything else decodes by its
- * `t` type. `numFmt` is the cell's resolved number-format code, used only for date detection.
+ * `t` type. `numFmt` is the cell's resolved number-format code, used only for date detection, and
+ * `epoch` the workbook's date system, which is what a serial under such a format counts from.
+ * `definedNames` is the workbook's defined names as `definedNameKeys` spells them, which decide whether
+ * a function passed as a value sheds its `_xleta.`.
  */
-export declare function decodeCellContent(raw: RawCell, sharedStrings: readonly SharedString[], numFmt: string | undefined): CellValue;
+export declare function decodeCellContent(raw: RawCell, sharedStrings: readonly SharedString[], numFmt: string | undefined, epoch: DateEpoch, definedNames: ReadonlySet<string>): CellValue;
 /** Decode a formula's cached `<v>` result by its `t` type, coercing a numeric result under a date
  * `numFmt` to a {@link Date} exactly as a bare numeric cell is, so a date-valued formula result
  * (e.g. `TODAY()`) reads back as a Date, not a serial. Shared by the buffered reader's shared-formula
  * clone resolution, which caches a result the same way a plain formula cell does. */
-export declare function decodeFormulaResult(type: string, valueText: string, numFmt?: string): FormulaResult | undefined;
+export declare function decodeFormulaResult(type: string, valueText: string, numFmt: string | undefined, epoch: DateEpoch, valueError?: ErrorCode): FormulaResult | undefined;

package/dist/io/xlsx/cell-value.js

@@ -1,58 +1,73 @@
-import { isDateFormat, serialToDate } from '../../core/date.js';
+import { coerceDateSerial, parseDateText } from '../../core/date.js';
 import { unmangleFunctions } from '../../core/formula.js';
 import { isErrorCode, } from '../../core/value.js';
-import { boolStrict, decodeSpreadsheetText, numFinite } from '../../xml/xml-scan.js';
-export function decodeCellContent(raw, sharedStrings, numFmt) {
+import { decodeSpreadsheetText, numFinite, numInteger } from '../../xml/xml-attrs.js';
+import { boolTristate } from '../../xml/xml-scan.js';
+export function decodeCellContent(raw, sharedStrings, numFmt, epoch, definedNames) {
     if (raw.hasFormula) {
-        const stored = unmangleFunctions(raw.formula);
-        const result = raw.hasValue ? decodeFormulaResult(raw.type, raw.valueText, numFmt) : undefined;
-        return result === undefined ? { formula: stored } : { formula: stored, result };
+        const stored = unmangleFunctions(raw.formula, definedNames);
+        const result = raw.hasValue
+            ? decodeFormulaResult(raw.type, raw.valueText, numFmt, epoch, raw.valueError)
+            : undefined;
+        const cached = result === undefined ? {} : { result };
+        if (raw.arrayRef !== undefined) {
+            return {
+                shareType: 'array',
+                formula: stored,
+                ref: raw.arrayRef,
+                ...(raw.dynamicArray === true ? { dynamic: true } : {}),
+                ...cached,
+            };
+        }
+        return { formula: stored, ...cached };
     }
     if (raw.type === 'inlineStr' && raw.richTextRuns !== undefined && raw.richTextRuns.length > 0) {
         return { richText: raw.richTextRuns };
     }
-    const value = decodeValue(raw.type, raw.valueText, raw.inlineText, raw.hasValue, sharedStrings);
-    return typeof value === 'number' && numFmt !== undefined && isDateFormat(numFmt)
-        ? serialToDate(value)
-        : value;
+    const value = decodeValue(raw, sharedStrings);
+    return coerceDateSerial(value, numFmt, epoch);
 }
-function decodeValue(type, valueText, inlineText, hasValue, sharedStrings) {
-    switch (type) {
+function decodeValue(raw, sharedStrings) {
+    const { valueText } = raw;
+    switch (raw.type) {
         case 'inlineStr':
-            return inlineText;
+            return raw.hasInlineString ? raw.inlineText : null;
         case 'str':
-            return decodeSpreadsheetText(valueText);
+            return raw.hasValue ? decodeSpreadsheetText(valueText) : null;
         case 'd':
-            return valueText === '' ? null : new Date(valueText);
+            return parseDateText(valueText);
         case 's': {
-            const index = Number(valueText);
-            return Number.isInteger(index) ? (sharedStrings[index] ?? '') : '';
+            const index = numInteger(valueText, 0);
+            return index === undefined ? null : (sharedStrings[index] ?? null);
         }
         case 'b':
-            return boolStrict(valueText);
+            return boolTristate(valueText) ?? null;
         case 'e':
-            return isErrorCode(valueText) ? { error: valueText } : valueText;
-        default: {
-            if (!hasValue)
+            if (valueText === '')
                 return null;
+            return errorOf(valueText, raw.valueError);
+        default:
             return numFinite(valueText) ?? null;
-        }
     }
 }
-export function decodeFormulaResult(type, valueText, numFmt) {
-    const result = decodeResult(type, valueText);
-    return typeof result === 'number' && numFmt !== undefined && isDateFormat(numFmt)
-        ? serialToDate(result)
-        : result;
+export function decodeFormulaResult(type, valueText, numFmt, epoch, valueError) {
+    return coerceDateSerial(decodeResult(type, valueText, valueError), numFmt, epoch);
+}
+function errorOf(valueText, valueError) {
+    if (valueError !== undefined)
+        return { error: valueError };
+    return isErrorCode(valueText) ? { error: valueText } : valueText;
 }
-function decodeResult(type, valueText) {
+function decodeResult(type, valueText, valueError) {
     switch (type) {
         case 'str':
             return decodeSpreadsheetText(valueText);
         case 'b':
-            return boolStrict(valueText);
+            return boolTristate(valueText);
         case 'e':
-            return isErrorCode(valueText) ? { error: valueText } : valueText;
+            if (valueText === '')
+                return undefined;
+            return errorOf(valueText, valueError);
         default:
             return numFinite(valueText);
     }

package/dist/io/xlsx/color-xml.js

@@ -1,10 +1,11 @@
 import { parseArgb } from '../../core/style.js';
-import { numFinite, numInteger } from '../../xml/xml-scan.js';
+import { quoted } from '../../errors.js';
+import { numFinite, numInteger } from '../../xml/xml-attrs.js';
 import { numberText } from '../../xml/xml.js';
 function normalizeArgb(argb) {
     const rgb = parseArgb(argb);
     if (rgb === undefined) {
-        throw new SyntaxError(`Invalid ARGB colour ${JSON.stringify(argb)}: expected 6 or 8 hexadecimal digits`);
+        throw new SyntaxError(`invalid ARGB colour ${quoted(argb)}: expected 6 or 8 hexadecimal digits`);
     }
     return rgb;
 }

package/dist/io/xlsx/column-span.d.ts

@@ -0,0 +1,11 @@
+import type { XmlAttributes } from '../../xml/xml-scan.ts';
+import { type ColumnRecordBudget } from '../read-policy/column-budget.ts';
+/**
+ * The columns a `<col min max>` element actually applies to, or `undefined` for one that applies to
+ * none: unreadable bounds, or anything {@link clampColumnSpan} refuses. Both XML worksheet readers
+ * ask this, so the two cannot read one `<col>` as covering different columns.
+ */
+export declare function takeColumnSpan(attrs: XmlAttributes, budget: ColumnRecordBudget): {
+    first: number;
+    last: number;
+} | undefined;

package/dist/io/xlsx/column-span.js

@@ -0,0 +1,9 @@
+import { numInteger } from '../../xml/xml-attrs.js';
+import { clampColumnSpan } from '../read-policy/column-budget.js';
+export function takeColumnSpan(attrs, budget) {
+    const first = numInteger(attrs.min, 1);
+    const last = numInteger(attrs.max, 1);
+    if (first === undefined || last === undefined)
+        return undefined;
+    return clampColumnSpan(first, last, budget);
+}

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

@@ -1,6 +1,8 @@
+import type { Cell } from '../../core/cell.ts';
 import type { CommentThread } from '../../core/comment-thread.ts';
 import type { Worksheet } from '../../core/worksheet.ts';
-/** A comment bound for `comments{n}.xml`, paired with the coordinates the VML anchor needs. */
+/** A comment bound for `comments{n}.xml`, paired with the coordinates the VML anchor needs.
+ */
 export interface CommentCell {
     readonly ref: string;
     /** 1-based row of the commented cell. */
@@ -28,7 +30,9 @@ export interface CommentCell {
  * Ordered by cell, row-major, the way Excel writes the list, so a fallback lands interleaved among the
  * notes rather than appended after them, and the VML shapes follow the same order.
  */
-export declare function collectComments(sheet: Worksheet, threads: readonly CommentThread[]): CommentCell[];
+export declare function collectComments(cells: Iterable<Cell>, threads: readonly CommentThread[], alreadyCollected?: readonly CommentCell[]): CommentCell[];
+/** The notes among a run of cells, for a writer that must ask before the cells are evicted. */
+export declare function collectNotes(cells: Iterable<Cell>): CommentCell[];
 /**
  * The `xl/comments{n}.xml` part.
  *
@@ -44,31 +48,6 @@ export declare function commentsXml(comments: readonly CommentCell[]): string;
  * pixel-exact layout. A thread's fallback shape is `ObjectType="Note"` like any other: Excel draws the
  * threaded-comment card itself and only needs the shape to exist. */
 export declare function vmlDrawingXml(comments: readonly CommentCell[]): string;
-/** One `<comment>` read back from a comments part. */
-export interface ParsedComment {
-    readonly text: string;
-    /**
-     * The thread head id this comment is the legacy fallback for, read off its synthetic `tc={headId}`
-     * author; absent for a user's own note.
-     */
-    readonly threadId?: string;
-}
-/**
- * Parse a `comments{n}.xml` part into a map of A1 reference → comment. Text runs within one comment are
- * concatenated; an author-name run is Excel's own convention and is not stripped, so a note reads back
- * as exactly the text that was written.
- */
-export declare function parseComments(xml: string): Map<string, ParsedComment>;
-/**
- * Apply a parsed comments part onto a sheet's cells as notes, addressing each by its A1 reference.
- *
- * A thread's legacy fallback is not a note and does not become one: its text is boilerplate wrapping a
- * copy of the conversation, so surfacing it as `cell.note` hands the caller garbage, and on write it
- * would be re-emitted as a plain note, destroying the `tc=`/`xr:uid` binding and leaving Excel unable to
- * see the thread at all.
- *
- * Suppressed only for a conversation the reader actually holds: a file whose thread part is missing or
- * damaged has nothing else left, so there the boilerplate is kept rather than the content lost. Call
- * after the sheet's threads are restored, since that is what this reads to decide.
- */
-export declare function applyNotes(sheet: Worksheet, comments: ReadonlyMap<string, ParsedComment>): void;
+/** Every cell a sheet still holds, row-major: what the writer gathers a sheet's notes from, beside the
+ * notes the streaming writer took off the rows it already flushed. */
+export declare function liveCells(sheet: Worksheet): Generator<Cell, void, undefined>;

package/dist/io/xlsx/comments.js

@@ -1,20 +1,29 @@
 import { tryDecodeCellRef } from '../../core/address.js';
-import { parseXml } from '../../xml/xml-read.js';
-import { decodeSpreadsheetText, localName, numInteger } from '../../xml/xml-scan.js';
 import { escapeText, textAttr, textElement, XML_DECLARATION } from '../../xml/xml.js';
 import { MARKUP_COMPATIBILITY_NS, REVISION_NS, SPREADSHEETML_NS } from './namespaces.js';
-export function collectComments(sheet, threads) {
+export function collectComments(cells, threads, alreadyCollected = []) {
     const fallbacks = threadFallbacks(threads);
     const anchored = new Set(fallbacks.map((fallback) => fallback.ref));
-    const comments = [...fallbacks];
-    for (const { cells } of sheet.rows()) {
-        for (const cell of cells) {
-            if (cell.note === undefined || anchored.has(cell.address))
-                continue;
-            comments.push({ ref: cell.address, row: cell.row, col: cell.col, text: cell.note });
-        }
+    const comments = [...fallbacks, ...alreadyCollected];
+    for (const cell of cells) {
+        if (cell.note === undefined || anchored.has(cell.address))
+            continue;
+        comments.push(noteOn(cell, cell.note));
+    }
+    return comments
+        .filter((comment) => comment.threadId !== undefined || !anchored.has(comment.ref))
+        .sort((a, b) => a.row - b.row || a.col - b.col);
+}
+export function collectNotes(cells) {
+    const notes = [];
+    for (const cell of cells) {
+        if (cell.note !== undefined)
+            notes.push(noteOn(cell, cell.note));
     }
-    return comments.sort((a, b) => a.row - b.row || a.col - b.col);
+    return notes;
+}
+function noteOn(cell, text) {
+    return { ref: cell.address, row: cell.row, col: cell.col, text };
 }
 function threadFallbacks(threads) {
     const fallbacks = [];
@@ -76,13 +85,14 @@ const VML_HEADER = '<xml xmlns:v="urn:schemas-microsoft-com:vml" ' +
     '<v:shapetype id="_x0000_t202" coordsize="21600,21600" o:spt="202" ' +
     'path="m,l,21600r21600,l21600,xe"><v:stroke joinstyle="miter"/>' +
     '<v:path gradientshapeok="t" o:connecttype="rect"/></v:shapetype>';
+const FIRST_SHAPE_ID = 1025;
 export function vmlDrawingXml(comments) {
     const shapes = comments
         .map((comment, i) => {
         const row0 = comment.row - 1;
         const col0 = comment.col - 1;
         const anchor = `${col0 + 1}, 15, ${row0}, 2, ${col0 + 3}, 15, ${row0 + 4}, 4`;
-        return (`<v:shape id="_x0000_s${1025 + i}" type="#_x0000_t202" ` +
+        return (`<v:shape id="_x0000_s${FIRST_SHAPE_ID + i}" type="#_x0000_t202" ` +
             'style="position:absolute;margin-left:59.25pt;margin-top:1.5pt;width:108pt;height:59.25pt;' +
             `z-index:${i + 1};visibility:hidden" fillcolor="#ffffe1" o:insetmode="auto">` +
             '<v:fill color2="#ffffe1"/><v:shadow on="t" color="black" obscured="t"/>' +
@@ -95,75 +105,7 @@ export function vmlDrawingXml(comments) {
         .join('');
     return `${VML_HEADER}${shapes}</xml>`;
 }
-const COMMENT_EMPTY_CLOSES = new Set(['author']);
-const THREAD_AUTHOR_PREFIX = 'tc=';
-export function parseComments(xml) {
-    const comments = new Map();
-    const authors = [];
-    let currentRef;
-    let currentAuthorId;
-    let capture;
-    let buffer = '';
-    parseXml(xml, {
-        onOpen(name, attrs) {
-            const local = localName(name);
-            if (local === 'comment') {
-                currentRef = attrs.ref;
-                currentAuthorId = attrs.authorId;
-                buffer = '';
-            }
-            else if (local === 'author') {
-                capture = 'author';
-                buffer = '';
-            }
-            else if (local === 'text') {
-                capture = 'text';
-            }
-        },
-        onText(text) {
-            if (capture !== undefined)
-                buffer += text;
-        },
-        onClose(name) {
-            const local = localName(name);
-            if (local === 'author') {
-                authors.push(buffer);
-                capture = undefined;
-                buffer = '';
-            }
-            else if (local === 'text') {
-                buffer = decodeSpreadsheetText(buffer);
-                capture = undefined;
-            }
-            else if (local === 'comment' && currentRef !== undefined) {
-                const threadId = threadIdOf(authors[numInteger(currentAuthorId, 0) ?? -1]);
-                comments.set(currentRef, {
-                    text: buffer,
-                    ...(threadId !== undefined ? { threadId } : {}),
-                });
-                currentRef = undefined;
-                currentAuthorId = undefined;
-            }
-        },
-    }, { closeEmptyElements: COMMENT_EMPTY_CLOSES });
-    return comments;
-}
-function threadIdOf(author) {
-    if (author === undefined || !author.startsWith(THREAD_AUTHOR_PREFIX))
-        return undefined;
-    const id = author.slice(THREAD_AUTHOR_PREFIX.length);
-    return id === '' ? undefined : id;
-}
-export function applyNotes(sheet, comments) {
-    const headIds = new Set(sheet.commentThreads.flatMap((thread) => {
-        const head = thread.comments[0];
-        return head === undefined ? [] : [head.id];
-    }));
-    for (const [ref, comment] of comments) {
-        if (comment.threadId !== undefined && headIds.has(comment.threadId))
-            continue;
-        if (tryDecodeCellRef(ref) === undefined)
-            continue;
-        sheet.getCell(ref).note = comment.text;
-    }
+export function* liveCells(sheet) {
+    for (const { cells } of sheet.rows())
+        yield* cells;
 }