@coco-vexel/coco-office-editor 0.0.0-stage → 1.0.1

package/dist/word-editing.js

@@ -0,0 +1,803 @@
+import { PluginKey, Plugin } from 'prosemirror-state';
+import { Schema } from 'prosemirror-model';
+import 'prosemirror-commands';
+import 'prosemirror-keymap';
+import 'prosemirror-view';
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var wordEditorSchema = new Schema({
+  nodes: {
+    doc: { content: "block+" },
+    paragraph: {
+      group: "block",
+      content: "inline*",
+      attrs: {
+        paraId: { default: "" },
+        story: { default: "body" },
+        styleId: { default: null },
+        format: { default: null }
+      },
+      parseDOM: [{ tag: "p" }],
+      toDOM: /* @__PURE__ */ __name((node) => ["p", paragraphDomAttrs(node.attrs), 0], "toDOM")
+    },
+    table: {
+      group: "block",
+      content: "table_row+",
+      attrs: {
+        tableId: { default: "" },
+        columnWidths: { default: null }
+      },
+      tableRole: "table",
+      toDOM: /* @__PURE__ */ __name((node) => [
+        "div",
+        { class: "coco-word-table-scroll" },
+        ["table", tableDomAttrs(node.attrs), ["tbody", 0]]
+      ], "toDOM")
+    },
+    table_row: {
+      content: "table_cell+",
+      tableRole: "row",
+      toDOM: /* @__PURE__ */ __name(() => ["tr", 0], "toDOM")
+    },
+    table_cell: {
+      content: "block+",
+      attrs: {
+        colspan: { default: 1 },
+        rowspan: { default: 1 },
+        width: { default: null },
+        shading: { default: null },
+        verticalAlignment: { default: null }
+      },
+      tableRole: "cell",
+      toDOM: /* @__PURE__ */ __name((node) => ["td", tableCellDomAttrs(node.attrs), 0], "toDOM")
+    },
+    image: {
+      inline: true,
+      group: "inline",
+      atom: true,
+      attrs: {
+        src: {},
+        alt: { default: "" },
+        width: { default: null },
+        height: { default: null },
+        drawingId: { default: null }
+      },
+      toDOM: /* @__PURE__ */ __name((node) => ["img", imageDomAttrs(node.attrs)], "toDOM")
+    },
+    text: { group: "inline" }
+  },
+  marks: {
+    strong: {
+      parseDOM: [{ tag: "strong" }, { tag: "b" }],
+      toDOM: /* @__PURE__ */ __name(() => ["strong", 0], "toDOM")
+    },
+    em: {
+      parseDOM: [{ tag: "em" }, { tag: "i" }],
+      toDOM: /* @__PURE__ */ __name(() => ["em", 0], "toDOM")
+    },
+    underline: {
+      parseDOM: [{ tag: "u" }],
+      toDOM: /* @__PURE__ */ __name(() => ["u", 0], "toDOM")
+    },
+    textStyle: {
+      attrs: {
+        color: { default: null },
+        fontSize: { default: null }
+      },
+      parseDOM: [{ tag: "span" }],
+      toDOM: /* @__PURE__ */ __name((mark) => ["span", textStyleDomAttrs(mark.attrs), 0], "toDOM")
+    }
+  }
+});
+new PluginKey("coco-word-decorations");
+var wordStructureNormalizationKey = new PluginKey("coco-word-structure-normalization");
+function paragraphDomAttrs(attrs) {
+  const domAttrs = {};
+  if (typeof attrs.paraId === "string" && attrs.paraId.length > 0) {
+    domAttrs["data-para-id"] = attrs.paraId;
+  }
+  if (typeof attrs.story === "string" && attrs.story.length > 0) {
+    domAttrs["data-story"] = attrs.story;
+  }
+  if (typeof attrs.styleId === "string" && attrs.styleId.length > 0) {
+    domAttrs["data-style-id"] = attrs.styleId;
+  }
+  const format = isParagraphFormat(attrs.format) ? attrs.format : null;
+  if ((format == null ? void 0 : format.outlineLevel) !== void 0) {
+    domAttrs["data-outline-level"] = String(format.outlineLevel);
+  }
+  const style = paragraphStyle(format);
+  if (style.length > 0) domAttrs.style = style;
+  return domAttrs;
+}
+__name(paragraphDomAttrs, "paragraphDomAttrs");
+function tableDomAttrs(attrs) {
+  const domAttrs = {};
+  if (typeof attrs.tableId === "string" && attrs.tableId.length > 0) {
+    domAttrs["data-table-id"] = attrs.tableId;
+  }
+  return domAttrs;
+}
+__name(tableDomAttrs, "tableDomAttrs");
+function tableCellDomAttrs(attrs) {
+  const domAttrs = {};
+  if (typeof attrs.colspan === "number" && attrs.colspan > 1) {
+    domAttrs.colspan = String(attrs.colspan);
+  }
+  if (typeof attrs.rowspan === "number" && attrs.rowspan > 1) {
+    domAttrs.rowspan = String(attrs.rowspan);
+  }
+  const style = [];
+  if (typeof attrs.width === "number" && attrs.width > 0) {
+    style.push(`width: ${twipsToPt(attrs.width)}`);
+  }
+  if (isShading(attrs.shading)) {
+    const fill = colorToCss(attrs.shading.fill);
+    if (fill) style.push(`background-color: ${fill}`);
+  }
+  if (typeof attrs.verticalAlignment === "string") {
+    style.push(`vertical-align: ${attrs.verticalAlignment === "center" ? "middle" : attrs.verticalAlignment}`);
+  }
+  if (style.length > 0) domAttrs.style = style.join("; ");
+  return domAttrs;
+}
+__name(tableCellDomAttrs, "tableCellDomAttrs");
+function imageDomAttrs(attrs) {
+  const domAttrs = {
+    src: typeof attrs.src === "string" ? attrs.src : "",
+    alt: typeof attrs.alt === "string" ? attrs.alt : ""
+  };
+  if (typeof attrs.drawingId === "string") domAttrs["data-drawing-id"] = attrs.drawingId;
+  const style = [];
+  if (typeof attrs.width === "number" && attrs.width > 0) {
+    style.push(`width: ${attrs.width}px`);
+  }
+  if (typeof attrs.height === "number" && attrs.height > 0) {
+    style.push(`height: ${attrs.height}px`);
+  }
+  if (style.length > 0) domAttrs.style = style.join("; ");
+  return domAttrs;
+}
+__name(imageDomAttrs, "imageDomAttrs");
+function isShading(value) {
+  return value !== null && typeof value === "object";
+}
+__name(isShading, "isShading");
+function textStyleDomAttrs(attrs) {
+  const style = [];
+  const color = typeof attrs.color === "string" ? colorToCss(attrs.color) : null;
+  if (color) style.push(`color: ${color}`);
+  if (typeof attrs.fontSize === "number") style.push(`font-size: ${attrs.fontSize}pt`);
+  return style.length > 0 ? { style: style.join("; ") } : {};
+}
+__name(textStyleDomAttrs, "textStyleDomAttrs");
+function isParagraphFormat(value) {
+  return value !== null && typeof value === "object";
+}
+__name(isParagraphFormat, "isParagraphFormat");
+function paragraphStyle(format) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  if (!format) return "";
+  const declarations = [];
+  if (format.alignment) declarations.push(`text-align: ${alignmentToCss(format.alignment)}`);
+  if (((_a = format.indent) == null ? void 0 : _a.left) !== void 0) declarations.push(`margin-left: ${twipsToPt(format.indent.left)}`);
+  if (((_b = format.indent) == null ? void 0 : _b.right) !== void 0) declarations.push(`margin-right: ${twipsToPt(format.indent.right)}`);
+  if (((_c = format.indent) == null ? void 0 : _c.firstLine) !== void 0) {
+    declarations.push(`text-indent: ${twipsToPt(format.indent.firstLine)}`);
+  }
+  if (((_d = format.spacing) == null ? void 0 : _d.before) !== void 0) {
+    declarations.push(`margin-top: ${twipsToPt(format.spacing.before)}`);
+  }
+  if (((_e = format.spacing) == null ? void 0 : _e.after) !== void 0) {
+    declarations.push(`margin-bottom: ${twipsToPt(format.spacing.after)}`);
+  }
+  const lineHeight = lineHeightToCss((_f = format.spacing) == null ? void 0 : _f.line, (_g = format.spacing) == null ? void 0 : _g.lineRule);
+  if (lineHeight) declarations.push(`line-height: ${lineHeight}`);
+  if (format.fontSize !== void 0) declarations.push(`font-size: ${format.fontSize}pt`);
+  if (format.bold !== void 0) declarations.push(`font-weight: ${format.bold ? "700" : "400"}`);
+  const borderBottom = borderToCss(format.borderBottom);
+  if (borderBottom) {
+    declarations.push(`border-bottom: ${borderBottom}`);
+    declarations.push(`padding-bottom: ${(_i = (_h = format.borderBottom) == null ? void 0 : _h.space) != null ? _i : 4}pt`);
+  }
+  return declarations.join("; ");
+}
+__name(paragraphStyle, "paragraphStyle");
+function alignmentToCss(alignment) {
+  if (alignment === "both" || alignment === "distribute") return "justify";
+  return alignment;
+}
+__name(alignmentToCss, "alignmentToCss");
+function borderToCss(border) {
+  var _a;
+  if (!border || border.val === "none" || border.val === "nil") return null;
+  const color = (_a = colorToCss(border.color)) != null ? _a : "#000000";
+  const widthPt = border.size !== void 0 ? Math.max(0.75, border.size / 8) : 0.75;
+  const style = border.val === "double" ? "double" : "solid";
+  return `${widthPt}pt ${style} ${color}`;
+}
+__name(borderToCss, "borderToCss");
+function lineHeightToCss(line, lineRule) {
+  if (line === void 0) return null;
+  if (lineRule === "exact" || lineRule === "atLeast") return twipsToPt(line);
+  return String(line / 240);
+}
+__name(lineHeightToCss, "lineHeightToCss");
+function twipsToPt(twips) {
+  return `${twips / 20}pt`;
+}
+__name(twipsToPt, "twipsToPt");
+function colorToCss(color) {
+  if (!color || color === "auto") return null;
+  return /^[0-9a-f]{6}$/i.test(color) ? `#${color}` : null;
+}
+__name(colorToCss, "colorToCss");
+
+// src/word/editing.ts
+var wordEditingPluginKey = new PluginKey("coco-word-editing");
+var changeSequence = 0;
+function createWordEditingPlugin(options = {}) {
+  return new Plugin({
+    key: wordEditingPluginKey,
+    appendTransaction(transactions, oldState, newState) {
+      if (!transactions.some((tr) => tr.docChanged)) return null;
+      if (transactions.every((tr) => tr.getMeta(wordStructureNormalizationKey))) return null;
+      const blockChanges = blockChangesFromDocumentDiff(oldState.doc, newState.doc);
+      const changes = blockChanges.length > 0 ? blockChanges : contentChangesFromDocumentDiff(oldState.doc, newState.doc);
+      return changes.length > 0 ? withChanges(newState.tr, changes) : null;
+    },
+    state: {
+      init: /* @__PURE__ */ __name(() => ({ changes: [] }), "init"),
+      apply(tr, previous) {
+        var _a, _b;
+        const meta = tr.getMeta(wordEditingPluginKey);
+        if (!((_a = meta == null ? void 0 : meta.changes) == null ? void 0 : _a.length)) return previous;
+        const next = { changes: [...previous.changes, ...meta.changes] };
+        (_b = options.onChangeSet) == null ? void 0 : _b.call(options, next);
+        return next;
+      }
+    }
+  });
+}
+__name(createWordEditingPlugin, "createWordEditingPlugin");
+function getWordChangeSet(state) {
+  var _a;
+  return (_a = wordEditingPluginKey.getState(state)) != null ? _a : { changes: [] };
+}
+__name(getWordChangeSet, "getWordChangeSet");
+function getWordSelectionInfo(state) {
+  var _a, _b;
+  const { from, to, empty } = state.selection;
+  const $from = state.selection.$from;
+  const cellDepth = findParentDepth($from, "table_cell");
+  const tableCell = cellDepth === null ? null : {
+    depth: cellDepth,
+    colspan: Number((_a = $from.node(cellDepth).attrs.colspan) != null ? _a : 1),
+    rowspan: Number((_b = $from.node(cellDepth).attrs.rowspan) != null ? _b : 1)
+  };
+  return {
+    from,
+    to,
+    empty,
+    selectedText: state.doc.textBetween(from, to, "\n"),
+    paragraphs: selectedParagraphs(state, from, to),
+    tableCell
+  };
+}
+__name(getWordSelectionInfo, "getWordSelectionInfo");
+function toggleBold(state, dispatch, view) {
+  const markType = wordEditorSchema.marks.strong;
+  return applySelectionMark(state, dispatch, view, markType, {}, "strong");
+}
+__name(toggleBold, "toggleBold");
+function setFontSize(sizePt) {
+  return (state, dispatch, view) => {
+    if (!Number.isFinite(sizePt) || sizePt <= 0) return false;
+    return applySelectionMark(state, dispatch, view, wordEditorSchema.marks.textStyle, { fontSize: sizePt }, "textStyle");
+  };
+}
+__name(setFontSize, "setFontSize");
+function setColor(color) {
+  return (state, dispatch, view) => {
+    const normalized = normalizeHexColor(color);
+    if (!normalized) return false;
+    return applySelectionMark(state, dispatch, view, wordEditorSchema.marks.textStyle, { color: normalized }, "textStyle");
+  };
+}
+__name(setColor, "setColor");
+function setParagraphAlign(alignment) {
+  return (state, dispatch) => {
+    const paragraphs = selectedParagraphs(state, state.selection.from, state.selection.to);
+    if (paragraphs.length === 0) return false;
+    if (!dispatch) return true;
+    let tr = state.tr;
+    state.doc.nodesBetween(state.selection.from, state.selection.to, (node, pos) => {
+      if (node.type !== wordEditorSchema.nodes.paragraph) return true;
+      const format = mergeParagraphFormat(node.attrs.format, { alignment });
+      tr = tr.setNodeMarkup(pos, void 0, __spreadProps(__spreadValues({}, node.attrs), { format }));
+      return false;
+    });
+    tr = withChange(tr, {
+      kind: "paragraph",
+      from: state.selection.from,
+      to: state.selection.to,
+      paragraphs,
+      target: changeTargetForParagraphs(paragraphs),
+      status: "captured",
+      attr: "alignment",
+      value: alignment
+    });
+    dispatch(tr.scrollIntoView());
+    return true;
+  };
+}
+__name(setParagraphAlign, "setParagraphAlign");
+function applySelectionMark(state, dispatch, view, markType, attrs, mark) {
+  const { from, to, empty } = state.selection;
+  if (empty) return false;
+  const paragraphs = selectedParagraphs(state, from, to);
+  if (paragraphs.length === 0) return false;
+  const shouldRemove = mark === "strong" && rangeHasMark(state.doc, from, to, markType);
+  if (!dispatch) return true;
+  let tr = state.tr;
+  if (shouldRemove) {
+    tr = tr.removeMark(from, to, markType);
+  } else {
+    tr = tr.addMark(from, to, markType.create(attrs));
+  }
+  tr = withChange(tr, {
+    kind: "mark",
+    from,
+    to,
+    paragraphs,
+    target: changeTargetForParagraphs(paragraphs),
+    status: "captured",
+    mark,
+    value: mark === "strong" ? !shouldRemove : attrs
+  });
+  dispatch(tr.scrollIntoView());
+  view == null ? void 0 : view.focus();
+  return true;
+}
+__name(applySelectionMark, "applySelectionMark");
+function selectedParagraphs(state, from, to) {
+  const paragraphs = [];
+  const scanTo = Math.max(to, from + 1);
+  state.doc.nodesBetween(from, scanTo, (node, pos) => {
+    if (node.type !== wordEditorSchema.nodes.paragraph) return true;
+    const contentStart = pos + 1;
+    const contentEnd = contentStart + node.content.size;
+    paragraphs.push({
+      paraId: typeof node.attrs.paraId === "string" ? node.attrs.paraId : "",
+      from: Math.max(from, contentStart) - contentStart,
+      to: Math.min(to, contentEnd) - contentStart,
+      text: node.textContent,
+      styleId: typeof node.attrs.styleId === "string" ? node.attrs.styleId : null,
+      story: typeof node.attrs.story === "string" ? node.attrs.story : "body"
+    });
+    return false;
+  });
+  return paragraphs;
+}
+__name(selectedParagraphs, "selectedParagraphs");
+function changeTargetForParagraphs(paragraphs) {
+  var _a;
+  const paragraph = paragraphs[0];
+  return __spreadValues({
+    story: (_a = paragraph == null ? void 0 : paragraph.story) != null ? _a : "body"
+  }, (paragraph == null ? void 0 : paragraph.paraId) ? { paraId: paragraph.paraId } : {});
+}
+__name(changeTargetForParagraphs, "changeTargetForParagraphs");
+function rangeHasMark(doc, from, to, markType) {
+  let found = false;
+  doc.nodesBetween(from, to, (node) => {
+    if (found || !node.isText) return !found;
+    found = markType.isInSet(node.marks) !== void 0;
+    return !found;
+  });
+  return found;
+}
+__name(rangeHasMark, "rangeHasMark");
+function withChange(tr, change) {
+  return withChanges(tr, [change]);
+}
+__name(withChange, "withChange");
+function withChanges(tr, changesToAdd) {
+  var _a, _b;
+  const meta = (_a = tr.getMeta(wordEditingPluginKey)) != null ? _a : {};
+  const changes = (_b = meta.changes) != null ? _b : [];
+  return tr.setMeta(wordEditingPluginKey, __spreadProps(__spreadValues({}, meta), {
+    changes: [
+      ...changes,
+      ...changesToAdd.map((change) => __spreadProps(__spreadValues({}, change), {
+        id: `word-edit:${++changeSequence}`,
+        createdAt: Date.now()
+      }))
+    ]
+  }));
+}
+__name(withChanges, "withChanges");
+function blockChangesFromDocumentDiff(oldDoc, newDoc) {
+  const oldBlocks = topLevelBlockSnapshots(oldDoc);
+  const newBlocks = topLevelBlockSnapshots(newDoc);
+  const split = splitBlockChange(oldBlocks, newBlocks);
+  if (split) return [split];
+  const merge = mergeBlockChange(oldBlocks, newBlocks);
+  if (merge) return [merge];
+  const insertOrDelete = insertOrDeleteBlockChange(oldBlocks, newBlocks);
+  return insertOrDelete ? [insertOrDelete] : [];
+}
+__name(blockChangesFromDocumentDiff, "blockChangesFromDocumentDiff");
+function splitBlockChange(oldBlocks, newBlocks) {
+  if (newBlocks.length !== oldBlocks.length + 1) return null;
+  for (let index = 0; index < oldBlocks.length; index += 1) {
+    if (!blockSequencesEqual(oldBlocks.slice(0, index), newBlocks.slice(0, index))) continue;
+    if (!blockSequencesEqual(oldBlocks.slice(index + 1), newBlocks.slice(index + 2))) continue;
+    const before = oldBlocks[index];
+    const first = newBlocks[index];
+    const second = newBlocks[index + 1];
+    if (before.block.kind !== "paragraph" || first.block.kind !== "paragraph" || second.block.kind !== "paragraph" || first.block.text + second.block.text !== before.block.text) {
+      continue;
+    }
+    return {
+      kind: "block",
+      blockOp: "split",
+      from: before.pos,
+      to: before.pos + before.size,
+      paragraphs: blockParagraphs([first, second]),
+      target: targetForBlock(before.block),
+      status: "captured",
+      blocks: [first.block, second.block],
+      deletedBlocks: [before.block],
+      value: {
+        before: before.block,
+        after: [first.block, second.block]
+      }
+    };
+  }
+  return null;
+}
+__name(splitBlockChange, "splitBlockChange");
+function mergeBlockChange(oldBlocks, newBlocks) {
+  if (oldBlocks.length !== newBlocks.length + 1) return null;
+  for (let index = 0; index < newBlocks.length; index += 1) {
+    if (!blockSequencesEqual(oldBlocks.slice(0, index), newBlocks.slice(0, index))) continue;
+    if (!blockSequencesEqual(oldBlocks.slice(index + 2), newBlocks.slice(index + 1))) continue;
+    const first = oldBlocks[index];
+    const second = oldBlocks[index + 1];
+    const after = newBlocks[index];
+    if (first.block.kind !== "paragraph" || second.block.kind !== "paragraph" || after.block.kind !== "paragraph" || first.block.text + second.block.text !== after.block.text) {
+      continue;
+    }
+    return {
+      kind: "block",
+      blockOp: "merge",
+      from: first.pos,
+      to: second.pos + second.size,
+      paragraphs: blockParagraphs([after]),
+      target: targetForBlock(after.block),
+      status: "captured",
+      blocks: [after.block],
+      deletedBlocks: [first.block, second.block],
+      value: {
+        before: [first.block, second.block],
+        after: after.block
+      }
+    };
+  }
+  return null;
+}
+__name(mergeBlockChange, "mergeBlockChange");
+function insertOrDeleteBlockChange(oldBlocks, newBlocks) {
+  var _a, _b, _c, _d, _e;
+  let prefix = 0;
+  const maxPrefix = Math.min(oldBlocks.length, newBlocks.length);
+  while (prefix < maxPrefix && blockEquals(oldBlocks[prefix], newBlocks[prefix])) prefix += 1;
+  let suffix = 0;
+  const maxSuffix = Math.min(oldBlocks.length - prefix, newBlocks.length - prefix);
+  while (suffix < maxSuffix && blockEquals(oldBlocks[oldBlocks.length - 1 - suffix], newBlocks[newBlocks.length - 1 - suffix])) {
+    suffix += 1;
+  }
+  const deleted = oldBlocks.slice(prefix, oldBlocks.length - suffix);
+  const inserted = newBlocks.slice(prefix, newBlocks.length - suffix);
+  if (deleted.length === 0 && inserted.length === 0) return null;
+  const first = (_a = inserted[0]) != null ? _a : deleted[0];
+  const last = (_c = (_b = inserted[inserted.length - 1]) != null ? _b : deleted[deleted.length - 1]) != null ? _c : first;
+  const operation = inserted.length > 0 && deleted.length > 0 ? "replace" : inserted.length > 0 ? "insert" : "delete";
+  return {
+    kind: "block",
+    blockOp: operation,
+    from: (_d = first == null ? void 0 : first.pos) != null ? _d : 0,
+    to: last ? last.pos + last.size : (_e = first == null ? void 0 : first.pos) != null ? _e : 0,
+    paragraphs: blockParagraphs(inserted.length > 0 ? inserted : deleted),
+    target: first ? targetForBlock(first.block) : { story: "body" },
+    status: "captured",
+    blocks: inserted.map((item) => item.block),
+    deletedBlocks: deleted.map((item) => item.block),
+    value: {
+      before: deleted.map((item) => item.block),
+      after: inserted.map((item) => item.block)
+    }
+  };
+}
+__name(insertOrDeleteBlockChange, "insertOrDeleteBlockChange");
+function contentChangesFromDocumentDiff(oldDoc, newDoc) {
+  const oldParagraphs = paragraphSnapshots(oldDoc);
+  const newParagraphs = paragraphSnapshots(newDoc);
+  const oldByParaId = new Map(oldParagraphs.map((paragraph) => [paragraph.paraId, paragraph]));
+  const changes = [];
+  for (const next of newParagraphs) {
+    if (!next.paraId) continue;
+    const previous = oldByParaId.get(next.paraId);
+    if (!previous || paragraphContentEquals(previous.content, next.content)) continue;
+    const diff = contentDiff(previous.content, next.content);
+    if (!diff) continue;
+    const from = next.pos + 1 + diff.from;
+    const to = next.pos + 1 + diff.toAfter;
+    const paragraph = {
+      paraId: next.paraId,
+      from: diff.from,
+      to: diff.toAfter,
+      text: next.text,
+      styleId: next.styleId,
+      story: next.story
+    };
+    if (contentListIsTextOnly(diff.insertedContent) && contentListIsTextOnly(diff.deletedContent)) {
+      changes.push({
+        kind: "text",
+        from,
+        to,
+        paragraphs: [paragraph],
+        target: changeTargetForParagraphs([paragraph]),
+        status: "captured",
+        textOp: diff.operation,
+        text: contentText(diff.insertedContent),
+        deletedText: contentText(diff.deletedContent),
+        value: {
+          operation: diff.operation,
+          before: previous.text,
+          after: next.text
+        }
+      });
+      continue;
+    }
+    changes.push({
+      kind: "content",
+      from,
+      to,
+      paragraphs: [paragraph],
+      target: changeTargetForParagraphs([paragraph]),
+      status: "captured",
+      contentOp: diff.operation,
+      content: mergeTextContent(diff.insertedContent),
+      deletedContent: mergeTextContent(diff.deletedContent),
+      value: {
+        operation: diff.operation,
+        before: mergeTextContent(previous.content.map((unit) => unit.content)),
+        after: mergeTextContent(next.content.map((unit) => unit.content))
+      }
+    });
+  }
+  return changes;
+}
+__name(contentChangesFromDocumentDiff, "contentChangesFromDocumentDiff");
+function paragraphSnapshots(doc) {
+  const paragraphs = [];
+  doc.descendants((node, pos) => {
+    if (node.type !== wordEditorSchema.nodes.paragraph) return true;
+    paragraphs.push({
+      paraId: typeof node.attrs.paraId === "string" ? node.attrs.paraId : "",
+      pos,
+      text: node.textContent,
+      content: paragraphContentUnits(node),
+      styleId: typeof node.attrs.styleId === "string" ? node.attrs.styleId : null,
+      story: typeof node.attrs.story === "string" ? node.attrs.story : "body"
+    });
+    return false;
+  });
+  return paragraphs;
+}
+__name(paragraphSnapshots, "paragraphSnapshots");
+function topLevelBlockSnapshots(doc) {
+  const blocks = [];
+  doc.forEach((node, offset, index) => {
+    if (node.type === wordEditorSchema.nodes.paragraph) {
+      const paraId = typeof node.attrs.paraId === "string" ? node.attrs.paraId : "";
+      const story = typeof node.attrs.story === "string" ? node.attrs.story : "body";
+      const block = {
+        kind: "paragraph",
+        paraId,
+        story,
+        styleId: typeof node.attrs.styleId === "string" ? node.attrs.styleId : null,
+        text: node.textContent,
+        content: mergeTextContent(paragraphContentUnits(node).map((unit) => unit.content))
+      };
+      blocks.push({
+        key: `paragraph:${paraId || index}`,
+        pos: offset,
+        size: node.nodeSize,
+        block
+      });
+      return;
+    }
+    if (node.type === wordEditorSchema.nodes.table) {
+      const tableId = typeof node.attrs.tableId === "string" ? node.attrs.tableId : "";
+      const block = {
+        kind: "table",
+        tableId,
+        text: node.textContent
+      };
+      blocks.push({
+        key: `table:${tableId || index}`,
+        pos: offset,
+        size: node.nodeSize,
+        block
+      });
+    }
+  });
+  return blocks;
+}
+__name(topLevelBlockSnapshots, "topLevelBlockSnapshots");
+function blockSequencesEqual(left, right) {
+  return left.length === right.length && left.every((block, index) => blockEquals(block, right[index]));
+}
+__name(blockSequencesEqual, "blockSequencesEqual");
+function blockEquals(left, right) {
+  return left.key === right.key;
+}
+__name(blockEquals, "blockEquals");
+function blockParagraphs(blocks) {
+  return blocks.flatMap((snapshot) => {
+    if (snapshot.block.kind !== "paragraph") return [];
+    return [
+      {
+        paraId: snapshot.block.paraId,
+        from: 0,
+        to: snapshot.block.text.length,
+        text: snapshot.block.text,
+        styleId: snapshot.block.styleId,
+        story: snapshot.block.story
+      }
+    ];
+  });
+}
+__name(blockParagraphs, "blockParagraphs");
+function targetForBlock(block) {
+  if (block.kind === "table") {
+    return __spreadValues({
+      story: "body"
+    }, block.tableId ? { tableId: block.tableId } : {});
+  }
+  return __spreadValues({
+    story: block.story
+  }, block.paraId ? { paraId: block.paraId } : {});
+}
+__name(targetForBlock, "targetForBlock");
+function paragraphContentUnits(paragraph) {
+  const units = [];
+  paragraph.forEach((child) => {
+    var _a, _b;
+    if (child.isText) {
+      for (const char of (_a = child.text) != null ? _a : "") {
+        units.push({ key: `text:${char}`, content: { kind: "text", text: char } });
+      }
+      return;
+    }
+    if (child.type === wordEditorSchema.nodes.image) {
+      const image = imageContent(child);
+      units.push({ key: `image:${(_b = image.drawingId) != null ? _b : image.src}`, content: image });
+      return;
+    }
+    units.push({
+      key: `${child.type.name}:${JSON.stringify(child.attrs)}`,
+      content: { kind: "text", text: child.textContent }
+    });
+  });
+  return units;
+}
+__name(paragraphContentUnits, "paragraphContentUnits");
+function imageContent(node) {
+  return {
+    kind: "image",
+    drawingId: typeof node.attrs.drawingId === "string" ? node.attrs.drawingId : null,
+    alt: typeof node.attrs.alt === "string" ? node.attrs.alt : "",
+    src: typeof node.attrs.src === "string" ? node.attrs.src : "",
+    width: typeof node.attrs.width === "number" ? node.attrs.width : null,
+    height: typeof node.attrs.height === "number" ? node.attrs.height : null
+  };
+}
+__name(imageContent, "imageContent");
+function contentDiff(before, after) {
+  var _a, _b, _c, _d;
+  if (paragraphContentEquals(before, after)) return null;
+  let prefix = 0;
+  const maxPrefix = Math.min(before.length, after.length);
+  while (prefix < maxPrefix && ((_a = before[prefix]) == null ? void 0 : _a.key) === ((_b = after[prefix]) == null ? void 0 : _b.key)) prefix += 1;
+  let suffix = 0;
+  const maxSuffix = Math.min(before.length - prefix, after.length - prefix);
+  while (suffix < maxSuffix && ((_c = before[before.length - 1 - suffix]) == null ? void 0 : _c.key) === ((_d = after[after.length - 1 - suffix]) == null ? void 0 : _d.key)) {
+    suffix += 1;
+  }
+  const toBefore = before.length - suffix;
+  const toAfter = after.length - suffix;
+  const insertedContent = after.slice(prefix, toAfter).map((unit) => unit.content);
+  const deletedContent = before.slice(prefix, toBefore).map((unit) => unit.content);
+  const operation = insertedContent.length > 0 && deletedContent.length > 0 ? "replace" : insertedContent.length > 0 ? "insert" : "delete";
+  return {
+    operation,
+    from: prefix,
+    toBefore,
+    toAfter,
+    insertedContent,
+    deletedContent
+  };
+}
+__name(contentDiff, "contentDiff");
+function paragraphContentEquals(left, right) {
+  return left.length === right.length && left.every((unit, index) => {
+    var _a;
+    return unit.key === ((_a = right[index]) == null ? void 0 : _a.key);
+  });
+}
+__name(paragraphContentEquals, "paragraphContentEquals");
+function contentListIsTextOnly(content) {
+  return content.every((item) => item.kind === "text");
+}
+__name(contentListIsTextOnly, "contentListIsTextOnly");
+function contentText(content) {
+  return content.map((item) => item.kind === "text" ? item.text : "").join("");
+}
+__name(contentText, "contentText");
+function mergeTextContent(content) {
+  const merged = [];
+  for (const item of content) {
+    const previous = merged[merged.length - 1];
+    if (item.kind === "text" && (previous == null ? void 0 : previous.kind) === "text") {
+      previous.text += item.text;
+    } else {
+      merged.push(__spreadValues({}, item));
+    }
+  }
+  return merged;
+}
+__name(mergeTextContent, "mergeTextContent");
+function mergeParagraphFormat(value, patch) {
+  const base = value !== null && typeof value === "object" ? value : {};
+  return __spreadValues(__spreadValues({}, base), patch);
+}
+__name(mergeParagraphFormat, "mergeParagraphFormat");
+function normalizeHexColor(color) {
+  const trimmed = color.trim().replace(/^#/, "");
+  return /^[0-9a-f]{6}$/i.test(trimmed) ? trimmed.toUpperCase() : null;
+}
+__name(normalizeHexColor, "normalizeHexColor");
+function findParentDepth($pos, nodeName) {
+  for (let depth = $pos.depth; depth > 0; depth -= 1) {
+    if ($pos.node(depth).type.name === nodeName) return depth;
+  }
+  return null;
+}
+__name(findParentDepth, "findParentDepth");
+
+export { createWordEditingPlugin, getWordChangeSet, getWordSelectionInfo, setColor, setFontSize, setParagraphAlign, toggleBold, wordEditingPluginKey };
+//# sourceMappingURL=word-editing.js.map
+//# sourceMappingURL=word-editing.js.map