@jvs-milkdown/crepe 1.2.12 → 1.2.14

package/lib/cjs/feature/inline-diff/index.js

@@ -0,0 +1,1298 @@
+'use strict';
+
+var core = require('@jvs-milkdown/kit/core');
+var state = require('@jvs-milkdown/kit/prose/state');
+var view = require('@jvs-milkdown/kit/prose/view');
+var utils = require('@jvs-milkdown/kit/utils');
+var ctx = require('@jvs-milkdown/kit/ctx');
+var vue = require('vue');
+var Diff = require('diff');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var Diff__namespace = /*#__PURE__*/_interopNamespaceDefault(Diff);
+
+const zhCN = {
+  // block handle
+  "handle.add": "\u63D2\u5165\u5185\u5BB9",
+  "handle.menu": "\u70B9\u51FB\u6253\u5F00\u83DC\u5355",
+  "handle.drag": "\u62D6\u62FD\u79FB\u52A8\u4F4D\u7F6E",
+  // placeholder
+  "placeholder.text": "\u8F93\u5165\u6B63\u6587\u6216 '/' \u5FEB\u901F\u63D2\u5165\u5185\u5BB9",
+  // toolbar
+  "toolbar.heading": "\u6807\u9898",
+  "toolbar.formatting": "\u683C\u5F0F",
+  "toolbar.function": "\u529F\u80FD",
+  "toolbar.formatPainter": "\u683C\u5F0F\u5237",
+  // menu bar
+  "menuBar.file": "\u6587\u4EF6",
+  "menuBar.edit": "\u7F16\u8F91",
+  "menuBar.view": "\u89C6\u56FE",
+  "menuBar.insert": "\u63D2\u5165",
+  "menuBar.format": "\u683C\u5F0F",
+  // view menu
+  "view.outline": "\u5927\u7EB2\u9762\u677F",
+  "view.outlineLeft": "\u5728\u5DE6\u4FA7\u663E\u793A",
+  "view.outlineRight": "\u5728\u53F3\u4FA7\u663E\u793A",
+  "view.docBackground": "\u6587\u6863\u80CC\u666F\u8272",
+  "view.title": "\u663E\u793A\u6807\u9898",
+  "view.cover": "\u663E\u793A\u5C01\u9762",
+  "view.editorWidth": "\u5185\u5BB9\u5BBD\u5EA6",
+  "view.widthDefault": "\u9ED8\u8BA4",
+  "view.widthWide": "\u8F83\u5BBD",
+  "view.widthFull": "\u5168\u5BBD",
+  // code-mirror
+  "codeMirror.searchPlaceholder": "\u641C\u7D22\u8BED\u8A00",
+  "codeMirror.noResultText": "\u65E0\u7ED3\u679C",
+  "codeMirror.previewToggleOptionEdit": "\u7F16\u8F91",
+  "codeMirror.previewToggleOptionHide": "\u9690\u85CF",
+  "codeMirror.previewLabel": "\u9884\u89C8",
+  "codeMirror.wrapText": "\u81EA\u52A8\u6362\u884C",
+  // link-tooltip
+  "linkTooltip.pasteLink": "\u7C98\u8D34\u94FE\u63A5...",
+  // image-block
+  "imageBlock.inlineUploadButton": "\u4E0A\u4F20",
+  "imageBlock.inlineUploadPlaceholder": "\u6216\u7C98\u8D34\u94FE\u63A5",
+  "imageBlock.blockUploadButton": "\u4E0A\u4F20\u6587\u4EF6",
+  "imageBlock.blockUploadPlaceholder": "\u6216\u7C98\u8D34\u94FE\u63A5",
+  "imageBlock.blockCaptionPlaceholder": "\u5199\u4E0B\u56FE\u7247\u63CF\u8FF0...",
+  "imageBlock.blockConfirmButton": "\u786E\u5B9A",
+  // attachment-block
+  "attachmentBlock.uploadButton": "\u4E0A\u4F20\u6587\u4EF6",
+  "attachmentBlock.uploadPlaceholderText": "\u6216\u70B9\u51FB\u4E0A\u4F20",
+  "attachmentBlock.download": "\u4E0B\u8F7D",
+  // menu categories
+  "menu.group.text": "\u6B63\u6587",
+  "menu.group.block": "\u6BB5\u843D",
+  "menu.group.list": "\u5217\u8868",
+  "menu.group.advanced": "\u9AD8\u7EA7",
+  // menu items
+  "menu.item.text": "\u666E\u901A\u6587\u672C",
+  "menu.item.h1": "\u6807\u9898 1",
+  "menu.item.h2": "\u6807\u9898 2",
+  "menu.item.h3": "\u6807\u9898 3",
+  "menu.item.h4": "\u6807\u9898 4",
+  "menu.item.h5": "\u6807\u9898 5",
+  "menu.item.h6": "\u6807\u9898 6",
+  "menu.item.quote": "\u5F15\u7528",
+  "menu.item.divider": "\u5206\u5272\u7EBF",
+  "menu.item.bulletList": "\u65E0\u5E8F\u5217\u8868",
+  "menu.item.orderedList": "\u6709\u5E8F\u5217\u8868",
+  "menu.item.taskList": "\u4EFB\u52A1\u5217\u8868",
+  "menu.item.image": "\u56FE\u7247",
+  "menu.item.attachment": "\u89C6\u9891\u6216\u6587\u4EF6",
+  "menu.item.code": "\u4EE3\u7801\u5757",
+  "menu.item.table": "\u8868\u683C",
+  "menu.item.math": "\u516C\u5F0F",
+  "menu.item.bold": "\u52A0\u7C97",
+  "menu.item.italic": "\u659C\u4F53",
+  "menu.item.strikethrough": "\u5220\u9664\u7EBF",
+  "menu.item.underline": "\u4E0B\u5212\u7EBF",
+  "menu.item.highlight": "\u9AD8\u4EAE",
+  "menu.item.lineCode": "\u884C\u5185\u4EE3\u7801",
+  "menu.item.link": "\u94FE\u63A5",
+  // menu tooltips
+  "menu.tooltip.text": "\u666E\u901A\u6587\u672C (Ctrl+Alt+0)",
+  "menu.tooltip.h1": "\u6807\u9898 1 (Ctrl+Alt+1)\nMarkdown: # \u7A7A\u683C",
+  "menu.tooltip.h2": "\u6807\u9898 2 (Ctrl+Alt+2)\nMarkdown: ## \u7A7A\u683C",
+  "menu.tooltip.h3": "\u6807\u9898 3 (Ctrl+Alt+3)\nMarkdown: ### \u7A7A\u683C",
+  "menu.tooltip.h4": "\u6807\u9898 4 (Ctrl+Alt+4)\nMarkdown: #### \u7A7A\u683C",
+  "menu.tooltip.h5": "\u6807\u9898 5 (Ctrl+Alt+5)\nMarkdown: ##### \u7A7A\u683C",
+  "menu.tooltip.h6": "\u6807\u9898 6 (Ctrl+Alt+6)\nMarkdown: ###### \u7A7A\u683C",
+  "menu.tooltip.quote": "\u5F15\u7528 (Ctrl+Shift+9)\nMarkdown: > \u7A7A\u683C",
+  "menu.tooltip.divider": "\u5206\u5272\u7EBF\nMarkdown: --- \u7A7A\u683C",
+  "menu.tooltip.bulletList": "\u65E0\u5E8F\u5217\u8868 (Ctrl+Shift+8)\nMarkdown: - \u7A7A\u683C \u6216 * \u7A7A\u683C",
+  "menu.tooltip.orderedList": "\u6709\u5E8F\u5217\u8868 (Ctrl+Shift+7)\nMarkdown: 1. \u7A7A\u683C",
+  "menu.tooltip.taskList": "\u4EFB\u52A1\u5217\u8868\nMarkdown: - [ ] \u7A7A\u683C",
+  "menu.tooltip.image": "\u56FE\u7247\nMarkdown: ![alt](url)",
+  "menu.tooltip.code": "\u4EE3\u7801\u5757 (Ctrl+Shift+\\)\nMarkdown: ``` \u56DE\u8F66",
+  "menu.tooltip.table": "\u8868\u683C\nMarkdown: | | |",
+  "menu.tooltip.math": "\u516C\u5F0F\nMarkdown: $$ \u56DE\u8F66",
+  // custom block menu items
+  "customMenu.indentAndAlign": "\u7F29\u8FDB\u548C\u5BF9\u9F50",
+  "customMenu.color": "\u989C\u8272",
+  "customMenu.cut": "\u526A\u5207",
+  "customMenu.copy": "\u590D\u5236",
+  "customMenu.delete": "\u5220\u9664",
+  "customMenu.addBelow": "\u5728\u4E0B\u65B9\u6DFB\u52A0",
+  "customMenu.alignLeft": "\u5DE6\u5BF9\u9F50",
+  "customMenu.alignCenter": "\u5C45\u4E2D\u5BF9\u9F50",
+  "customMenu.alignRight": "\u53F3\u5BF9\u9F50",
+  "customMenu.increaseIndent": "\u589E\u52A0\u7F29\u8FDB",
+  "customMenu.decreaseIndent": "\u51CF\u5C11\u7F29\u8FDB",
+  "customMenu.textColor": "\u5B57\u4F53\u989C\u8272",
+  "customMenu.bgColor": "\u80CC\u666F\u989C\u8272",
+  "customMenu.restoreDefault": "\u6062\u590D\u9ED8\u8BA4",
+  "customMenu.colorDefault": "\u9ED8\u8BA4",
+  "customMenu.colorRed": "\u7EA2\u8272",
+  "customMenu.colorOrange": "\u6A59\u8272",
+  "customMenu.colorYellow": "\u9EC4\u8272",
+  "customMenu.colorGreen": "\u7EFF\u8272",
+  "customMenu.colorBlue": "\u84DD\u8272",
+  "customMenu.colorPurple": "\u7D2B\u8272",
+  "customMenu.colorGray": "\u7070\u8272",
+  "customMenu.insertTable": "\u63D2\u5165\u652F\u6301\u5BCC\u6587\u672C\u7684\u8868\u683C",
+  "customMenu.fontDefault": "\u9ED8\u8BA4",
+  "font.fangSong": "\u4EFF\u5B8B",
+  "font.stFangsong": "\u534E\u6587\u4EFF\u5B8B",
+  "font.stSong": "\u534E\u6587\u5B8B\u4F53",
+  "font.stKaiti": "\u534E\u6587\u6977\u4F53",
+  "font.simSun": "\u5B8B\u4F53",
+  "font.microsoftYaHei": "\u5FAE\u8F6F\u96C5\u9ED1",
+  "font.kaiTi": "\u6977\u4F53",
+  "font.simHei": "\u9ED1\u4F53",
+  // latex
+  "latex.escToExit": "\u6309 ESC \u5B8C\u6210\u8F93\u5165",
+  "latex.helpDoc": "\u67E5\u770B\u5E2E\u52A9\u6587\u6863",
+  "latex.emptyPlaceholder": "\u6DFB\u52A0 LaTeX \u516C\u5F0F",
+  "latex.inputPlaceholder": "\u8BF7\u8F93\u5165\u516C\u5F0F",
+  // shortcuts
+  "shortcuts.title": "\u952E\u76D8\u5FEB\u6377\u952E",
+  "shortcuts.formatting": "\u6587\u672C\u683C\u5F0F",
+  "shortcuts.bold": "\u52A0\u7C97",
+  "shortcuts.italic": "\u659C\u4F53",
+  "shortcuts.underline": "\u4E0B\u5212\u7EBF",
+  "shortcuts.strikethrough": "\u5220\u9664\u7EBF",
+  "shortcuts.inlineCode": "\u884C\u5185\u4EE3\u7801",
+  "shortcuts.highlight": "\u9AD8\u4EAE",
+  "shortcuts.paragraph": "\u6BB5\u843D",
+  "shortcuts.heading": "\u6807\u9898",
+  "shortcuts.block": "\u5757\u7EA7\u5143\u7D20",
+  "shortcuts.codeBlock": "\u4EE3\u7801\u5757",
+  "shortcuts.blockquote": "\u5F15\u7528",
+  "shortcuts.orderedList": "\u6709\u5E8F\u5217\u8868",
+  "shortcuts.bulletList": "\u65E0\u5E8F\u5217\u8868",
+  "shortcuts.indent": "\u589E\u52A0\u7F29\u8FDB",
+  "shortcuts.outdent": "\u51CF\u5C11\u7F29\u8FDB",
+  "shortcuts.hardBreak": "\u6362\u884C",
+  "shortcuts.history": "\u5386\u53F2\u8BB0\u5F55",
+  "shortcuts.undo": "\u64A4\u9500",
+  "shortcuts.redo": "\u91CD\u505A",
+  // inline-diff
+  "inlineDiff.accept": "\u63A5\u53D7",
+  "inlineDiff.reject": "\u62D2\u7EDD"
+};
+const enUS = {
+  "handle.add": "Add content",
+  "handle.menu": "Open menu",
+  "handle.drag": "Drag to move",
+  "placeholder.text": "Type '/' to use slash menu",
+  "toolbar.heading": "Heading",
+  "toolbar.formatting": "Formatting",
+  "toolbar.function": "Function",
+  "toolbar.formatPainter": "Format Painter",
+  "menuBar.file": "File",
+  "menuBar.edit": "Edit",
+  "menuBar.view": "View",
+  "menuBar.insert": "Insert",
+  "menuBar.format": "Format",
+  "view.outline": "Outline Panel",
+  "view.outlineLeft": "Show on Left",
+  "view.outlineRight": "Show on Right",
+  "view.docBackground": "Document Background",
+  "view.title": "Show Title",
+  "view.cover": "Show Cover",
+  "view.editorWidth": "Content Width",
+  "view.widthDefault": "Default",
+  "view.widthWide": "Wide",
+  "view.widthFull": "Full Width",
+  "codeMirror.searchPlaceholder": "Search language",
+  "codeMirror.noResultText": "No result",
+  "codeMirror.previewToggleOptionEdit": "Edit",
+  "codeMirror.previewToggleOptionHide": "Hide",
+  "codeMirror.previewLabel": "Preview",
+  "codeMirror.wrapText": "Wrap",
+  "linkTooltip.pasteLink": "Paste link...",
+  "imageBlock.inlineUploadButton": "Upload",
+  "imageBlock.inlineUploadPlaceholder": "or paste link",
+  "imageBlock.blockUploadButton": "Upload file",
+  "imageBlock.blockUploadPlaceholder": "or paste link",
+  "imageBlock.blockCaptionPlaceholder": "Write Image Caption",
+  "imageBlock.blockConfirmButton": "Confirm",
+  "attachmentBlock.uploadButton": "Upload file",
+  "attachmentBlock.uploadPlaceholderText": "or click to upload",
+  "attachmentBlock.download": "Download",
+  "menu.group.text": "Text",
+  "menu.group.block": "Block",
+  "menu.group.list": "List",
+  "menu.group.advanced": "Advanced",
+  "menu.item.text": "Text",
+  "menu.item.h1": "Heading 1",
+  "menu.item.h2": "Heading 2",
+  "menu.item.h3": "Heading 3",
+  "menu.item.h4": "Heading 4",
+  "menu.item.h5": "Heading 5",
+  "menu.item.h6": "Heading 6",
+  "menu.item.quote": "Quote",
+  "menu.item.divider": "Divider",
+  "menu.item.bulletList": "Bullet List",
+  "menu.item.orderedList": "Ordered List",
+  "menu.item.taskList": "Task List",
+  "menu.item.image": "Image",
+  "menu.item.attachment": "Video or File",
+  "menu.item.code": "Code",
+  "menu.item.table": "Table",
+  "menu.item.math": "Math",
+  "menu.item.bold": "Bold",
+  "menu.item.italic": "Italic",
+  "menu.item.strikethrough": "Strikethrough",
+  "menu.item.underline": "Underline",
+  "menu.item.highlight": "Highlight",
+  "menu.item.lineCode": "Inline Code",
+  "menu.item.link": "Link",
+  "menu.tooltip.text": "Text (Ctrl+Alt+0)",
+  "menu.tooltip.h1": "Heading 1 (Ctrl+Alt+1)\nMarkdown: # Space",
+  "menu.tooltip.h2": "Heading 2 (Ctrl+Alt+2)\nMarkdown: ## Space",
+  "menu.tooltip.h3": "Heading 3 (Ctrl+Alt+3)\nMarkdown: ### Space",
+  "menu.tooltip.h4": "Heading 4 (Ctrl+Alt+4)\nMarkdown: #### Space",
+  "menu.tooltip.h5": "Heading 5 (Ctrl+Alt+5)\nMarkdown: ##### Space",
+  "menu.tooltip.h6": "Heading 6 (Ctrl+Alt+6)\nMarkdown: ###### Space",
+  "menu.tooltip.quote": "Quote (Ctrl+Shift+9)\nMarkdown: > Space",
+  "menu.tooltip.divider": "Divider\nMarkdown: --- Space",
+  "menu.tooltip.bulletList": "Bullet List (Ctrl+Shift+8)\nMarkdown: - Space or * Space",
+  "menu.tooltip.orderedList": "Ordered List (Ctrl+Shift+7)\nMarkdown: 1. Space",
+  "menu.tooltip.taskList": "Task List\nMarkdown: - [ ] Space",
+  "menu.tooltip.image": "Image\nMarkdown: ![alt](url)",
+  "menu.tooltip.code": "Code Block (Ctrl+Shift+\\)\nMarkdown: ``` Enter",
+  "menu.tooltip.table": "Table\nMarkdown: | | |",
+  "menu.tooltip.math": "Math\nMarkdown: $$ Enter",
+  "customMenu.indentAndAlign": "Indent & Align",
+  "customMenu.color": "Color",
+  "customMenu.cut": "Cut",
+  "customMenu.copy": "Copy",
+  "customMenu.delete": "Delete",
+  "customMenu.addBelow": "Add below",
+  "customMenu.alignLeft": "Align Left",
+  "customMenu.alignCenter": "Align Center",
+  "customMenu.alignRight": "Align Right",
+  "customMenu.increaseIndent": "Increase Indent",
+  "customMenu.decreaseIndent": "Decrease Indent",
+  "customMenu.textColor": "Text Color",
+  "customMenu.bgColor": "Background Color",
+  "customMenu.restoreDefault": "Restore Default",
+  "customMenu.colorDefault": "Default",
+  "customMenu.colorRed": "Red",
+  "customMenu.colorOrange": "Orange",
+  "customMenu.colorYellow": "Yellow",
+  "customMenu.colorGreen": "Green",
+  "customMenu.colorBlue": "Blue",
+  "customMenu.colorPurple": "Purple",
+  "customMenu.colorGray": "Gray",
+  "customMenu.insertTable": "Insert Table",
+  "customMenu.fontDefault": "Default",
+  "font.fangSong": "FangSong",
+  "font.stFangsong": "STFangsong",
+  "font.stSong": "STSong",
+  "font.stKaiti": "STKaiti",
+  "font.simSun": "SimSun",
+  "font.microsoftYaHei": "Microsoft YaHei",
+  "font.kaiTi": "KaiTi",
+  "font.simHei": "SimHei",
+  "latex.escToExit": "Press ESC to finish",
+  "latex.helpDoc": "Help Doc",
+  "latex.emptyPlaceholder": "Add LaTeX",
+  "latex.inputPlaceholder": "Please enter formula",
+  "shortcuts.title": "Keyboard Shortcuts",
+  "shortcuts.formatting": "Text Formatting",
+  "shortcuts.bold": "Bold",
+  "shortcuts.italic": "Italic",
+  "shortcuts.underline": "Underline",
+  "shortcuts.strikethrough": "Strikethrough",
+  "shortcuts.inlineCode": "Inline Code",
+  "shortcuts.highlight": "Highlight",
+  "shortcuts.paragraph": "Paragraph",
+  "shortcuts.heading": "Heading",
+  "shortcuts.block": "Block Elements",
+  "shortcuts.codeBlock": "Code Block",
+  "shortcuts.blockquote": "Blockquote",
+  "shortcuts.orderedList": "Ordered List",
+  "shortcuts.bulletList": "Bullet List",
+  "shortcuts.indent": "Indent",
+  "shortcuts.outdent": "Outdent",
+  "shortcuts.hardBreak": "Hard Break",
+  "shortcuts.history": "History",
+  "shortcuts.undo": "Undo",
+  "shortcuts.redo": "Redo",
+  "inlineDiff.accept": "Accept",
+  "inlineDiff.reject": "Reject"
+};
+const translationsCtx = ctx.createSlice(
+  {
+    "zh-CN": zhCN,
+    "en-US": enUS
+  },
+  "translationsCtx"
+);
+const localeCtx = ctx.createSlice("zh-CN", "localeCtx");
+function i18n(ctx, key) {
+  var _a, _b, _c, _d, _e;
+  const translations = ctx.get(translationsCtx);
+  const locale = ctx.get(localeCtx);
+  return (_e = (_d = (_c = (_a = translations[locale]) == null ? void 0 : _a[key]) != null ? _c : (_b = translations["zh-CN"]) == null ? void 0 : _b[key]) != null ? _d : enUS[key]) != null ? _e : key;
+}
+
+ctx.createSlice([], "FeaturesCtx");
+ctx.createSlice({}, "CrepeCtx");
+function useCrepeFeatures(ctx) {
+  return ctx.use("FeaturesCtx");
+}
+function crepeFeatureConfig(feature) {
+  return (ctx) => {
+    useCrepeFeatures(ctx).update((features) => {
+      if (features.includes(feature)) {
+        return features;
+      }
+      return [...features, feature];
+    });
+  };
+}
+
+var CrepeFeature = /* @__PURE__ */ ((CrepeFeature2) => {
+  CrepeFeature2["CodeMirror"] = "code-mirror";
+  CrepeFeature2["ListItem"] = "list-item";
+  CrepeFeature2["LinkTooltip"] = "link-tooltip";
+  CrepeFeature2["Cursor"] = "cursor";
+  CrepeFeature2["ImageBlock"] = "image-block";
+  CrepeFeature2["BlockEdit"] = "block-edit";
+  CrepeFeature2["Toolbar"] = "toolbar";
+  CrepeFeature2["FixedToolbar"] = "fixed-toolbar";
+  CrepeFeature2["Placeholder"] = "placeholder";
+  CrepeFeature2["Table"] = "table";
+  CrepeFeature2["Latex"] = "latex";
+  CrepeFeature2["Attachment"] = "attachment";
+  CrepeFeature2["InlineDiff"] = "inline-diff";
+  CrepeFeature2["DiffBlock"] = "diff-block";
+  return CrepeFeature2;
+})(CrepeFeature || {});
+
+const typeLabels = {
+  added: "\u65B0\u589E",
+  removed: "\u5220\u9664"
+};
+const typeColors = {
+  added: "#4caf50",
+  removed: "#c0392b"
+};
+function mountChangePanel(container, changes, onNavigate, onClose) {
+  const app = vue.createApp({
+    setup() {
+      const activeTab = vue.ref("all");
+      const filteredChanges = vue.computed(() => {
+        if (activeTab.value === "all") return changes;
+        return changes.filter((c) => c.type === activeTab.value);
+      });
+      const counts = vue.computed(() => ({
+        all: changes.length,
+        removed: changes.filter((c) => c.type === "removed").length,
+        added: changes.filter((c) => c.type === "added").length
+      }));
+      function renderTab(tab, label) {
+        const isActive = activeTab.value === tab;
+        return vue.h(
+          "button",
+          {
+            style: {
+              padding: "6px 10px",
+              border: "none",
+              background: "none",
+              cursor: "pointer",
+              fontSize: "12px",
+              color: isActive ? "#1890ff" : "#666",
+              borderBottom: isActive ? "2px solid #1890ff" : "2px solid transparent"
+            },
+            onClick: () => {
+              activeTab.value = tab;
+            }
+          },
+          label
+        );
+      }
+      function renderItem(change, index) {
+        const color = typeColors[change.type];
+        const children = [
+          vue.h("div", { style: { marginBottom: "4px" } }, [
+            vue.h(
+              "span",
+              {
+                style: {
+                  display: "inline-block",
+                  padding: "1px 6px",
+                  borderRadius: "3px",
+                  color: "#fff",
+                  fontSize: "11px",
+                  fontWeight: "500",
+                  backgroundColor: color
+                }
+              },
+              `${index} ${typeLabels[change.type]}`
+            )
+          ])
+        ];
+        if (change.oldText) {
+          children.push(
+            vue.h(
+              "div",
+              {
+                style: {
+                  marginTop: "3px",
+                  fontSize: "12px",
+                  lineHeight: "1.5",
+                  color: "#555",
+                  wordBreak: "break-all"
+                }
+              },
+              [
+                vue.h(
+                  "span",
+                  { style: { color: "#999", fontSize: "11px" } },
+                  "\u539F\u6587: "
+                ),
+                vue.h("span", null, change.oldText)
+              ]
+            )
+          );
+        }
+        if (change.newText) {
+          children.push(
+            vue.h(
+              "div",
+              {
+                style: {
+                  marginTop: "3px",
+                  fontSize: "12px",
+                  lineHeight: "1.5",
+                  wordBreak: "break-all"
+                }
+              },
+              [
+                vue.h(
+                  "span",
+                  { style: { color: "#999", fontSize: "11px" } },
+                  "\u5DEE\u5F02: "
+                ),
+                vue.h("span", { style: { color } }, change.newText)
+              ]
+            )
+          );
+        }
+        return vue.h(
+          "div",
+          {
+            style: {
+              padding: "8px 10px",
+              borderRadius: "4px",
+              marginBottom: "6px",
+              background: "rgba(0,0,0,0.02)",
+              border: "1px solid #eee",
+              cursor: change.from > 0 ? "pointer" : "default"
+            },
+            onClick: () => {
+              if (change.from > 0) onNavigate(change.from);
+            }
+          },
+          children
+        );
+      }
+      return () => vue.h(
+        "div",
+        {
+          style: {
+            width: "100%",
+            height: "100%",
+            display: "flex",
+            flexDirection: "column",
+            backgroundColor: "var(--crepe-color-surface, #fff)",
+            boxSizing: "border-box",
+            fontFamily: '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif',
+            fontSize: "13px",
+            color: "var(--crepe-color-on-surface, #333)",
+            overflow: "hidden"
+          }
+        },
+        [
+          // Header
+          vue.h(
+            "div",
+            {
+              style: {
+                padding: "12px 16px",
+                fontSize: "14px",
+                fontWeight: "bold",
+                borderBottom: "1px solid var(--crepe-color-outline-variant, color-mix(in srgb, var(--crepe-color-outline, #ddd), transparent 80%))",
+                color: "var(--crepe-color-on-surface, #333)",
+                display: "flex",
+                justifyContent: "space-between",
+                alignItems: "center",
+                flexShrink: 0
+              }
+            },
+            [
+              vue.h("span", null, "\u6587\u6863\u5DEE\u5F02\u53D8\u66F4"),
+              onClose ? vue.h(
+                "div",
+                {
+                  style: {
+                    cursor: "pointer",
+                    display: "flex",
+                    alignItems: "center",
+                    justifyContent: "center",
+                    width: "24px",
+                    height: "24px",
+                    borderRadius: "4px",
+                    color: "var(--crepe-color-outline, #999)",
+                    transition: "background-color 0.2s, color 0.2s"
+                  },
+                  onClick: onClose,
+                  onMouseenter: (e) => {
+                    const target = e.currentTarget;
+                    target.style.backgroundColor = "var(--crepe-color-hover, rgba(0,0,0,0.05))";
+                    target.style.color = "var(--crepe-color-on-surface, #333)";
+                  },
+                  onMouseleave: (e) => {
+                    const target = e.currentTarget;
+                    target.style.backgroundColor = "transparent";
+                    target.style.color = "var(--crepe-color-outline, #999)";
+                  },
+                  title: "\u5173\u95ED\u5DEE\u5F02"
+                },
+                [
+                  vue.h(
+                    "svg",
+                    {
+                      width: "16",
+                      height: "16",
+                      viewBox: "0 0 24 24",
+                      fill: "none",
+                      stroke: "currentColor",
+                      strokeWidth: "2",
+                      strokeLinecap: "round",
+                      strokeLinejoin: "round"
+                    },
+                    [
+                      vue.h("line", { x1: "18", y1: "6", x2: "6", y2: "18" }),
+                      vue.h("line", { x1: "6", y1: "6", x2: "18", y2: "18" })
+                    ]
+                  )
+                ]
+              ) : null
+            ]
+          ),
+          // Tabs
+          vue.h(
+            "div",
+            {
+              style: {
+                display: "flex",
+                borderBottom: "1px solid #eee",
+                padding: "0 8px",
+                flexShrink: 0
+              }
+            },
+            [
+              renderTab("all", `\u5168\u90E8(${counts.value.all})`),
+              renderTab("removed", `\u5220\u9664(${counts.value.removed})`),
+              renderTab("added", `\u65B0\u589E(${counts.value.added})`)
+            ]
+          ),
+          // List
+          vue.h(
+            "div",
+            {
+              style: {
+                flex: 1,
+                overflowY: "auto",
+                padding: "8px"
+              }
+            },
+            filteredChanges.value.map(
+              (change, i) => renderItem(change, i + 1)
+            )
+          )
+        ]
+      );
+    }
+  });
+  app.mount(container);
+  return app;
+}
+
+const inlineDiffConfig = utils.$ctx(
+  {
+    addedClass: "crepe-diff-added",
+    deletedClass: "crepe-diff-deleted"
+  },
+  "inlineDiffConfigCtx"
+);
+const noopApi = {
+  showDiff: () => {
+  },
+  hideDiff: () => {
+  },
+  isShowing: () => false
+};
+const inlineDiffApiCtx = utils.$ctx(noopApi, "inlineDiffApiCtx");
+
+function lcs(a, b, eq) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from(
+    { length: m + 1 },
+    () => Array.from({ length: n + 1 }, () => 0)
+  );
+  for (let i2 = m - 1; i2 >= 0; i2--) {
+    for (let j2 = n - 1; j2 >= 0; j2--) {
+      const diag = (_b = (_a = dp[i2 + 1]) == null ? void 0 : _a[j2 + 1]) != null ? _b : 0;
+      const down = (_d = (_c = dp[i2 + 1]) == null ? void 0 : _c[j2]) != null ? _d : 0;
+      const right = (_f = (_e = dp[i2]) == null ? void 0 : _e[j2 + 1]) != null ? _f : 0;
+      dp[i2][j2] = eq(a[i2], b[j2]) ? 1 + diag : Math.max(down, right);
+    }
+  }
+  const pairs = [];
+  let i = 0;
+  let j = 0;
+  while (i < m && j < n) {
+    const down = (_h = (_g = dp[i + 1]) == null ? void 0 : _g[j]) != null ? _h : 0;
+    const right = (_j = (_i = dp[i]) == null ? void 0 : _i[j + 1]) != null ? _j : 0;
+    if (eq(a[i], b[j])) {
+      pairs.push([i, j]);
+      i++;
+      j++;
+    } else if (down >= right) {
+      i++;
+    } else {
+      j++;
+    }
+  }
+  return pairs;
+}
+function computeDiff(oldBlocks, newBlocks) {
+  const result = [];
+  let chunkCounter = 0;
+  const pushChunk = (diffs) => {
+    if (diffs.length > 0) {
+      result.push({
+        id: `chunk-${chunkCounter++}`,
+        diffs,
+        status: "pending"
+      });
+    }
+  };
+  const pairs = lcs(
+    oldBlocks,
+    newBlocks,
+    (a, b) => a.textContent === b.textContent
+  );
+  let oi = 0;
+  let ni = 0;
+  for (const [pi, pj] of pairs) {
+    const gapOld = pi - oi;
+    const gapNew = pj - ni;
+    const gapMax = Math.max(gapOld, gapNew);
+    for (let k = 0; k < gapMax; k++) {
+      const hasOld = oi + k < pi;
+      const hasNew = ni + k < pj;
+      const currentDiffs = [];
+      if (hasOld && hasNew) {
+        const oldNode2 = oldBlocks[oi + k];
+        const newNode2 = newBlocks[ni + k];
+        const changes = Diff__namespace.diffWordsWithSpace(
+          oldNode2.textContent,
+          newNode2.textContent
+        );
+        const parts = changes.map((c) => ({
+          type: c.added ? "insert" : c.removed ? "delete" : "equal",
+          value: c.value
+        }));
+        currentDiffs.push({ type: "removed", oldNode: oldNode2, parts });
+        currentDiffs.push({ type: "added", newNode: newNode2, parts });
+      } else if (hasOld) {
+        currentDiffs.push({ type: "removed", oldNode: oldBlocks[oi + k] });
+      } else {
+        currentDiffs.push({ type: "added", newNode: newBlocks[ni + k] });
+      }
+      pushChunk(currentDiffs);
+    }
+    const oldNode = oldBlocks[pi];
+    const newNode = newBlocks[pj];
+    if (oldNode.textContent === newNode.textContent && oldNode.eq(newNode)) {
+      pushChunk([{ type: "unchanged", oldNode, newNode }]);
+    } else {
+      const changes = Diff__namespace.diffWordsWithSpace(
+        oldNode.textContent,
+        newNode.textContent
+      );
+      const parts = changes.map((c) => ({
+        type: c.added ? "insert" : c.removed ? "delete" : "equal",
+        value: c.value
+      }));
+      pushChunk([
+        { type: "removed", oldNode, parts },
+        { type: "added", newNode, parts }
+      ]);
+    }
+    oi = pi + 1;
+    ni = pj + 1;
+  }
+  const trailOld = oldBlocks.length - oi;
+  const trailNew = newBlocks.length - ni;
+  const trailMax = Math.max(trailOld, trailNew);
+  for (let k = 0; k < trailMax; k++) {
+    const hasOld = oi + k < oldBlocks.length;
+    const hasNew = ni + k < newBlocks.length;
+    const currentDiffs = [];
+    if (hasOld && hasNew) {
+      const oldNode = oldBlocks[oi + k];
+      const newNode = newBlocks[ni + k];
+      const changes = Diff__namespace.diffWordsWithSpace(
+        oldNode.textContent,
+        newNode.textContent
+      );
+      const parts = changes.map((c) => ({
+        type: c.added ? "insert" : c.removed ? "delete" : "equal",
+        value: c.value
+      }));
+      currentDiffs.push({ type: "removed", oldNode, parts });
+      currentDiffs.push({ type: "added", newNode, parts });
+    } else if (hasOld) {
+      currentDiffs.push({ type: "removed", oldNode: oldBlocks[oi + k] });
+    } else {
+      currentDiffs.push({ type: "added", newNode: newBlocks[ni + k] });
+    }
+    pushChunk(currentDiffs);
+  }
+  return result;
+}
+
+function buildNewDoc(chunks, schema) {
+  var _a, _b, _c, _d;
+  const children = [];
+  const pending = [];
+  for (const chunk of chunks) {
+    if (chunk.status === "accepted") {
+      for (const diff of chunk.diffs) {
+        if (diff.type === "added") children.push(diff.newNode);
+        if (diff.type === "unchanged") children.push(diff.newNode);
+      }
+    } else if (chunk.status === "rejected") {
+      for (const diff of chunk.diffs) {
+        if (diff.type === "removed") children.push(diff.oldNode);
+        if (diff.type === "unchanged") children.push(diff.oldNode);
+      }
+    } else {
+      for (const diff of chunk.diffs) {
+        if (diff.type === "unchanged") {
+          children.push(diff.newNode);
+        } else if (diff.type === "added") {
+          pending.push({
+            type: "added",
+            childIndex: children.length,
+            oldText: "",
+            newText: (_b = (_a = diff.newNode) == null ? void 0 : _a.textContent) != null ? _b : "",
+            parts: diff.parts,
+            chunkId: chunk.id
+          });
+          children.push(diff.newNode);
+        } else if (diff.type === "removed") {
+          pending.push({
+            type: "removed",
+            childIndex: children.length,
+            oldText: (_d = (_c = diff.oldNode) == null ? void 0 : _c.textContent) != null ? _d : "",
+            newText: "",
+            parts: diff.parts,
+            chunkId: chunk.id
+          });
+          children.push(diff.oldNode);
+        }
+      }
+    }
+  }
+  if (children.length === 0) {
+    children.push(schema.node("paragraph", null, []));
+  }
+  const doc = schema.node("doc", null, children);
+  let pos = 0;
+  const positions = [];
+  for (const child of children) {
+    positions.push({ from: pos, to: pos + child.nodeSize });
+    pos += child.nodeSize;
+  }
+  const changes = pending.map((pc) => {
+    var _a2, _b2;
+    const cp = positions[pc.childIndex];
+    const inlineRanges = [];
+    let offset = cp.from + 1;
+    if (pc.type === "removed") {
+      for (const part of (_a2 = pc.parts) != null ? _a2 : []) {
+        if (part.type === "delete") {
+          inlineRanges.push({ from: offset, to: offset + part.value.length });
+          offset += part.value.length;
+        } else if (part.type === "equal") {
+          offset += part.value.length;
+        }
+      }
+      return {
+        type: "removed",
+        from: cp.from,
+        oldText: pc.oldText,
+        newText: "",
+        blockRange: { from: cp.from, to: cp.to },
+        inlineRanges,
+        chunkId: pc.chunkId
+      };
+    }
+    for (const part of (_b2 = pc.parts) != null ? _b2 : []) {
+      if (part.type === "insert") {
+        inlineRanges.push({ from: offset, to: offset + part.value.length });
+        offset += part.value.length;
+      } else if (part.type === "equal") {
+        offset += part.value.length;
+      }
+    }
+    return {
+      type: "added",
+      from: cp.from,
+      oldText: "",
+      newText: pc.newText,
+      blockRange: { from: cp.from, to: cp.to },
+      inlineRanges,
+      chunkId: pc.chunkId
+    };
+  });
+  return { doc, changes };
+}
+
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _ctx, _view, _isActive, _panelApp, _panelContainer, _resizeObserver, _scrollContainers, _updateGeometry, _originalEditable, _chunks, _schema, _render, _InlineDiffView_instances, scrollTo_fn, createPanel_fn, removePanel_fn;
+const inlineDiffKey = new state.PluginKey("CREPE_INLINE_DIFF");
+const PANEL_WIDTH = 280;
+let sharedDecorationSet = view.DecorationSet.empty;
+class InlineDiffView {
+  constructor(ctx, view$1) {
+    __privateAdd(this, _InlineDiffView_instances);
+    __privateAdd(this, _ctx);
+    __privateAdd(this, _view);
+    __privateAdd(this, _isActive, false);
+    __privateAdd(this, _panelApp, null);
+    __privateAdd(this, _panelContainer, null);
+    __privateAdd(this, _resizeObserver, null);
+    __privateAdd(this, _scrollContainers, []);
+    __privateAdd(this, _updateGeometry, null);
+    __privateAdd(this, _originalEditable, null);
+    __privateAdd(this, _chunks, []);
+    __privateAdd(this, _schema, null);
+    this.showDiff = (oldMarkdown, newMarkdown) => {
+      if (__privateGet(this, _isActive)) return;
+      const parser = __privateGet(this, _ctx).get(core.parserCtx);
+      __privateSet(this, _schema, __privateGet(this, _view).state.schema);
+      let oldDoc;
+      let newDoc;
+      try {
+        oldDoc = parser(oldMarkdown);
+        if (typeof newMarkdown === "string" && newMarkdown.trim() !== "") {
+          newDoc = parser(newMarkdown);
+        } else {
+          newDoc = __privateGet(this, _view).state.doc;
+        }
+      } catch (e) {
+        return;
+      }
+      const oldBlocks = [];
+      const newBlocks = [];
+      oldDoc.forEach((node) => oldBlocks.push(node));
+      newDoc.forEach((node) => newBlocks.push(node));
+      __privateSet(this, _chunks, computeDiff(oldBlocks, newBlocks));
+      const { changes } = buildNewDoc(__privateGet(this, _chunks), __privateGet(this, _schema));
+      if (changes.length === 0) {
+        return;
+      }
+      if (!__privateGet(this, _originalEditable)) {
+        __privateSet(this, _originalEditable, __privateGet(this, _view).someProp("editable") || (() => true));
+      }
+      __privateGet(this, _view).setProps({
+        editable: () => false
+      });
+      __privateSet(this, _isActive, true);
+      __privateGet(this, _render).call(this, true);
+    };
+    __privateAdd(this, _render, (initPanel = false) => {
+      const { doc: newDocWithPos, changes } = buildNewDoc(
+        __privateGet(this, _chunks),
+        __privateGet(this, _schema)
+      );
+      const acceptText = i18n(__privateGet(this, _ctx), "inlineDiff.accept");
+      const rejectText = i18n(__privateGet(this, _ctx), "inlineDiff.reject");
+      const ds = buildDecorations(
+        newDocWithPos,
+        changes,
+        (id) => this.acceptChunk(id),
+        (id) => this.rejectChunk(id),
+        acceptText,
+        rejectText
+      );
+      sharedDecorationSet = ds;
+      const tr = __privateGet(this, _view).state.tr.replaceWith(
+        0,
+        __privateGet(this, _view).state.doc.content.size,
+        newDocWithPos.content
+      );
+      __privateGet(this, _view).dispatch(tr);
+      if (initPanel) {
+        __privateMethod(this, _InlineDiffView_instances, createPanel_fn).call(this, changes);
+      } else if (__privateGet(this, _panelApp)) {
+        __privateMethod(this, _InlineDiffView_instances, createPanel_fn).call(this, changes);
+      }
+    });
+    this.acceptChunk = (id) => {
+      const chunk = __privateGet(this, _chunks).find((c) => c.id === id);
+      if (chunk) {
+        chunk.status = "accepted";
+        const hasPending = __privateGet(this, _chunks).some(
+          (c) => c.status === "pending" && c.diffs.some((d) => d.type !== "unchanged")
+        );
+        if (!hasPending) {
+          this.hideDiff();
+        } else {
+          __privateGet(this, _render).call(this);
+        }
+      }
+    };
+    this.rejectChunk = (id) => {
+      const chunk = __privateGet(this, _chunks).find((c) => c.id === id);
+      if (chunk) {
+        chunk.status = "rejected";
+        const hasPending = __privateGet(this, _chunks).some(
+          (c) => c.status === "pending" && c.diffs.some((d) => d.type !== "unchanged")
+        );
+        if (!hasPending) {
+          this.hideDiff();
+        } else {
+          __privateGet(this, _render).call(this);
+        }
+      }
+    };
+    this.hideDiff = () => {
+      if (!__privateGet(this, _isActive)) return;
+      __privateMethod(this, _InlineDiffView_instances, removePanel_fn).call(this);
+      for (const chunk of __privateGet(this, _chunks)) {
+        if (chunk.status === "pending") {
+          chunk.status = "accepted";
+        }
+      }
+      const { doc: finalDoc } = buildNewDoc(__privateGet(this, _chunks), __privateGet(this, _schema));
+      const tr = __privateGet(this, _view).state.tr.replaceWith(
+        0,
+        __privateGet(this, _view).state.doc.content.size,
+        finalDoc.content
+      );
+      sharedDecorationSet = view.DecorationSet.empty;
+      __privateSet(this, _isActive, false);
+      __privateSet(this, _chunks, []);
+      __privateGet(this, _view).dispatch(tr);
+      if (__privateGet(this, _originalEditable)) {
+        __privateGet(this, _view).setProps({
+          editable: __privateGet(this, _originalEditable)
+        });
+        __privateSet(this, _originalEditable, null);
+      } else {
+        __privateGet(this, _view).setProps({
+          editable: () => true
+        });
+      }
+    };
+    this.update = (view) => {
+      __privateSet(this, _view, view);
+    };
+    this.destroy = () => {
+      __privateMethod(this, _InlineDiffView_instances, removePanel_fn).call(this);
+    };
+    __privateSet(this, _ctx, ctx);
+    __privateSet(this, _view, view$1);
+    const api = {
+      showDiff: (oldMd, newMd) => this.showDiff(oldMd, newMd),
+      hideDiff: () => this.hideDiff(),
+      isShowing: () => __privateGet(this, _isActive)
+    };
+    ctx.set(inlineDiffApiCtx.key, api);
+  }
+}
+_ctx = new WeakMap();
+_view = new WeakMap();
+_isActive = new WeakMap();
+_panelApp = new WeakMap();
+_panelContainer = new WeakMap();
+_resizeObserver = new WeakMap();
+_scrollContainers = new WeakMap();
+_updateGeometry = new WeakMap();
+_originalEditable = new WeakMap();
+_chunks = new WeakMap();
+_schema = new WeakMap();
+_render = new WeakMap();
+_InlineDiffView_instances = new WeakSet();
+scrollTo_fn = function(pos) {
+  try {
+    const view = __privateGet(this, _view);
+    const coords = view.coordsAtPos(pos);
+    let scrollTarget = view.dom;
+    while (scrollTarget) {
+      const { overflowY } = getComputedStyle(scrollTarget);
+      if ((overflowY === "auto" || overflowY === "scroll") && scrollTarget.scrollHeight > scrollTarget.clientHeight) {
+        break;
+      }
+      scrollTarget = scrollTarget.parentElement;
+    }
+    if (scrollTarget) {
+      const targetRect = scrollTarget.getBoundingClientRect();
+      const scrollOffset = coords.top - targetRect.top + scrollTarget.scrollTop - 60;
+      scrollTarget.scrollTo({ top: scrollOffset, behavior: "smooth" });
+    } else {
+      window.scrollTo({
+        top: coords.top + window.scrollY - 100,
+        behavior: "smooth"
+      });
+    }
+  } catch (e) {
+  }
+};
+createPanel_fn = function(changes) {
+  __privateMethod(this, _InlineDiffView_instances, removePanel_fn).call(this);
+  const editorContainer = __privateGet(this, _view).dom.parentElement;
+  if (!editorContainer) return;
+  const root = editorContainer.parentElement;
+  if (!root) return;
+  const container = document.createElement("div");
+  container.style.position = "fixed";
+  container.style.zIndex = "100";
+  container.style.width = `${PANEL_WIDTH}px`;
+  container.style.overflow = "hidden";
+  container.style.borderLeft = "1px solid var(--crepe-color-outline-variant, color-mix(in srgb, var(--crepe-color-outline, #ddd), transparent 80%))";
+  container.style.backgroundColor = "var(--crepe-color-surface, #fff)";
+  root.appendChild(container);
+  __privateSet(this, _panelContainer, container);
+  editorContainer.style.paddingRight = `${PANEL_WIDTH}px`;
+  __privateSet(this, _panelApp, mountChangePanel(
+    container,
+    changes,
+    (from) => __privateMethod(this, _InlineDiffView_instances, scrollTo_fn).call(this, from),
+    () => this.hideDiff()
+  ));
+  __privateSet(this, _updateGeometry, () => {
+    const rootRect = root.getBoundingClientRect();
+    let top = rootRect.top;
+    const toolbar = root.querySelector(
+      ".milkdown-fixed-toolbar"
+    );
+    if (toolbar && toolbar.offsetHeight > 0) {
+      const toolbarRect = toolbar.getBoundingClientRect();
+      top = Math.max(top, toolbarRect.bottom);
+    }
+    const coverEl = root.querySelector(
+      ".milkdown-document-cover"
+    );
+    if (coverEl && coverEl.offsetHeight > 0) {
+      top = Math.max(top, coverEl.getBoundingClientRect().bottom);
+    }
+    let height = window.innerHeight - top;
+    if (top + height > rootRect.bottom) {
+      height = Math.max(0, rootRect.bottom - top);
+    }
+    container.style.top = `${top}px`;
+    container.style.height = `${height}px`;
+    container.style.left = "auto";
+    let baseOffset = window.innerWidth - rootRect.right;
+    let rightOffset = baseOffset;
+    let hasVScroll = false;
+    if (document.documentElement.scrollHeight > window.innerHeight) {
+      hasVScroll = true;
+    }
+    let parent = root;
+    while (parent && parent !== document.body) {
+      const { overflowY } = getComputedStyle(parent);
+      if (overflowY === "auto" || overflowY === "scroll") {
+        if (parent.scrollHeight > parent.clientHeight) {
+          hasVScroll = true;
+          break;
+        }
+      }
+      parent = parent.parentElement;
+    }
+    if (hasVScroll) {
+      rightOffset = Math.max(rightOffset, 32);
+    } else {
+      rightOffset = Math.max(rightOffset, 0);
+    }
+    container.style.right = `${rightOffset}px`;
+    editorContainer.style.paddingRight = `${PANEL_WIDTH}px`;
+  });
+  __privateGet(this, _updateGeometry).call(this);
+  setTimeout(() => {
+    var _a;
+    (_a = __privateGet(this, _updateGeometry)) == null ? void 0 : _a.call(this);
+  }, 100);
+  __privateSet(this, _resizeObserver, new ResizeObserver(__privateGet(this, _updateGeometry)));
+  __privateGet(this, _resizeObserver).observe(root);
+  window.addEventListener("resize", __privateGet(this, _updateGeometry));
+  window.addEventListener("scroll", __privateGet(this, _updateGeometry), {
+    capture: true,
+    passive: true
+  });
+  let scrollerNode = root;
+  while (scrollerNode && scrollerNode !== document) {
+    if (scrollerNode instanceof Element) {
+      scrollerNode.addEventListener("scroll", __privateGet(this, _updateGeometry), {
+        passive: true
+      });
+      __privateGet(this, _scrollContainers).push(scrollerNode);
+    }
+    scrollerNode = scrollerNode.parentNode || scrollerNode.host;
+  }
+};
+removePanel_fn = function() {
+  if (__privateGet(this, _panelApp)) {
+    __privateGet(this, _panelApp).unmount();
+    __privateSet(this, _panelApp, null);
+  }
+  if (__privateGet(this, _panelContainer)) {
+    __privateGet(this, _panelContainer).remove();
+    __privateSet(this, _panelContainer, null);
+  }
+  if (__privateGet(this, _resizeObserver)) {
+    __privateGet(this, _resizeObserver).disconnect();
+    __privateSet(this, _resizeObserver, null);
+  }
+  if (__privateGet(this, _updateGeometry)) {
+    window.removeEventListener("resize", __privateGet(this, _updateGeometry));
+    window.removeEventListener("scroll", __privateGet(this, _updateGeometry), {
+      capture: true
+    });
+    for (const container of __privateGet(this, _scrollContainers)) {
+      container.removeEventListener("scroll", __privateGet(this, _updateGeometry));
+    }
+    __privateSet(this, _scrollContainers, []);
+    __privateSet(this, _updateGeometry, null);
+  }
+  const editorContainer = __privateGet(this, _view).dom.parentElement;
+  if (editorContainer) {
+    editorContainer.style.paddingRight = "";
+  }
+};
+function buildDecorations(doc, changes, onAccept, onReject, acceptText, rejectText) {
+  const decorations = [];
+  const addedWidgets = /* @__PURE__ */ new Set();
+  for (const change of changes) {
+    if (!addedWidgets.has(change.chunkId)) {
+      addedWidgets.add(change.chunkId);
+      decorations.push(
+        view.Decoration.widget(
+          change.blockRange.from,
+          () => {
+            const wrapper = document.createElement("div");
+            wrapper.style.position = "relative";
+            wrapper.style.width = "100%";
+            wrapper.style.height = "0";
+            wrapper.style.overflow = "visible";
+            const container = document.createElement("div");
+            container.className = "crepe-diff-actions";
+            container.style.position = "absolute";
+            container.style.right = "4px";
+            container.style.top = "4px";
+            container.style.zIndex = "10";
+            container.style.display = "flex";
+            container.style.gap = "4px";
+            const btnAccept = document.createElement("button");
+            btnAccept.textContent = acceptText;
+            btnAccept.style.backgroundColor = "#2ea043";
+            btnAccept.style.color = "white";
+            btnAccept.style.border = "none";
+            btnAccept.style.borderRadius = "4px";
+            btnAccept.style.padding = "2px 8px";
+            btnAccept.style.cursor = "pointer";
+            btnAccept.style.fontSize = "12px";
+            btnAccept.addEventListener("mousedown", (e) => {
+              e.preventDefault();
+              onAccept(change.chunkId);
+            });
+            const btnReject = document.createElement("button");
+            btnReject.textContent = rejectText;
+            btnReject.style.backgroundColor = "#f85149";
+            btnReject.style.color = "white";
+            btnReject.style.border = "none";
+            btnReject.style.borderRadius = "4px";
+            btnReject.style.padding = "2px 8px";
+            btnReject.style.cursor = "pointer";
+            btnReject.style.fontSize = "12px";
+            btnReject.addEventListener("mousedown", (e) => {
+              e.preventDefault();
+              onReject(change.chunkId);
+            });
+            container.appendChild(btnAccept);
+            container.appendChild(btnReject);
+            wrapper.appendChild(container);
+            return wrapper;
+          },
+          { side: -1 }
+        )
+      );
+    }
+    const blockCls = change.type === "added" ? "crepe-diff-added" : "crepe-diff-deleted";
+    decorations.push(
+      view.Decoration.node(change.blockRange.from, change.blockRange.to, {
+        class: blockCls
+      })
+    );
+    const inlineCls = change.type === "added" ? "crepe-diff-inline-added" : "crepe-diff-inline-deleted";
+    for (const r of change.inlineRanges) {
+      if (r.to > r.from) {
+        decorations.push(view.Decoration.inline(r.from, r.to, { class: inlineCls }));
+      }
+    }
+  }
+  return view.DecorationSet.create(doc, decorations);
+}
+const inlineDiffPlugin = utils.$prose((ctx) => {
+  return new state.Plugin({
+    key: inlineDiffKey,
+    view: (view) => new InlineDiffView(ctx, view),
+    props: {
+      decorations: () => sharedDecorationSet
+    }
+  });
+});
+const inlineDiff = (editor, config) => {
+  editor.config(crepeFeatureConfig(CrepeFeature.InlineDiff)).config((ctx) => {
+    if (config) {
+      ctx.update(inlineDiffConfig.key, (prev) => ({
+        ...prev,
+        ...config
+      }));
+    }
+  }).use(inlineDiffApiCtx).use(inlineDiffConfig).use(inlineDiffPlugin);
+};
+
+exports.inlineDiff = inlineDiff;
+exports.inlineDiffApiCtx = inlineDiffApiCtx;
+exports.inlineDiffKey = inlineDiffKey;
+exports.inlineDiffPlugin = inlineDiffPlugin;
+//# sourceMappingURL=index.js.map