@dou-ui/sheet 0.0.0-stage → 0.1.0-alpha.0

package/dist/core/transaction.js

@@ -0,0 +1,1582 @@
+import { boundsOf, columnIndex, dropReferences, formatRange, moveReferences, parseCell, parseRange, renameReferences, shiftFormula, splitSheet } from "./address.js";
+import { cellOf, colCountOf, compactCell, rowCountOf, valueOf } from "./model.js";
+import { continueValues } from "./fill.js";
+import { mergesOf, overlaps } from "./merge.js";
+import { groupRange, groupSpan, groupsOf } from "./group.js";
+import { sortRows, textCollator } from "./data.js";
+import { rangesOf } from "./conditional.js";
+// src/core/transaction.ts
+/** The lists of rules a sheet keeps, each rule with a `range`. */
+/** Throws when a rule's ranges aren't all ranges. */
+function checkRuleRange(range) {
+	const texts = rangesOf(range);
+	if (!texts.length) throw new RangeError("[@dou-ui/sheet] a rule needs a range");
+	for (const text of texts) if (!parseRange(text)) throw new RangeError(`[@dou-ui/sheet] "${text}" isn't a range`);
+}
+/** A style written the same way whatever order its fields came in. */
+var styleKey = (style) => JSON.stringify(style, Object.keys(style).sort());
+/** What a step calls a sheet: its `id`, or its name when it has none. */
+var sheetKey = (sheet) => sheet.id ?? sheet.name;
+/**
+* A batch of changes. Steps apply as they are added, so later calls see
+* earlier ones; `doc` is the result. Cells and ranges without a sheet are
+* on `sheet` (in the grid, the one shown).
+*/
+var SheetTransaction = class {
+	before;
+	sheet;
+	steps = [];
+	/** What undoes each step, in the order the steps were made. */
+	undoing = [];
+	reversed = null;
+	/** The steps that undo this transaction, in the order to apply them. */
+	get inverse() {
+		this.reversed ??= this.undoing.slice().reverse();
+		return this.reversed;
+	}
+	meta = {};
+	book;
+	/** What this transaction has copied, so it copies each thing once. */
+	own = {
+		book: false,
+		sheets: false,
+		styles: false,
+		types: false
+	};
+	/** The sheets this transaction copied, and the rows it copied of each. */
+	ownSheets = /* @__PURE__ */ new WeakSet();
+	ownRows = /* @__PURE__ */ new WeakMap();
+	constructor(before, sheet = 0) {
+		this.before = before;
+		this.sheet = sheet;
+		this.book = before;
+	}
+	get doc() {
+		return this.book;
+	}
+	/** Whether the change makes any change: it has steps and wasn't cancelled. */
+	get changed() {
+		return this.steps.length > 0 && !this.stopped;
+	}
+	stopped = null;
+	/**
+	* Stops the change: none of it is applied or kept for undo, and the
+	* editor fires `transactionCancel` and says why. For an extension's `transaction`
+	* hook, e.g. to keep people from changing what they may not; hooks after
+	* it don't run. A change kept out of the history (`meta.history: false`),
+	* such as undo, redo or another person's, can't be cancelled and goes ahead.
+	*/
+	cancel(reason) {
+		if (this.meta.history !== false) this.stopped = { reason };
+		else warnUncancellable();
+		return this;
+	}
+	/** Whether `cancel` stopped it. */
+	get cancelled() {
+		return this.stopped !== null;
+	}
+	/** What `cancel` was given, to tell people why. */
+	get cancelReason() {
+		return this.stopped?.reason;
+	}
+	setMeta(meta) {
+		Object.assign(this.meta, meta);
+		return this;
+	}
+	/** The index of a sheet, by index, `id` or name; `-1` when there is none. */
+	indexOf(ref = this.sheet) {
+		const { sheets } = this.book;
+		if (typeof ref === "number") return ref >= 0 && ref < sheets.length ? ref : -1;
+		const byId = sheets.findIndex((sheet) => sheet.id === ref);
+		return byId === -1 ? sheets.findIndex((sheet) => sheet.id == null && sheet.name === ref) : byId;
+	}
+	/** A sheet as it is now in this transaction. */
+	getSheet(ref = this.sheet) {
+		const index = this.indexOf(ref);
+		if (index === -1) throw new RangeError(`[@dou-ui/sheet] there is no sheet "${ref}"`);
+		return this.book.sheets[index];
+	}
+	getCell(at) {
+		const { index, row, col } = this.cellAt(at);
+		return this.book.sheets[index].cells[row]?.[col] ?? void 0;
+	}
+	step(step) {
+		const inverse = this.apply(step);
+		if (inverse) {
+			this.steps.push(step);
+			this.undoing.push(inverse);
+			this.reversed = null;
+		}
+		return this;
+	}
+	/** Replaces a cell; `undefined` empties it. */
+	setCell(at, cell) {
+		const { index, row, col } = this.cellAt(at);
+		return this.step({
+			type: "setCell",
+			sheet: this.keyOf(index),
+			row,
+			col,
+			cell
+		});
+	}
+	/** Changes some of a cell's fields and keeps the rest. */
+	updateCell(at, patch) {
+		const target = this.cellAt(at);
+		const point = {
+			sheet: target.index,
+			row: target.row,
+			col: target.col
+		};
+		return this.setCell(point, compactCell({
+			...cellOf(this.getCell(point)),
+			...patch
+		}));
+	}
+	/** Writes a cell's value and keeps its style and format. */
+	setValue(at, value) {
+		return this.updateCell(at, { value: value ?? void 0 });
+	}
+	/** Empties the values in a range, keeping styles and formats. */
+	clearValues(at) {
+		const { index, bounds } = this.rangeAt(at);
+		const { cells } = this.book.sheets[index];
+		const last = Math.min(bounds.bottom, cells.length - 1);
+		for (let row = bounds.top; row <= last; row++) {
+			const line = cells[row];
+			if (!line) continue;
+			const end = Math.min(bounds.right, line.length - 1);
+			for (let col = bounds.left; col <= end; col++) {
+				const cell = line[col];
+				if (cell != null && cell !== "" && (typeof cell !== "object" || cell.value != null)) this.setValue({
+					sheet: index,
+					row,
+					col
+				}, void 0);
+			}
+		}
+		return this;
+	}
+	/** Writes a cell's note; empty text or `undefined` takes it off. */
+	setNote(at, note) {
+		return this.updateCell(at, { note: note?.trim() ? note : void 0 });
+	}
+	/**
+	* Puts a comment thread on a cell, or takes it off with `undefined`. Use
+	* it with `{ history: false }`: a thread stays when the change before it
+	* is undone.
+	*/
+	setComment(at, id) {
+		return this.updateCell(at, { comment: id || void 0 });
+	}
+	/** Takes the notes off the cells in a range, keeping what they hold. */
+	clearNotes(at) {
+		const { index, bounds } = this.rangeAt(at);
+		const { cells } = this.book.sheets[index];
+		const last = Math.min(bounds.bottom, cells.length - 1);
+		for (let row = bounds.top; row <= last; row++) {
+			const line = cells[row];
+			if (!line) continue;
+			const end = Math.min(bounds.right, line.length - 1);
+			for (let col = bounds.left; col <= end; col++) {
+				const cell = line[col];
+				if (cell && typeof cell === "object" && cell.note != null) this.setNote({
+					sheet: index,
+					row,
+					col
+				}, void 0);
+			}
+		}
+		return this;
+	}
+	/** Sets a row's height or a column's width in px; `undefined` for the default, `0` hides it. */
+	setSize(axis, index, size, sheet) {
+		const key = this.keyOf(this.mustIndex(sheet));
+		return this.step({
+			type: "setSize",
+			sheet: key,
+			axis,
+			index,
+			size
+		});
+	}
+	/** Changes a sheet's name, freeze, row or column count. */
+	updateSheet(patch, sheet) {
+		return this.step({
+			type: "updateSheet",
+			sheet: this.keyOf(this.mustIndex(sheet)),
+			patch
+		});
+	}
+	/** Changes the workbook's own settings, such as `protect`. */
+	updateBook(patch) {
+		return this.step({
+			type: "updateBook",
+			patch
+		});
+	}
+	/**
+	* Protects a sheet, or with `false` stops protecting it: its locked cells
+	* (all but those whose style has `locked: false`) can't be changed, nor
+	* can the sheet's rows, columns and rules, except what `options` allows.
+	*/
+	protectSheet(protect, sheet) {
+		return this.updateSheet({ protect: protect === false ? void 0 : protect }, sheet);
+	}
+	setStyle(name, style) {
+		return this.step({
+			type: "setStyle",
+			name,
+			style
+		});
+	}
+	/** Adds, replaces or (with `undefined`) removes a named cell type, such as a list to pick from. */
+	setType(name, setup) {
+		return this.step({
+			type: "setType",
+			name,
+			setup
+		});
+	}
+	/**
+	* Writes a block of cells with its top left corner at `at`, row by row.
+	* `undefined` in the block empties a cell; a shorter row leaves the cells
+	* past it as they are.
+	*/
+	setCells(at, block) {
+		const { index, row, col } = this.cellAt(at);
+		block.forEach((line, r) => line.forEach((cell, c) => this.setCell({
+			sheet: index,
+			row: row + r,
+			col: col + c
+		}, cell)));
+		return this;
+	}
+	/**
+	* Fills `to` from `from`, the cells it extends down, up, right or left:
+	* each line of cells continues as the fill handle does (see
+	* `continueValues`), with the styles and formats of the cells it repeats.
+	* Formulas are copied with their references moved along. `mode` is
+	* `auto` as dragging does, `series` to count a single number up too, or
+	* `copy` to only repeat, as Ctrl+D does. With `keepStyle`, the filled
+	* cells keep their own styles and formats, as on a protected sheet.
+	*/
+	fill(from, to, options = {}) {
+		const { index, bounds: s } = this.rangeAt(from);
+		const t = this.rangeAt(to).bounds;
+		const vertical = t.left === s.left && t.right === s.right;
+		const horizontal = t.top === s.top && t.bottom === s.bottom;
+		if (vertical && horizontal) return this;
+		let direction;
+		if (vertical && t.top === s.top && t.bottom > s.bottom) direction = "down";
+		else if (vertical && t.bottom === s.bottom && t.top < s.top) direction = "up";
+		else if (horizontal && t.left === s.left && t.right > s.right) direction = "right";
+		else if (horizontal && t.right === s.right && t.left < s.left) direction = "left";
+		else throw new RangeError("[@dou-ui/sheet] the range to fill must extend the cells it is filled from");
+		const down = direction === "down" || direction === "up";
+		const forward = direction === "down" || direction === "right";
+		const count = down ? t.bottom - t.top - (s.bottom - s.top) : t.right - t.left - (s.right - s.left);
+		const length = down ? s.bottom - s.top + 1 : s.right - s.left + 1;
+		const lines = down ? [s.left, s.right] : [s.top, s.bottom];
+		const cells = this.book.sheets[index].cells;
+		for (let line = lines[0]; line <= lines[1]; line++) {
+			const points = Array.from({ length }, (_, i) => {
+				const along = forward ? i : length - 1 - i;
+				return down ? {
+					row: s.top + along,
+					col: line
+				} : {
+					row: line,
+					col: s.left + along
+				};
+			});
+			const sources = points.map((p) => cells[p.row]?.[p.col] ?? void 0);
+			const values = continueValues(sources.map(valueOf), count, {
+				mode: options.mode,
+				back: !forward
+			});
+			for (let i = 0; i < count; i++) {
+				const k = i % length;
+				const origin = points[k];
+				const step = (forward ? 1 : -1) * (length + i - k);
+				const point = down ? {
+					row: origin.row + step,
+					col: line
+				} : {
+					row: line,
+					col: origin.col + step
+				};
+				const source = cellOf(sources[k]);
+				const value = source?.value;
+				const next = typeof value === "string" && value.startsWith("=") ? shiftFormula(value, point.row - origin.row, point.col - origin.col) : values[i];
+				const look = options.keepStyle ? cellOf(cells[point.row]?.[point.col]) : source;
+				const target = {
+					sheet: index,
+					...point
+				};
+				this.setCell(target, compactCell({
+					...source,
+					value: next ?? void 0,
+					style: look?.style,
+					format: look?.format,
+					comment: cellOf(this.getCell(target))?.comment
+				}));
+			}
+		}
+		return this;
+	}
+	/**
+	* Sorts the rows of a range by the values in `keys`' columns; the cells
+	* outside the range stay. `header` keeps the first row in place. Equal rows
+	* keep their order, and empty values go last either way. Formulas move
+	* with their rows and their references move along, as when copied.
+	* `valueAt` gives what a cell comes to, e.g. a formula's result; the value
+	* as written is used without it. Ranges with merged cells are not sorted.
+	*/
+	sortRange(at, keys, options = {}) {
+		const { index, bounds } = this.rangeIn(at);
+		const sheet = this.book.sheets[index];
+		const top = bounds.top + (options.header ? 1 : 0);
+		if (top >= bounds.bottom || !keys.length) return this;
+		const body = {
+			...bounds,
+			top
+		};
+		if (mergesOf(sheet).touching(body).length) throw new RangeError("[@dou-ui/sheet] a range with merged cells cannot be sorted");
+		const rows = Array.from({ length: bounds.bottom - top + 1 }, (_, i) => top + i);
+		const cells = sheet.cells;
+		const valueAt = options.valueAt ?? ((row, col) => valueOf(cells[row]?.[col] ?? void 0));
+		const order = sortRows(rows, keys, valueAt, textCollator(options.lang));
+		const moved = order.map((from) => Array.from({ length: bounds.right - bounds.left + 1 }, (_, c) => cellOf(cells[from]?.[bounds.left + c] ?? void 0)));
+		order.forEach((from, i) => {
+			const to = top + i;
+			if (from === to) return;
+			moved[i].forEach((cell, c) => {
+				const value = cell?.value;
+				const next = typeof value === "string" && value.startsWith("=") ? compactCell({
+					...cell,
+					value: shiftFormula(value, to - from, 0)
+				}) : compactCell(cell);
+				this.setCell({
+					sheet: index,
+					row: to,
+					col: bounds.left + c
+				}, next);
+			});
+		});
+		return this;
+	}
+	/**
+	* Puts a filter on a range, headings in its first row; `null` takes the
+	* filter off, showing the rows it hid. A new range drops the old rules.
+	*/
+	setFilter(at) {
+		if (at == null) {
+			const index = this.mustIndex();
+			if (!this.book.sheets[index].filter) return this;
+			return this.updateSheet({ filter: void 0 }, index);
+		}
+		const { index, bounds } = this.rangeIn(at);
+		const old = this.book.sheets[index].filter;
+		const range = rangeText(bounds);
+		if (old?.range === range) return this;
+		return this.updateSheet({ filter: { range } }, index);
+	}
+	/**
+	* Sets which rows a column of the filter keeps; `undefined` keeps all.
+	* `sorted` marks the column the rows were sorted by, for its button.
+	*/
+	filterColumn(col, rule, sheet = this.sheet) {
+		const index = this.mustIndex(sheet);
+		const filter = this.book.sheets[index].filter;
+		if (!filter) throw new RangeError("[@dou-ui/sheet] the sheet has no filter");
+		const columns = { ...filter.columns };
+		if (rule) columns[col] = rule;
+		else delete columns[col];
+		const next = {
+			...filter,
+			columns: Object.keys(columns).length ? columns : void 0
+		};
+		if (!next.columns) delete next.columns;
+		return this.updateSheet({ filter: next }, index);
+	}
+	/** Remembers the filter column the rows were sorted by, or forgets it with `undefined`. */
+	markSorted(sorted, sheet = this.sheet) {
+		const index = this.mustIndex(sheet);
+		const filter = this.book.sheets[index].filter;
+		if (!filter) return this;
+		const next = {
+			...filter,
+			sorted
+		};
+		if (!sorted) delete next.sorted;
+		return this.updateSheet({ filter: next }, index);
+	}
+	/**
+	* Adds a conditional format after the sheet's others; where two give the
+	* same part of a cell's look, the earlier one wins. The format's `range`
+	* names cells of `sheet`.
+	*/
+	addConditionalFormat(format, sheet = this.sheet) {
+		return this.addRule("conditionalFormats", format, sheet);
+	}
+	/** Sets a sheet's conditional formats, in order, e.g. after moving one up; `[]` removes them all. */
+	setConditionalFormats(formats, sheet = this.sheet) {
+		return this.setRules("conditionalFormats", formats, sheet);
+	}
+	/**
+	* Removes the conditional formats whose cells overlap a range, such as
+	* the selection; without a range, all of the sheet's.
+	*/
+	clearConditionalFormats(at) {
+		return this.clearRules("conditionalFormats", at);
+	}
+	/**
+	* Adds a validation rule after the sheet's others; where two cover a
+	* cell, the earlier one applies. The rule's `range` names cells of `sheet`.
+	*/
+	addValidation(rule, sheet = this.sheet) {
+		return this.addRule("validations", rule, sheet);
+	}
+	/** Sets a sheet's validation rules, in order; `[]` removes them all. */
+	setValidations(rules, sheet = this.sheet) {
+		return this.setRules("validations", rules, sheet);
+	}
+	/**
+	* Removes the validation rules whose cells overlap a range, such as the
+	* selection; without a range, all of the sheet's.
+	*/
+	clearValidations(at) {
+		return this.clearRules("validations", at);
+	}
+	addRule(key, rule, sheet) {
+		const index = this.mustIndex(sheet);
+		checkRuleRange(rule.range);
+		const rules = this.book.sheets[index][key] ?? [];
+		return this.updateSheet({ [key]: [...rules, rule] }, index);
+	}
+	setRules(key, rules, sheet) {
+		const index = this.mustIndex(sheet);
+		for (const rule of rules) checkRuleRange(rule.range);
+		return this.updateSheet({ [key]: rules.length ? [...rules] : void 0 }, index);
+	}
+	clearRules(key, at) {
+		const { index, bounds } = at == null ? {
+			index: this.mustIndex(),
+			bounds: null
+		} : this.rangeAt(at);
+		const rules = this.book.sheets[index][key];
+		if (!rules?.length) return this;
+		const kept = bounds ? rules.filter((rule) => rangesOf(rule.range).every((text) => {
+			const range = parseRange(text);
+			return range && !overlaps(boundsOf(range), bounds);
+		})) : [];
+		if (kept.length === rules.length) return this;
+		return this.updateSheet({ [key]: kept.length ? kept : void 0 }, index);
+	}
+	/**
+	* Groups rows so they can be folded away: `groupRows('3:8')` or
+	* `groupRows(2, 6)`. A group may hold other groups, at most eight deep;
+	* one beside a group of the same level joins it, and one that would cross
+	* a group, or nest too deep, throws a `RangeError`.
+	*/
+	groupRows(at, count, sheet) {
+		const lines = linesOf("row", at, count);
+		return this.groupLines("row", lines.from, lines.count, sheet);
+	}
+	/** Groups columns so they can be folded away: `groupCols('B:D')`. */
+	groupCols(at, count, sheet) {
+		const lines = linesOf("col", at, count);
+		return this.groupLines("col", lines.from, lines.count, sheet);
+	}
+	/**
+	* Takes rows out of their groups: the groups that lie within them go (the
+	* outer ones, when groups nest); without any, the rows leave the innermost
+	* group they are in, which may split it in two.
+	*/
+	ungroupRows(at, count, sheet) {
+		const lines = linesOf("row", at, count);
+		return this.ungroupLines("row", lines.from, lines.count, sheet);
+	}
+	/** Takes columns out of their groups, as `ungroupRows` does rows. */
+	ungroupCols(at, count, sheet) {
+		const lines = linesOf("col", at, count);
+		return this.ungroupLines("col", lines.from, lines.count, sheet);
+	}
+	/** Folds a group away: `collapseGroup('3:8')`, `range` being the group's rows or columns. */
+	collapseGroup(range, sheet) {
+		return this.foldGroup(range, true, sheet);
+	}
+	/** Shows a folded group again: `expandGroup('3:8')`. */
+	expandGroup(range, sheet) {
+		return this.foldGroup(range, false, sheet);
+	}
+	foldGroup(range, collapsed, sheet = this.sheet) {
+		const index = this.mustIndex(sheet);
+		const data = this.book.sheets[index];
+		const span = groupSpan(range);
+		const group = span && groupsOf(data).axis(span.axis).find(span.start, span.end);
+		if (!group) throw new RangeError(`[@dou-ui/sheet] there is no group "${range}"`);
+		if (group.collapsed === collapsed) return this;
+		return this.setGroups(index, (g, i) => i === group.index ? {
+			...g,
+			collapsed
+		} : g);
+	}
+	/**
+	* Shows the groups of an axis down to a level, as the outline's level
+	* buttons do: level 1 folds every group, level 2 shows the outer groups
+	* with theirs folded, and one past the deepest shows them all.
+	*/
+	showGroupLevel(axis, level, sheet = this.sheet) {
+		const index = this.mustIndex(sheet);
+		const laid = groupsOf(this.book.sheets[index]).axis(axis);
+		const fold = /* @__PURE__ */ new Map();
+		for (const g of laid.list) if (g.collapsed !== g.depth >= level) fold.set(g.index, !g.collapsed);
+		if (!fold.size) return this;
+		return this.setGroups(index, (g, i) => fold.has(i) ? {
+			...g,
+			collapsed: fold.get(i)
+		} : g);
+	}
+	groupLines(axis, from, count, ref) {
+		if (count <= 0) return this;
+		const index = this.mustIndex(ref);
+		const data = this.book.sheets[index];
+		let start = from;
+		let end = from + count - 1;
+		const laid = groupsOf(data).axis(axis);
+		if (laid.find(start, end)) return this;
+		const problem = laid.problem(start, end);
+		if (problem === "deep") throw new RangeError(`[@dou-ui/sheet] "${groupRange(axis, start, end)}" would nest more than eight deep`);
+		if (problem) {
+			const other = groupRange(axis, problem.cross.start, problem.cross.end);
+			throw new RangeError(`[@dou-ui/sheet] "${groupRange(axis, start, end)}" would cross the group "${other}"`);
+		}
+		const joined = /* @__PURE__ */ new Set();
+		for (const g of laid.beside(start, end)) {
+			joined.add(g.index);
+			start = Math.min(start, g.start);
+			end = Math.max(end, g.end);
+		}
+		const kept = (data.groups ?? []).filter((_, i) => !joined.has(i));
+		return this.updateSheet({ groups: [...kept, { range: groupRange(axis, start, end) }] }, index);
+	}
+	ungroupLines(axis, from, count, ref) {
+		if (count <= 0) return this;
+		const index = this.mustIndex(ref);
+		const data = this.book.sheets[index];
+		const laid = groupsOf(data).axis(axis);
+		const end = from + count - 1;
+		const within = laid.list.filter((g) => g.start >= from && g.end <= end);
+		if (within.length) {
+			const gone = /* @__PURE__ */ new Set();
+			for (const g of within) if (!within.some((o) => o !== g && o.depth < g.depth && o.start <= g.start && o.end >= g.end)) gone.add(g.index);
+			return this.setGroups(index, (g, i) => gone.has(i) ? null : g);
+		}
+		const touching = laid.list.filter((g) => g.start <= end && g.end >= from);
+		if (!touching.length) return this;
+		const deepest = Math.max(...touching.map((g) => g.depth));
+		const parts = /* @__PURE__ */ new Map();
+		for (const g of touching) {
+			if (g.depth !== deepest) continue;
+			const group = data.groups[g.index];
+			const split = [];
+			const keep = (a, b) => split.push({
+				...group,
+				range: groupRange(axis, a, b)
+			});
+			if (g.start < from) keep(g.start, from - 1);
+			if (g.end > end) keep(end + 1, g.end);
+			parts.set(g.index, split);
+		}
+		return this.setGroups(index, (g, i) => parts.get(i) ?? g);
+	}
+	/** Rewrites a sheet's groups: each to itself, another, several or none. */
+	setGroups(index, map) {
+		const next = [];
+		this.book.sheets[index].groups?.forEach((g, i) => {
+			const out = map(g, i);
+			if (Array.isArray(out)) next.push(...out);
+			else if (out) next.push(out);
+		});
+		return this.updateSheet({ groups: next.length ? next : void 0 }, index);
+	}
+	/**
+	* Adds empty rows before `at`: `insertRows(4, 2)` or `insertRows('5:6')`
+	* both add two rows where row 5 was. Frozen rows and the row count grow
+	* with them, and formulas pointing below follow their cells.
+	*/
+	insertRows(at, count, sheet) {
+		const lines = linesOf("row", at, count);
+		return this.insertLines("row", lines.from, lines.count, sheet);
+	}
+	/** Adds empty columns before `at`, `insertCols('C')` or `insertCols(2)`. */
+	insertCols(at, count, sheet) {
+		const lines = linesOf("col", at, count);
+		return this.insertLines("col", lines.from, lines.count, sheet);
+	}
+	/**
+	* Removes rows with their cells and heights: `deleteRows('5:7')` or
+	* `deleteRows(4, 3)`. Formulas pointing at them read `#REF!`.
+	*/
+	deleteRows(at, count, sheet) {
+		const lines = linesOf("row", at, count);
+		return this.deleteLines("row", lines.from, lines.count, sheet);
+	}
+	/** Removes columns with their cells and widths: `deleteCols('B:C')`. */
+	deleteCols(at, count, sheet) {
+		const lines = linesOf("col", at, count);
+		return this.deleteLines("col", lines.from, lines.count, sheet);
+	}
+	/**
+	* Moves rows to before row `to`, numbered as before the move:
+	* `moveRows('2:3', '6')` puts rows 2 and 3 above what was row 6.
+	* Formulas pointing at them follow.
+	*/
+	moveRows(lines, to, sheet) {
+		const { from, count } = linesOf("row", lines);
+		return this.moveLines("row", from, count, linesOf("row", to).from, sheet);
+	}
+	/** Moves columns to before column `to`: `moveCols('C', 'A')`. */
+	moveCols(lines, to, sheet) {
+		const { from, count } = linesOf("col", lines);
+		return this.moveLines("col", from, count, linesOf("col", to).from, sheet);
+	}
+	/**
+	* Moves a block of cells so its top left corner is at `to`, as cutting
+	* and pasting does: the cells at `from` empty, those at `to` are
+	* replaced, and formulas pointing at the block follow it.
+	*/
+	moveCells(from, to) {
+		const source = this.rangeAt(from);
+		const target = this.cellAt(to);
+		const b = source.bounds;
+		const rows = target.row - b.top;
+		const cols = target.col - b.left;
+		if (rows === 0 && cols === 0 && source.index === target.index) return this;
+		const cells = this.book.sheets[source.index].cells;
+		const block = Array.from({ length: b.bottom - b.top + 1 }, (_, r) => Array.from({ length: b.right - b.left + 1 }, (_cell, c) => cells[b.top + r]?.[b.left + c]));
+		for (let r = b.top; r <= b.bottom; r++) for (let c = b.left; c <= b.right; c++) this.setCell({
+			sheet: source.index,
+			row: r,
+			col: c
+		}, void 0);
+		this.setCells(target, block);
+		const dest = {
+			top: target.row,
+			left: target.col,
+			bottom: b.bottom + rows,
+			right: b.right + cols
+		};
+		const sourceName = this.book.sheets[source.index].name;
+		const destName = this.book.sheets[target.index].name;
+		const same = sourceName === destName;
+		this.rewriteReferences(destName, (r) => inside(r, dest) && !(same && inside(r, b)) ? null : r);
+		this.rewriteReferences(sourceName, (r) => {
+			if (!inside(r, b)) return r;
+			const moved = {
+				top: r.top + rows,
+				left: r.left + cols,
+				bottom: r.bottom + rows,
+				right: r.right + cols
+			};
+			return same ? moved : {
+				sheet: destName,
+				bounds: moved
+			};
+		});
+		return this;
+	}
+	insertLines(axis, index, count, ref) {
+		if (count <= 0) return this;
+		const at = this.mustIndex(ref);
+		const sheet = this.book.sheets[at];
+		this.step({
+			type: "insertLines",
+			sheet: this.keyOf(at),
+			axis,
+			index,
+			count
+		});
+		this.updateSheet(linesPatch(sheet, axis, (n) => n > index ? n + count : n, count), at);
+		const add = (n) => n >= index ? n + count : n;
+		return this.moveRanges(at, lineMap(axis, (a, b) => [add(a), add(b)]));
+	}
+	deleteLines(axis, index, count, ref) {
+		if (count <= 0) return this;
+		const at = this.mustIndex(ref);
+		const sheet = this.book.sheets[at];
+		this.step({
+			type: "removeLines",
+			sheet: this.keyOf(at),
+			axis,
+			index,
+			count
+		});
+		const left = (n) => n - Math.max(0, Math.min(n, index + count) - index);
+		this.updateSheet(linesPatch(sheet, axis, left, -count), at);
+		const end = index + count;
+		return this.moveRanges(at, lineMap(axis, (a, b) => {
+			if (a >= index && b < end) return null;
+			return [a < index ? a : a >= end ? a - count : index, b < index ? b : b >= end ? b - count : index - 1];
+		}));
+	}
+	moveLines(axis, from, count, to, ref) {
+		if (count <= 0 || to >= from && to <= from + count) return this;
+		const at = this.mustIndex(ref);
+		this.step({
+			type: "moveLines",
+			sheet: this.keyOf(at),
+			axis,
+			from,
+			count,
+			to
+		});
+		const place = movedIndex(from, count, to);
+		return this.moveRanges(at, lineMap(axis, (a, b) => {
+			const x = place(a);
+			const y = place(b);
+			return [Math.min(x, y), Math.max(x, y)];
+		}));
+	}
+	/**
+	* After rows or columns of a sheet change: rewrites formulas pointing at
+	* it, and moves its merged cells, dropping those that are gone or now
+	* one cell.
+	*/
+	moveRanges(index, map) {
+		const sheet = this.book.sheets[index];
+		this.rewriteReferences(sheet.name, map);
+		this.moveFilter(index, map);
+		this.moveRules("conditionalFormats", index, map);
+		this.moveRules("validations", index, map);
+		this.moveGroups(index, map);
+		const merges = sheet.merges;
+		if (!merges?.length) return this;
+		const next = [];
+		for (const text of merges) {
+			const range = parseRange(text);
+			if (!range) continue;
+			const moved = map(boundsOf(range));
+			if (!moved) continue;
+			const b = "bounds" in moved ? moved.bounds : moved;
+			if (b.top === b.bottom && b.left === b.right) continue;
+			next.push(rangeText(b));
+		}
+		return next.length === merges.length && next.every((m, i) => m === merges[i]) ? this : this.updateSheet({ merges: next.length ? next : void 0 }, index);
+	}
+	/** Moves a sheet's rules with their cells; a rule goes when its cells do. */
+	moveRules(key, index, map) {
+		const rules = this.book.sheets[index][key];
+		if (!rules?.length) return;
+		const next = [];
+		for (const rule of rules) {
+			const texts = [];
+			for (const text of rangesOf(rule.range)) {
+				const range = parseRange(text);
+				const moved = range && map(boundsOf(range));
+				if (moved) texts.push(rangeText("bounds" in moved ? moved.bounds : moved));
+			}
+			if (!texts.length) continue;
+			const range = Array.isArray(rule.range) ? texts : texts[0];
+			const same = Array.isArray(rule.range) ? texts.length === rule.range.length && texts.every((t, i) => t === rule.range[i]) : range === rule.range;
+			next.push(same ? rule : {
+				...rule,
+				range
+			});
+		}
+		if (next.length !== rules.length || next.some((rule, i) => rule !== rules[i])) this.updateSheet({ [key]: next.length ? next : void 0 }, index);
+	}
+	/** Moves a sheet's groups with their lines; a group goes when its lines do. */
+	moveGroups(index, map) {
+		const groups = this.book.sheets[index].groups;
+		if (!groups?.length) return;
+		const next = [];
+		for (const group of groups) {
+			const range = parseRange(group.range);
+			const moved = range && map(boundsOf(range));
+			if (!moved) continue;
+			const text = rangeText("bounds" in moved ? moved.bounds : moved);
+			next.push(text === group.range ? group : {
+				...group,
+				range: text
+			});
+		}
+		if (next.length !== groups.length || next.some((g, i) => g !== groups[i])) this.updateSheet({ groups: next.length ? next : void 0 }, index);
+	}
+	/** Moves a sheet's filter with its rows and columns; it goes when its range does. */
+	moveFilter(index, map) {
+		const filter = this.book.sheets[index].filter;
+		if (!filter) return;
+		const range = parseRange(filter.range);
+		const moved = range && map(boundsOf(range));
+		if (!moved) {
+			this.updateSheet({ filter: void 0 }, index);
+			return;
+		}
+		const b = "bounds" in moved ? moved.bounds : moved;
+		const columns = {};
+		for (const [key, rule] of Object.entries(filter.columns ?? {})) {
+			const col = Number(key);
+			const to = map({
+				top: b.top,
+				bottom: b.top,
+				left: col,
+				right: col
+			});
+			if (!to) continue;
+			const at = "bounds" in to ? to.bounds : to;
+			if (at.left === at.right) columns[at.left] = rule;
+		}
+		const next = { range: rangeText(b) };
+		if (Object.keys(columns).length) next.columns = columns;
+		if (filter.sorted) {
+			const col = filter.sorted.col;
+			const to = map({
+				top: b.top,
+				bottom: b.top,
+				left: col,
+				right: col
+			});
+			const at = to && ("bounds" in to ? to.bounds : to);
+			if (at && at.left === at.right) next.sorted = {
+				...filter.sorted,
+				col: at.left
+			};
+		}
+		if (JSON.stringify(next) !== JSON.stringify(filter)) this.updateSheet({ filter: next }, index);
+	}
+	/**
+	* Merges a range into one cell. Merges it touches are taken into it. The
+	* top left cell keeps its content; the values of the other cells are
+	* cleared, keeping their styles, unless `keep` leaves them hidden under the
+	* merge, to show again when it is split.
+	*/
+	mergeCells(at, options = {}) {
+		const { index, bounds } = this.rangeAt(at);
+		const sheet = this.book.sheets[index];
+		const b = mergesOf(sheet).expand(bounds);
+		if (b.top === b.bottom && b.left === b.right) return this;
+		if (!options.keep) {
+			for (let row = b.top; row <= b.bottom; row++) for (let col = b.left; col <= b.right; col++) if ((row !== b.top || col !== b.left) && valueOf(sheet.cells[row]?.[col]) != null) this.setValue({
+				sheet: index,
+				row,
+				col
+			}, void 0);
+		}
+		const kept = (sheet.merges ?? []).filter((text) => {
+			const range = parseRange(text);
+			return !range || !overlaps(boundsOf(range), b);
+		});
+		return this.updateSheet({ merges: [...kept, rangeText(b)] }, index);
+	}
+	/** Splits the merged cells a range touches back into single cells. */
+	unmergeCells(at) {
+		const { index, bounds } = this.rangeAt(at);
+		const sheet = this.book.sheets[index];
+		if (!sheet.merges?.length) return this;
+		const kept = sheet.merges.filter((text) => {
+			const range = parseRange(text);
+			return !range || !overlaps(boundsOf(range), bounds);
+		});
+		if (kept.length === sheet.merges.length) return this;
+		return this.updateSheet({ merges: kept.length ? kept : void 0 }, index);
+	}
+	/**
+	* Changes how the cells in a range look: each cell's style with `patch`
+	* laid over it, where a field set to `undefined` (or `false`, but for
+	* `locked`) is taken off; `null` takes the whole style off. Cells that end up looking the
+	* same share one style: one in `styles` that matches, or a new one named
+	* `s1`, `s2`…. Whole columns and rows stop at the sheet's edge.
+	*/
+	styleCells(at, patch) {
+		const { index, bounds } = this.rangeIn(at);
+		const next = /* @__PURE__ */ new Map();
+		for (let row = bounds.top; row <= bounds.bottom; row++) for (let col = bounds.left; col <= bounds.right; col++) {
+			const point = {
+				sheet: index,
+				row,
+				col
+			};
+			const style = cellOf(this.getCell(point))?.style;
+			if (!next.has(style)) next.set(style, this.styleFor(style, patch));
+			const name = next.get(style);
+			if (name !== style) this.updateCell(point, { style: name });
+		}
+		return this;
+	}
+	/**
+	* Sets the number or date format of the cells in a range (`undefined`
+	* for none), or changes each with a function of its format and value,
+	* such as `(format, value) => changeDecimals(format, value, 1)`.
+	*/
+	formatCells(at, format) {
+		const { index, bounds } = this.rangeIn(at);
+		for (let row = bounds.top; row <= bounds.bottom; row++) for (let col = bounds.left; col <= bounds.right; col++) {
+			const point = {
+				sheet: index,
+				row,
+				col
+			};
+			const input = this.getCell(point);
+			const old = cellOf(input)?.format;
+			const value = typeof format === "function" ? format(old, valueOf(input)) : format;
+			if ((value || void 0) !== old) this.updateCell(point, { format: value || void 0 });
+		}
+		return this;
+	}
+	/** The name of a style that looks like `name`'s with `patch` laid over it. */
+	styleFor(name, patch) {
+		const styles = this.book.styles ?? {};
+		const style = {};
+		if (patch) {
+			for (const [key, value] of Object.entries({
+				...name ? styles[name] : void 0,
+				...patch
+			})) if (value !== void 0 && (value !== false || key === "locked") && value !== "") style[key] = value;
+		}
+		const key = styleKey(style);
+		if (key === "{}") return void 0;
+		if (name && styles[name] && styleKey(styles[name]) === key) return name;
+		for (const [other, look] of Object.entries(styles)) if (styleKey(look) === key) return other;
+		let n = 1;
+		while (styles[`s${n}`]) n++;
+		this.setStyle(`s${n}`, style);
+		return `s${n}`;
+	}
+	/**
+	* Adds a sheet, at the end or at `index`. Its name must not be taken
+	* (`uniqueName` gives one that isn't); it is `Sheet1`, `Sheet2`… when
+	* left out, whatever the language. Returns the transaction; the new sheet
+	* is `tr.getSheet(name)`.
+	*/
+	addSheet(sheet = {}, index = this.book.sheets.length) {
+		const name = sheet.name ?? this.freeName("Sheet");
+		this.checkName(name, sheet.id);
+		const data = {
+			...sheet,
+			name,
+			cells: sheet.cells ?? []
+		};
+		return this.step({
+			type: "insertSheet",
+			index,
+			data
+		});
+	}
+	/**
+	* Removes a sheet. The last one stays: a workbook always has a sheet.
+	* Formulas on other sheets pointing at it read `#REF!`.
+	*/
+	removeSheet(sheet = this.sheet) {
+		const index = this.mustIndex(sheet);
+		if (this.book.sheets.length < 2) return this;
+		const { name } = this.book.sheets[index];
+		this.step({
+			type: "removeSheet",
+			sheet: this.keyOf(index)
+		});
+		return this.rewriteFormulas((formula) => dropReferences(formula, name));
+	}
+	/** Moves a sheet to `index`, counted among the sheets without it. */
+	moveSheet(sheet, index) {
+		return this.step({
+			type: "moveSheet",
+			sheet: this.keyOf(this.mustIndex(sheet)),
+			index
+		});
+	}
+	/** Renames a sheet; formulas naming it follow. The name must not be taken. */
+	renameSheet(sheet, name) {
+		const index = this.mustIndex(sheet);
+		const old = this.book.sheets[index];
+		if (old.name === name) return this;
+		this.checkName(name, old.id, index);
+		this.updateSheet({ name }, index);
+		return this.rewriteFormulas((formula) => renameReferences(formula, old.name, name));
+	}
+	/**
+	* Adds a copy of a sheet right after it, named `name` or the sheet's name
+	* with a number, such as `数据 (2)`. Formulas on the copy that name the
+	* sheet keep pointing at the original.
+	*/
+	duplicateSheet(sheet = this.sheet, name) {
+		const index = this.mustIndex(sheet);
+		const original = this.book.sheets[index];
+		const { id: _id, ...source } = original;
+		this.ownSheets.delete(original);
+		this.ownRows.delete(original);
+		const next = name ?? this.uniqueName(source.name);
+		this.checkName(next);
+		return this.step({
+			type: "insertSheet",
+			index: index + 1,
+			data: {
+				...source,
+				name: next
+			}
+		});
+	}
+	/**
+	* `name` if no sheet has it, otherwise the name with the first free
+	* number: `门店 (2)`, `门店 (3)`…
+	*/
+	uniqueName(name) {
+		const taken = new Set(this.book.sheets.map((sheet) => sheet.name));
+		if (!taken.has(name)) return name;
+		let n = 2;
+		while (taken.has(`${name} (${n})`)) n++;
+		return `${name} (${n})`;
+	}
+	/** Passes every formula of the workbook through `rewrite`. */
+	rewriteFormulas(rewrite) {
+		this.book.sheets.forEach((sheet, index) => sheet.cells.forEach((line, row) => line?.forEach((cell, col) => {
+			const value = typeof cell === "object" ? cell?.value : cell;
+			if (typeof value !== "string" || !value.startsWith("=")) return;
+			const next = rewrite(value);
+			if (next !== value) this.setValue({
+				sheet: index,
+				row,
+				col
+			}, next);
+		})));
+		return this.rewriteRuleFormulas((formula) => rewrite(formula));
+	}
+	/**
+	* Rewrites the formulas of every sheet's rules: conditional formats' and
+	* validations' formulas, and the references of validation lists.
+	*/
+	rewriteRuleFormulas(rewrite) {
+		this.book.sheets.forEach((sheet, index) => {
+			for (const key of ["conditionalFormats", "validations"]) {
+				const rules = sheet[key];
+				if (!rules?.length) continue;
+				let changed = false;
+				const next = rules.map((rule) => {
+					if ("formula" in rule) {
+						const formula = rewrite(rule.formula, sheet);
+						if (formula === rule.formula) return rule;
+						changed = true;
+						return {
+							...rule,
+							formula
+						};
+					}
+					if ("list" in rule && typeof rule.list === "string") {
+						const list = rewrite(rule.list, sheet);
+						if (list === rule.list) return rule;
+						changed = true;
+						return {
+							...rule,
+							list
+						};
+					}
+					return rule;
+				});
+				if (changed) this.updateSheet({ [key]: next }, index);
+			}
+		});
+		return this;
+	}
+	/** The first name `prefix` + a number, from the count of sheets on, that no sheet has. */
+	freeName(prefix) {
+		const taken = new Set(this.book.sheets.map((sheet) => sheet.name));
+		let n = this.book.sheets.length + 1;
+		while (taken.has(`${prefix}${n}`)) n++;
+		return `${prefix}${n}`;
+	}
+	checkName(name, id, self = -1) {
+		if (!name.trim()) throw new RangeError("[@dou-ui/sheet] a sheet needs a name");
+		this.book.sheets.forEach((sheet, i) => {
+			if (i === self) return;
+			if (sheet.name === name) throw new RangeError(`[@dou-ui/sheet] there is a sheet "${name}" already`);
+			if (id != null && sheet.id === id) throw new RangeError(`[@dou-ui/sheet] there is a sheet "${id}" already`);
+		});
+	}
+	/** Rewrites the references to cells on sheet `name` in every formula of the workbook. */
+	rewriteReferences(name, map) {
+		this.book.sheets.forEach((sheet, index) => {
+			sheet.cells.forEach((line, row) => line?.forEach((cell, col) => {
+				const value = typeof cell === "object" ? cell?.value : cell;
+				if (typeof value !== "string" || !value.startsWith("=")) return;
+				const next = moveReferences(value, sheet.name, name, map);
+				if (next !== value) this.setValue({
+					sheet: index,
+					row,
+					col
+				}, next);
+			}));
+		});
+		return this.rewriteRuleFormulas((formula, sheet) => moveReferences(formula, sheet.name, name, map));
+	}
+	mustIndex(ref = this.sheet) {
+		const index = this.indexOf(ref);
+		if (index === -1) throw new RangeError(`[@dou-ui/sheet] there is no sheet "${ref}"`);
+		return index;
+	}
+	keyOf(index) {
+		return sheetKey(this.book.sheets[index]);
+	}
+	cellAt(at) {
+		if (typeof at === "string") {
+			const { sheet, ref } = splitSheet(at);
+			const point = parseCell(ref);
+			if (!point) throw new RangeError(`[@dou-ui/sheet] "${at}" isn't a cell`);
+			return {
+				index: this.mustIndex(sheet),
+				...point
+			};
+		}
+		return {
+			index: this.mustIndex(at.sheet),
+			row: at.row,
+			col: at.col
+		};
+	}
+	rangeAt(at) {
+		let sheet;
+		let bounds;
+		if (typeof at === "string") {
+			const split = splitSheet(at);
+			sheet = split.sheet;
+			const range = parseRange(split.ref);
+			if (!range) throw new RangeError(`[@dou-ui/sheet] "${at}" isn't a range`);
+			bounds = boundsOf(range);
+		} else {
+			sheet = at.sheet;
+			bounds = "start" in at ? boundsOf(at) : {
+				top: at.top,
+				left: at.left,
+				bottom: at.bottom,
+				right: at.right
+			};
+		}
+		return {
+			index: this.mustIndex(sheet),
+			bounds
+		};
+	}
+	/** A range kept inside its sheet, so whole columns and rows end at its edge. */
+	rangeIn(at) {
+		const { index, bounds } = this.rangeAt(at);
+		const sheet = this.book.sheets[index];
+		return {
+			index,
+			bounds: {
+				top: Math.max(0, bounds.top),
+				left: Math.max(0, bounds.left),
+				bottom: Math.min(rowCountOf(sheet) - 1, bounds.bottom),
+				right: Math.min(colCountOf(sheet) - 1, bounds.right)
+			}
+		};
+	}
+	/** Applies a step, returning the step that undoes it, or `null` when nothing changes. */
+	apply(step) {
+		if (step.type === "setStyle") {
+			const old = this.book.styles?.[step.name];
+			if (old === step.style) return null;
+			const book = this.ownBook();
+			const styles = this.own.styles ? book.styles : { ...book.styles };
+			this.own.styles = true;
+			if (step.style) styles[step.name] = step.style;
+			else delete styles[step.name];
+			book.styles = styles;
+			return {
+				type: "setStyle",
+				name: step.name,
+				style: old
+			};
+		}
+		if (step.type === "setType") {
+			const old = this.book.types?.[step.name];
+			if (old === step.setup) return null;
+			const book = this.ownBook();
+			const types = this.own.types ? book.types : { ...book.types };
+			this.own.types = true;
+			if (step.setup) types[step.name] = step.setup;
+			else delete types[step.name];
+			book.types = types;
+			return {
+				type: "setType",
+				name: step.name,
+				setup: old
+			};
+		}
+		if (step.type === "updateBook") {
+			const book = this.book;
+			const old = {};
+			let changed = false;
+			for (const [key, value] of Object.entries(step.patch)) {
+				old[key] = book[key];
+				if (book[key] !== value) changed = true;
+			}
+			if (!changed) return null;
+			const own = this.ownBook();
+			for (const [key, value] of Object.entries(step.patch)) if (value === void 0) delete own[key];
+			else own[key] = value;
+			return {
+				type: "updateBook",
+				patch: old
+			};
+		}
+		if (step.type === "insertSheet") {
+			const sheets = this.ownList();
+			const index = Math.max(0, Math.min(sheets.length, step.index));
+			sheets.splice(index, 0, step.data);
+			return {
+				type: "removeSheet",
+				sheet: sheetKey(step.data)
+			};
+		}
+		const index = this.mustIndex(step.sheet);
+		const sheet = this.book.sheets[index];
+		switch (step.type) {
+			case "removeSheet":
+				this.ownList().splice(index, 1);
+				this.ownSheets.delete(sheet);
+				this.ownRows.delete(sheet);
+				return {
+					type: "insertSheet",
+					index,
+					data: sheet
+				};
+			case "moveSheet": {
+				const sheets = this.book.sheets;
+				const to = Math.max(0, Math.min(sheets.length - 1, step.index));
+				if (to === index) return null;
+				const list = this.ownList();
+				list.splice(index, 1);
+				list.splice(to, 0, sheet);
+				return {
+					type: "moveSheet",
+					sheet: step.sheet,
+					index
+				};
+			}
+			case "setCell": {
+				const { row, col } = step;
+				const cell = step.cell ?? void 0;
+				const old = sheet.cells[row]?.[col] ?? void 0;
+				if (old === cell || old == null && cell == null) return null;
+				this.row(index, row)[col] = cell;
+				return {
+					...step,
+					cell: old
+				};
+			}
+			case "setSize": {
+				const key = step.axis === "row" ? "rowSizes" : "colSizes";
+				const sizes = sheet[key];
+				const old = sizes?.[step.index];
+				if (old === step.size) return null;
+				const next = { ...sizes };
+				if (step.size == null) delete next[step.index];
+				else next[step.index] = step.size;
+				this.ownSheet(index)[key] = next;
+				return {
+					...step,
+					size: old
+				};
+			}
+			case "updateSheet": {
+				const old = {};
+				let changed = false;
+				for (const key of Object.keys(step.patch)) {
+					old[key] = sheet[key];
+					if (sheet[key] !== step.patch[key]) changed = true;
+				}
+				if (!changed) return null;
+				const own = this.ownSheet(index);
+				for (const [key, value] of Object.entries(step.patch)) if (value === void 0) delete own[key];
+				else own[key] = value;
+				return {
+					type: "updateSheet",
+					sheet: this.keyOf(index),
+					patch: old
+				};
+			}
+			case "insertLines": return this.insertAt(index, step);
+			case "removeLines": return this.removeAt(index, step);
+			case "moveLines": return this.moveAt(index, step);
+		}
+	}
+	insertAt(index, step) {
+		const { axis, count } = step;
+		const at = step.index;
+		const own = this.ownSheet(index);
+		const fill = step.cells;
+		if (axis === "row") {
+			if (at < own.cells.length || fill?.some((line) => line?.length)) {
+				while (own.cells.length < at) own.cells.push(null);
+				own.cells.splice(at, 0, ...Array.from({ length: count }, (_, i) => fill?.[i] ?? null));
+			}
+			this.ownRows.delete(own);
+		} else {
+			const length = Math.max(own.cells.length, fill?.length ?? 0);
+			for (let r = 0; r < length; r++) {
+				const line = own.cells[r];
+				const part = fill?.[r];
+				if (!part?.length && (!line || line.length <= at)) continue;
+				const next = this.row(index, r);
+				while (next.length < at) next.push(void 0);
+				next.splice(at, 0, ...Array.from({ length: count }, (_, i) => part?.[i] ?? void 0));
+			}
+		}
+		shiftSizes(own, axis, (n) => n >= at ? n + count : n, at, step.sizes);
+		return {
+			type: "removeLines",
+			sheet: step.sheet,
+			axis,
+			index: at,
+			count
+		};
+	}
+	removeAt(index, step) {
+		const { axis, count } = step;
+		const at = step.index;
+		const own = this.ownSheet(index);
+		let cells;
+		if (axis === "row") {
+			if (at < own.cells.length) cells = own.cells.splice(at, count).map((line) => line ?? null);
+			this.ownRows.delete(own);
+		} else {
+			for (let r = 0; r < own.cells.length; r++) {
+				const line = own.cells[r];
+				if (!line || line.length <= at) continue;
+				const removed = this.row(index, r).splice(at, count);
+				if (removed.some((cell) => cell != null)) (cells ??= [])[r] = removed;
+			}
+			if (cells) for (let r = 0; r < cells.length; r++) cells[r] ??= null;
+		}
+		const old = own[axis === "row" ? "rowSizes" : "colSizes"];
+		let sizes;
+		if (old) {
+			for (let i = 0; i < count; i++) if (old[at + i] != null) (sizes ??= Array(count).fill(null))[i] = old[at + i];
+		}
+		shiftSizes(own, axis, (n) => n < at ? n : n >= at + count ? n - count : -1);
+		const inverse = {
+			type: "insertLines",
+			sheet: step.sheet,
+			axis,
+			index: at,
+			count
+		};
+		if (cells) inverse.cells = cells;
+		if (sizes) inverse.sizes = sizes;
+		return inverse;
+	}
+	moveAt(index, step) {
+		const { axis, from, count, to } = step;
+		const own = this.ownSheet(index);
+		const place = movedIndex(from, count, to);
+		const reorder = (list, empty) => {
+			const end = Math.max(from + count, to);
+			if (list.length <= Math.min(from, to)) return list;
+			const out = list.slice();
+			while (out.length < end) out.push(empty);
+			for (let i = Math.min(from, to); i < end; i++) out[place(i)] = list[i] ?? empty;
+			while (out.length && out[out.length - 1] == null) out.pop();
+			return out;
+		};
+		if (axis === "row") {
+			own.cells = reorder(own.cells, null);
+			this.ownRows.delete(own);
+		} else for (let r = 0; r < own.cells.length; r++) {
+			const line = own.cells[r];
+			if (!line || line.length <= Math.min(from, to)) continue;
+			const next = reorder(line, void 0);
+			if (next !== line) own.cells[r] = next;
+		}
+		shiftSizes(own, axis, place);
+		const back = to > from ? to - count : to;
+		return {
+			type: "moveLines",
+			sheet: step.sheet,
+			axis,
+			from: back,
+			count,
+			to: to > from ? from : from + count
+		};
+	}
+	ownBook() {
+		if (!this.own.book) {
+			this.book = { ...this.book };
+			this.own.book = true;
+		}
+		return this.book;
+	}
+	/** The list of sheets as an array this transaction may change. */
+	ownList() {
+		const book = this.ownBook();
+		if (!this.own.sheets) {
+			book.sheets = book.sheets.slice();
+			this.own.sheets = true;
+		}
+		return book.sheets;
+	}
+	ownSheet(index) {
+		const book = this.ownBook();
+		this.ownList();
+		let sheet = book.sheets[index];
+		if (!this.ownSheets.has(sheet)) {
+			sheet = book.sheets[index] = {
+				...sheet,
+				cells: sheet.cells.slice()
+			};
+			this.ownSheets.add(sheet);
+		}
+		return sheet;
+	}
+	/** The row as an array this transaction may change. */
+	row(sheet, row) {
+		const own = this.ownSheet(sheet);
+		let rows = this.ownRows.get(own);
+		if (!rows) this.ownRows.set(own, rows = /* @__PURE__ */ new Set());
+		if (!rows.has(row)) {
+			own.cells[row] = own.cells[row]?.slice() ?? [];
+			rows.add(row);
+		}
+		return own.cells[row];
+	}
+};
+var rangeText = (b) => formatRange({
+	start: {
+		row: b.top,
+		col: b.left
+	},
+	end: {
+		row: b.bottom,
+		col: b.right
+	}
+});
+/** Whether `x` lies inside `y`. */
+var inside = (x, y) => x.top >= y.top && x.bottom <= y.bottom && x.left >= y.left && x.right <= y.right;
+/** Rows or columns written as a number, `'5:7'` or `'B:C'`, as a first line and a count. */
+function linesOf(axis, at, count) {
+	if (typeof at === "number") return {
+		from: at,
+		count: count ?? 1
+	};
+	if (typeof at === "object") return at;
+	const [a = "", b = a, extra] = at.replaceAll("$", "").trim().split(":");
+	const line = (text) => axis === "row" ? /^[1-9]\d*$/.test(text) ? Number(text) - 1 : -1 : columnIndex(text);
+	const first = line(a);
+	const last = line(b);
+	if (extra != null || first < 0 || last < 0) throw new RangeError(`[@dou-ui/sheet] "${at}" isn't ${axis === "row" ? "rows" : "columns"}`);
+	return {
+		from: Math.min(first, last),
+		count: count ?? Math.abs(last - first) + 1
+	};
+}
+/**
+* A reference map for a change to rows or columns: `span` gives a range's
+* new first and last line on that axis, or `null` when they are gone.
+* Whole rows are not touched by a change to columns, and so on.
+*/
+function lineMap(axis, span) {
+	return (b) => {
+		const [a, z] = axis === "row" ? [b.top, b.bottom] : [b.left, b.right];
+		if (a === 0 && z === Infinity) return b;
+		const next = span(a, z === Infinity ? a : z);
+		if (!next) return null;
+		const last = z === Infinity ? Infinity : next[1];
+		return axis === "row" ? {
+			...b,
+			top: next[0],
+			bottom: last
+		} : {
+			...b,
+			left: next[0],
+			right: last
+		};
+	};
+}
+/** Where line `i` ends up when `count` lines from `from` move to before `to`. */
+function movedIndex(from, count, to) {
+	return (i) => {
+		if (i >= from && i < from + count) return to > from ? i - from + to - count : i - from + to;
+		if (to > from && i >= from + count && i < to) return i - count;
+		if (to < from && i >= to && i < from) return i + count;
+		return i;
+	};
+}
+/** Renumbers a sheet's changed sizes; a number below 0 drops the size. */
+function shiftSizes(sheet, axis, to, insertAt, inserted) {
+	const key = axis === "row" ? "rowSizes" : "colSizes";
+	const old = sheet[key];
+	if (!old && !inserted?.some((size) => size != null)) return;
+	const next = {};
+	for (const [n, size] of Object.entries(old ?? {})) {
+		const moved = to(Number(n));
+		if (moved >= 0) next[moved] = size;
+	}
+	inserted?.forEach((size, i) => {
+		if (size != null) next[insertAt + i] = size;
+	});
+	sheet[key] = next;
+}
+/** The frozen count and line count after lines are added or removed. */
+function linesPatch(sheet, axis, frozen, change) {
+	const patch = {};
+	const countKey = axis === "row" ? "rowCount" : "colCount";
+	const freezeKey = axis === "row" ? "rows" : "cols";
+	const count = sheet[countKey];
+	if (count != null) patch[countKey] = Math.max(1, count + change);
+	const freeze = sheet.freeze?.[freezeKey];
+	if (freeze) {
+		const next = frozen(freeze);
+		if (next !== freeze) patch.freeze = {
+			...sheet.freeze,
+			[freezeKey]: next
+		};
+	}
+	return patch;
+}
+/** Applies steps to a workbook, as one transaction. */
+function applySheetSteps(doc, steps) {
+	const tr = new SheetTransaction(doc);
+	for (const step of steps) tr.step(step);
+	return tr;
+}
+var keyOf = (step) => {
+	switch (step.type) {
+		case "setCell": return `c${step.sheet}:${step.row}:${step.col}`;
+		case "setSize": return `s${step.sheet}:${step.axis}:${step.index}`;
+		case "setStyle": return `y${step.name}`;
+		case "setType": return `t${step.name}`;
+		default: return null;
+	}
+};
+/**
+* The same changes in fewer steps: of several steps writing the same cell,
+* size or style, keeps only the last, which is the one that counts.
+*/
+function compactSheetSteps(steps) {
+	const out = [];
+	const at = /* @__PURE__ */ new Map();
+	for (const step of steps) {
+		const key = keyOf(step);
+		if (key == null) {
+			at.clear();
+			out.push(step);
+			continue;
+		}
+		const index = at.get(key);
+		if (index == null) {
+			at.set(key, out.length);
+			out.push(step);
+		} else out[index] = step;
+	}
+	return out;
+}
+var warnedUncancellable = false;
+/** Says once that cancelling a change kept out of the history does nothing. */
+function warnUncancellable() {
+	if (process.env.NODE_ENV === "production" || warnedUncancellable) return;
+	warnedUncancellable = true;
+	console.warn("[@dou-ui/sheet] a change kept out of the history (undo, redo or another person's) can't be cancelled; it goes ahead");
+}
+export { SheetTransaction, applySheetSteps, compactSheetSteps, movedIndex, sheetKey };
+
+//# sourceMappingURL=transaction.js.map