@rowsncolumns/y-spreadsheet 16.0.0 → 16.1.0-beta.0

package/dist/cjs/helpers-v5.js

@@ -0,0 +1,970 @@
+"use strict";
+// ============================================================================
+// V5 documents (stable line ids): reader and legacy-path writer
+// ============================================================================
+// Encoding: libs/rnc-yrs-store/docs/v5-document-encoding.md. Names in comments
+// (`RNC_CELLS`, `c0_floor`, …) are the Rust ones in rust/crates/rnc-yrs-store/src
+// (lib.rs unless a module is named); they win over this module.
+//
+// Readers (hot plane only; cold-block cells are not decoded): `sheetDataV5ToV2`,
+// `getCellV5`, `processSheetDataChangesV5`; `uf` from the composed style plane,
+// `note` from `rncNotes`, so a cell read here can be written back unchanged.
+// Writer: `addSheetDataPatchesV5` applies immer `SheetData` patches positionally
+// (a structural edit arrives as rewritten rows, v3 parity); it names lines past
+// an axis with client-0 ids exactly as `YrsStore::ensure_lines` does and logs
+// `uf` changes as `STYLE_LOG_V2` ops. It never writes `ft`: a JS formula is
+// positional in its write frame.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteSheetV5 = exports.deleteCellV5 = exports.setCellV5 = exports.addSheetDataPatchesV5 = exports.processSheetDataChangesV5 = exports.getCellV5 = exports.createCellReaderV5 = exports.sheetDataV5ToV2 = exports.readStyleOverlayV5 = exports.parseCellKeyV5 = exports.createCellKeyV5 = exports.readLineIds = void 0;
+var tslib_1 = require("tslib");
+var utils_1 = require("@rowsncolumns/utils");
+var decoding = tslib_1.__importStar(require("lib0/decoding"));
+var encoding = tslib_1.__importStar(require("lib0/encoding"));
+var cloneDeep_1 = tslib_1.__importDefault(require("lodash/cloneDeep"));
+var isEqual_1 = tslib_1.__importDefault(require("lodash/isEqual"));
+var set_1 = tslib_1.__importDefault(require("lodash/set"));
+var unset_1 = tslib_1.__importDefault(require("lodash/unset"));
+var CELLS_V5 = "rncCells"; // RNC_CELLS
+var NOTES_V5 = "rncNotes"; // NOTES
+var DIMS_V5 = "rncDimensions"; // DIMS
+var STYLES_SEED_V5 = "rncCellStyles"; // RNC_STYLES (legacy, read-only seed)
+var STYLES_LOG_V5 = "rncCellStylesLog"; // RNC_STYLES_LOG
+var BLOCKS_V5 = "rncColumnBlocks"; // RNC_COLUMN_BLOCKS
+var BLOCK_ROWS = 32768; // BLOCK_ROWS
+var BLOCK_V2_MAGIC = 0x80000000; // BLOCK_V2_MAGIC
+var BLOCK_V2_DENSE = 0x40000000; // BLOCK_V2_DENSE
+var STYLE_LOG_V1 = 1; // STYLE_LOG_V1
+var STYLE_LOG_V2 = 2; // STYLE_LOG_V2
+var CELL_KEY_V5 = /^(-?\d+):(-?\d+):(-?\d+)$/; // cell_key
+var BLOCK_KEY_V5 = /^(-?\d+):(-?\d+):(\d+)$/; // block_key
+var DIM_KEY_V5 = /^(-?\d+):([RC]):(-?\d+)$/; // dim_id_key
+var SEED_KEY = /^(-?\d+)!([A-Z]+)(\d+)$/; // `"{sheetId}!{A1}"`, parse_a1
+// ── ids (axis.rs: make_id, id_client, id_counter) ───────────────────────────
+var idCounter = function (id) {
+    return Number((BigInt.asUintN(64, id) >> BigInt(32)) & BigInt(0xffffffff));
+};
+var idClient = function (id) { return Number(BigInt.asUintN(32, id)); };
+/** Decimal client-0 id of `counter` (`make_id(0, counter)`). */
+var c0Id = function (counter) { return (BigInt(counter) << BigInt(32)).toString(); };
+/** Client-0 counter of a decimal id; 0 for another client's id. */
+var c0Counter = function (id) {
+    var value = BigInt(id);
+    return idClient(value) === 0 ? idCounter(value) : 0;
+};
+/** The array value of a padded id: `counter << 32` is exact as a float (yjs cannot insert a bigint). */
+var idValue = function (counter) { return counter * 4294967296; };
+var lineIdsRootName = function (sheetId, axis) {
+    return "".concat(axis === "row" ? "rncRowIds" : "rncColIds", ":").concat(sheetId);
+};
+/** Decimal text of a stored line id (yjs gives a number or a bigint); null otherwise. */
+var lineIdText = function (value) {
+    if (typeof value === "bigint")
+        return value.toString();
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return BigInt(Math.trunc(value)).toString();
+    }
+    return null;
+};
+/**
+ * A sheet's line ids in grid order (position = index + 1), as decimal strings.
+ * Later duplicates and non-id values are skipped, as the engine's index does.
+ */
+var readLineIds = function (doc, sheetId, axis) {
+    var e_1, _a;
+    var name = lineIdsRootName(sheetId, axis);
+    if (!doc.share.has(name))
+        return [];
+    var ids = [];
+    var seen = new Set();
+    try {
+        for (var _b = tslib_1.__values(doc.getArray(name).toArray()), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var value = _c.value;
+            var id = lineIdText(value);
+            if (id === null || seen.has(id))
+                continue;
+            seen.add(id);
+            ids.push(id);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return ids;
+};
+exports.readLineIds = readLineIds;
+/** The `rncCells` / `rncNotes` key of a cell by its line ids. */
+var createCellKeyV5 = function (sheetId, rowId, colId) { return "".concat(sheetId, ":").concat(rowId, ":").concat(colId); };
+exports.createCellKeyV5 = createCellKeyV5;
+/** Parse a v5 key `"{sheetId}:{rowId}:{colId}"`; null when malformed. */
+var parseCellKeyV5 = function (key) {
+    var match = CELL_KEY_V5.exec(key);
+    if (!match)
+        return null;
+    var sheetId = Number(match[1]);
+    var rowId = BigInt(match[2]);
+    var colId = BigInt(match[3]);
+    if (!Number.isSafeInteger(sheetId) ||
+        BigInt.asIntN(64, rowId) !== rowId ||
+        BigInt.asIntN(64, colId) !== colId) {
+        return null;
+    }
+    return { sheetId: sheetId, rowId: rowId.toString(), colId: colId.toString() };
+};
+exports.parseCellKeyV5 = parseCellKeyV5;
+var isPlainObject = function (value) {
+    return value !== null &&
+        typeof value === "object" &&
+        Object.getPrototypeOf(value) === Object.prototype;
+};
+/** A stored v5 value as `CellData` without the engine-owned `ft`; null for a tombstone. */
+var cellDataV5 = function (value) {
+    if (!isPlainObject(value))
+        return null;
+    var _ft = value.ft, cell = tslib_1.__rest(value, ["ft"]);
+    return cell;
+};
+var toPositions = function (ids) {
+    return new Map(ids.map(function (id, i) { return [id, i + 1]; }));
+};
+/** The line index of a sheet, read once per call site into `cache`. */
+var sheetLinesV5 = function (doc, cache, sheetId) {
+    var lines = cache.get(sheetId);
+    if (!lines) {
+        lines = {
+            rows: toPositions((0, exports.readLineIds)(doc, sheetId, "row")),
+            cols: toPositions((0, exports.readLineIds)(doc, sheetId, "column")),
+        };
+        cache.set(sheetId, lines);
+    }
+    return lines;
+};
+/** 1-based `[row, col]` of a parsed key; null for an orphan (a deleted or unknown line). */
+var positionV5 = function (doc, cache, _a) {
+    var sheetId = _a.sheetId, rowId = _a.rowId, colId = _a.colId;
+    var _b = sheetLinesV5(doc, cache, sheetId), rows = _b.rows, cols = _b.cols;
+    var row = rows.get(rowId);
+    var col = cols.get(colId);
+    return row === undefined || col === undefined ? null : [row, col];
+};
+// ── style plane (encode_style_ops, fold_style_ops, CellFormat::merge) ───────
+var isStyleReference = function (format) {
+    return isPlainObject(format) && ("sid" in format || "styleId" in format);
+};
+/**
+ * `CellFormat::merge`: each set property of `patch` wins; `textFormat` and
+ * `borders` merge one level deep; a `""` colour removes it. Pure (both inputs
+ * may be frozen). `mergeFormat({}, f)` = `into_normalized`.
+ */
+var mergeFormat = function (base, patch) {
+    var e_2, _a, e_3, _b;
+    var out = tslib_1.__assign({}, base);
+    try {
+        for (var _c = tslib_1.__values(Object.entries(patch)), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var _f = tslib_1.__read(_d.value, 2), key = _f[0], value = _f[1];
+            if (value === null || value === undefined)
+                continue;
+            if ((key === "textFormat" || key === "borders") && isPlainObject(value)) {
+                var prev = out[key];
+                var nested = isPlainObject(prev) ? tslib_1.__assign({}, prev) : {};
+                try {
+                    for (var _g = (e_3 = void 0, tslib_1.__values(Object.entries(value))), _h = _g.next(); !_h.done; _h = _g.next()) {
+                        var _j = tslib_1.__read(_h.value, 2), k = _j[0], v = _j[1];
+                        if (v === null || v === undefined)
+                            continue;
+                        if (key === "textFormat" && k === "color" && v === "")
+                            delete nested[k];
+                        else
+                            nested[k] = v;
+                    }
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                }
+                out[key] = nested;
+            }
+            else if ((key === "backgroundColor" || key === "foregroundColor") &&
+                value === "") {
+                delete out[key];
+            }
+            else {
+                out[key] = value;
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return out;
+};
+/** A cell's `uf` comparable with the composed plane: unset fields dropped; a reference as is. */
+var normalizedFormat = function (format) {
+    return isPlainObject(format) && !isStyleReference(format)
+        ? mergeFormat({}, format)
+        : (format !== null && format !== void 0 ? format : null);
+};
+var letterIndex = function (letters) {
+    return letters.split("").reduce(function (n, ch) { return n * 26 + ch.charCodeAt(0) - 64; }, 0);
+};
+/** Fold one log buffer onto `overlay`; a truncated buffer keeps the ops before the cut. */
+var foldStyleBuffer = function (overlay, buf) {
+    var decoder = decoding.createDecoder(buf);
+    if (!decoding.hasContent(decoder))
+        return;
+    var version = decoding.readUint8(decoder);
+    if (version !== STYLE_LOG_V1 && version !== STYLE_LOG_V2)
+        return;
+    try {
+        while (decoding.hasContent(decoder)) {
+            var sheet = decoding.readBigInt64(decoder);
+            var _a = tslib_1.__read(version === STYLE_LOG_V1
+                ? [c0Id(decoding.readVarUint(decoder)), c0Id(decoding.readVarUint(decoder))]
+                : [
+                    decoding.readBigInt64(decoder).toString(),
+                    decoding.readBigInt64(decoder).toString(),
+                ], 2), row = _a[0], col = _a[1];
+            var value = decoding.readAny(decoder);
+            var key = "".concat(sheet, ":").concat(row, ":").concat(col);
+            // A `STYLE_LOG_BASE_SENTINEL_SHEET` op is a clear of a cell that cannot exist.
+            if (value === null || value === undefined) {
+                overlay.delete(key);
+            }
+            else if (isPlainObject(value)) {
+                var prev = overlay.get(key);
+                overlay.set(key, mergeFormat(prev !== null && prev !== void 0 ? prev : {}, value));
+            }
+        }
+    }
+    catch (_e) {
+        // Reading past the end: the buffer stops here, as `fold_style_ops` does.
+    }
+};
+/**
+ * The composed style plane of a v5 doc (`refold_style_overlay`): the legacy
+ * `rncCellStyles` seed (`"{sheetId}!{A1}"`, the client-0 ids of that position)
+ * with every `rncCellStylesLog` buffer folded on in array order. Walks the log.
+ */
+var readStyleOverlayV5 = function (doc) {
+    var e_4, _a;
+    var overlay = new Map();
+    if (doc.share.has(STYLES_SEED_V5)) {
+        doc.getMap(STYLES_SEED_V5).forEach(function (value, key) {
+            var match = SEED_KEY.exec(key);
+            if (!match || !isPlainObject(value))
+                return;
+            var row = c0Id(Number(match[3]));
+            var col = c0Id(letterIndex(match[2]));
+            overlay.set("".concat(BigInt(match[1]), ":").concat(row, ":").concat(col), mergeFormat({}, value));
+        });
+    }
+    if (doc.share.has(STYLES_LOG_V5)) {
+        try {
+            for (var _b = tslib_1.__values(doc.getArray(STYLES_LOG_V5).toArray()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var buf = _c.value;
+                if (buf instanceof Uint8Array)
+                    foldStyleBuffer(overlay, buf);
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+    }
+    return overlay;
+};
+exports.readStyleOverlayV5 = readStyleOverlayV5;
+/** `STYLE_LOG_V2`, then per op `i64 sheet, i64 rowId, i64 colId` (big-endian) and one `Any`. */
+var encodeStyleOps = function (ops) {
+    var e_5, _a;
+    var encoder = encoding.createEncoder();
+    encoding.writeUint8(encoder, STYLE_LOG_V2);
+    try {
+        for (var ops_1 = tslib_1.__values(ops), ops_1_1 = ops_1.next(); !ops_1_1.done; ops_1_1 = ops_1.next()) {
+            var _b = tslib_1.__read(ops_1_1.value, 4), sheetId = _b[0], rowId = _b[1], colId = _b[2], format = _b[3];
+            encoding.writeBigInt64(encoder, BigInt(sheetId));
+            encoding.writeBigInt64(encoder, BigInt(rowId));
+            encoding.writeBigInt64(encoder, BigInt(colId));
+            encoding.writeAny(encoder, format);
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (ops_1_1 && !ops_1_1.done && (_a = ops_1.return)) _a.call(ops_1);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    return encoding.toUint8Array(encoder);
+};
+// ── cold blocks (encode_cell_block, decode_cell_block_bodies, block_row_offsets) ──
+/** Row offsets of a block from its uncompressed header (no inflate). */
+var blockRowOffsets = function (buf) {
+    if (buf.length < 4)
+        return [];
+    var view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+    var first = view.getUint32(0, true);
+    var out = [];
+    if (first & BLOCK_V2_MAGIC) {
+        var count = Math.min(buf.length >= 8 ? view.getUint32(4, true) : 0, BLOCK_ROWS);
+        if (first & BLOCK_V2_DENSE) {
+            for (var i = 0; i < count; i++)
+                out.push(i);
+            return out;
+        }
+        for (var i = 0, pos = 8; i < count && pos + 4 <= buf.length; i++, pos += 4) {
+            out.push(view.getUint32(pos, true));
+        }
+        return out;
+    }
+    for (var i = 0, pos = 4; i < first && pos + 8 <= buf.length; i++) {
+        out.push(view.getUint32(pos, true));
+        pos += 8 + view.getUint32(pos + 4, true);
+    }
+    return out;
+};
+/** Whether `rowId`'s client-0 counter has an entry in the column's block (header only). */
+var coldCellExists = function (doc, cache, sheetId, rowId, colId) {
+    var counter = c0Counter(rowId);
+    if (!counter || !doc.share.has(BLOCKS_V5))
+        return false;
+    var key = "".concat(sheetId, ":").concat(colId, ":").concat(Math.floor((counter - 1) / BLOCK_ROWS));
+    var offsets = cache.get(key);
+    if (!offsets) {
+        var buf = doc.getMap(BLOCKS_V5).get(key);
+        offsets = new Set(buf instanceof Uint8Array ? blockRowOffsets(buf) : []);
+        cache.set(key, offsets);
+    }
+    return offsets.has((counter - 1) % BLOCK_ROWS);
+};
+// ── readers ─────────────────────────────────────────────────────────────────
+/**
+ * The cell under `key` as the readers show it: the hot value (`ft` stripped),
+ * `uf` from `styles` where it has an entry, `note` from `rncNotes` where it has
+ * one. Null when none of the three holds anything.
+ */
+var composeCell = function (doc, key, styles) {
+    var cell = doc.share.has(CELLS_V5)
+        ? cellDataV5(doc.getMap(CELLS_V5).get(key))
+        : null;
+    var uf = styles.get(key);
+    if (uf)
+        cell = tslib_1.__assign(tslib_1.__assign({}, cell), { uf: uf });
+    var note = doc.share.has(NOTES_V5) ? doc.getMap(NOTES_V5).get(key) : undefined;
+    if (typeof note === "string")
+        cell = tslib_1.__assign(tslib_1.__assign({}, cell), { note: note });
+    return cell;
+};
+/**
+ * A v5 doc as V2 `SheetData` (same shape as `sheetDataV3ToV2`), hot plane only:
+ * every key of `rncCells`, `rncNotes` and the composed style plane composed as
+ * `composeCell` does (tombstones and orphans skipped).
+ */
+var sheetDataV5ToV2 = function (doc, styles) {
+    var e_6, _a, e_7, _b, e_8, _c;
+    var _d, _f;
+    var _g;
+    if (styles === void 0) { styles = (0, exports.readStyleOverlayV5)(doc); }
+    var sheetData = {};
+    var cache = new Map();
+    var keys = new Set(styles.keys());
+    try {
+        for (var _h = tslib_1.__values([CELLS_V5, NOTES_V5]), _j = _h.next(); !_j.done; _j = _h.next()) {
+            var name_1 = _j.value;
+            if (doc.share.has(name_1))
+                try {
+                    for (var _k = (e_7 = void 0, tslib_1.__values(doc.getMap(name_1).keys())), _l = _k.next(); !_l.done; _l = _k.next()) {
+                        var key = _l.value;
+                        keys.add(key);
+                    }
+                }
+                catch (e_7_1) { e_7 = { error: e_7_1 }; }
+                finally {
+                    try {
+                        if (_l && !_l.done && (_b = _k.return)) _b.call(_k);
+                    }
+                    finally { if (e_7) throw e_7.error; }
+                }
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (_j && !_j.done && (_a = _h.return)) _a.call(_h);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+    try {
+        for (var keys_1 = tslib_1.__values(keys), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) {
+            var key = keys_1_1.value;
+            var parsed = (0, exports.parseCellKeyV5)(key);
+            var pos = parsed && positionV5(doc, cache, parsed);
+            var cell = pos && composeCell(doc, key, styles);
+            if (!parsed || !pos || !cell)
+                continue;
+            var _m = tslib_1.__read(pos, 2), rowIdx = _m[0], colIdx = _m[1];
+            var rows = ((_d = sheetData[_g = parsed.sheetId]) !== null && _d !== void 0 ? _d : (sheetData[_g] = []));
+            while (rows.length <= rowIdx)
+                rows.push(null);
+            var row = ((_f = rows[rowIdx]) !== null && _f !== void 0 ? _f : (rows[rowIdx] = { values: [] }));
+            if (!row.values)
+                row.values = [];
+            while (row.values.length <= colIdx)
+                row.values.push(null);
+            row.values[colIdx] = cell;
+        }
+    }
+    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    finally {
+        try {
+            if (keys_1_1 && !keys_1_1.done && (_c = keys_1.return)) _c.call(keys_1);
+        }
+        finally { if (e_8) throw e_8.error; }
+    }
+    return sheetData;
+};
+exports.sheetDataV5ToV2 = sheetDataV5ToV2;
+/**
+ * A reader of the cell at a 1-based position (`composeCell`), line ids read once
+ * per sheet. Undefined when nothing is there or the line is unnamed.
+ */
+var createCellReaderV5 = function (doc, styles) {
+    if (styles === void 0) { styles = (0, exports.readStyleOverlayV5)(doc); }
+    var lines = new Map();
+    return function (sheetId, rowIndex, columnIndex) {
+        var _a;
+        var ids = lines.get(sheetId);
+        if (!ids) {
+            ids = [(0, exports.readLineIds)(doc, sheetId, "row"), (0, exports.readLineIds)(doc, sheetId, "column")];
+            lines.set(sheetId, ids);
+        }
+        var rowId = ids[0][rowIndex - 1];
+        var colId = ids[1][columnIndex - 1];
+        if (rowId === undefined || colId === undefined)
+            return undefined;
+        return (_a = composeCell(doc, (0, exports.createCellKeyV5)(sheetId, rowId, colId), styles)) !== null && _a !== void 0 ? _a : undefined;
+    };
+};
+exports.createCellReaderV5 = createCellReaderV5;
+/** `createCellReaderV5` for one cell (reads both id arrays: O(lines)). */
+var getCellV5 = function (doc, sheetId, rowIndex, columnIndex, styles) { return (0, exports.createCellReaderV5)(doc, styles)(sheetId, rowIndex, columnIndex); };
+exports.getCellV5 = getCellV5;
+/**
+ * Apply changed `rncCells` / `rncNotes` keys to `currentSheetData` (copy-on-write,
+ * like `processSheetDataEventsV3`), `uf` from `styles`. Only valid while no id
+ * array and no style changed (those need `sheetDataV5ToV2`). Null when nothing changed.
+ */
+var processSheetDataChangesV5 = function (changedKeys, currentSheetData, doc, styles) {
+    var e_9, _a;
+    var _b, _c, _d;
+    if (styles === void 0) { styles = (0, exports.readStyleOverlayV5)(doc); }
+    var cache = new Map();
+    var next = tslib_1.__assign({}, currentSheetData);
+    var clonedSheets = new Set();
+    var clonedRows = new Set();
+    var hasChanges = false;
+    try {
+        for (var _f = tslib_1.__values(new Set(changedKeys)), _g = _f.next(); !_g.done; _g = _f.next()) {
+            var key = _g.value;
+            var parsed = (0, exports.parseCellKeyV5)(key);
+            var pos = parsed && positionV5(doc, cache, parsed);
+            if (!parsed || !pos)
+                continue;
+            var _h = tslib_1.__read(pos, 2), rowIdx = _h[0], colIdx = _h[1];
+            var sheetId = parsed.sheetId;
+            var cell = composeCell(doc, key, styles);
+            var row = (_b = next[sheetId]) === null || _b === void 0 ? void 0 : _b[rowIdx];
+            if (!cell && !((_c = row === null || row === void 0 ? void 0 : row.values) === null || _c === void 0 ? void 0 : _c[colIdx]))
+                continue;
+            if (!clonedSheets.has(sheetId)) {
+                next[sheetId] = tslib_1.__spreadArray([], tslib_1.__read(((_d = next[sheetId]) !== null && _d !== void 0 ? _d : [])), false);
+                clonedSheets.add(sheetId);
+            }
+            var sheet = next[sheetId];
+            if (sheet.length <= rowIdx)
+                sheet.length = rowIdx + 1;
+            var rowKey = "".concat(sheetId, ":").concat(rowIdx);
+            if (!clonedRows.has(rowKey)) {
+                var prev = sheet[rowIdx];
+                sheet[rowIdx] = tslib_1.__assign(tslib_1.__assign({}, prev), { values: (prev === null || prev === void 0 ? void 0 : prev.values) ? tslib_1.__spreadArray([], tslib_1.__read(prev.values), false) : [] });
+                clonedRows.add(rowKey);
+            }
+            var values = sheet[rowIdx].values;
+            if (values.length <= colIdx)
+                values.length = colIdx + 1;
+            values[colIdx] = cell;
+            hasChanges = true;
+        }
+    }
+    catch (e_9_1) { e_9 = { error: e_9_1 }; }
+    finally {
+        try {
+            if (_g && !_g.done && (_a = _f.return)) _a.call(_f);
+        }
+        finally { if (e_9) throw e_9.error; }
+    }
+    return hasChanges ? next : null;
+};
+exports.processSheetDataChangesV5 = processSheetDataChangesV5;
+var axisKey = function (sheetId, isRow) {
+    return "".concat(sheetId, ":").concat(isRow ? "R" : "C");
+};
+var writerStyles = function (w) { var _a; return ((_a = w.styles) !== null && _a !== void 0 ? _a : (w.styles = (0, exports.readStyleOverlayV5)(w.doc))); };
+var writerAxis = function (w, sheetId, isRow) {
+    var key = axisKey(sheetId, isRow);
+    var axis = w.axes.get(key);
+    if (!axis) {
+        var ids = (0, exports.readLineIds)(w.doc, sheetId, isRow ? "row" : "column");
+        axis = { ids: ids, maxC0: ids.reduce(function (max, id) { return Math.max(max, c0Counter(id)); }, 0) };
+        w.axes.set(key, axis);
+    }
+    return axis;
+};
+/**
+ * `YrsStore::c0_floor` of every sheet and axis, keyed by `axisKey`: the highest
+ * client-0 counter any hot key (tombstones and orphans too), composed style,
+ * note, dimension or cold block references. One pass over the keys.
+ */
+var c0Floors = function (doc, styles) {
+    var e_10, _a;
+    var floors = new Map();
+    var raise = function (sheetId, isRow, counter) {
+        var _a;
+        var key = axisKey(Number(sheetId), isRow);
+        if (counter > ((_a = floors.get(key)) !== null && _a !== void 0 ? _a : 0))
+            floors.set(key, counter);
+    };
+    var cellKey = function (key) {
+        var match = CELL_KEY_V5.exec(key);
+        if (!match)
+            return;
+        raise(match[1], true, c0Counter(match[2]));
+        raise(match[1], false, c0Counter(match[3]));
+    };
+    try {
+        for (var _b = tslib_1.__values([CELLS_V5, NOTES_V5]), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var name_2 = _c.value;
+            if (doc.share.has(name_2))
+                doc.getMap(name_2).forEach(function (_v, key) { return cellKey(key); });
+        }
+    }
+    catch (e_10_1) { e_10 = { error: e_10_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_10) throw e_10.error; }
+    }
+    styles.forEach(function (_v, key) { return cellKey(key); });
+    if (doc.share.has(DIMS_V5)) {
+        doc.getMap(DIMS_V5).forEach(function (_v, key) {
+            var match = DIM_KEY_V5.exec(key);
+            if (match && idCounter(BigInt(match[3])) !== 0) {
+                raise(match[1], match[2] === "R", c0Counter(match[3]));
+            }
+        });
+    }
+    if (doc.share.has(BLOCKS_V5)) {
+        // Rows: the last offset of each column's highest block (`block_c0_max`).
+        var top_1 = new Map();
+        doc.getMap(BLOCKS_V5).forEach(function (value, key) {
+            var _a, _b;
+            var match = BLOCK_KEY_V5.exec(key);
+            if (!match || idCounter(BigInt(match[2])) === 0)
+                return;
+            raise(match[1], false, c0Counter(match[2]));
+            var block = Number(match[3]);
+            var col = "".concat(match[1], ":").concat(match[2]);
+            if (value instanceof Uint8Array && block >= ((_b = (_a = top_1.get(col)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : -1)) {
+                top_1.set(col, [match[1], block, value]);
+            }
+        });
+        top_1.forEach(function (_a) {
+            var _b = tslib_1.__read(_a, 3), sheetId = _b[0], block = _b[1], buf = _b[2];
+            var offsets = blockRowOffsets(buf);
+            if (offsets.length) {
+                raise(sheetId, true, block * BLOCK_ROWS + Math.max.apply(Math, tslib_1.__spreadArray([], tslib_1.__read(offsets), false)) + 1);
+            }
+        });
+    }
+    return floors;
+};
+/**
+ * The id of 1-based line `pos`, naming every line up to it first: implicit
+ * client-0 ids, counters past the axis's highest client-0 counter and past the
+ * floor (`AxisIndex::ensure_len`), appended at the array's end.
+ */
+var ensureLine = function (w, sheetId, isRow, pos) {
+    var _a;
+    var _b, _c;
+    var axis = writerAxis(w, sheetId, isRow);
+    if (pos > axis.ids.length) {
+        (_b = w.floors) !== null && _b !== void 0 ? _b : (w.floors = c0Floors(w.doc, writerStyles(w)));
+        var start_1 = Math.max(axis.maxC0, (_c = w.floors.get(axisKey(sheetId, isRow))) !== null && _c !== void 0 ? _c : 0) + 1;
+        var counters = Array.from({ length: pos - axis.ids.length }, function (_, i) { return start_1 + i; });
+        w.doc
+            .getArray(lineIdsRootName(sheetId, isRow ? "row" : "column"))
+            .push(counters.map(idValue));
+        (_a = axis.ids).push.apply(_a, tslib_1.__spreadArray([], tslib_1.__read(counters.map(c0Id)), false));
+        axis.maxC0 = start_1 + counters.length - 1;
+    }
+    return axis.ids[pos - 1];
+};
+var validPosition = function (row, col) {
+    return Number.isInteger(row) && Number.isInteger(col) && row >= 1 && col >= 1;
+};
+/** Queues a style op and applies it to the writer's composed plane. */
+var queueStyle = function (w, sheetId, rowId, colId, format) {
+    w.ops.push([sheetId, rowId, colId, format]);
+    var key = (0, exports.createCellKeyV5)(sheetId, rowId, colId);
+    if (format)
+        writerStyles(w).set(key, format);
+    else
+        writerStyles(w).delete(key);
+};
+/**
+ * Writes `cell` at a position. A `uf` that differs from the stored one (the
+ * composed plane's entry, else the inline `uf`) is logged as a replace (a
+ * clear, then the format; a style reference only clears: the engine cannot
+ * resolve it). A note lives in `rncNotes` when the key has an entry there,
+ * inline otherwise. An unchanged cell is not rewritten (its `ft` survives).
+ */
+var writeCell = function (w, sheetId, row, col, cell) {
+    var _a;
+    if (!validPosition(row, col))
+        return;
+    var rowId = ensureLine(w, sheetId, true, row);
+    var colId = ensureLine(w, sheetId, false, col);
+    var key = (0, exports.createCellKeyV5)(sheetId, rowId, colId);
+    var stored = cellDataV5(w.cells.get(key));
+    var format = normalizedFormat((0, utils_1.getCellUserEnteredFormat)(cell));
+    var storedFormat = normalizedFormat((_a = writerStyles(w).get(key)) !== null && _a !== void 0 ? _a : (0, utils_1.getCellUserEnteredFormat)(stored));
+    if (!(0, isEqual_1.default)(format, storedFormat)) {
+        queueStyle(w, sheetId, rowId, colId, null);
+        if (isPlainObject(format) && !isStyleReference(format)) {
+            queueStyle(w, sheetId, rowId, colId, format);
+        }
+    }
+    var next = cell;
+    var notes = w.doc.share.has(NOTES_V5) ? w.doc.getMap(NOTES_V5) : null;
+    if (notes === null || notes === void 0 ? void 0 : notes.has(key)) {
+        var note = cell.note, rest = tslib_1.__rest(cell, ["note"]);
+        if (typeof note === "string" && note) {
+            if (notes.get(key) !== note)
+                notes.set(key, note);
+        }
+        else {
+            notes.delete(key);
+        }
+        next = rest;
+    }
+    if (!stored || !(0, isEqual_1.default)(stored, next))
+        w.cells.set(key, next);
+};
+/**
+ * Removes the cell at a position (`remove_cell`): a hot `null` when a cold block
+ * holds it, else the hot entry is dropped; its composed style is cleared and its
+ * `rncNotes` entry removed. An unnamed position holds nothing.
+ */
+var removeCell = function (w, sheetId, row, col) {
+    if (!validPosition(row, col))
+        return;
+    var rowId = writerAxis(w, sheetId, true).ids[row - 1];
+    var colId = writerAxis(w, sheetId, false).ids[col - 1];
+    if (rowId === undefined || colId === undefined)
+        return;
+    var key = (0, exports.createCellKeyV5)(sheetId, rowId, colId);
+    if (coldCellExists(w.doc, w.offsets, sheetId, rowId, colId)) {
+        if (w.cells.get(key) !== null)
+            w.cells.set(key, null);
+    }
+    else if (w.cells.has(key)) {
+        w.cells.delete(key);
+    }
+    if (writerStyles(w).has(key))
+        queueStyle(w, sheetId, rowId, colId, null);
+    if (w.doc.share.has(NOTES_V5)) {
+        var notes = w.doc.getMap(NOTES_V5);
+        if (notes.has(key))
+            notes.delete(key);
+    }
+};
+/** The cells of a row value (`{ values }`), by 1-based column. */
+var rowCells = function (row) {
+    var e_11, _a;
+    var out = new Map();
+    var values = isPlainObject(row) ? row.values : undefined;
+    if (values && typeof values === "object") {
+        try {
+            for (var _b = tslib_1.__values(Object.entries(values)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = tslib_1.__read(_c.value, 2), col = _d[0], cell = _d[1];
+                if (isPlainObject(cell))
+                    out.set(Number(col), cell);
+            }
+        }
+        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_11) throw e_11.error; }
+        }
+    }
+    return out;
+};
+/** Replaces a whole row: every named column the new row leaves empty is removed. */
+var replaceRow = function (w, sheetId, row, value) {
+    if (!Number.isInteger(row) || row < 1)
+        return;
+    var cells = rowCells(value);
+    var named = writerAxis(w, sheetId, false).ids.length;
+    for (var col = 1; col <= named; col++) {
+        if (!cells.has(col))
+            removeCell(w, sheetId, row, col);
+    }
+    cells.forEach(function (cell, col) { return writeCell(w, sheetId, row, col, cell); });
+};
+var writeSheet = function (w, sheetId, rows) {
+    var e_12, _a;
+    if (!rows || typeof rows !== "object")
+        return;
+    var _loop_1 = function (row, value) {
+        rowCells(value).forEach(function (cell, col) { return writeCell(w, sheetId, Number(row), col, cell); });
+    };
+    try {
+        for (var _b = tslib_1.__values(Object.entries(rows)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var _d = tslib_1.__read(_c.value, 2), row = _d[0], value = _d[1];
+            _loop_1(row, value);
+        }
+    }
+    catch (e_12_1) { e_12 = { error: e_12_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_12) throw e_12.error; }
+    }
+};
+/**
+ * Removes every cell of the matching sheets (`remove_sheet`'s point data): hot
+ * keys (orphans and tombstones too), cold blocks, composed styles (clear ops)
+ * and legacy seed entries, notes. Walks those planes; id arrays and dimensions stay.
+ */
+var clearSheets = function (w, match) {
+    var e_13, _a;
+    var sheetOf = function (key) { return Number(key.slice(0, Math.max(0, key.search(/[:!]/)))); };
+    var drop = function (name) {
+        var e_14, _a;
+        if (!w.doc.share.has(name))
+            return;
+        var map = w.doc.getMap(name);
+        try {
+            for (var _b = tslib_1.__values(Array.from(map.keys())), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var key = _c.value;
+                if (match(sheetOf(key)))
+                    map.delete(key);
+            }
+        }
+        catch (e_14_1) { e_14 = { error: e_14_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_14) throw e_14.error; }
+        }
+    };
+    drop(CELLS_V5);
+    drop(BLOCKS_V5);
+    drop(NOTES_V5);
+    drop(STYLES_SEED_V5);
+    try {
+        for (var _b = tslib_1.__values(Array.from(writerStyles(w).keys())), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var key = _c.value;
+            var parsed = (0, exports.parseCellKeyV5)(key);
+            if (parsed && match(parsed.sheetId)) {
+                queueStyle(w, parsed.sheetId, parsed.rowId, parsed.colId, null);
+            }
+        }
+    }
+    catch (e_13_1) { e_13 = { error: e_13_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_13) throw e_13.error; }
+    }
+    w.offsets.clear();
+};
+/** The cell a nested patch edits: the stored cell as the readers show it. */
+var nestedBase = function (w, sheetId, row, col) {
+    var _a;
+    var rowId = writerAxis(w, sheetId, true).ids[row - 1];
+    var colId = writerAxis(w, sheetId, false).ids[col - 1];
+    if (rowId === undefined || colId === undefined)
+        return {};
+    var key = (0, exports.createCellKeyV5)(sheetId, rowId, colId);
+    if (!w.cells.has(key) && coldCellExists(w.doc, w.offsets, sheetId, rowId, colId)) {
+        return null;
+    }
+    return (_a = composeCell(w.doc, key, writerStyles(w))) !== null && _a !== void 0 ? _a : {};
+};
+var applyPatchV5 = function (w, _a) {
+    var e_15, _b;
+    var op = _a.op, path = _a.path, value = _a.value;
+    if (path.length === 0) {
+        if (op === "replace")
+            clearSheets(w, function () { return true; });
+        if (value && typeof value === "object") {
+            try {
+                for (var _c = tslib_1.__values(Object.entries(value)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var _f = tslib_1.__read(_d.value, 2), sheetId_1 = _f[0], rows = _f[1];
+                    writeSheet(w, Number(sheetId_1), rows);
+                }
+            }
+            catch (e_15_1) { e_15 = { error: e_15_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                }
+                finally { if (e_15) throw e_15.error; }
+            }
+        }
+        return;
+    }
+    var sheetId = Number(path[0]);
+    var row = Number(path[1]);
+    if (path.length > 4) {
+        var col = Number(path[3]);
+        if (!validPosition(row, col))
+            return;
+        var base = nestedBase(w, sheetId, row, col);
+        if (base === null) {
+            // Cold-only cell: its body needs an async inflate, a sync writer cannot merge into it.
+            console.warn("y-spreadsheet v5: nested patch on cold cell ".concat(sheetId, "!R").concat(row, "C").concat(col, " skipped"));
+            return;
+        }
+        var cell = (0, cloneDeep_1.default)(base);
+        var nested = path.slice(4);
+        if (op === "remove") {
+            if (!Object.keys(base).length)
+                return;
+            (0, unset_1.default)(cell, nested);
+        }
+        else {
+            (0, set_1.default)(cell, nested, (0, cloneDeep_1.default)(value));
+        }
+        writeCell(w, sheetId, row, col, cell);
+    }
+    else if (path.length === 3 && path[2] === "values") {
+        if (op !== "remove")
+            replaceRow(w, sheetId, row, { values: value });
+    }
+    else if (path.length === 2) {
+        replaceRow(w, sheetId, row, op === "remove" ? null : value);
+    }
+    else if (path.length === 1) {
+        clearSheets(w, function (id) { return id === sheetId; });
+        if (op !== "remove")
+            writeSheet(w, sheetId, value);
+    }
+};
+/**
+ * Apply immer `SheetData` patches to a v5 doc in one transaction (`origin`, the
+ * caller's; nested in an open transaction it joins that one). Positional, like
+ * the v3 path: a row insert/delete arrives as rewritten rows and is applied as
+ * cell writes/removals at each position's line ids; no line is inserted or
+ * deleted. Writes past an axis name lines (client-0 padding, `ensure_lines`).
+ * `uf` changes append ONE `STYLE_LOG_V2` buffer to `rncCellStylesLog` and stay
+ * inline on the cell. `styles`, when given, is the caller's composed style plane
+ * (`readStyleOverlayV5`), used instead of folding the log and updated in place.
+ */
+var addSheetDataPatchesV5 = function (doc, patches, origin, styles) {
+    if (origin === void 0) { origin = null; }
+    if (!(patches === null || patches === void 0 ? void 0 : patches.length))
+        return;
+    doc.transact(function () {
+        var e_16, _a;
+        var w = {
+            doc: doc,
+            cells: doc.getMap(CELLS_V5),
+            axes: new Map(),
+            floors: null,
+            styles: styles !== null && styles !== void 0 ? styles : null,
+            ops: [],
+            offsets: new Map(),
+        };
+        // Consecutive cell patches are consolidated (the later one wins) but never
+        // reordered across a row-, sheet- or document-level patch (v3 parity).
+        var pending = new Map();
+        var flush = function () {
+            pending.forEach(function (_a) {
+                var _b = tslib_1.__read(_a, 4), sheetId = _b[0], row = _b[1], col = _b[2], cell = _b[3];
+                return cell ? writeCell(w, sheetId, row, col, cell) : removeCell(w, sheetId, row, col);
+            });
+            pending.clear();
+        };
+        try {
+            for (var patches_1 = tslib_1.__values(patches), patches_1_1 = patches_1.next(); !patches_1_1.done; patches_1_1 = patches_1.next()) {
+                var patch = patches_1_1.value;
+                var op = patch.op, path = patch.path, value = patch.value;
+                if (path.length === 4 &&
+                    (op === "replace" || op === "add" || op === "remove")) {
+                    var _b = tslib_1.__read(path.map(Number), 4), sheetId = _b[0], row = _b[1], col = _b[3];
+                    pending.set("".concat(sheetId, ":").concat(row, ":").concat(col), [
+                        sheetId,
+                        row,
+                        col,
+                        op !== "remove" && isPlainObject(value) ? value : null,
+                    ]);
+                    continue;
+                }
+                flush();
+                applyPatchV5(w, patch);
+            }
+        }
+        catch (e_16_1) { e_16 = { error: e_16_1 }; }
+        finally {
+            try {
+                if (patches_1_1 && !patches_1_1.done && (_a = patches_1.return)) _a.call(patches_1);
+            }
+            finally { if (e_16) throw e_16.error; }
+        }
+        flush();
+        if (w.ops.length) {
+            doc.getArray(STYLES_LOG_V5).push([encodeStyleOps(w.ops)]);
+        }
+    }, origin);
+};
+exports.addSheetDataPatchesV5 = addSheetDataPatchesV5;
+/** Set one cell of a v5 doc (see `addSheetDataPatchesV5`). */
+var setCellV5 = function (doc, sheetId, rowIndex, columnIndex, value) {
+    return (0, exports.addSheetDataPatchesV5)(doc, [
+        { op: "replace", path: [sheetId, rowIndex, "values", columnIndex], value: value },
+    ]);
+};
+exports.setCellV5 = setCellV5;
+/** Remove one cell of a v5 doc (see `addSheetDataPatchesV5`). */
+var deleteCellV5 = function (doc, sheetId, rowIndex, columnIndex) {
+    return (0, exports.addSheetDataPatchesV5)(doc, [
+        { op: "remove", path: [sheetId, rowIndex, "values", columnIndex] },
+    ]);
+};
+exports.deleteCellV5 = deleteCellV5;
+/** Remove every cell of a sheet of a v5 doc; its line ids and dimensions stay. */
+var deleteSheetV5 = function (doc, sheetId) {
+    return (0, exports.addSheetDataPatchesV5)(doc, [{ op: "remove", path: [sheetId] }]);
+};
+exports.deleteSheetV5 = deleteSheetV5;