@sofereditor/core 0.1.0

package/dist/index.js

@@ -0,0 +1,1772 @@
+// src/types.ts
+var MAX_LIST_LEVEL = 5;
+function isImageEmbed(v) {
+  return typeof v === "object" && v !== null && v.type === "image" && typeof v.src === "string";
+}
+function isLegacySerializedDocument(v) {
+  return Array.isArray(v);
+}
+
+// src/schema.ts
+var BLOCK_SPECS = {
+  paragraph: {
+    type: "paragraph",
+    defaultAttrs: {}
+  },
+  heading: {
+    type: "heading",
+    defaultAttrs: { level: 1 }
+  },
+  blockquote: {
+    type: "blockquote",
+    defaultAttrs: {}
+  },
+  codeBlock: {
+    type: "codeBlock",
+    defaultAttrs: {}
+  },
+  listItem: {
+    type: "listItem",
+    defaultAttrs: { listKind: "bullet", listLevel: 0 }
+  },
+  table: {
+    type: "table",
+    defaultAttrs: { rows: 1, cols: 1 }
+  }
+};
+function isKnownBlockType(t) {
+  return t in BLOCK_SPECS;
+}
+function defaultAttrsFor(type) {
+  return { ...BLOCK_SPECS[type].defaultAttrs };
+}
+
+// src/page-settings.ts
+var PAGE_PRESETS = {
+  a4: { width: 794, height: 1123 },
+  // 210×297 mm
+  letter: { width: 816, height: 1056 },
+  // 8.5×11 in
+  oficio: { width: 816, height: 1248 }
+  // 216×330 mm (BR Ofício)
+};
+var MARGIN_PRESETS = {
+  normal: 96,
+  // 25.4 mm = 1 in
+  narrow: 48,
+  // 12.7 mm = 0.5 in
+  wide: 192
+  // 50.8 mm = 2 in
+};
+var DEFAULT_PAGE_SETTINGS = {
+  ...PAGE_PRESETS.a4,
+  marginTop: MARGIN_PRESETS.normal,
+  marginBottom: MARGIN_PRESETS.normal,
+  marginLeft: MARGIN_PRESETS.normal,
+  marginRight: MARGIN_PRESETS.normal,
+  preset: "a4"
+};
+var PX_PER_MM = 96 / 25.4;
+function mmToPx(mm) {
+  return mm * PX_PER_MM;
+}
+function pxToMm(px) {
+  return px / PX_PER_MM;
+}
+function detectPreset(width, height) {
+  const TOL = mmToPx(0.5);
+  for (const [name, size] of Object.entries(PAGE_PRESETS)) {
+    if (Math.abs(width - size.width) <= TOL && Math.abs(height - size.height) <= TOL) {
+      return name;
+    }
+  }
+  return "custom";
+}
+function withDefaults(partial) {
+  const merged = { ...DEFAULT_PAGE_SETTINGS, ...partial ?? {} };
+  return { ...merged, preset: detectPreset(merged.width, merged.height) };
+}
+
+// src/document.ts
+import * as Y from "yjs";
+var EditorDocument = class _EditorDocument {
+  ydoc;
+  blocks;
+  /** Document-level settings (page size, margins). See `getPageSettings`. */
+  docSettings;
+  constructor(ydoc) {
+    this.ydoc = ydoc ?? new Y.Doc();
+    this.blocks = this.ydoc.getArray("blocks");
+    this.docSettings = this.ydoc.getMap("docSettings");
+    if (this.blocks.length === 0) {
+      this.ydoc.transact(() => {
+        this.blocks.push([createBlock("paragraph")]);
+      }, "init");
+    }
+  }
+  /**
+   * Returns the current page settings. Missing fields fall back to
+   * `DEFAULT_PAGE_SETTINGS`. The returned object is a fresh snapshot — mutating
+   * it does not write back to the Y.Doc. Use `setPageSettings` for that.
+   */
+  getPageSettings() {
+    const m = this.docSettings;
+    const pick = (key) => {
+      const v = m.get(key);
+      return typeof v === "number" || typeof v === "string" ? v : void 0;
+    };
+    const merged = {
+      width: pick("width") ?? DEFAULT_PAGE_SETTINGS.width,
+      height: pick("height") ?? DEFAULT_PAGE_SETTINGS.height,
+      marginTop: pick("marginTop") ?? DEFAULT_PAGE_SETTINGS.marginTop,
+      marginBottom: pick("marginBottom") ?? DEFAULT_PAGE_SETTINGS.marginBottom,
+      marginLeft: pick("marginLeft") ?? DEFAULT_PAGE_SETTINGS.marginLeft,
+      marginRight: pick("marginRight") ?? DEFAULT_PAGE_SETTINGS.marginRight
+    };
+    merged.preset = detectPreset(merged.width, merged.height);
+    return merged;
+  }
+  /**
+   * Merge `partial` into the docSettings Y.Map. Runs in a `ydoc.transact` with
+   * origin `"pageSettings"` (NOT tracked by the UndoManager, mirroring the
+   * `"import"` convention from Fase 9.5).
+   */
+  setPageSettings(partial) {
+    this.ydoc.transact(() => {
+      for (const [k, v] of Object.entries(partial)) {
+        if (k === "preset") continue;
+        if (v === void 0) continue;
+        this.docSettings.set(k, v);
+      }
+    }, "pageSettings");
+  }
+  /** Listen for page-settings changes. Returns an unsubscribe function. */
+  observePageSettings(cb) {
+    const handler = () => cb();
+    this.docSettings.observe(handler);
+    return () => this.docSettings.unobserve(handler);
+  }
+  getBlock(index) {
+    if (index < 0 || index >= this.blocks.length) return void 0;
+    return this.blocks.get(index);
+  }
+  getBlockText(index) {
+    const b = this.getBlock(index);
+    return b?.get("text");
+  }
+  getBlockType(index) {
+    const b = this.getBlock(index);
+    return b?.get("type");
+  }
+  getBlockAttrsMap(index) {
+    const b = this.getBlock(index);
+    return b?.get("attrs");
+  }
+  getBlockAttrs(index) {
+    const m = this.getBlockAttrsMap(index);
+    if (!m) return {};
+    return Object.fromEntries(m.entries());
+  }
+  blockCount() {
+    return this.blocks.length;
+  }
+  // ---------- Table helpers ----------
+  isTable(index) {
+    return this.getBlockType(index) === "table";
+  }
+  /** Returns rows/cols read from the block's attrs map. `{0,0}` for non-table blocks. */
+  getTableSize(index) {
+    const attrs = this.getBlockAttrs(index);
+    const rows = typeof attrs.rows === "number" ? attrs.rows : 0;
+    const cols = typeof attrs.cols === "number" ? attrs.cols : 0;
+    return { rows, cols };
+  }
+  getCells(index) {
+    const b = this.getBlock(index);
+    return b?.get("cells");
+  }
+  getCell(blockIndex, cellIndex) {
+    const cells = this.getCells(blockIndex);
+    if (!cells) return void 0;
+    if (cellIndex < 0 || cellIndex >= cells.length) return void 0;
+    return cells.get(cellIndex);
+  }
+  getCellText(blockIndex, cellIndex) {
+    const cell = this.getCell(blockIndex, cellIndex);
+    return cell?.get("text");
+  }
+  getCellAttrsMap(blockIndex, cellIndex) {
+    const cell = this.getCell(blockIndex, cellIndex);
+    return cell?.get("attrs");
+  }
+  getCellAttrs(blockIndex, cellIndex) {
+    const m = this.getCellAttrsMap(blockIndex, cellIndex);
+    if (!m) return {};
+    return Object.fromEntries(m.entries());
+  }
+  /**
+   * Returns the editable Y.Text targeted by a position:
+   * - When `cellIndex` is set: the cell's text (or the owner's text if the
+   *   target cell is covered by a span — we treat the covered position as
+   *   addressing the owner).
+   * - Otherwise: the block's own text.
+   */
+  textAt(blockIndex, cellIndex) {
+    if (cellIndex == null) return this.getBlockText(blockIndex);
+    const real = this.realCellIndex(blockIndex, cellIndex);
+    if (real == null) return void 0;
+    return this.getCellText(blockIndex, real);
+  }
+  /**
+   * Returns the "real" (non-covered) cell index for a target cell. When the
+   * target is already a real cell, returns it unchanged. When covered, walks
+   * up-and-left to find the owner.
+   *
+   * The walk is robust to oversized or non-rectangular spans by skipping
+   * candidates whose declared span doesn't actually cover the target.
+   */
+  realCellIndex(blockIndex, cellIndex) {
+    if (!this.isTable(blockIndex)) return void 0;
+    const { rows, cols } = this.getTableSize(blockIndex);
+    if (rows <= 0 || cols <= 0) return void 0;
+    if (cellIndex < 0 || cellIndex >= rows * cols) return void 0;
+    const targetAttrs = this.getCellAttrs(blockIndex, cellIndex);
+    if (targetAttrs.covered !== true) return cellIndex;
+    const tRow = Math.floor(cellIndex / cols);
+    const tCol = cellIndex - tRow * cols;
+    for (let or = tRow; or >= 0; or--) {
+      for (let oc = tCol; oc >= 0; oc--) {
+        const idx = or * cols + oc;
+        if (idx === cellIndex) continue;
+        const a = this.getCellAttrs(blockIndex, idx);
+        if (a.covered === true) continue;
+        const rs = spanOf(a.rowspan);
+        const cs = spanOf(a.colspan);
+        if (or + rs - 1 >= tRow && oc + cs - 1 >= tCol) return idx;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Replace the document contents with a `SerializedDocument`. Runs in a single
+   * `ydoc.transact` with origin `"import"` so the UndoManager can group or skip
+   * the operation as one step.
+   *
+   * Reuses `createBlock` / `createTableBlock` so every block ends up with the
+   * exact same Y.js shape produced by the rest of the editor.
+   */
+  loadFromJSON(serialized) {
+    const { blocks: sourceBlocks, pageSettings } = normalizeSerialized(serialized);
+    this.ydoc.transact(() => {
+      if (this.blocks.length > 0) {
+        this.blocks.delete(0, this.blocks.length);
+      }
+      const sources = sourceBlocks.length > 0 ? sourceBlocks : [makeEmptyParagraphSource()];
+      const fresh = sources.map((b) => buildEmptyBlockFromSerialized(b));
+      this.blocks.push(fresh);
+      for (let i = 0; i < sources.length; i++) {
+        const src = sources[i];
+        const yBlock = this.blocks.get(i);
+        applyDeltaIntoBlock(yBlock, src);
+      }
+      if (pageSettings) {
+        for (const [k, v] of Object.entries(pageSettings)) {
+          if (k === "preset") continue;
+          if (v === void 0) continue;
+          this.docSettings.set(k, v);
+        }
+      }
+    }, "import");
+  }
+  /** Build a fresh `EditorDocument` from a `SerializedDocument`. */
+  static fromJSON(serialized) {
+    const ydoc = new Y.Doc();
+    ydoc.getArray("blocks");
+    const doc = new _EditorDocument(ydoc);
+    doc.loadFromJSON(serialized);
+    return doc;
+  }
+  toJSON() {
+    const blocks = this.blocks.toArray().map((b) => {
+      const type = b.get("type") ?? "paragraph";
+      const attrsMap = b.get("attrs");
+      const attrs = attrsMap ? Object.fromEntries(attrsMap.entries()) : {};
+      if (type === "table") {
+        const cellsArray = b.get("cells");
+        const cells = cellsArray ? cellsArray.toArray().map((c) => serializeCell(c)) : [];
+        return {
+          type,
+          text: "",
+          delta: [],
+          attrs,
+          cells
+        };
+      }
+      const yText = b.get("text");
+      return {
+        type,
+        text: yText?.toString() ?? "",
+        delta: yText?.toDelta() ?? [],
+        attrs
+      };
+    });
+    return { blocks, pageSettings: this.getPageSettings() };
+  }
+};
+function normalizeSerialized(v) {
+  if (isLegacySerializedDocument(v)) {
+    return { blocks: v };
+  }
+  return { blocks: v.blocks, pageSettings: v.pageSettings };
+}
+function serializeCell(c) {
+  const yText = c.get("text");
+  const attrsMap = c.get("attrs");
+  return {
+    text: yText?.toString() ?? "",
+    delta: yText?.toDelta() ?? [],
+    attrs: attrsMap ? Object.fromEntries(attrsMap.entries()) : {}
+  };
+}
+function createBlock(type, initialText = "", attrs) {
+  if (type === "table") {
+    const merged2 = { ...defaultAttrsFor("table"), ...attrs ?? {} };
+    const rows = typeof merged2.rows === "number" && merged2.rows > 0 ? Math.trunc(merged2.rows) : 1;
+    const cols = typeof merged2.cols === "number" && merged2.cols > 0 ? Math.trunc(merged2.cols) : 1;
+    return createTableBlock(rows, cols);
+  }
+  const block = new Y.Map();
+  block.set("type", type);
+  const yText = new Y.Text();
+  if (initialText.length > 0) yText.insert(0, initialText);
+  block.set("text", yText);
+  const attrsMap = new Y.Map();
+  const merged = { ...defaultAttrsFor(type), ...attrs ?? {} };
+  for (const [k, v] of Object.entries(merged)) {
+    if (v !== void 0) attrsMap.set(k, v);
+  }
+  block.set("attrs", attrsMap);
+  return block;
+}
+function createTableBlock(rows, cols) {
+  const r = Math.max(1, Math.trunc(rows));
+  const c = Math.max(1, Math.trunc(cols));
+  const block = new Y.Map();
+  block.set("type", "table");
+  const attrsMap = new Y.Map();
+  attrsMap.set("rows", r);
+  attrsMap.set("cols", c);
+  block.set("attrs", attrsMap);
+  const cells = new Y.Array();
+  const total = r * c;
+  const fresh = [];
+  for (let i = 0; i < total; i++) fresh.push(createCell());
+  cells.push(fresh);
+  block.set("cells", cells);
+  return block;
+}
+function createCell(attrs) {
+  const m = new Y.Map();
+  m.set("text", new Y.Text());
+  const attrsMap = new Y.Map();
+  if (attrs) {
+    for (const [k, v] of Object.entries(attrs)) {
+      if (v === void 0) continue;
+      attrsMap.set(k, v);
+    }
+  }
+  m.set("attrs", attrsMap);
+  return m;
+}
+function makeEmptyParagraphSource() {
+  return { type: "paragraph", text: "", delta: [], attrs: {} };
+}
+function buildEmptyBlockFromSerialized(block) {
+  if (block.type === "table") {
+    const rows = typeof block.attrs.rows === "number" ? Math.max(1, Math.trunc(block.attrs.rows)) : 1;
+    const cols = typeof block.attrs.cols === "number" ? Math.max(1, Math.trunc(block.attrs.cols)) : 1;
+    const yBlock = new Y.Map();
+    yBlock.set("type", "table");
+    const attrsMap = new Y.Map();
+    attrsMap.set("rows", rows);
+    attrsMap.set("cols", cols);
+    for (const [k, v] of Object.entries(block.attrs)) {
+      if (k === "rows" || k === "cols") continue;
+      if (v === void 0) continue;
+      attrsMap.set(k, v);
+    }
+    yBlock.set("attrs", attrsMap);
+    const cellsArr = new Y.Array();
+    const total = rows * cols;
+    const fresh = [];
+    const cells = block.cells ?? [];
+    for (let i = 0; i < total; i++) {
+      const src = cells[i];
+      fresh.push(createCell(src?.attrs ?? void 0));
+    }
+    cellsArr.push(fresh);
+    yBlock.set("cells", cellsArr);
+    return yBlock;
+  }
+  return createBlock(block.type, "", block.attrs);
+}
+function applyDeltaIntoBlock(yBlock, src) {
+  if (!yBlock) return;
+  if (src.type === "table") {
+    const cellsArr = yBlock.get("cells");
+    if (!cellsArr) return;
+    const cells = src.cells ?? [];
+    for (let i = 0; i < cellsArr.length; i++) {
+      const cellSrc = cells[i];
+      if (!cellSrc || !cellSrc.delta || cellSrc.delta.length === 0) continue;
+      const cell = cellsArr.get(i);
+      const yText2 = cell.get("text");
+      if (!yText2) continue;
+      yText2.applyDelta(cellSrc.delta);
+    }
+    return;
+  }
+  if (!src.delta || src.delta.length === 0) return;
+  const yText = yBlock.get("text");
+  if (!yText) return;
+  yText.applyDelta(src.delta);
+}
+function spanOf(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return 1;
+  return Math.max(1, Math.trunc(value));
+}
+
+// src/selection.ts
+function isCollapsed(sel) {
+  return positionsEqual(sel.anchor, sel.focus);
+}
+function positionsEqual(a, b) {
+  return a.blockIndex === b.blockIndex && (a.cellIndex ?? -1) === (b.cellIndex ?? -1) && a.offset === b.offset;
+}
+function comparePositions(a, b) {
+  if (a.blockIndex !== b.blockIndex) return a.blockIndex - b.blockIndex;
+  const ac = a.cellIndex ?? -1;
+  const bc = b.cellIndex ?? -1;
+  if (ac !== bc) return ac - bc;
+  return a.offset - b.offset;
+}
+function orderedRange(sel) {
+  if (comparePositions(sel.anchor, sel.focus) <= 0) {
+    return { start: sel.anchor, end: sel.focus };
+  }
+  return { start: sel.focus, end: sel.anchor };
+}
+function collapsedSelection(pos) {
+  return { anchor: pos, focus: pos };
+}
+function sameTextRun(a, b) {
+  return a.blockIndex === b.blockIndex && (a.cellIndex ?? -1) === (b.cellIndex ?? -1);
+}
+
+// src/marks.ts
+function iterateRunsInRange(yText, start, end, visit) {
+  if (start >= end) return;
+  const delta = yText.toDelta();
+  let cursor = 0;
+  for (const op of delta) {
+    if (typeof op.insert !== "string") {
+      if (op.insert == null) continue;
+      cursor += 1;
+      if (cursor > end) break;
+      continue;
+    }
+    const opStart = cursor;
+    const opEnd = cursor + op.insert.length;
+    cursor = opEnd;
+    if (opEnd <= start) continue;
+    if (opStart >= end) break;
+    const runStart = Math.max(opStart, start);
+    const runEnd = Math.min(opEnd, end);
+    visit(op, runStart, runEnd);
+  }
+}
+function getMarksInRange(yText, start, end) {
+  const result = {};
+  if (start >= end) return result;
+  const total = end - start;
+  const coveredByName = {};
+  iterateRunsInRange(yText, start, end, (run, runStart, runEnd) => {
+    const len = runEnd - runStart;
+    const attrs = run.attributes ?? {};
+    Object.keys(attrs).forEach((name) => {
+      const value = attrs[name];
+      if (value === void 0 || value === null) return;
+      const prev = result[name];
+      if (prev === void 0) {
+        result[name] = value;
+      } else if (prev !== "mixed" && !sameMarkValue(prev, value)) {
+        result[name] = "mixed";
+      }
+      coveredByName[name] = (coveredByName[name] ?? 0) + len;
+    });
+  });
+  Object.keys(result).forEach((name) => {
+    if ((coveredByName[name] ?? 0) < total) {
+      result[name] = "mixed";
+    }
+  });
+  return result;
+}
+function isMarkUniformInRange(yText, start, end, name, value) {
+  if (start >= end) return false;
+  const total = end - start;
+  let covered = 0;
+  let observed;
+  let ok = true;
+  iterateRunsInRange(yText, start, end, (run, runStart, runEnd) => {
+    if (!ok) return;
+    const len = runEnd - runStart;
+    const attr = (run.attributes ?? {})[name];
+    if (attr === void 0 || attr === null) {
+      ok = false;
+      return;
+    }
+    if (value !== void 0 && !sameMarkValue(value, attr)) {
+      ok = false;
+      return;
+    }
+    if (observed === void 0) {
+      observed = attr;
+    } else if (!sameMarkValue(observed, attr)) {
+      ok = false;
+      return;
+    }
+    covered += len;
+  });
+  return ok && covered === total;
+}
+function deltaLength(delta) {
+  let sum = 0;
+  for (const op of delta) {
+    if (typeof op.insert === "string") sum += op.insert.length;
+    else if (op.insert != null) sum += 1;
+  }
+  return sum;
+}
+function sliceDelta(delta, start, end) {
+  if (end <= start) return [];
+  const out = [];
+  let cursor = 0;
+  for (const op of delta) {
+    if (typeof op.insert === "string") {
+      const opStart = cursor;
+      const opEnd = cursor + op.insert.length;
+      cursor = opEnd;
+      if (opEnd <= start) continue;
+      if (opStart >= end) break;
+      const sliceFrom = Math.max(opStart, start) - opStart;
+      const sliceTo = Math.min(opEnd, end) - opStart;
+      out.push({
+        insert: op.insert.slice(sliceFrom, sliceTo),
+        attributes: op.attributes
+      });
+    } else if (op.insert != null) {
+      const opStart = cursor;
+      const opEnd = cursor + 1;
+      cursor = opEnd;
+      if (opEnd <= start) continue;
+      if (opStart >= end) break;
+      out.push({ insert: op.insert, attributes: op.attributes });
+    }
+  }
+  return out;
+}
+function sameMarkValue(a, b) {
+  if (a === b) return true;
+  if (typeof a === "object" && typeof b === "object" && a && b) {
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length) return false;
+    return aKeys.every((k) => a[k] === b[k]);
+  }
+  return false;
+}
+
+// src/commands.ts
+import * as Y2 from "yjs";
+var COMMAND_ORIGIN = /* @__PURE__ */ Symbol("editor-command");
+function transact(doc, fn) {
+  doc.ydoc.transact(fn, COMMAND_ORIGIN);
+}
+function insertText(ctx, text, marks) {
+  if (text.length === 0) return;
+  const collapsedFromRect = clearRectCells(ctx);
+  transact(ctx.doc, () => {
+    const sel = collapsedFromRect ?? ctx.getSelection();
+    let cursor = sel;
+    if (!isCollapsed(sel)) {
+      cursor = deleteRange(ctx.doc, sel);
+    }
+    const pos = cursor.focus;
+    const yText = ctx.doc.textAt(pos.blockIndex, pos.cellIndex);
+    if (!yText) return;
+    yText.insert(pos.offset, text);
+    if (marks && Object.keys(marks).length > 0) {
+      yText.format(pos.offset, text.length, marks);
+    }
+    const newPos = {
+      blockIndex: pos.blockIndex,
+      cellIndex: pos.cellIndex,
+      offset: pos.offset + text.length
+    };
+    ctx.setSelection(collapsedSelection(newPos));
+  });
+}
+function insertParagraph(ctx) {
+  clearRectCells(ctx);
+  transact(ctx.doc, () => {
+    const sel = ctx.getSelection();
+    let cursor = sel;
+    if (!isCollapsed(sel)) {
+      cursor = deleteRange(ctx.doc, sel);
+    }
+    const pos = cursor.focus;
+    if (pos.cellIndex != null) {
+      const yText2 = ctx.doc.getCellText(pos.blockIndex, pos.cellIndex);
+      if (!yText2) return;
+      yText2.insert(pos.offset, "\n");
+      ctx.setSelection(
+        collapsedSelection({
+          blockIndex: pos.blockIndex,
+          cellIndex: pos.cellIndex,
+          offset: pos.offset + 1
+        })
+      );
+      return;
+    }
+    const yText = ctx.doc.getBlockText(pos.blockIndex);
+    if (!yText) return;
+    const totalLen = yText.length;
+    const tailDelta = totalLen > pos.offset ? sliceDelta(yText.toDelta(), pos.offset, totalLen) : [];
+    if (totalLen > pos.offset) {
+      yText.delete(pos.offset, totalLen - pos.offset);
+    }
+    const newBlock = createBlock("paragraph");
+    ctx.doc.blocks.insert(pos.blockIndex + 1, [newBlock]);
+    if (tailDelta.length > 0) {
+      const newYText = newBlock.get("text");
+      writeDeltaInto(newYText, 0, tailDelta);
+    }
+    const newPos = { blockIndex: pos.blockIndex + 1, offset: 0 };
+    ctx.setSelection(collapsedSelection(newPos));
+  });
+}
+function deleteBackward(ctx) {
+  if (clearRectCells(ctx)) return;
+  transact(ctx.doc, () => {
+    const sel = ctx.getSelection();
+    if (!isCollapsed(sel)) {
+      const cursor = deleteRange(ctx.doc, sel);
+      ctx.setSelection(cursor);
+      return;
+    }
+    const pos = sel.focus;
+    if (pos.offset > 0) {
+      const yText = ctx.doc.textAt(pos.blockIndex, pos.cellIndex);
+      if (!yText) return;
+      yText.delete(pos.offset - 1, 1);
+      ctx.setSelection(
+        collapsedSelection({
+          blockIndex: pos.blockIndex,
+          cellIndex: pos.cellIndex,
+          offset: pos.offset - 1
+        })
+      );
+      return;
+    }
+    if (pos.cellIndex != null) return;
+    const blockType = ctx.doc.getBlockType(pos.blockIndex);
+    if (blockType === "listItem") {
+      const block = ctx.doc.getBlock(pos.blockIndex);
+      const attrsMap = block?.get("attrs");
+      const rawLevel = attrsMap?.get("listLevel");
+      const level = typeof rawLevel === "number" && Number.isFinite(rawLevel) ? Math.max(0, Math.min(MAX_LIST_LEVEL, Math.trunc(rawLevel))) : 0;
+      if (level > 0) {
+        attrsMap.set("listLevel", level - 1);
+        ctx.setSelection(collapsedSelection(pos));
+        return;
+      }
+      setBlockTypeAtIndex(ctx.doc, pos.blockIndex, "paragraph", {});
+      ctx.setSelection(collapsedSelection(pos));
+      return;
+    }
+    if (pos.blockIndex > 0) {
+      const prevType = ctx.doc.getBlockType(pos.blockIndex - 1);
+      if (prevType === "table") {
+        const tableIdx = pos.blockIndex - 1;
+        const { rows, cols } = ctx.doc.getTableSize(tableIdx);
+        const lastCell = rows * cols - 1;
+        const cellText = ctx.doc.getCellText(tableIdx, lastCell);
+        const off = cellText?.length ?? 0;
+        ctx.setSelection(
+          collapsedSelection({ blockIndex: tableIdx, cellIndex: lastCell, offset: off })
+        );
+        return;
+      }
+      mergeWithPrevious(ctx, pos.blockIndex);
+    }
+  });
+}
+function deleteForward(ctx) {
+  if (clearRectCells(ctx)) return;
+  transact(ctx.doc, () => {
+    const sel = ctx.getSelection();
+    if (!isCollapsed(sel)) {
+      const cursor = deleteRange(ctx.doc, sel);
+      ctx.setSelection(cursor);
+      return;
+    }
+    const pos = sel.focus;
+    const yText = ctx.doc.textAt(pos.blockIndex, pos.cellIndex);
+    if (!yText) return;
+    if (pos.offset < yText.length) {
+      yText.delete(pos.offset, 1);
+      ctx.setSelection(collapsedSelection(pos));
+      return;
+    }
+    if (pos.cellIndex != null) return;
+    if (pos.blockIndex + 1 < ctx.doc.blockCount()) {
+      const nextType = ctx.doc.getBlockType(pos.blockIndex + 1);
+      if (nextType === "table") {
+        const tableIdx = pos.blockIndex + 1;
+        ctx.setSelection(collapsedSelection({ blockIndex: tableIdx, cellIndex: 0, offset: 0 }));
+        return;
+      }
+      const nextText = ctx.doc.getBlockText(pos.blockIndex + 1);
+      if (!nextText) return;
+      const tail = nextText.toString();
+      if (tail.length > 0) yText.insert(yText.length, tail);
+      ctx.doc.blocks.delete(pos.blockIndex + 1, 1);
+      ctx.setSelection(collapsedSelection(pos));
+    }
+  });
+}
+var booleanMarks = /* @__PURE__ */ new Set(["bold", "italic", "underline", "strike"]);
+function toggleMark(ctx, name, value) {
+  const sel = ctx.getSelection();
+  if (isCollapsed(sel)) return;
+  transact(ctx.doc, () => {
+    const { start, end } = orderedRange(sel);
+    forEachBlockTextInRange(ctx.doc, start, end, (yText, localStart, localEnd) => {
+      const uniform = isMarkUniformInRange(yText, localStart, localEnd, name, value);
+      const attrs = {};
+      if (uniform) {
+        attrs[name] = null;
+      } else {
+        attrs[name] = value ?? (booleanMarks.has(name) ? true : null);
+      }
+      if (attrs[name] === null && !uniform) return;
+      yText.format(localStart, localEnd - localStart, attrs);
+    });
+    ctx.setSelection(sel);
+  });
+}
+function setMark(ctx, name, value) {
+  const sel = ctx.getSelection();
+  if (isCollapsed(sel)) return;
+  transact(ctx.doc, () => {
+    const { start, end } = orderedRange(sel);
+    forEachBlockTextInRange(ctx.doc, start, end, (yText, localStart, localEnd) => {
+      yText.format(localStart, localEnd - localStart, { [name]: value });
+    });
+    ctx.setSelection(sel);
+  });
+}
+function removeMark(ctx, name) {
+  const sel = ctx.getSelection();
+  if (isCollapsed(sel)) return;
+  transact(ctx.doc, () => {
+    const { start, end } = orderedRange(sel);
+    forEachBlockTextInRange(ctx.doc, start, end, (yText, localStart, localEnd) => {
+      yText.format(localStart, localEnd - localStart, { [name]: null });
+    });
+    ctx.setSelection(sel);
+  });
+}
+function setBlockType(ctx, type, attrs) {
+  transact(ctx.doc, () => {
+    const sel = ctx.getSelection();
+    if (sel.anchor.cellIndex != null || sel.focus.cellIndex != null) return;
+    const indices = selectedBlockIndices(sel, ctx.doc.blockCount());
+    for (const i of indices) {
+      const block = ctx.doc.getBlock(i);
+      if (!block) continue;
+      block.set("type", type);
+      const attrsMap = block.get("attrs") ?? new Y2.Map();
+      if (!block.get("attrs")) block.set("attrs", attrsMap);
+      const next = { ...defaultAttrsFor(type), ...attrs ?? {} };
+      const keep = new Set(Object.keys(next));
+      for (const k of Array.from(attrsMap.keys())) {
+        if (!keep.has(k)) attrsMap.delete(k);
+      }
+      for (const [k, v] of Object.entries(next)) {
+        if (v === void 0) continue;
+        if (attrsMap.get(k) !== v) attrsMap.set(k, v);
+      }
+    }
+    ctx.setSelection(sel);
+  });
+}
+function setBlockAttr(ctx, key, value) {
+  transact(ctx.doc, () => {
+    const sel = ctx.getSelection();
+    if (sel.anchor.cellIndex != null || sel.focus.cellIndex != null) return;
+    const indices = selectedBlockIndices(sel, ctx.doc.blockCount());
+    for (const i of indices) {
+      const block = ctx.doc.getBlock(i);
+      if (!block) continue;
+      const attrsMap = block.get("attrs") ?? new Y2.Map();
+      if (!block.get("attrs")) block.set("attrs", attrsMap);
+      if (value === null || value === void 0) {
+        attrsMap.delete(key);
+      } else {
+        attrsMap.set(key, value);
+      }
+    }
+    ctx.setSelection(sel);
+  });
+}
+function selectedBlockIndices(sel, blockCount) {
+  const { start, end } = orderedRange(sel);
+  const out = [];
+  const last = Math.min(end.blockIndex, blockCount - 1);
+  for (let i = Math.max(start.blockIndex, 0); i <= last; i++) out.push(i);
+  return out;
+}
+function forEachBlockTextInRange(doc, start, end, visit) {
+  if (sameTextRun(start, end)) {
+    const yText = doc.textAt(start.blockIndex, start.cellIndex);
+    if (!yText) return;
+    if (start.offset < end.offset) visit(yText, start.offset, end.offset);
+    return;
+  }
+  if (start.cellIndex != null || end.cellIndex != null) return;
+  for (let i = start.blockIndex; i <= end.blockIndex; i++) {
+    const yText = doc.getBlockText(i);
+    if (!yText) continue;
+    const localStart = i === start.blockIndex ? start.offset : 0;
+    const localEnd = i === end.blockIndex ? end.offset : yText.length;
+    if (localStart < localEnd) visit(yText, localStart, localEnd);
+  }
+}
+function deleteRange(doc, sel) {
+  const { start, end } = orderedRange(sel);
+  if (sameTextRun(start, end)) {
+    const yText = doc.textAt(start.blockIndex, start.cellIndex);
+    if (yText) yText.delete(start.offset, end.offset - start.offset);
+    return collapsedSelection(start);
+  }
+  if (start.cellIndex != null || end.cellIndex != null) {
+    return collapsedSelection(start);
+  }
+  const startText = doc.getBlockText(start.blockIndex);
+  const endText = doc.getBlockText(end.blockIndex);
+  if (!startText || !endText) return collapsedSelection(start);
+  startText.delete(start.offset, startText.length - start.offset);
+  const remainingTail = endText.toString().slice(end.offset);
+  if (remainingTail.length > 0) {
+    startText.insert(startText.length, remainingTail);
+  }
+  doc.blocks.delete(start.blockIndex + 1, end.blockIndex - start.blockIndex);
+  return collapsedSelection(start);
+}
+function mergeWithPrevious(ctx, blockIndex) {
+  const prevText = ctx.doc.getBlockText(blockIndex - 1);
+  const currText = ctx.doc.getBlockText(blockIndex);
+  if (!prevText || !currText) return;
+  const prevLen = prevText.length;
+  const tail = currText.toString();
+  if (tail.length > 0) prevText.insert(prevLen, tail);
+  ctx.doc.blocks.delete(blockIndex, 1);
+  ctx.setSelection(collapsedSelection({ blockIndex: blockIndex - 1, offset: prevLen }));
+}
+function toggleList(ctx, kind) {
+  transact(ctx.doc, () => {
+    const sel = ctx.getSelection();
+    if (sel.anchor.cellIndex != null || sel.focus.cellIndex != null) return;
+    const indices = selectedBlockIndices(sel, ctx.doc.blockCount());
+    const allMatching = indices.every((i) => {
+      const block = ctx.doc.getBlock(i);
+      if (!block) return false;
+      if (block.get("type") !== "listItem") return false;
+      const attrs = ctx.doc.getBlockAttrs(i);
+      return attrs.listKind === kind;
+    });
+    for (const i of indices) {
+      if (allMatching) {
+        setBlockTypeAtIndex(ctx.doc, i, "paragraph", {});
+      } else {
+        const prev = ctx.doc.getBlockAttrs(i);
+        const level = clampLevel(prev.listLevel);
+        setBlockTypeAtIndex(ctx.doc, i, "listItem", { listKind: kind, listLevel: level });
+      }
+    }
+    ctx.setSelection(sel);
+  });
+}
+function indentList(ctx) {
+  transact(ctx.doc, () => {
+    const sel = ctx.getSelection();
+    if (sel.anchor.cellIndex != null || sel.focus.cellIndex != null) return;
+    const indices = selectedBlockIndices(sel, ctx.doc.blockCount());
+    for (const i of indices) {
+      const block = ctx.doc.getBlock(i);
+      if (!block || block.get("type") !== "listItem") continue;
+      const attrsMap = block.get("attrs");
+      const current = clampLevel(attrsMap.get("listLevel") ?? 0);
+      const next = Math.min(current + 1, MAX_LIST_LEVEL);
+      if (next !== current) attrsMap.set("listLevel", next);
+    }
+    ctx.setSelection(sel);
+  });
+}
+function dedentList(ctx) {
+  transact(ctx.doc, () => {
+    const sel = ctx.getSelection();
+    if (sel.anchor.cellIndex != null || sel.focus.cellIndex != null) return;
+    const indices = selectedBlockIndices(sel, ctx.doc.blockCount());
+    for (const i of indices) {
+      const block = ctx.doc.getBlock(i);
+      if (!block || block.get("type") !== "listItem") continue;
+      const attrsMap = block.get("attrs");
+      const current = clampLevel(attrsMap.get("listLevel") ?? 0);
+      if (current > 0) {
+        attrsMap.set("listLevel", current - 1);
+      } else {
+        setBlockTypeAtIndex(ctx.doc, i, "paragraph", {});
+      }
+    }
+    ctx.setSelection(sel);
+  });
+}
+function splitListItem(ctx) {
+  const sel = ctx.getSelection();
+  if (!isCollapsed(sel)) return false;
+  const pos = sel.focus;
+  if (pos.cellIndex != null) return false;
+  const block = ctx.doc.getBlock(pos.blockIndex);
+  if (!block || block.get("type") !== "listItem") return false;
+  const yText = ctx.doc.getBlockText(pos.blockIndex);
+  if (!yText) return false;
+  const attrs = ctx.doc.getBlockAttrs(pos.blockIndex);
+  const kind = attrs.listKind ?? "bullet";
+  const level = clampLevel(attrs.listLevel ?? 0);
+  transact(ctx.doc, () => {
+    if (yText.length === 0) {
+      if (level > 0) {
+        const m = block.get("attrs");
+        m.set("listLevel", level - 1);
+      } else {
+        setBlockTypeAtIndex(ctx.doc, pos.blockIndex, "paragraph", {});
+      }
+      ctx.setSelection(collapsedSelection({ blockIndex: pos.blockIndex, offset: 0 }));
+      return;
+    }
+    const tail = yText.toString().slice(pos.offset);
+    if (tail.length > 0) yText.delete(pos.offset, tail.length);
+    ctx.doc.blocks.insert(pos.blockIndex + 1, [
+      createBlock("listItem", tail, { listKind: kind, listLevel: level })
+    ]);
+    ctx.setSelection(collapsedSelection({ blockIndex: pos.blockIndex + 1, offset: 0 }));
+  });
+  return true;
+}
+function setBlockTypeAtIndex(doc, index, type, attrs) {
+  const block = doc.getBlock(index);
+  if (!block) return;
+  block.set("type", type);
+  const attrsMap = block.get("attrs") ?? new Y2.Map();
+  if (!block.get("attrs")) block.set("attrs", attrsMap);
+  const next = { ...defaultAttrsFor(type), ...attrs };
+  const keep = new Set(Object.keys(next));
+  for (const k of Array.from(attrsMap.keys())) {
+    if (!keep.has(k)) attrsMap.delete(k);
+  }
+  for (const [k, v] of Object.entries(next)) {
+    if (v === void 0) continue;
+    if (attrsMap.get(k) !== v) attrsMap.set(k, v);
+  }
+}
+function clampLevel(l) {
+  if (typeof l !== "number" || !Number.isFinite(l)) return 0;
+  return Math.max(0, Math.min(MAX_LIST_LEVEL, Math.trunc(l)));
+}
+function insertTable(ctx, rows, cols) {
+  const r = Math.max(1, Math.trunc(rows));
+  const c = Math.max(1, Math.trunc(cols));
+  transact(ctx.doc, () => {
+    const sel = ctx.getSelection();
+    const focusBlock = Math.max(0, Math.min(sel.focus.blockIndex, ctx.doc.blockCount() - 1));
+    const insertAt = focusBlock + 1;
+    ctx.doc.blocks.insert(insertAt, [createTableBlock(r, c)]);
+    ctx.setSelection(
+      collapsedSelection({ blockIndex: insertAt, cellIndex: 0, offset: 0 })
+    );
+  });
+}
+function deleteTable(ctx, blockIndex) {
+  if (!ctx.doc.isTable(blockIndex)) return;
+  transact(ctx.doc, () => {
+    ctx.doc.blocks.delete(blockIndex, 1);
+    if (ctx.doc.blocks.length === 0) {
+      ctx.doc.blocks.push([createBlock("paragraph")]);
+      ctx.setSelection(collapsedSelection({ blockIndex: 0, offset: 0 }));
+      return;
+    }
+    const targetIdx = Math.max(0, Math.min(blockIndex, ctx.doc.blockCount() - 1));
+    const targetType = ctx.doc.getBlockType(targetIdx);
+    if (targetType === "table") {
+      ctx.setSelection(collapsedSelection({ blockIndex: targetIdx, cellIndex: 0, offset: 0 }));
+    } else {
+      ctx.setSelection(collapsedSelection({ blockIndex: targetIdx, offset: 0 }));
+    }
+  });
+}
+function tableLocationOf(doc, pos) {
+  if (pos.cellIndex == null) return null;
+  if (!doc.isTable(pos.blockIndex)) return null;
+  const { cols } = doc.getTableSize(pos.blockIndex);
+  if (cols <= 0) return null;
+  const real = doc.realCellIndex(pos.blockIndex, pos.cellIndex);
+  if (real == null) return null;
+  const row = Math.floor(real / cols);
+  const col = real - row * cols;
+  return { blockIndex: pos.blockIndex, row, col };
+}
+function insertTableRow(ctx, blockIndex, row, where) {
+  if (!ctx.doc.isTable(blockIndex)) return;
+  const { rows, cols } = ctx.doc.getTableSize(blockIndex);
+  if (rows <= 0 || cols <= 0) return;
+  const targetRow = Math.max(0, Math.min(row, rows - 1));
+  const P = where === "before" ? targetRow : targetRow + 1;
+  transact(ctx.doc, () => {
+    const cells = ctx.doc.getCells(blockIndex);
+    const attrs = ctx.doc.getBlockAttrsMap(blockIndex);
+    if (!cells || !attrs) return;
+    const newRowCovered = new Array(cols).fill(false);
+    if (P > 0 && P < rows) {
+      for (let r = 0; r < P; r++) {
+        for (let c = 0; c < cols; c++) {
+          const a = ctx.doc.getCellAttrs(blockIndex, r * cols + c);
+          if (a.covered === true) continue;
+          const rs = spanOf(a.rowspan);
+          const cs = spanOf(a.colspan);
+          if (r < P && r + rs > P) {
+            for (let cc = c; cc < c + cs && cc < cols; cc++) newRowCovered[cc] = true;
+          }
+        }
+      }
+      for (let r = 0; r < P; r++) {
+        for (let c = 0; c < cols; c++) {
+          const idx = r * cols + c;
+          const a = ctx.doc.getCellAttrs(blockIndex, idx);
+          if (a.covered === true) continue;
+          const rs = spanOf(a.rowspan);
+          if (r < P && r + rs > P) {
+            const m = ctx.doc.getCellAttrsMap(blockIndex, idx);
+            m?.set("rowspan", rs + 1);
+          }
+        }
+      }
+    }
+    const fresh = [];
+    for (let c = 0; c < cols; c++) {
+      fresh.push(createCell(newRowCovered[c] ? { covered: true } : void 0));
+    }
+    cells.insert(P * cols, fresh);
+    attrs.set("rows", rows + 1);
+    const firstReal = newRowCovered.findIndex((v) => !v);
+    const targetCellIdx = P * cols + (firstReal < 0 ? 0 : firstReal);
+    ctx.setSelection(
+      collapsedSelection({ blockIndex, cellIndex: targetCellIdx, offset: 0 })
+    );
+  });
+}
+function deleteTableRow(ctx, blockIndex, row) {
+  if (!ctx.doc.isTable(blockIndex)) return;
+  const { rows, cols } = ctx.doc.getTableSize(blockIndex);
+  if (rows <= 0 || cols <= 0) return;
+  if (rows === 1) {
+    deleteTable(ctx, blockIndex);
+    return;
+  }
+  const R = Math.max(0, Math.min(row, rows - 1));
+  transact(ctx.doc, () => {
+    const cells = ctx.doc.getCells(blockIndex);
+    const attrs = ctx.doc.getBlockAttrsMap(blockIndex);
+    if (!cells || !attrs) return;
+    for (let r = 0; r < R; r++) {
+      for (let c = 0; c < cols; c++) {
+        const idx = r * cols + c;
+        const a = ctx.doc.getCellAttrs(blockIndex, idx);
+        if (a.covered === true) continue;
+        const rs = spanOf(a.rowspan);
+        if (r < R && r + rs > R) {
+          const m = ctx.doc.getCellAttrsMap(blockIndex, idx);
+          m?.set("rowspan", rs - 1);
+          if (rs - 1 === 1) m?.delete("rowspan");
+        }
+      }
+    }
+    const promotions = [];
+    for (let c = 0; c < cols; c++) {
+      const a = ctx.doc.getCellAttrs(blockIndex, R * cols + c);
+      if (a.covered === true) continue;
+      const rs = spanOf(a.rowspan);
+      const cs = spanOf(a.colspan);
+      if (rs > 1 && R + 1 < rows) {
+        promotions.push({ flatNew: R * cols + c, rowspan: rs - 1, colspan: cs });
+      }
+    }
+    cells.delete(R * cols, cols);
+    attrs.set("rows", rows - 1);
+    for (const p of promotions) {
+      const m = ctx.doc.getCellAttrsMap(blockIndex, p.flatNew);
+      if (!m) continue;
+      m.delete("covered");
+      if (p.rowspan > 1) m.set("rowspan", p.rowspan);
+      else m.delete("rowspan");
+      if (p.colspan > 1) m.set("colspan", p.colspan);
+      else m.delete("colspan");
+    }
+    const newRow = Math.min(R, rows - 2);
+    const target = findNextRealCell(ctx.doc, blockIndex, newRow * cols, (rows - 1) * cols) ?? 0;
+    ctx.setSelection(
+      collapsedSelection({ blockIndex, cellIndex: target, offset: 0 })
+    );
+  });
+}
+function insertTableColumn(ctx, blockIndex, col, where) {
+  if (!ctx.doc.isTable(blockIndex)) return;
+  const { rows, cols } = ctx.doc.getTableSize(blockIndex);
+  if (rows <= 0 || cols <= 0) return;
+  const targetCol = Math.max(0, Math.min(col, cols - 1));
+  const C = where === "before" ? targetCol : targetCol + 1;
+  transact(ctx.doc, () => {
+    const cells = ctx.doc.getCells(blockIndex);
+    const attrs = ctx.doc.getBlockAttrsMap(blockIndex);
+    if (!cells || !attrs) return;
+    const newColCovered = new Array(rows).fill(false);
+    if (C > 0 && C < cols) {
+      for (let r = 0; r < rows; r++) {
+        for (let c = 0; c < C; c++) {
+          const a = ctx.doc.getCellAttrs(blockIndex, r * cols + c);
+          if (a.covered === true) continue;
+          const rs = spanOf(a.rowspan);
+          const cs = spanOf(a.colspan);
+          if (c < C && c + cs > C) {
+            for (let rr = r; rr < r + rs && rr < rows; rr++) newColCovered[rr] = true;
+          }
+        }
+      }
+      for (let r = 0; r < rows; r++) {
+        for (let c = 0; c < C; c++) {
+          const idx = r * cols + c;
+          const a = ctx.doc.getCellAttrs(blockIndex, idx);
+          if (a.covered === true) continue;
+          const cs = spanOf(a.colspan);
+          if (c < C && c + cs > C) {
+            const m = ctx.doc.getCellAttrsMap(blockIndex, idx);
+            m?.set("colspan", cs + 1);
+          }
+        }
+      }
+    }
+    for (let r = rows - 1; r >= 0; r--) {
+      const at = r * cols + C;
+      cells.insert(at, [createCell(newColCovered[r] ? { covered: true } : void 0)]);
+    }
+    attrs.set("cols", cols + 1);
+    const widths = attrs.get("colWidths");
+    if (Array.isArray(widths) && widths.length === cols) {
+      const next = widths.slice();
+      next.splice(C, 0, 100);
+      attrs.set("colWidths", next);
+    }
+    const newCols = cols + 1;
+    const focusRow = 0;
+    const firstReal = newColCovered.findIndex((_, r) => r === focusRow && !newColCovered[r]);
+    ctx.setSelection(
+      collapsedSelection({
+        blockIndex,
+        cellIndex: focusRow * newCols + C + (firstReal < 0 ? 0 : 0),
+        offset: 0
+      })
+    );
+  });
+}
+function deleteTableColumn(ctx, blockIndex, col) {
+  if (!ctx.doc.isTable(blockIndex)) return;
+  const { rows, cols } = ctx.doc.getTableSize(blockIndex);
+  if (rows <= 0 || cols <= 0) return;
+  if (cols === 1) {
+    deleteTable(ctx, blockIndex);
+    return;
+  }
+  const C = Math.max(0, Math.min(col, cols - 1));
+  transact(ctx.doc, () => {
+    const cells = ctx.doc.getCells(blockIndex);
+    const attrs = ctx.doc.getBlockAttrsMap(blockIndex);
+    if (!cells || !attrs) return;
+    for (let r = 0; r < rows; r++) {
+      for (let c = 0; c < C; c++) {
+        const idx = r * cols + c;
+        const a = ctx.doc.getCellAttrs(blockIndex, idx);
+        if (a.covered === true) continue;
+        const cs = spanOf(a.colspan);
+        if (c < C && c + cs > C) {
+          const m = ctx.doc.getCellAttrsMap(blockIndex, idx);
+          m?.set("colspan", cs - 1);
+          if (cs - 1 === 1) m?.delete("colspan");
+        }
+      }
+    }
+    const promotions = [];
+    const newCols = cols - 1;
+    for (let r = 0; r < rows; r++) {
+      const a = ctx.doc.getCellAttrs(blockIndex, r * cols + C);
+      if (a.covered === true) continue;
+      const rs = spanOf(a.rowspan);
+      const cs = spanOf(a.colspan);
+      if (cs > 1 && C + 1 < cols) {
+        promotions.push({
+          flatNew: r * newCols + C,
+          rowspan: rs,
+          colspan: cs - 1
+        });
+      }
+    }
+    for (let r = rows - 1; r >= 0; r--) {
+      const at = r * cols + C;
+      cells.delete(at, 1);
+    }
+    attrs.set("cols", newCols);
+    for (const p of promotions) {
+      const m = ctx.doc.getCellAttrsMap(blockIndex, p.flatNew);
+      if (!m) continue;
+      m.delete("covered");
+      if (p.rowspan > 1) m.set("rowspan", p.rowspan);
+      else m.delete("rowspan");
+      if (p.colspan > 1) m.set("colspan", p.colspan);
+      else m.delete("colspan");
+    }
+    const widths = attrs.get("colWidths");
+    if (Array.isArray(widths) && widths.length === cols) {
+      const next = widths.slice();
+      next.splice(C, 1);
+      attrs.set("colWidths", next);
+    }
+    const newCol = Math.min(C, newCols - 1);
+    const target = findNextRealCell(ctx.doc, blockIndex, newCol, rows * newCols) ?? 0;
+    ctx.setSelection(
+      collapsedSelection({ blockIndex, cellIndex: target, offset: 0 })
+    );
+  });
+}
+function tableRectSelection(doc, sel) {
+  if (sel.anchor.blockIndex !== sel.focus.blockIndex) return null;
+  if (sel.anchor.cellIndex == null || sel.focus.cellIndex == null) return null;
+  const blockIndex = sel.anchor.blockIndex;
+  if (!doc.isTable(blockIndex)) return null;
+  const aLoc = tableLocationOf(doc, sel.anchor);
+  const fLoc = tableLocationOf(doc, sel.focus);
+  if (!aLoc || !fLoc) return null;
+  if (aLoc.row === fLoc.row && aLoc.col === fLoc.col) return null;
+  return expandTableRect(
+    doc,
+    blockIndex,
+    Math.min(aLoc.row, fLoc.row),
+    Math.min(aLoc.col, fLoc.col),
+    Math.max(aLoc.row, fLoc.row),
+    Math.max(aLoc.col, fLoc.col)
+  );
+}
+function expandTableRect(doc, blockIndex, initTop, initLeft, initBottom, initRight) {
+  const { rows, cols } = doc.getTableSize(blockIndex);
+  let top = Math.max(0, initTop);
+  let left = Math.max(0, initLeft);
+  let bottom = Math.min(rows - 1, initBottom);
+  let right = Math.min(cols - 1, initRight);
+  let changed = true;
+  let guard = rows * cols + 1;
+  while (changed && guard-- > 0) {
+    changed = false;
+    for (let r = top; r <= bottom; r++) {
+      for (let c = left; c <= right; c++) {
+        const idx = r * cols + c;
+        const a = doc.getCellAttrs(blockIndex, idx);
+        if (a.covered === true) {
+          const owner = doc.realCellIndex(blockIndex, idx);
+          if (owner == null) continue;
+          const oRow = Math.floor(owner / cols);
+          const oCol = owner - oRow * cols;
+          if (oRow < top) {
+            top = oRow;
+            changed = true;
+          }
+          if (oCol < left) {
+            left = oCol;
+            changed = true;
+          }
+          const oAttrs = doc.getCellAttrs(blockIndex, owner);
+          const oRs = spanOf(oAttrs.rowspan);
+          const oCs = spanOf(oAttrs.colspan);
+          if (oRow + oRs - 1 > bottom) {
+            bottom = oRow + oRs - 1;
+            changed = true;
+          }
+          if (oCol + oCs - 1 > right) {
+            right = oCol + oCs - 1;
+            changed = true;
+          }
+        } else {
+          const rs = spanOf(a.rowspan);
+          const cs = spanOf(a.colspan);
+          if (r + rs - 1 > bottom) {
+            bottom = r + rs - 1;
+            changed = true;
+          }
+          if (c + cs - 1 > right) {
+            right = c + cs - 1;
+            changed = true;
+          }
+        }
+      }
+    }
+  }
+  return { blockIndex, top, left, bottom, right };
+}
+function cellsInRect(doc, rect) {
+  const { cols } = doc.getTableSize(rect.blockIndex);
+  const out = [];
+  for (let r = rect.top; r <= rect.bottom; r++) {
+    for (let c = rect.left; c <= rect.right; c++) out.push(r * cols + c);
+  }
+  return out;
+}
+function mergeSelection(ctx) {
+  const sel = ctx.getSelection();
+  const rect = tableRectSelection(ctx.doc, sel);
+  if (!rect) return false;
+  const { blockIndex, top, left, bottom, right } = rect;
+  const { cols } = ctx.doc.getTableSize(blockIndex);
+  const ownerIdx = top * cols + left;
+  transact(ctx.doc, () => {
+    const ownerText = ctx.doc.getCellText(blockIndex, ownerIdx);
+    if (!ownerText) return;
+    for (let r = top; r <= bottom; r++) {
+      for (let c = left; c <= right; c++) {
+        const idx = r * cols + c;
+        if (idx === ownerIdx) continue;
+        const a = ctx.doc.getCellAttrs(blockIndex, idx);
+        if (a.covered !== true) {
+          const t = ctx.doc.getCellText(blockIndex, idx);
+          if (t && t.length > 0) {
+            const sep = ownerText.length > 0 ? " " : "";
+            const delta = t.toDelta();
+            let pos = ownerText.length;
+            if (sep) {
+              ownerText.insert(pos, sep);
+              pos += 1;
+            }
+            writeDeltaInto(ownerText, pos, delta);
+            t.delete(0, t.length);
+          }
+        }
+        const m = ctx.doc.getCellAttrsMap(blockIndex, idx);
+        if (m) {
+          m.delete("rowspan");
+          m.delete("colspan");
+          m.set("covered", true);
+        }
+      }
+    }
+    const oMap = ctx.doc.getCellAttrsMap(blockIndex, ownerIdx);
+    if (oMap) {
+      const newRs = bottom - top + 1;
+      const newCs = right - left + 1;
+      if (newRs > 1) oMap.set("rowspan", newRs);
+      else oMap.delete("rowspan");
+      if (newCs > 1) oMap.set("colspan", newCs);
+      else oMap.delete("colspan");
+      oMap.delete("covered");
+    }
+    ctx.setSelection(
+      collapsedSelection({ blockIndex, cellIndex: ownerIdx, offset: 0 })
+    );
+  });
+  return true;
+}
+function clearRectCells(ctx) {
+  const sel = ctx.getSelection();
+  const rect = tableRectSelection(ctx.doc, sel);
+  if (!rect) return null;
+  const { blockIndex, top, left, bottom, right } = rect;
+  const { cols } = ctx.doc.getTableSize(blockIndex);
+  const ownerIdx = top * cols + left;
+  let result = null;
+  transact(ctx.doc, () => {
+    for (let r = top; r <= bottom; r++) {
+      for (let c = left; c <= right; c++) {
+        const idx = r * cols + c;
+        const a = ctx.doc.getCellAttrs(blockIndex, idx);
+        if (a.covered === true) continue;
+        const t = ctx.doc.getCellText(blockIndex, idx);
+        if (t && t.length > 0) t.delete(0, t.length);
+      }
+    }
+    result = collapsedSelection({ blockIndex, cellIndex: ownerIdx, offset: 0 });
+    ctx.setSelection(result);
+  });
+  return result;
+}
+function mergeRight(ctx, blockIndex, row, col) {
+  if (!ctx.doc.isTable(blockIndex)) return false;
+  const { rows, cols } = ctx.doc.getTableSize(blockIndex);
+  if (row < 0 || row >= rows || col < 0 || col >= cols) return false;
+  const ownerIdx = row * cols + col;
+  const ownerAttrs = ctx.doc.getCellAttrs(blockIndex, ownerIdx);
+  if (ownerAttrs.covered === true) return false;
+  const ownerRs = spanOf(ownerAttrs.rowspan);
+  const ownerCs = spanOf(ownerAttrs.colspan);
+  const nbCol = col + ownerCs;
+  if (nbCol >= cols) return false;
+  const nbIdx = row * cols + nbCol;
+  const nbAttrs = ctx.doc.getCellAttrs(blockIndex, nbIdx);
+  if (nbAttrs.covered === true) return false;
+  const nbRs = spanOf(nbAttrs.rowspan);
+  const nbCs = spanOf(nbAttrs.colspan);
+  if (nbRs !== ownerRs) return false;
+  transact(ctx.doc, () => {
+    const ownerText = ctx.doc.getCellText(blockIndex, ownerIdx);
+    const nbText = ctx.doc.getCellText(blockIndex, nbIdx);
+    if (ownerText && nbText && nbText.length > 0) {
+      const sep = ownerText.length > 0 ? " " : "";
+      const delta = nbText.toDelta();
+      let pos = ownerText.length;
+      if (sep) {
+        ownerText.insert(pos, sep);
+        pos += 1;
+      }
+      writeDeltaInto(ownerText, pos, delta);
+    }
+    if (nbText && nbText.length > 0) nbText.delete(0, nbText.length);
+    const ownerMap = ctx.doc.getCellAttrsMap(blockIndex, ownerIdx);
+    if (ownerMap) ownerMap.set("colspan", ownerCs + nbCs);
+    for (let r = row; r < row + ownerRs; r++) {
+      for (let c = nbCol; c < nbCol + nbCs; c++) {
+        const m = ctx.doc.getCellAttrsMap(blockIndex, r * cols + c);
+        if (!m) continue;
+        m.delete("rowspan");
+        m.delete("colspan");
+        m.set("covered", true);
+      }
+    }
+    ctx.setSelection(collapsedSelection({ blockIndex, cellIndex: ownerIdx, offset: 0 }));
+  });
+  return true;
+}
+function mergeDown(ctx, blockIndex, row, col) {
+  if (!ctx.doc.isTable(blockIndex)) return false;
+  const { rows, cols } = ctx.doc.getTableSize(blockIndex);
+  if (row < 0 || row >= rows || col < 0 || col >= cols) return false;
+  const ownerIdx = row * cols + col;
+  const ownerAttrs = ctx.doc.getCellAttrs(blockIndex, ownerIdx);
+  if (ownerAttrs.covered === true) return false;
+  const ownerRs = spanOf(ownerAttrs.rowspan);
+  const ownerCs = spanOf(ownerAttrs.colspan);
+  const nbRow = row + ownerRs;
+  if (nbRow >= rows) return false;
+  const nbIdx = nbRow * cols + col;
+  const nbAttrs = ctx.doc.getCellAttrs(blockIndex, nbIdx);
+  if (nbAttrs.covered === true) return false;
+  const nbRs = spanOf(nbAttrs.rowspan);
+  const nbCs = spanOf(nbAttrs.colspan);
+  if (nbCs !== ownerCs) return false;
+  transact(ctx.doc, () => {
+    const ownerText = ctx.doc.getCellText(blockIndex, ownerIdx);
+    const nbText = ctx.doc.getCellText(blockIndex, nbIdx);
+    if (ownerText && nbText && nbText.length > 0) {
+      const sep = ownerText.length > 0 ? " " : "";
+      const delta = nbText.toDelta();
+      let pos = ownerText.length;
+      if (sep) {
+        ownerText.insert(pos, sep);
+        pos += 1;
+      }
+      writeDeltaInto(ownerText, pos, delta);
+    }
+    if (nbText && nbText.length > 0) nbText.delete(0, nbText.length);
+    const ownerMap = ctx.doc.getCellAttrsMap(blockIndex, ownerIdx);
+    if (ownerMap) ownerMap.set("rowspan", ownerRs + nbRs);
+    for (let r = nbRow; r < nbRow + nbRs; r++) {
+      for (let c = col; c < col + ownerCs; c++) {
+        const m = ctx.doc.getCellAttrsMap(blockIndex, r * cols + c);
+        if (!m) continue;
+        m.delete("rowspan");
+        m.delete("colspan");
+        m.set("covered", true);
+      }
+    }
+    ctx.setSelection(collapsedSelection({ blockIndex, cellIndex: ownerIdx, offset: 0 }));
+  });
+  return true;
+}
+function splitCell(ctx, blockIndex, row, col) {
+  if (!ctx.doc.isTable(blockIndex)) return false;
+  const { rows, cols } = ctx.doc.getTableSize(blockIndex);
+  if (row < 0 || row >= rows || col < 0 || col >= cols) return false;
+  const idx = row * cols + col;
+  const attrs = ctx.doc.getCellAttrs(blockIndex, idx);
+  if (attrs.covered === true) return false;
+  const rs = spanOf(attrs.rowspan);
+  const cs = spanOf(attrs.colspan);
+  if (rs === 1 && cs === 1) return false;
+  transact(ctx.doc, () => {
+    const ownerMap = ctx.doc.getCellAttrsMap(blockIndex, idx);
+    if (ownerMap) {
+      ownerMap.delete("rowspan");
+      ownerMap.delete("colspan");
+    }
+    for (let r = row; r < row + rs; r++) {
+      for (let c = col; c < col + cs; c++) {
+        if (r === row && c === col) continue;
+        const m = ctx.doc.getCellAttrsMap(blockIndex, r * cols + c);
+        if (!m) continue;
+        m.delete("covered");
+        m.delete("rowspan");
+        m.delete("colspan");
+      }
+    }
+    ctx.setSelection(collapsedSelection({ blockIndex, cellIndex: idx, offset: 0 }));
+  });
+  return true;
+}
+function setColumnWidth(ctx, blockIndex, col, widthPx) {
+  if (!ctx.doc.isTable(blockIndex)) return;
+  const { cols } = ctx.doc.getTableSize(blockIndex);
+  if (col < 0 || col >= cols) return;
+  const w = Math.max(20, Math.round(widthPx));
+  transact(ctx.doc, () => {
+    const attrsMap = ctx.doc.getBlockAttrsMap(blockIndex);
+    if (!attrsMap) return;
+    const current = attrsMap.get("colWidths");
+    const next = Array.isArray(current) && current.length === cols ? current.slice() : new Array(cols).fill(120);
+    next[col] = w;
+    attrsMap.set("colWidths", next);
+  });
+}
+function moveToNextCell(ctx) {
+  const sel = ctx.getSelection();
+  const loc = tableLocationOf(ctx.doc, sel.focus);
+  if (!loc) return false;
+  const { rows, cols } = ctx.doc.getTableSize(loc.blockIndex);
+  if (rows <= 0 || cols <= 0) return false;
+  const startFlat = loc.row * cols + loc.col + 1;
+  const next = findNextRealCell(ctx.doc, loc.blockIndex, startFlat, rows * cols);
+  if (next == null) {
+    insertTableRow(ctx, loc.blockIndex, rows - 1, "after");
+    return true;
+  }
+  ctx.setSelection(
+    collapsedSelection({ blockIndex: loc.blockIndex, cellIndex: next, offset: 0 })
+  );
+  return true;
+}
+function moveToPrevCell(ctx) {
+  const sel = ctx.getSelection();
+  const loc = tableLocationOf(ctx.doc, sel.focus);
+  if (!loc) return false;
+  const { rows, cols } = ctx.doc.getTableSize(loc.blockIndex);
+  if (rows <= 0 || cols <= 0) return false;
+  const startFlat = loc.row * cols + loc.col - 1;
+  if (startFlat < 0) return true;
+  const prev = findPrevRealCell(ctx.doc, loc.blockIndex, startFlat);
+  if (prev == null) return true;
+  const cellText = ctx.doc.getCellText(loc.blockIndex, prev);
+  const off = cellText?.length ?? 0;
+  ctx.setSelection(
+    collapsedSelection({ blockIndex: loc.blockIndex, cellIndex: prev, offset: off })
+  );
+  return true;
+}
+function findNextRealCell(doc, blockIndex, startFlat, total) {
+  for (let i = startFlat; i < total; i++) {
+    if (doc.getCellAttrs(blockIndex, i).covered !== true) return i;
+  }
+  return null;
+}
+function findPrevRealCell(doc, blockIndex, startFlat) {
+  for (let i = startFlat; i >= 0; i--) {
+    if (doc.getCellAttrs(blockIndex, i).covered !== true) return i;
+  }
+  return null;
+}
+function writeDeltaInto(yText, pos, delta) {
+  let cursor = pos;
+  for (const op of delta) {
+    if (typeof op.insert === "string") {
+      if (op.insert.length === 0) continue;
+      if (op.attributes && Object.keys(op.attributes).length > 0) {
+        yText.insert(cursor, op.insert, op.attributes);
+      } else {
+        yText.insert(cursor, op.insert);
+      }
+      cursor += op.insert.length;
+    } else if (op.insert != null) {
+      if (op.attributes && Object.keys(op.attributes).length > 0) {
+        yText.insert(
+          cursor,
+          op.insert,
+          op.attributes
+        );
+      } else {
+        yText.insert(cursor, op.insert);
+      }
+      cursor += 1;
+    }
+  }
+  return cursor;
+}
+function insertImage(ctx, embed) {
+  clearRectCells(ctx);
+  transact(ctx.doc, () => {
+    const sel0 = ctx.getSelection();
+    let cursor = sel0;
+    if (!isCollapsed(sel0)) cursor = deleteRange(ctx.doc, sel0);
+    const pos = cursor.focus;
+    const yText = ctx.doc.textAt(pos.blockIndex, pos.cellIndex);
+    if (!yText) return;
+    yText.insert(pos.offset, embed);
+    const newPos = {
+      blockIndex: pos.blockIndex,
+      cellIndex: pos.cellIndex,
+      offset: pos.offset + 1
+    };
+    ctx.setSelection(collapsedSelection(newPos));
+  });
+}
+function setImageAttrs(ctx, blockIndex, embedOffset, partial, cellIndex, newOffset) {
+  transact(ctx.doc, () => {
+    const yText = ctx.doc.textAt(blockIndex, cellIndex);
+    if (!yText) return;
+    const delta = yText.toDelta();
+    let cursor = 0;
+    let prev = null;
+    for (const op of delta) {
+      if (typeof op.insert === "string") {
+        cursor += op.insert.length;
+        continue;
+      }
+      if (cursor === embedOffset && isImageEmbed(op.insert)) {
+        prev = op.insert;
+        break;
+      }
+      cursor += 1;
+    }
+    if (!prev) return;
+    const merged = { ...prev, ...partial };
+    yText.delete(embedOffset, 1);
+    const insertAt = newOffset != null && newOffset !== embedOffset ? Math.max(0, Math.min(newOffset, yText.length)) : embedOffset;
+    yText.insert(insertAt, merged);
+  });
+}
+function isCommandOrigin(origin) {
+  return origin === COMMAND_ORIGIN;
+}
+var TRACKED_ORIGINS = /* @__PURE__ */ new Set([COMMAND_ORIGIN]);
+
+// src/history.ts
+import * as Y3 from "yjs";
+var EditorHistory = class {
+  undoManager;
+  constructor(doc) {
+    this.undoManager = new Y3.UndoManager(doc.blocks, {
+      trackedOrigins: TRACKED_ORIGINS,
+      captureTimeout: 400
+    });
+  }
+  undo() {
+    return this.undoManager.undo() != null;
+  }
+  redo() {
+    return this.undoManager.redo() != null;
+  }
+  destroy() {
+    this.undoManager.destroy();
+  }
+};
+export {
+  BLOCK_SPECS,
+  COMMAND_ORIGIN,
+  DEFAULT_PAGE_SETTINGS,
+  EditorDocument,
+  EditorHistory,
+  MARGIN_PRESETS,
+  MAX_LIST_LEVEL,
+  PAGE_PRESETS,
+  TRACKED_ORIGINS,
+  Y2 as Y,
+  cellsInRect,
+  clearRectCells,
+  collapsedSelection,
+  comparePositions,
+  createBlock,
+  createCell,
+  createTableBlock,
+  dedentList,
+  defaultAttrsFor,
+  deleteBackward,
+  deleteForward,
+  deleteTable,
+  deleteTableColumn,
+  deleteTableRow,
+  deltaLength,
+  detectPreset,
+  expandTableRect,
+  getMarksInRange,
+  indentList,
+  insertImage,
+  insertParagraph,
+  insertTable,
+  insertTableColumn,
+  insertTableRow,
+  insertText,
+  isCollapsed,
+  isCommandOrigin,
+  isImageEmbed,
+  isKnownBlockType,
+  isLegacySerializedDocument,
+  isMarkUniformInRange,
+  mergeDown,
+  mergeRight,
+  mergeSelection,
+  mmToPx,
+  moveToNextCell,
+  moveToPrevCell,
+  orderedRange,
+  positionsEqual,
+  pxToMm,
+  removeMark,
+  sameTextRun,
+  setBlockAttr,
+  setBlockType,
+  setColumnWidth,
+  setImageAttrs,
+  setMark,
+  sliceDelta,
+  spanOf,
+  splitCell,
+  splitListItem,
+  tableLocationOf,
+  tableRectSelection,
+  toggleList,
+  toggleMark,
+  withDefaults
+};
+//# sourceMappingURL=index.js.map