@ai-matrx/office 0.6.0 → 0.8.0

package/dist/collab-sheets-transform.cjs

@@ -0,0 +1,789 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/collab/sheets/transform/index.ts
+var transform_exports = {};
+__export(transform_exports, {
+  CONTENT_KEYS: () => CONTENT_KEYS,
+  PAIR_BARRIERS: () => PAIR_BARRIERS,
+  SHEET_MUTATIONS: () => SHEET_MUTATIONS,
+  SHEET_TRANSFORMER_VERSION: () => SHEET_TRANSFORMER_VERSION,
+  allowParams: () => allowParams,
+  cellRef: () => cellRef,
+  completeCellContent: () => completeCellContent,
+  exactMergeRemovals: () => exactMergeRemovals,
+  isBarrier: () => isBarrier,
+  mapIndex: () => mapIndex,
+  mergeThrough: () => mergeThrough,
+  sheetTransformer: () => sheetTransformer,
+  transformAxis: () => transformAxis,
+  transformGroup: () => transformGroup,
+  transformMutation: () => transformMutation
+});
+module.exports = __toCommonJS(transform_exports);
+
+// src/collab/sheets/transform/types.ts
+var isBarrier = (r) => r.barrier === true;
+
+// src/collab/sheets/transform/registry.ts
+var covered = (family, ...allow) => ({ kind: "covered", family, allow: ["subUnitId", ...allow] });
+var never = (reason) => ({ kind: "never-travels", reason });
+var barrier = (until, reason) => ({ kind: "barrier", until, reason });
+var FORMULA_RESULT = "formula engine output; every seat computes it (dropped at capture)";
+var FORMULA = "formula state; C5b rewrites references";
+var RESOURCE = "ranged resource keyed by id; C5c";
+var UNIVER_COMMENTS = "Univer's own thread-comment store; our comments anchor elsewhere (design \xA78)";
+var SHEET_MUTATIONS = {
+  // ── covered (C5a) ────────────────────────────────────────────────────────────────────────────────
+  "sheet.mutation.set-range-values": covered("cell", "cellValue"),
+  "sheet.mutation.insert-row": covered("structure", "range", "rowInfo"),
+  "sheet.mutation.remove-rows": covered("structure", "range"),
+  "sheet.mutation.insert-col": covered("structure", "range", "colInfo"),
+  "sheet.mutation.remove-col": covered("structure", "range"),
+  "sheet.mutation.move-rows": covered("structure", "sourceRange", "targetRange"),
+  "sheet.mutation.move-columns": covered("structure", "sourceRange", "targetRange"),
+  "sheet.mutation.add-worksheet-merge": covered("merge", "ranges"),
+  "sheet.mutation.remove-worksheet-merge": covered("merge", "ranges"),
+  "sheet.mutation.set-worksheet-row-height": covered("size", "ranges", "rowHeight"),
+  "sheet.mutation.set-worksheet-row-is-auto-height": covered("size", "ranges", "autoHeightInfo"),
+  "sheet.mutation.set-worksheet-row-auto-height": covered("size", "rowsAutoHeightInfo"),
+  "sheet.mutation.set-worksheet-col-width": covered("size", "ranges", "colWidth"),
+  "sheet.mutation.set-worksheet-name": covered("name", "name"),
+  // ── never travels ────────────────────────────────────────────────────────────────────────────────
+  "formula.mutation.set-formula-calculation-start": never(FORMULA_RESULT),
+  "formula.mutation.set-trigger-formula-calculation-start": never(FORMULA_RESULT),
+  "formula.mutation.set-formula-calculation-stop": never(FORMULA_RESULT),
+  "formula.mutation.set-formula-calculation-notification": never(FORMULA_RESULT),
+  "formula.mutation.set-formula-calculation-result": never(FORMULA_RESULT),
+  "formula.mutation.set-array-formula-data": never(FORMULA_RESULT),
+  "formula.mutation.set-formula-data": never(FORMULA_RESULT),
+  "formula.mutation.set-image-formula-data": never(FORMULA_RESULT),
+  "formula.mutation.set-formula-string-batch-calculation": never(FORMULA_RESULT),
+  "formula.mutation.set-formula-string-batch-calculation-result": never(FORMULA_RESULT),
+  "formula.mutation.set-formula-dependency-calculation": never(FORMULA_RESULT),
+  "formula.mutation.set-formula-dependency-calculation-result": never(FORMULA_RESULT),
+  "formula.mutation.set-cell-formula-dependency-calculation": never(FORMULA_RESULT),
+  "formula.mutation.set-cell-formula-dependency-calculation-result": never(FORMULA_RESULT),
+  "formula.mutation.set-query-formula-dependency": never(FORMULA_RESULT),
+  "formula.mutation.set-query-formula-dependency-result": never(FORMULA_RESULT),
+  "formula.mutation.set-query-formula-dependency-all": never(FORMULA_RESULT),
+  "formula.mutation.set-query-formula-dependency-all-result": never(FORMULA_RESULT),
+  "formula.mutation.register-function": never("registers a function body on this seat's engine"),
+  "sheet.mutation.data-validation-formula-mark-dirty": never("dirty mark"),
+  "sheet.mutation.mark-dirty-filter-change": never("dirty mark"),
+  "sheet.mutation.re-calc-filter": never("filter recalculation result"),
+  "sheet.mutation.toggle-note-popup": never("popup state"),
+  "sheet.operation.clear-drawing-transformer": never("drawing selection handles (declared as a mutation)"),
+  "sheet.mutation.copy-worksheet-end": never("end marker of a copy; the copy travels as insert-sheet"),
+  "sheet.mutation.empty": never("no content"),
+  "thread-comment.mutation.add-comment": never(UNIVER_COMMENTS),
+  "thread-comment.mutation.update-comment": never(UNIVER_COMMENTS),
+  "thread-comment.mutation.update-comment-ref": never(UNIVER_COMMENTS),
+  "thread-comment.mutation.resolve-comment": never(UNIVER_COMMENTS),
+  "thread-comment.mutation.delete-comment": never(UNIVER_COMMENTS),
+  // ── barriers: X (no transform yet, design §10) ───────────────────────────────────────────────────
+  "sheet.mutation.reorder-range": barrier("X", "sort: a permutation, not transformed yet"),
+  "sheet.mutation.set-worksheet-row-count": barrier("X", "absolute row count; needs delta semantics"),
+  "sheet.mutation.set-worksheet-column-count": barrier("X", "absolute column count; needs delta semantics"),
+  "sheet.mutation.set-worksheet-order": barrier("X", "absolute sheet order; needs move semantics"),
+  "sheet.mutation.move-range": barrier("X", "cut-paste carries the sender's cell matrices"),
+  "sheet.mutation.insert-sheet": barrier("X", "sheet add: not in C5a"),
+  "sheet.mutation.remove-sheet": barrier("X", "sheet remove: not in C5a"),
+  "sheet.mutation.set-worksheet-hidden": barrier("X", "sheet-level setting: not in C5a"),
+  "sheet.mutation.set-tab-color": barrier("X", "sheet-level setting: not in C5a"),
+  "sheet.mutation.set-workbook-name": barrier("X", "workbook-level setting: not in C5a"),
+  "sheet.mutation.set-worksheet-right-to-left": barrier("X", "sheet-level setting: not in C5a"),
+  "sheet.mutation.toggle-gridlines": barrier("X", "sheet-level setting: not in C5a"),
+  "sheet.mutation.set-gridlines-color": barrier("X", "sheet-level setting: not in C5a"),
+  "sheet.mutation.set-worksheet-default-style": barrier("X", "sheet-level setting: not in C5a"),
+  "sheet.mutation.set-frozen": barrier("X", "absolute frozen indices: not in C5a"),
+  "sheet.mutation.set-row-data": barrier("X", "row properties by index: not in C5a"),
+  "sheet.mutation.set-col-data": barrier("X", "column properties by index: not in C5a"),
+  "sheet.mutation.set-row-hidden": barrier("X", "row visibility: not in C5a"),
+  "sheet.mutation.set-row-visible": barrier("X", "row visibility: not in C5a"),
+  "sheet.mutation.set-col-hidden": barrier("X", "column visibility: not in C5a"),
+  "sheet.mutation.set-col-visible": barrier("X", "column visibility: not in C5a"),
+  "sheet.mutation.set.numfmt": barrier("X", "number formats by range: not in C5a"),
+  "sheet.mutation.remove.numfmt": barrier("X", "number formats by range: not in C5a"),
+  "sheet.mutation.add-range-protection": barrier("X", "permissions: not in C5a"),
+  "sheet.mutation.set-range-protection": barrier("X", "permissions: not in C5a"),
+  "sheet.mutation.delete-range-protection": barrier("X", "permissions: not in C5a"),
+  "sheet.mutation.add-worksheet-protection": barrier("X", "permissions: not in C5a"),
+  "sheet.mutation.set-worksheet-protection": barrier("X", "permissions: not in C5a"),
+  "sheet.mutation.delete-worksheet-protection": barrier("X", "permissions: not in C5a"),
+  "sheet.mutation.set-worksheet-permission-points": barrier("X", "permissions: not in C5a"),
+  // ── barriers until C5b (formulas) ────────────────────────────────────────────────────────────────
+  "formula.mutation.set-defined-name": barrier("C5b", FORMULA),
+  "formula.mutation.remove-defined-name": barrier("C5b", FORMULA),
+  "formula.mutation.set-feature-calculation": barrier("C5b", FORMULA),
+  "formula.mutation.remove-feature-calculation": barrier("C5b", FORMULA),
+  "formula.mutation.set-other-formula": barrier("C5b", FORMULA),
+  "formula.mutation.remove-other-formula": barrier("C5b", FORMULA),
+  "formula.mutation.set-super-table": barrier("C5b", FORMULA),
+  "formula.mutation.remove-super-table": barrier("C5b", FORMULA),
+  "formula.mutation.set-super-table-option": barrier("C5b", FORMULA),
+  // ── barriers until C5c (ranged resources) ────────────────────────────────────────────────────────
+  "sheet.mutation.add-conditional-rule": barrier("C5c", RESOURCE),
+  "sheet.mutation.set-conditional-rule": barrier("C5c", RESOURCE),
+  "sheet.mutation.delete-conditional-rule": barrier("C5c", RESOURCE),
+  "sheet.mutation.move-conditional-rule": barrier("C5c", "conditional-format priority (ordered list)"),
+  "data-validation.mutation.addRule": barrier("C5c", RESOURCE),
+  "data-validation.mutation.updateRule": barrier("C5c", RESOURCE),
+  "data-validation.mutation.removeRule": barrier("C5c", RESOURCE),
+  "sheet.mutation.set-filter-range": barrier("C5c", RESOURCE),
+  "sheet.mutation.set-filter-criteria": barrier("C5c", RESOURCE),
+  "sheet.mutation.remove-filter": barrier("C5c", RESOURCE),
+  "sheet.mutation.add-table": barrier("C5c", RESOURCE),
+  "sheet.mutation.delete-table": barrier("C5c", RESOURCE),
+  "sheet.mutation.set-sheet-table": barrier("C5c", RESOURCE),
+  "sheet.mutation.set-table-filter": barrier("C5c", RESOURCE),
+  "sheet.mutation.move-table": barrier("C5c", RESOURCE),
+  "sheets.mutation.add-hyper-link": barrier("C5c", RESOURCE),
+  "sheets.mutation.remove-hyper-link": barrier("C5c", RESOURCE),
+  "sheets.mutation.update-hyper-link": barrier("C5c", RESOURCE),
+  "sheets.mutation.update-hyper-link-ref": barrier("C5c", RESOURCE),
+  "sheets.mutation.update-rich-hyper-link": barrier("C5c", RESOURCE),
+  "sheet.mutation.update-note": barrier("C5c", RESOURCE),
+  "sheet.mutation.remove-note": barrier("C5c", RESOURCE),
+  "sheet.mutation.update-note-position": barrier("C5c", RESOURCE),
+  "sheet.mutation.set-drawing-apply": barrier("C5c", RESOURCE),
+  "sheet.mutation.set-worksheet-background-image": barrier("C5c", RESOURCE),
+  "sheet.mutation.add-range-theme": barrier("C5c", RESOURCE),
+  "sheet.mutation.set-range-theme": barrier("C5c", RESOURCE),
+  "sheet.mutation.remove-range-theme": barrier("C5c", RESOURCE),
+  "sheet.mutation.set-worksheet-range-theme-style": barrier("C5c", RESOURCE),
+  "sheet.mutation.remove-worksheet-range-theme-style": barrier("C5c", RESOURCE),
+  "sheet.mutation.register-worksheet-range-theme-style": barrier("C5c", RESOURCE),
+  "sheet.mutation.unregister-worksheet-range-theme-style": barrier("C5c", RESOURCE)
+};
+function allowParams(id, params) {
+  const entry = SHEET_MUTATIONS[id];
+  if (!entry || entry.kind !== "covered") return null;
+  const out = {};
+  for (const f of entry.allow) if (params[f] !== void 0) out[f] = params[f];
+  return out;
+}
+
+// src/collab/sheets/transform/transform.ts
+var import_sheets = require("@univerjs/sheets");
+
+// src/collab/sheets/transform/axis.ts
+function isNoopMove(op) {
+  return op.count <= 0 || op.to >= op.from && op.to <= op.from + op.count;
+}
+function movedBlockStart(op) {
+  return op.to > op.from ? op.to - op.count : op.to;
+}
+function mapIndex(op, i) {
+  switch (op.kind) {
+    case "insert":
+      return i >= op.at ? i + op.count : i;
+    case "remove":
+      if (i < op.start) return i;
+      if (i < op.start + op.count) return null;
+      return i - op.count;
+    case "move": {
+      if (isNoopMove(op)) return i;
+      const { from, count, to } = op;
+      if (i >= from && i < from + count) return movedBlockStart(op) + (i - from);
+      if (to > from) return i >= from + count && i < to ? i - count : i;
+      return i >= to && i < from ? i + count : i;
+    }
+  }
+}
+function runs(indices) {
+  const sorted = [...new Set(indices)].sort((a, b) => a - b);
+  const out = [];
+  for (const i of sorted) {
+    const last = out[out.length - 1];
+    if (last && last.start + last.count === i) last.count++;
+    else out.push({ start: i, count: 1 });
+  }
+  return out;
+}
+function mapGapThroughMove(p, mv) {
+  const { from, count, to } = mv;
+  if (p > from && p < from + count) return movedBlockStart(mv) + (p - from);
+  const g = p <= from ? p : p - count;
+  const tg = to <= from ? to : to - count;
+  return g <= tg ? g : g + count;
+}
+function transformAxis(x, y, side) {
+  if (y.kind === "move" && isNoopMove(y)) return [x];
+  if (x.kind === "move" && isNoopMove(x)) return [];
+  switch (x.kind) {
+    case "insert": {
+      if (y.kind === "insert") {
+        if (x.at < y.at || x.at === y.at && side === "left") return [x];
+        return [{ ...x, at: x.at + y.count }];
+      }
+      if (y.kind === "remove") {
+        if (x.at <= y.start) return [x];
+        if (x.at >= y.start + y.count) return [{ ...x, at: x.at - y.count }];
+        return [{ ...x, at: y.start }];
+      }
+      return [{ ...x, at: mapGapThroughMove(x.at, y) }];
+    }
+    case "remove": {
+      const kept = [];
+      for (let i = x.start; i < x.start + x.count; i++) {
+        const m = mapIndex(y, i);
+        if (m !== null) kept.push(m);
+      }
+      if (y.kind === "insert" || y.kind === "remove" || y.kind === "move") {
+        return runs(kept).reverse().map((r) => ({ kind: "remove", start: r.start, count: r.count }));
+      }
+      return null;
+    }
+    case "move": {
+      if (y.kind === "insert") {
+        const inside = y.at > x.from && y.at < x.from + x.count;
+        const from = inside || y.at > x.from ? x.from : x.from + y.count;
+        const count = inside ? x.count + y.count : x.count;
+        const to2 = x.to >= y.at ? x.to + y.count : x.to;
+        const out2 = { kind: "move", from, count, to: to2 };
+        return isNoopMove(out2) ? [] : [out2];
+      }
+      if (y.kind === "remove") {
+        const kept = [];
+        for (let i = x.from; i < x.from + x.count; i++) {
+          const m = mapIndex(y, i);
+          if (m !== null) kept.push(m);
+        }
+        if (kept.length === 0) return [];
+        const r2 = runs(kept);
+        if (r2.length !== 1) return null;
+        const to2 = x.to <= y.start ? x.to : x.to >= y.start + y.count ? x.to - y.count : y.start;
+        const out2 = { kind: "move", from: r2[0].start, count: r2[0].count, to: to2 };
+        return isNoopMove(out2) ? [] : [out2];
+      }
+      const overlap = Math.min(x.from + x.count, y.from + y.count) - Math.max(x.from, y.from);
+      if (overlap > 0) {
+        if (x.from !== y.from || x.count !== y.count) return null;
+        if (side === "right") return [];
+        const out2 = { kind: "move", from: movedBlockStart(y), count: x.count, to: mapGapThroughMove(x.to, y) };
+        return isNoopMove(out2) ? [] : [out2];
+      }
+      const mapped = [];
+      for (let i = x.from; i < x.from + x.count; i++) mapped.push(mapIndex(y, i));
+      const r = runs(mapped);
+      if (r.length !== 1) return null;
+      let to;
+      if (x.to > y.from && x.to < y.from + y.count) to = movedBlockStart(y) + (x.to - y.from);
+      else to = mapGapThroughMove(x.to, y) + (x.to === y.to && side === "right" ? y.count : 0);
+      const out = { kind: "move", from: r[0].start, count: r[0].count, to };
+      if (to > out.from && to < out.from + out.count) return null;
+      return isNoopMove(out) ? [] : [out];
+    }
+  }
+}
+
+// src/collab/sheets/transform/transform.ts
+var SHEET_TRANSFORMER_VERSION = "c5a-1";
+var ID = {
+  values: "sheet.mutation.set-range-values",
+  insertRow: "sheet.mutation.insert-row",
+  removeRows: "sheet.mutation.remove-rows",
+  insertCol: "sheet.mutation.insert-col",
+  removeCol: "sheet.mutation.remove-col",
+  moveRows: "sheet.mutation.move-rows",
+  moveCols: "sheet.mutation.move-columns",
+  addMerge: "sheet.mutation.add-worksheet-merge",
+  removeMerge: "sheet.mutation.remove-worksheet-merge",
+  rowHeight: "sheet.mutation.set-worksheet-row-height",
+  rowIsAuto: "sheet.mutation.set-worksheet-row-is-auto-height",
+  rowAutoHeight: "sheet.mutation.set-worksheet-row-auto-height",
+  colWidth: "sheet.mutation.set-worksheet-col-width",
+  name: "sheet.mutation.set-worksheet-name"
+};
+var PAIR_BARRIERS = {};
+var pairKey = (a, b) => a < b ? `${a}|${b}` : `${b}|${a}`;
+var barrier2 = (reason) => ({ barrier: true, reason });
+var ok = (op, lost = [], dropped = []) => ({ op, lost, dropped });
+var flip = (side) => side === "left" ? "right" : "left";
+var sheetOf = (m) => String(m.params.subUnitId ?? "");
+function colName(c) {
+  let s = "";
+  for (let n = c + 1; n > 0; n = Math.floor((n - 1) / 26)) s = String.fromCharCode(65 + (n - 1) % 26) + s;
+  return s;
+}
+var cellRef = (sheet, row, col) => `${sheet}!${colName(col)}${row + 1}`;
+var rangeRef = (sheet, r) => `${sheet}!${colName(r.startColumn)}${r.startRow + 1}:${colName(r.endColumn)}${r.endRow + 1}`;
+function structuralOf(m) {
+  const p = m.params;
+  switch (m.id) {
+    case ID.insertRow:
+      return { axis: "row", op: { kind: "insert", at: p.range.startRow, count: p.range.endRow - p.range.startRow + 1 } };
+    case ID.removeRows:
+      return { axis: "row", op: { kind: "remove", start: p.range.startRow, count: p.range.endRow - p.range.startRow + 1 } };
+    case ID.insertCol:
+      return { axis: "col", op: { kind: "insert", at: p.range.startColumn, count: p.range.endColumn - p.range.startColumn + 1 } };
+    case ID.removeCol:
+      return { axis: "col", op: { kind: "remove", start: p.range.startColumn, count: p.range.endColumn - p.range.startColumn + 1 } };
+    case ID.moveRows:
+      return {
+        axis: "row",
+        op: { kind: "move", from: p.sourceRange.startRow, count: p.sourceRange.endRow - p.sourceRange.startRow + 1, to: p.targetRange.startRow }
+      };
+    case ID.moveCols:
+      return {
+        axis: "col",
+        op: {
+          kind: "move",
+          from: p.sourceRange.startColumn,
+          count: p.sourceRange.endColumn - p.sourceRange.startColumn + 1,
+          to: p.targetRange.startColumn
+        }
+      };
+    default:
+      return null;
+  }
+}
+var S = (axis) => axis === "row" ? ["startRow", "endRow"] : ["startColumn", "endColumn"];
+function buildStructural(template, axis, op) {
+  const [a0, a1] = S(axis);
+  const p = template.params;
+  if (op.kind === "move") {
+    const src = p.sourceRange;
+    const tgt = p.targetRange;
+    return {
+      id: template.id,
+      params: {
+        ...p,
+        sourceRange: { ...src, [a0]: op.from, [a1]: op.from + op.count - 1 },
+        targetRange: { ...tgt, [a0]: op.to, [a1]: op.to + op.count - 1 }
+      }
+    };
+  }
+  const start = op.kind === "insert" ? op.at : op.start;
+  return { id: template.id, params: { ...p, range: { ...p.range, [a0]: start, [a1]: start + op.count - 1 } } };
+}
+function univerMutationInfo(axis, op) {
+  const FULL = { startRow: 0, endRow: Number.MAX_SAFE_INTEGER, startColumn: 0, endColumn: Number.MAX_SAFE_INTEGER };
+  const start = op.kind === "insert" ? op.at : op.start;
+  const range = axis === "row" ? { ...FULL, startRow: start, endRow: start + op.count - 1 } : { ...FULL, startColumn: start, endColumn: start + op.count - 1 };
+  const id = op.kind === "insert" ? axis === "row" ? ID.insertRow : ID.insertCol : axis === "row" ? ID.removeRows : ID.removeCol;
+  return { id, params: { unitId: "", subUnitId: "", range } };
+}
+var intersects = (a, b) => a.startRow <= b.endRow && b.startRow <= a.endRow && a.startColumn <= b.endColumn && b.startColumn <= a.endColumn;
+var isSingleCell = (r) => r.startRow === r.endRow && r.startColumn === r.endColumn;
+function mergeThrough(s, m) {
+  const [a0, a1] = S(s.axis);
+  const lo = m[a0];
+  const hi = m[a1];
+  const op = s.op;
+  if (op.kind === "insert") {
+    const fixup = lo < op.at && op.at <= hi;
+    return { range: (0, import_sheets.adjustRangeOnMutation)(m, univerMutationInfo(s.axis, op)), fixup };
+  }
+  if (op.kind === "remove") {
+    const e = op.start + op.count - 1;
+    if (e < lo || op.start > hi) return { range: (0, import_sheets.adjustRangeOnMutation)(m, univerMutationInfo(s.axis, op)), fixup: false };
+    if (op.start <= lo && e >= hi) return { range: null, fixup: true };
+    const r = { ...m };
+    if (op.start >= lo && e <= hi) r[a1] = hi - op.count;
+    else if (op.start < lo) {
+      r[a0] = op.start;
+      r[a1] = hi - op.count;
+    } else r[a1] = op.start - 1;
+    return { range: isSingleCell(r) ? null : r, fixup: true };
+  }
+  const fe = op.from + op.count - 1;
+  if (hi < op.from || lo > fe) {
+    const r = { ...m };
+    if (op.from < lo && op.to > hi) {
+      r[a0] = lo - op.count;
+      r[a1] = hi - op.count;
+    } else if (op.from > hi && op.to <= lo) {
+      r[a0] = lo + op.count;
+      r[a1] = hi + op.count;
+    }
+    return { range: r, fixup: false };
+  }
+  if (lo >= op.from && hi <= fe) {
+    const r = { ...m, [a0]: mapIndex(op, lo), [a1]: mapIndex(op, hi) };
+    return { range: r, fixup: true };
+  }
+  return { range: m, fixup: false };
+}
+function exactMergeRemovals(group, merges) {
+  const sim = new Map(Object.entries(merges).map(([k, v]) => [k, v.map((r) => ({ ...r }))]));
+  const out = [];
+  for (const m of group) {
+    const sheet = sheetOf(m);
+    const cur = sim.get(sheet) ?? [];
+    if (m.id === ID.removeMerge) {
+      const hit = cur.filter((q) => mergeRanges(m).some((r) => intersects(r, q)));
+      sim.set(sheet, cur.filter((q) => !hit.includes(q)));
+      if (hit.length) out.push(withRanges(m, hit.map((r) => ({ ...r }))));
+      continue;
+    }
+    if (m.id === ID.addMerge) sim.set(sheet, [...cur, ...mergeRanges(m).map((r) => ({ ...r }))]);
+    const st = structuralOf(m);
+    if (st) sim.set(sheet, cur.map((q) => mergeThrough(st, q).range).filter((q) => q !== null));
+    out.push(m);
+  }
+  return out;
+}
+var mergeRanges = (m) => m.params.ranges ?? [];
+var withRanges = (m, ranges) => ({ id: m.id, params: { ...m.params, ranges } });
+var mergeMutation = (id, sheet, ranges) => ({ id, params: { subUnitId: sheet, ranges } });
+var CONTENT_KEYS = ["v", "t", "p", "f", "si", "custom"];
+var CONTENT_TOUCH = ["v", "p", "f", "si", "custom"];
+var KNOWN_CELL_KEYS = /* @__PURE__ */ new Set([...CONTENT_KEYS, "s"]);
+function completeCellContent(entry, post) {
+  if (entry === null) return null;
+  if (!CONTENT_TOUCH.some((k) => k in entry)) return entry;
+  const out = {};
+  for (const k of CONTENT_KEYS) out[k] = post && post[k] !== void 0 ? post[k] : null;
+  if (out.v === null) delete out.t;
+  if ("s" in entry) out.s = entry.s;
+  return out;
+}
+function cellsOf(m) {
+  return m.params.cellValue ?? {};
+}
+function forEachCell(cells, fn) {
+  for (const r of Object.keys(cells)) for (const c of Object.keys(cells[r] ?? {})) fn(Number(r), Number(c), cells[r][c] ?? null);
+}
+function cellsMutation(template, cells) {
+  return { id: template.id, params: { ...template.params, cellValue: cells } };
+}
+function putCell(cells, r, c, v) {
+  (cells[r] ??= {})[c] = v;
+}
+var isEmptyMatrix = (cells) => Object.values(cells).every((row) => Object.keys(row).length === 0);
+function cellBarrier(m) {
+  if (m.params.isOverrideStyle) return "set-range-values with isOverrideStyle (whole-style replace) is not covered";
+  let why = null;
+  forEachCell(cellsOf(m), (_r, _c, v) => {
+    if (why || v === null) return;
+    for (const k of Object.keys(v)) {
+      if (!KNOWN_CELL_KEYS.has(k)) why = `cell key "${k}" is not covered`;
+      else if ((k === "f" || k === "si") && v[k] != null) why = "formula content (f/si) belongs to C5b";
+    }
+    if (typeof v.s === "string") why = "a style id travels (style ids are seat-local; capture must send the style object)";
+    if (!why && CONTENT_TOUCH.some((k) => k in v) && !CONTENT_KEYS.every((k) => k in v || k === "t" && v.v == null))
+      why = "cell content is not completed (capture must call completeCellContent)";
+  });
+  return why;
+}
+var hasContent = (v) => CONTENT_TOUCH.some((k) => k in v);
+var contentOf = (v) => {
+  const out = {};
+  for (const k of Object.keys(v)) if (k !== "s") out[k] = v[k];
+  return out;
+};
+var richText = (v) => v.p != null;
+function styleKeys(s) {
+  const out = [];
+  for (const k of Object.keys(s)) {
+    if (k === "bd" && s.bd && typeof s.bd === "object") for (const side of Object.keys(s.bd)) out.push(`bd.${side}`);
+    else out.push(k);
+  }
+  return out;
+}
+function withoutStyleKeys(s, drop) {
+  const out = {};
+  for (const k of Object.keys(s)) {
+    if (k === "bd" && s.bd && typeof s.bd === "object") {
+      const bd = {};
+      for (const side of Object.keys(s.bd)) if (!drop.has(`bd.${side}`)) bd[side] = s.bd[side];
+      if (Object.keys(bd).length) out.bd = bd;
+    } else if (!drop.has(k)) out[k] = s[k];
+  }
+  return Object.keys(out).length ? out : null;
+}
+function transformCell(X, Y, side) {
+  if (X === null || Y === null) {
+    if (side === "left") return { entries: [X], xLost: false, yLost: true };
+    return X === null ? { entries: [null, Y], xLost: true, yLost: false } : { entries: [], xLost: true, yLost: false };
+  }
+  if (hasContent(X) && richText(X) && "s" in Y || hasContent(Y) && richText(Y) && "s" in X)
+    return "rich-text content concurrent with a style change on the same cell is not covered";
+  const out = {};
+  let xLost = false;
+  let yLost = false;
+  if (hasContent(X)) {
+    if (!hasContent(Y) || side === "left") Object.assign(out, contentOf(X));
+    else xLost = true;
+    if (hasContent(Y) && side === "left") yLost = true;
+  }
+  const tail = [];
+  if ("s" in X) {
+    const xs = X.s;
+    const ys = "s" in Y ? Y.s : void 0;
+    if (ys === void 0 || side === "left") {
+      if (xs !== void 0) out.s = xs;
+      if (ys !== void 0) yLost = true;
+    } else if (ys === null) {
+      xLost = true;
+    } else if (xs === null) {
+      out.s = null;
+      tail.push({ s: ys });
+      xLost = true;
+    } else {
+      const kept = withoutStyleKeys(xs, new Set(styleKeys(ys)));
+      if (kept) out.s = kept;
+      if (styleKeys(xs).length !== styleKeys(kept ?? {}).length) xLost = true;
+    }
+  }
+  return { entries: Object.keys(out).length ? [out, ...tail] : tail, xLost, yLost };
+}
+function transformCellsOverCells(x, y, side) {
+  if (sheetOf(x) !== sheetOf(y)) return ok([x]);
+  const ycells = cellsOf(y);
+  const passes = [{}];
+  const lost = [];
+  const dropped = [];
+  let why = null;
+  forEachCell(cellsOf(x), (r, c, X) => {
+    if (why) return;
+    const yRow = ycells[r];
+    if (!yRow || !(String(c) in yRow)) {
+      putCell(passes[0], r, c, X);
+      return;
+    }
+    const res = transformCell(X, yRow[c] ?? null, side);
+    if (typeof res === "string") {
+      why = res;
+      return;
+    }
+    res.entries.forEach((e, i) => putCell(passes[i] ??= {}, r, c, e));
+    if (res.xLost) dropped.push(cellRef(sheetOf(x), r, c));
+    if (res.yLost) lost.push(cellRef(sheetOf(x), r, c));
+  });
+  if (why) return barrier2(why);
+  const op = passes.filter((p) => !isEmptyMatrix(p)).map((p) => cellsMutation(x, p));
+  return ok(op, lost, dropped);
+}
+function transformCellsOverStructural(x, s) {
+  const out = {};
+  const dropped = [];
+  forEachCell(cellsOf(x), (r, c, v) => {
+    const nr = s.axis === "row" ? mapIndex(s.op, r) : r;
+    const nc = s.axis === "col" ? mapIndex(s.op, c) : c;
+    if (nr === null || nc === null) dropped.push(cellRef(sheetOf(x), r, c));
+    else putCell(out, nr, nc, v);
+  });
+  return ok(isEmptyMatrix(out) ? [] : [cellsMutation(x, out)], [], dropped);
+}
+function sizeOf(m) {
+  const p = m.params;
+  const values = /* @__PURE__ */ new Map();
+  if (m.id === ID.rowAutoHeight) {
+    for (const { row, autoHeight } of p.rowsAutoHeightInfo ?? []) values.set(row, autoHeight);
+    return { axis: "row", attr: "ah", values };
+  }
+  const axis = m.id === ID.colWidth ? "col" : "row";
+  const field = m.id === ID.colWidth ? "colWidth" : m.id === ID.rowHeight ? "rowHeight" : "autoHeightInfo";
+  const value = p[field];
+  const [a0, a1] = S(axis);
+  for (const r of p.ranges ?? [])
+    for (let i = r[a0]; i <= r[a1]; i++) {
+      if (typeof value === "number") values.set(i, value);
+      else if (m.id === ID.rowIsAuto) values.set(i, value?.[i]);
+      else if (value?.[i] != null) values.set(i, value[i]);
+    }
+  return { axis, attr: m.id === ID.colWidth ? "w" : m.id === ID.rowHeight ? "h" : "ia", values };
+}
+function buildSize(template, values) {
+  if (values.size === 0) return null;
+  const p = template.params;
+  if (template.id === ID.rowAutoHeight)
+    return { id: template.id, params: { ...p, rowsAutoHeightInfo: [...values].sort((a, b) => a[0] - b[0]).map(([row, autoHeight]) => ({ row, autoHeight })) } };
+  const axis = template.id === ID.colWidth ? "col" : "row";
+  const field = template.id === ID.colWidth ? "colWidth" : template.id === ID.rowHeight ? "rowHeight" : "autoHeightInfo";
+  const [a0, a1] = S(axis);
+  const first = (p.ranges ?? [])[0] ?? { startRow: 0, endRow: 0, startColumn: 0, endColumn: 0 };
+  const ranges = runs(values.keys()).map((r) => ({ ...first, [a0]: r.start, [a1]: r.start + r.count - 1 }));
+  const uniform = typeof p[field] === "number" ? p[field] : void 0;
+  const value = uniform !== void 0 && [...values.values()].every((v) => v === uniform) ? uniform : Object.fromEntries(values);
+  return { id: template.id, params: { ...p, ranges, [field]: value } };
+}
+function familyOf(id) {
+  const e = SHEET_MUTATIONS[id];
+  return e && e.kind === "covered" ? e.family : "";
+}
+function transformMutation(x, y, side) {
+  for (const m of [x, y]) {
+    const e = SHEET_MUTATIONS[m.id];
+    if (!e) return barrier2(`${m.id} is not in the registry`);
+    if (e.kind !== "covered") return barrier2(`${m.id}: ${e.kind === "barrier" ? `barrier until ${e.until} (${e.reason})` : "never travels"}`);
+    if (m.id === ID.values) {
+      const why = cellBarrier(m);
+      if (why) return barrier2(why);
+    }
+  }
+  const pb = PAIR_BARRIERS[pairKey(x.id, y.id)];
+  if (pb) return barrier2(`${x.id} \xD7 ${y.id}: ${pb.reason}${pb.seed === null ? "" : ` (fuzz seed ${pb.seed})`}`);
+  if (sheetOf(x) !== sheetOf(y)) return ok([x]);
+  const fx = familyOf(x.id);
+  const fy = familyOf(y.id);
+  const sy = structuralOf(y);
+  const sx = structuralOf(x);
+  if (sx && sy) {
+    if (sx.axis !== sy.axis) return ok([x]);
+    const out = transformAxis(sx.op, sy.op, side);
+    if (!out) return barrier2(`${x.id} over ${y.id}: moved blocks overlap in part, or the block would split`);
+    const dropped = out.length === 0 && sx.op.kind === "move" ? [`${sheetOf(x)}: moved ${sx.axis}s`] : [];
+    return ok(out.map((o) => buildStructural(x, sx.axis, o)), [], dropped);
+  }
+  if (sy) {
+    if (fx === "cell") return transformCellsOverStructural(x, sy);
+    if (fx === "merge") {
+      const kept = [];
+      const dropped = [];
+      for (const r of mergeRanges(x)) {
+        const t = mergeThrough(sy, r).range;
+        if (t) kept.push(t);
+        else dropped.push(rangeRef(sheetOf(x), r));
+      }
+      return ok(kept.length ? [withRanges(x, kept)] : [], [], x.id === ID.addMerge ? dropped : []);
+    }
+    if (fx === "size") {
+      const size = sizeOf(x);
+      if (size.axis !== sy.axis) return ok([x]);
+      const next = /* @__PURE__ */ new Map();
+      for (const [i, v] of size.values) {
+        const m = mapIndex(sy.op, i);
+        if (m !== null) next.set(m, v);
+      }
+      const built = buildSize(x, next);
+      return ok(built ? [built] : []);
+    }
+    return ok([x]);
+  }
+  if (sx) {
+    if (fy === "cell") {
+      const lost = [];
+      forEachCell(cellsOf(y), (r, c) => {
+        if ((sx.axis === "row" ? mapIndex(sx.op, r) : mapIndex(sx.op, c)) === null) lost.push(cellRef(sheetOf(y), r, c));
+      });
+      return ok([x], lost);
+    }
+    if (fy !== "merge" || y.id !== ID.addMerge) return ok([x]);
+    const remove = [];
+    const add = [];
+    for (const r of mergeRanges(y)) {
+      const t = mergeThrough(sx, r);
+      if (!t.fixup) continue;
+      remove.push(r);
+      if (t.range) add.push(t.range);
+    }
+    const lostMerges = mergeRanges(y).filter((r) => mergeThrough(sx, r).range === null).map((r) => rangeRef(sheetOf(y), r));
+    if (!remove.length) return ok([x], lostMerges);
+    const sheet = sheetOf(x);
+    const pre = sx.op.kind === "insert" ? [] : [mergeMutation(ID.removeMerge, sheet, remove)];
+    const mid = sx.op.kind === "insert" ? [mergeMutation(ID.removeMerge, sheet, remove)] : [];
+    return ok([...pre, x, ...mid, ...add.length ? [mergeMutation(ID.addMerge, sheet, add)] : []], lostMerges);
+  }
+  if (fx === "cell" && fy === "cell") return transformCellsOverCells(x, y, side);
+  if (fx === "merge" && fy === "merge") {
+    const xr = mergeRanges(x);
+    const yr = mergeRanges(y);
+    const hit = (r) => yr.some((q) => intersects(r, q));
+    const sheet = sheetOf(x);
+    if (x.id === ID.addMerge && y.id === ID.addMerge) {
+      if (!xr.some(hit)) return ok([x]);
+      if (side === "left") {
+        const lost = yr.filter((q) => xr.some((r) => intersects(r, q))).map((q) => rangeRef(sheet, q));
+        return ok([mergeMutation(ID.removeMerge, sheet, xr.filter(hit)), x], lost);
+      }
+      const kept = xr.filter((r) => !hit(r));
+      return ok(kept.length ? [withRanges(x, kept)] : [], [], xr.filter(hit).map((r) => rangeRef(sheet, r)));
+    }
+    if (x.id === ID.addMerge && y.id === ID.removeMerge) {
+      if (side === "left" || !xr.some(hit)) return ok([x], side === "left" && xr.some(hit) ? yr.filter((q) => xr.some((r) => intersects(r, q))).map((q) => rangeRef(sheet, q)) : []);
+      const kept = xr.filter((r) => !hit(r));
+      return ok(kept.length ? [withRanges(x, kept)] : [], [], xr.filter(hit).map((r) => rangeRef(sheet, r)));
+    }
+    if (x.id === ID.removeMerge && y.id === ID.addMerge) {
+      const touched = yr.filter((q) => xr.some((r) => intersects(r, q)));
+      if (!touched.length) return ok([x]);
+      if (side === "left") return ok([x], touched.map((q) => rangeRef(sheet, q)));
+      return ok([x, mergeMutation(ID.addMerge, sheet, touched)], [], xr.filter(hit).map((r) => rangeRef(sheet, r)));
+    }
+    return ok([x]);
+  }
+  if (fx === "size" && fy === "size") {
+    const a = sizeOf(x);
+    const b = sizeOf(y);
+    if (a.axis !== b.axis || a.attr !== b.attr) return ok([x]);
+    if (side === "left") {
+      const lost = [...a.values.keys()].filter((i) => b.values.has(i)).map((i) => `${sheetOf(x)}: ${a.axis} ${i + 1} ${a.attr}`);
+      return ok([x], lost);
+    }
+    const next = new Map([...a.values].filter(([i]) => !b.values.has(i)));
+    const built = buildSize(x, next);
+    const dropped = [...a.values.keys()].filter((i) => b.values.has(i)).map((i) => `${sheetOf(x)}: ${a.axis} ${i + 1} ${a.attr}`);
+    return ok(built ? [built] : [], [], dropped);
+  }
+  if (fx === "name" && fy === "name") {
+    if (side === "left") return ok([x], [`${sheetOf(x)}: name "${String(y.params.name)}"`]);
+    return ok([], [], [`${sheetOf(x)}: name "${String(x.params.name)}"`]);
+  }
+  return ok([x]);
+}
+var blocked = (p) => !Array.isArray(p);
+function tSeq(xs, ys, side, acc) {
+  if (xs.length === 0 || ys.length === 0) return [xs, ys];
+  if (xs.length === 1 && ys.length === 1) {
+    const a = transformMutation(xs[0], ys[0], side);
+    if (isBarrier(a)) return a;
+    const b = transformMutation(ys[0], xs[0], flip(side));
+    if (isBarrier(b)) return b;
+    acc.lost.push(...a.lost);
+    acc.dropped.push(...a.dropped);
+    return [a.op, b.op];
+  }
+  if (xs.length > 1) {
+    const first2 = tSeq([xs[0]], ys, side, acc);
+    if (blocked(first2)) return first2;
+    const rest2 = tSeq(xs.slice(1), first2[1], side, acc);
+    if (blocked(rest2)) return rest2;
+    return [[...first2[0], ...rest2[0]], rest2[1]];
+  }
+  const first = tSeq(xs, [ys[0]], side, acc);
+  if (blocked(first)) return first;
+  const rest = tSeq(first[0], ys.slice(1), side, acc);
+  if (blocked(rest)) return rest;
+  return [rest[0], [...first[1], ...rest[1]]];
+}
+function transformGroup(x, y, side) {
+  const acc = { lost: [], dropped: [] };
+  const r = tSeq([...x], [...y], side, acc);
+  if (blocked(r)) return r;
+  return { op: r[0], lost: [...new Set(acc.lost)], dropped: [...new Set(acc.dropped)] };
+}
+var sheetTransformer = {
+  version: SHEET_TRANSFORMER_VERSION,
+  transform(x, y, side) {
+    const r = transformGroup(x, y, side);
+    if (isBarrier(r)) return r;
+    return { op: r.op.length ? r.op : null, lost: r.lost, dropped: r.dropped };
+  },
+  compose(a, b) {
+    return [...a, ...b];
+  },
+  isNoop(op) {
+    return op.length === 0;
+  }
+};
+//# sourceMappingURL=collab-sheets-transform.cjs.map