wendang-react 0.0.0-stage → 0.5.6

package/dist/chunks/extensions-B-CVVQhp.js

@@ -0,0 +1,4210 @@
+"use client";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key2, value) => key2 in obj ? __defProp(obj, key2, { enumerable: true, configurable: true, writable: true, value }) : obj[key2] = value;
+var __publicField = (obj, key2, value) => __defNormalProp(obj, typeof key2 !== "symbol" ? key2 + "" : key2, value);
+import StarterKit from "@tiptap/starter-kit";
+import Link from "@tiptap/extension-link";
+import Placeholder from "@tiptap/extension-placeholder";
+import { Table } from "@tiptap/extension-table";
+import TableRow from "@tiptap/extension-table-row";
+import TaskList from "@tiptap/extension-task-list";
+import TaskItem from "@tiptap/extension-task-item";
+import Collaboration from "@tiptap/extension-collaboration";
+import { a as MindMapTopic, b as MindMapDescription, c as MindMapNote, d as MindMapRelation, T as TextStyle, H as Highlight, V as VideoEmbed, M as MindMap, C as Callout } from "./nodes-iKqTGr_N.js";
+import { Fragment, Slice } from "@tiptap/pm/model";
+import { u as unavailableAttachment, c as attachmentObjectUrl, d as downloadAttachment, f as formatBytes, e as ContentContextBridge } from "./host-C-V688Rq.js";
+import { w as whenNearViewport, e as ensureKatexCss, r as renderMathAsync } from "./katex-WjrodtTU.js";
+import { IMAGE_GALLERY_DEFAULT_HEIGHT, normalizeGalleryHeight, normalizeImageAspectRatio, IMAGE_GALLERY_MAX_IMAGES, imageAspectRatioFromSize } from "wendang/internal/image-gallery";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useState, useRef } from "react";
+import { createRoot } from "react-dom/client";
+import { calloutDOMAttributes, effectiveCallout, CALLOUT_COLORS, CALLOUT_FILLS, CALLOUT_TONES, calloutSwatchStyle, CALLOUT_ICONS } from "wendang/shared";
+import { closeHistory } from "@tiptap/pm/history";
+import { yUndoPluginKey, yCursorPlugin } from "@tiptap/y-tiptap";
+import { validCalloutAttrs } from "wendang/internal/callout";
+import { A as AnchoredPanel } from "./AnchoredPanel-D3nte06T.js";
+import { W as WButton, b as WIcon } from "./index-Ii536CFG.js";
+import { C as CodeToolbar, s as showCommentHint, h as hideCommentHint } from "./comment-hint-DN7LKJAn.js";
+import CodeBlock from "@tiptap/extension-code-block";
+import { codeBlockDisplay, codeLineNumbers, codeBlockClass } from "wendang/internal/code-block";
+import { Node as Node$1, mergeAttributes, Extension } from "@tiptap/core";
+import { Plugin, PluginKey, Selection, TextSelection, SelectionRange } from "@tiptap/pm/state";
+import { r as resetCompositionState, e as endComposition, b as beginComposition, s as shouldIgnoreForIme } from "./composition-state-Bl-U1R_2.js";
+import { Decoration, DecorationSet } from "@tiptap/pm/view";
+import { e as ensureCodeHighlight, c as codeTokens } from "./code-highlight-BmaqTe1m.js";
+import { resolveInlineComments } from "wendang/internal/inline-comments";
+import { readableTextColor } from "wendang/internal/presence";
+import { CellSelection, TableMap, addRow, addColumn, selectedRect } from "@tiptap/pm/tables";
+import { cellBackground, CELL_BACKGROUNDS } from "wendang/internal/table-cell-format";
+import { TABLE_CELL_MIN_WIDTH } from "wendang/internal/table-layout";
+import TableCell from "@tiptap/extension-table-cell";
+import TableHeader from "@tiptap/extension-table-header";
+import { paletteColor } from "wendang/internal/document-colors";
+import Image from "@tiptap/extension-image";
+const MAX_COLUMNS = 5;
+const MIN_COLUMNS = 1;
+const Columns = Node$1.create({
+  name: "columns",
+  group: "block",
+  // 至少一栏：空行容器会让光标无处可落
+  content: "column+",
+  defining: true,
+  parseHTML() {
+    return [{ tag: "div[data-columns]" }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return [
+      "div",
+      // 分栏是多列结构：铺整块蓝底会把栏间空隙也染上，只加外圈
+      mergeAttributes(HTMLAttributes, {
+        "data-columns": "true",
+        "data-block-chrome": "",
+        class: "doc-columns"
+      }),
+      0
+    ];
+  }
+});
+const Column = Node$1.create({
+  name: "column",
+  // 刻意不设 group：只能作为 columns 的子节点存在（见文件头说明）
+  content: "block+",
+  defining: true,
+  parseHTML() {
+    return [{ tag: "div[data-column]" }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return [
+      "div",
+      mergeAttributes(HTMLAttributes, { "data-column": "true", class: "doc-column" }),
+      0
+    ];
+  }
+});
+function buildColumnsJson(count) {
+  const n = Math.min(Math.max(Math.round(count), MIN_COLUMNS), MAX_COLUMNS);
+  return {
+    type: "columns",
+    content: Array.from({ length: n }, () => ({
+      type: "column",
+      content: [{ type: "paragraph" }]
+    }))
+  };
+}
+const FileAttachment = Node$1.create({
+  name: "fileAttachment",
+  group: "block",
+  atom: true,
+  selectable: true,
+  draggable: false,
+  addAttributes() {
+    return {
+      attachmentId: { default: null },
+      filename: { default: "" },
+      /** MIME 类型：前端据此显示图标/是否可内嵌播放 */
+      mimeType: { default: "" },
+      /** 字节数（用于显示文件大小） */
+      size: { default: 0 }
+    };
+  },
+  parseHTML() {
+    return [{ tag: "div[data-file-attachment]" }];
+  },
+  renderHTML({ HTMLAttributes, node }) {
+    const name = node.attrs.filename || "附件";
+    return [
+      "div",
+      mergeAttributes(HTMLAttributes, {
+        "data-file-attachment": "true",
+        "data-attachment-id": node.attrs.attachmentId ?? "",
+        // 附件卡片自带外框与底色：块选中时只加外圈，不铺蓝底（同思维导图）
+        "data-block-chrome": "",
+        class: "doc-file-attachment"
+      }),
+      `［附件］${name}`
+    ];
+  },
+  /** 导出为文本时的降级表示（真正的 Markdown 导出由服务端序列化器处理）。 */
+  renderText({ node }) {
+    return node.attrs.filename || "附件";
+  }
+});
+const YwikiImage = Image.extend({
+  addAttributes() {
+    var _a;
+    return {
+      // 保留官方属性（src/alt/title）
+      ...(_a = this.parent) == null ? void 0 : _a.call(this),
+      attachmentId: {
+        default: null,
+        parseHTML: (el) => el.getAttribute("data-attachment-id"),
+        renderHTML: (attrs) => attrs.attachmentId ? { "data-attachment-id": attrs.attachmentId } : {}
+      },
+      /**
+       * 显示宽度（px）。null = 跟随正文宽度（默认）。
+       *
+       * 为什么只存宽度、不存高度（对齐飞书）：图片缩放是**等比**的，
+       * 存两个数字会带来"宽高不一致"的坏数据，而高度由宽度和原始宽高比
+       * 天然推出。服务端属性白名单已登记 `width`（doc-schema 的 image 集合）。
+       */
+      width: {
+        default: null,
+        parseHTML: (el) => {
+          const raw = el.getAttribute("data-width") ?? el.getAttribute("width");
+          const n = Number(raw);
+          return Number.isFinite(n) && n > 0 ? Math.round(n) : null;
+        },
+        renderHTML: (attrs) => {
+          const n = Number(attrs.width);
+          return Number.isFinite(n) && n > 0 ? { "data-width": String(Math.round(n)), width: String(Math.round(n)) } : {};
+        }
+      },
+      /**
+       * 水平对齐：left / center / right；null = 跟随默认观感
+       * （未缩放的图居中、已缩放的图靠左，见两端样式）。
+       *
+       * 对应飞书选中图片后上方工具条的「左/中/右对齐」（用户口径：
+       * 飞书的图片编辑是两部分——四角手柄调大小 + 工具条做对齐等操作）。
+       * 渲染成 `data-align`，编辑端与阅读端共用同一套 margin 规则。
+       */
+      align: {
+        default: null,
+        parseHTML: (el) => {
+          const v = el.getAttribute("data-align");
+          return v === "left" || v === "center" || v === "right" ? v : null;
+        },
+        renderHTML: (attrs) => {
+          const v = attrs.align;
+          return v === "left" || v === "center" || v === "right" ? { "data-align": v } : {};
+        }
+      },
+      /**
+       * 原图宽高比（宽 / 高），供图片行按比例分配列宽。
+       * 不替代 `width`：独立图片仍按显式像素宽度显示。
+       */
+      aspectRatio: {
+        default: null,
+        parseHTML: (el) => {
+          const value = Number(el.getAttribute("data-aspect-ratio"));
+          return Number.isFinite(value) && value > 0 ? value : null;
+        },
+        renderHTML: (attrs) => {
+          const value = Number(attrs.aspectRatio);
+          return Number.isFinite(value) && value > 0 ? { "data-aspect-ratio": String(value) } : {};
+        }
+      },
+      /**
+       * 图片行内的**相对宽度权重**（1 = 按原始比例参与分配）。
+       *
+       * 对应飞书"在图库里拖四角调大小"：不是改某张图的绝对像素，而是改它
+       * 相对同行的权重，整行重新归一化分配——所以同行仍然等高、也不会溢出。
+       * 独立图片不使用该属性（用 `width`）。
+       */
+      galleryScale: {
+        default: null,
+        parseHTML: (el) => {
+          const value = Number(el.getAttribute("data-gallery-scale"));
+          return Number.isFinite(value) && value > 0 ? value : null;
+        },
+        renderHTML: (attrs) => {
+          const value = Number(attrs.galleryScale);
+          return Number.isFinite(value) && value > 0 && value !== 1 ? { "data-gallery-scale": String(value) } : {};
+        }
+      },
+      /**
+       * 图注（显示在图片下方的一行说明文字）。
+       *
+       * 为什么放在节点属性而不是独立段落：图注与图片是**一体**的，
+       * 移动/删除图片时图注要跟着走；独立段落会在复制、拖拽时被拆散。
+       */
+      caption: {
+        default: null,
+        parseHTML: (el) => el.getAttribute("data-caption") || null,
+        renderHTML: (attrs) => attrs.caption ? { "data-caption": String(attrs.caption) } : {}
+      }
+    };
+  },
+  parseHTML() {
+    var _a;
+    return [{ tag: "img[data-attachment-id]" }, ...((_a = this.parent) == null ? void 0 : _a.call(this)) ?? []];
+  }
+});
+const ImageGallery = Node$1.create({
+  name: "imageGallery",
+  group: "block",
+  content: "image{2,10}",
+  defining: true,
+  addAttributes() {
+    return {
+      height: {
+        default: IMAGE_GALLERY_DEFAULT_HEIGHT,
+        parseHTML: (element) => normalizeGalleryHeight(element.getAttribute("data-gallery-height")),
+        renderHTML: (attrs) => {
+          const height = normalizeGalleryHeight(attrs.height);
+          return {
+            "data-gallery-height": String(height),
+            style: `--image-gallery-height:${height}px`
+          };
+        }
+      }
+    };
+  },
+  parseHTML() {
+    return [{ tag: "div[data-image-gallery]" }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return [
+      "div",
+      mergeAttributes(HTMLAttributes, {
+        "data-image-gallery": "true",
+        class: "ywiki-image-gallery"
+      }),
+      0
+    ];
+  }
+});
+const MathInline = Node$1.create({
+  name: "mathInline",
+  group: "inline",
+  inline: true,
+  atom: true,
+  selectable: true,
+  addAttributes() {
+    return {
+      latex: {
+        default: "",
+        parseHTML: (el) => el.getAttribute("data-latex") ?? "",
+        renderHTML: (attrs) => ({ "data-latex": attrs.latex })
+      }
+    };
+  },
+  parseHTML() {
+    return [{ tag: "span[data-math-inline]" }];
+  },
+  renderHTML({ HTMLAttributes, node }) {
+    return [
+      "span",
+      mergeAttributes(HTMLAttributes, {
+        "data-math-inline": "true",
+        class: "doc-math-inline"
+      }),
+      `$${node.attrs.latex}$`
+    ];
+  },
+  renderText({ node }) {
+    return `$${node.attrs.latex}$`;
+  }
+});
+const MathBlock = Node$1.create({
+  name: "mathBlock",
+  group: "block",
+  atom: true,
+  selectable: true,
+  addAttributes() {
+    return {
+      latex: {
+        default: "",
+        parseHTML: (el) => el.getAttribute("data-latex") ?? "",
+        renderHTML: (attrs) => ({ "data-latex": attrs.latex })
+      }
+    };
+  },
+  parseHTML() {
+    return [{ tag: "div[data-math-block]" }];
+  },
+  renderHTML({ HTMLAttributes, node }) {
+    return [
+      "div",
+      mergeAttributes(HTMLAttributes, {
+        "data-math-block": "true",
+        /**
+         * 公式块自己是一块居中画布，选中时只加外圈、不铺蓝底。
+         *
+         * 铺蓝底会用到 `::before` 并向外扩 6px，而公式块是 `overflow-x: auto`
+         * 的容器——溢出的伪元素直接变成可滚动内容，选中时右侧/底部就冒出
+         * 一对滚动条（用户实测反馈："公式选中为什么有滚动条了"）。
+         */
+        "data-block-chrome": "",
+        class: "doc-math-block"
+      }),
+      `$$${node.attrs.latex}$$`
+    ];
+  },
+  renderText({ node }) {
+    return `$$
+${node.attrs.latex}
+$$`;
+  }
+});
+const PageLink = Node$1.create({
+  name: "pageLink",
+  group: "inline",
+  inline: true,
+  atom: true,
+  selectable: true,
+  addAttributes() {
+    return {
+      pageId: { default: null },
+      label: { default: "" }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "span[data-page-link]",
+        getAttrs: (el) => {
+          const dom = el;
+          return {
+            pageId: dom.getAttribute("data-page-id") ?? null,
+            label: dom.textContent ?? ""
+          };
+        }
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes, node }) {
+    return [
+      "span",
+      mergeAttributes(HTMLAttributes, {
+        "data-page-link": "true",
+        "data-page-id": node.attrs.pageId,
+        class: "doc-page-link"
+      }),
+      node.attrs.label || "页面"
+    ];
+  },
+  renderText({ node }) {
+    return node.attrs.label || "页面";
+  }
+});
+const Mention = Node$1.create({
+  name: "mention",
+  group: "inline",
+  inline: true,
+  atom: true,
+  selectable: true,
+  addAttributes() {
+    return {
+      userId: { default: null },
+      label: { default: "" }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "span[data-mention]",
+        getAttrs: (el) => {
+          var _a;
+          const dom = el;
+          return {
+            userId: dom.getAttribute("data-user-id") ?? null,
+            label: ((_a = dom.textContent) == null ? void 0 : _a.replace(/^@/, "")) ?? ""
+          };
+        }
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes, node }) {
+    return [
+      "span",
+      mergeAttributes(HTMLAttributes, {
+        "data-mention": "true",
+        "data-user-id": node.attrs.userId,
+        class: "doc-mention"
+      }),
+      `@${node.attrs.label || "用户"}`
+    ];
+  },
+  renderText({ node }) {
+    return `@${node.attrs.label || "用户"}`;
+  }
+});
+const CELL_ALIGNS = ["left", "center", "right"];
+const isCellAlign = (v) => typeof v === "string" && CELL_ALIGNS.includes(v);
+const alignAttribute = {
+  default: null,
+  parseHTML: (el) => {
+    var _a;
+    const fromStyle = (_a = el.style) == null ? void 0 : _a.textAlign;
+    if (isCellAlign(fromStyle)) return fromStyle;
+    const fromData = el.getAttribute("data-align");
+    return isCellAlign(fromData) ? fromData : null;
+  },
+  renderHTML: (attrs) => {
+    return isCellAlign(attrs.align) ? { "data-align": attrs.align, style: `text-align: ${attrs.align}` } : {};
+  }
+};
+const backgroundAttribute = {
+  default: null,
+  parseHTML: (el) => paletteColor(el.getAttribute("data-cell-background") ?? el.style.backgroundColor, CELL_BACKGROUNDS),
+  renderHTML: (attrs) => {
+    const color = cellBackground(attrs.backgroundColor);
+    return color ? { "data-cell-background": color, style: `background-color: ${color}; color: #202124` } : {};
+  }
+};
+const AlignedTableCell = TableCell.extend({
+  addAttributes() {
+    var _a;
+    return {
+      ...(_a = this.parent) == null ? void 0 : _a.call(this),
+      align: alignAttribute,
+      backgroundColor: backgroundAttribute
+    };
+  }
+});
+const AlignedTableHeader = TableHeader.extend({
+  addAttributes() {
+    var _a;
+    return {
+      ...(_a = this.parent) == null ? void 0 : _a.call(this),
+      align: alignAttribute,
+      backgroundColor: backgroundAttribute
+    };
+  }
+});
+const MIN_WIDTH = 40;
+let standaloneImageDrag = null;
+function imageDragLayer() {
+  const portal = document.querySelector(".wendang-portal");
+  if (portal instanceof HTMLElement) return portal;
+  const shell = document.querySelector(".editor-shell");
+  if (shell instanceof HTMLElement) return shell;
+  return document.body;
+}
+function clearImageDropTargets() {
+  for (const element of document.querySelectorAll(".is-image-drop-target")) {
+    element.classList.remove("is-image-drop-target");
+  }
+  const indicator = document.getElementById("ywiki-image-drop-line");
+  indicator == null ? void 0 : indicator.remove();
+}
+const createImageNodeView = (fetcher = unavailableAttachment, scope) => ({ node, getPos, editor }) => {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const frame = document.createElement("div");
+  frame.className = "ywiki-image-frame";
+  const inner = document.createElement("div");
+  inner.className = "ywiki-image-inner";
+  frame.appendChild(inner);
+  const dom = document.createElement("img");
+  dom.className = "ywiki-image";
+  dom.setAttribute("draggable", "false");
+  let attachmentId = String(((_a = node.attrs) == null ? void 0 : _a.attachmentId) ?? "");
+  const inImageGallery = () => {
+    const pos = typeof getPos === "function" ? getPos() : null;
+    if (pos === null || pos === void 0 || editor.isDestroyed || pos >= editor.state.doc.content.size) return false;
+    try {
+      return editor.state.doc.resolve(pos).parent.type.name === "imageGallery";
+    } catch {
+      return false;
+    }
+  };
+  let fallbackAlt = String(((_b = node.attrs) == null ? void 0 : _b.alt) ?? "");
+  let currentNode = node;
+  const aspectCloseEnough = (a, b) => {
+    if (!Number.isFinite(a) || !Number.isFinite(b) || b <= 0) return false;
+    return Math.abs(a - b) / b <= 0.02;
+  };
+  const backfillAspectRatio = () => {
+    var _a2, _b2;
+    const natural = imageAspectRatioFromSize(dom.naturalWidth, dom.naturalHeight);
+    if (natural === null) return;
+    const stored = normalizeImageAspectRatio((_a2 = currentNode.attrs) == null ? void 0 : _a2.aspectRatio);
+    if (stored !== null && aspectCloseEnough(stored, natural)) return;
+    const pos = typeof getPos === "function" ? getPos() : null;
+    if (pos === null || pos === void 0 || editor.isDestroyed || !editor.isEditable) return;
+    const current = editor.state.doc.nodeAt(pos);
+    if (!current || current.type.name !== "image") return;
+    const latest = normalizeImageAspectRatio((_b2 = current.attrs) == null ? void 0 : _b2.aspectRatio);
+    if (latest !== null && aspectCloseEnough(latest, natural)) return;
+    editor.view.dispatch(editor.state.tr.setNodeMarkup(pos, void 0, {
+      ...current.attrs,
+      aspectRatio: natural
+    }));
+  };
+  const markLoaded = () => {
+    dom.removeAttribute("data-image-loading");
+    if (fallbackAlt) {
+      dom.alt = fallbackAlt;
+      dom.title = fallbackAlt;
+    }
+    backfillAspectRatio();
+  };
+  const markFailed = () => {
+    dom.removeAttribute("data-image-loading");
+    if (fallbackAlt) {
+      dom.alt = fallbackAlt;
+      dom.title = fallbackAlt;
+    }
+    dom.setAttribute("data-image-error", "true");
+  };
+  dom.setAttribute("data-image-loading", "true");
+  const applyWidth = (value) => {
+    if (inImageGallery()) {
+      dom.style.removeProperty("width");
+      frame.removeAttribute("data-sized");
+      return;
+    }
+    const n = Number(value);
+    if (Number.isFinite(n) && n > 0) {
+      dom.style.width = `${Math.round(n)}px`;
+      frame.setAttribute("data-sized", "true");
+    } else {
+      dom.style.removeProperty("width");
+      frame.removeAttribute("data-sized");
+    }
+  };
+  applyWidth((_c = node.attrs) == null ? void 0 : _c.width);
+  const applyAspectRatio = (value) => {
+    const ratio = normalizeImageAspectRatio(value);
+    if (ratio === null) {
+      frame.style.removeProperty("--ywiki-image-ratio");
+      frame.removeAttribute("data-aspect-ratio");
+    } else {
+      frame.style.setProperty("--ywiki-image-ratio", String(ratio));
+      frame.setAttribute("data-aspect-ratio", String(ratio));
+    }
+  };
+  const applyGalleryScale = (value) => {
+    const scale = Number(value);
+    if (Number.isFinite(scale) && scale > 0 && scale !== 1) {
+      frame.style.setProperty("--ywiki-image-weight", String(scale));
+      frame.setAttribute("data-gallery-scale", String(scale));
+    } else {
+      frame.style.removeProperty("--ywiki-image-weight");
+      frame.removeAttribute("data-gallery-scale");
+    }
+  };
+  applyAspectRatio((_d = node.attrs) == null ? void 0 : _d.aspectRatio);
+  applyGalleryScale((_e = node.attrs) == null ? void 0 : _e.galleryScale);
+  const caption = document.createElement("div");
+  caption.className = "ywiki-image-caption";
+  caption.setAttribute("contenteditable", "false");
+  let editingCaption = false;
+  const applyCaption = (value) => {
+    const text = typeof value === "string" ? value : "";
+    if (editingCaption) return;
+    caption.textContent = text;
+    caption.hidden = text.length === 0;
+    frame.classList.toggle("has-caption", text.length > 0);
+    if (text) caption.title = text;
+  };
+  applyCaption((_f = node.attrs) == null ? void 0 : _f.caption);
+  function commitCaption(value) {
+    var _a2;
+    editingCaption = false;
+    caption.removeAttribute("contenteditable");
+    caption.classList.remove("is-editing");
+    const pos = typeof getPos === "function" ? getPos() : null;
+    if (pos === null || pos === void 0 || editor.isDestroyed) return;
+    const latest = editor.state.doc.nodeAt(pos);
+    if (!latest || latest.type.name !== "image") return;
+    const next = value.trim().slice(0, 500);
+    if ((((_a2 = latest.attrs) == null ? void 0 : _a2.caption) ?? "") === (next || null)) {
+      applyCaption(next);
+      return;
+    }
+    editor.view.dispatch(editor.state.tr.setNodeMarkup(pos, void 0, {
+      ...latest.attrs,
+      caption: next || null
+    }));
+  }
+  function startCaptionEdit() {
+    var _a2;
+    if (!editor.isEditable) return;
+    editingCaption = true;
+    caption.hidden = false;
+    frame.classList.add("has-caption");
+    caption.textContent = String(((_a2 = node.attrs) == null ? void 0 : _a2.caption) ?? "");
+    caption.setAttribute("contenteditable", "true");
+    caption.classList.add("is-editing");
+    caption.focus();
+    const range = document.createRange();
+    range.selectNodeContents(caption);
+    range.collapse(false);
+    const selection = window.getSelection();
+    selection == null ? void 0 : selection.removeAllRanges();
+    selection == null ? void 0 : selection.addRange(range);
+  }
+  caption.addEventListener("dblclick", (event) => {
+    event.preventDefault();
+    event.stopPropagation();
+    startCaptionEdit();
+  });
+  caption.addEventListener("keydown", (event) => {
+    if (!editingCaption) return;
+    event.stopPropagation();
+    if (event.key === "Escape") {
+      event.preventDefault();
+      commitCaption("");
+    } else if (event.key === "Enter") {
+      event.preventDefault();
+      commitCaption(caption.textContent ?? "");
+    }
+  });
+  caption.addEventListener("blur", () => {
+    if (editingCaption) commitCaption(caption.textContent ?? "");
+  });
+  frame.addEventListener("ywiki-caption-edit", startCaptionEdit);
+  const applyAlign = (value) => {
+    if (value === "left" || value === "center" || value === "right") {
+      frame.setAttribute("data-align", value);
+    } else {
+      frame.removeAttribute("data-align");
+    }
+  };
+  applyAlign((_g = node.attrs) == null ? void 0 : _g.align);
+  let stopWatch = null;
+  let releaseUrl;
+  const fetchInto = (id) => {
+    releaseUrl == null ? void 0 : releaseUrl();
+    releaseUrl = attachmentObjectUrl(id, (url) => {
+      if (attachmentId !== id) return;
+      dom.src = url;
+      if (dom.complete && dom.naturalWidth > 0) markLoaded();
+      else dom.addEventListener("load", () => markLoaded(), { once: true });
+    }, fetcher, () => {
+      if (attachmentId === id) markFailed();
+    }, scope);
+  };
+  const load = (id) => {
+    releaseUrl == null ? void 0 : releaseUrl();
+    stopWatch == null ? void 0 : stopWatch();
+    stopWatch = null;
+    if (!id) {
+      dom.removeAttribute("src");
+      dom.removeAttribute("data-image-loading");
+      dom.setAttribute("data-image-missing", "true");
+      return;
+    }
+    dom.removeAttribute("data-image-missing");
+    dom.removeAttribute("data-image-error");
+    if (dom.getAttribute("src")) markLoaded();
+    else dom.setAttribute("data-image-loading", "true");
+    stopWatch = whenNearViewport(dom, () => fetchInto(id));
+  };
+  load(attachmentId);
+  const CORNER_CURSOR = {
+    nw: "nwse-resize",
+    ne: "nesw-resize",
+    sw: "nesw-resize",
+    se: "nwse-resize"
+  };
+  const handles = [];
+  for (const corner of ["nw", "ne", "sw", "se"]) {
+    const h = document.createElement("div");
+    h.className = `ywiki-image-handle handle-${corner}`;
+    h.setAttribute("aria-hidden", "true");
+    h.setAttribute("contenteditable", "false");
+    h.addEventListener("mousedown", (e) => startResize(e, corner));
+    inner.appendChild(h);
+    handles.push(h);
+  }
+  const syncGalleryMode = () => {
+    const inGallery = inImageGallery();
+    frame.classList.toggle("is-in-gallery", inGallery);
+    frame.setAttribute("draggable", inGallery ? "false" : "true");
+    for (const h of handles) h.hidden = inGallery;
+  };
+  syncGalleryMode();
+  requestAnimationFrame(() => syncGalleryMode());
+  const setSelected = (on) => {
+    frame.classList.toggle("is-selected", on);
+  };
+  let galleryDrag = null;
+  let galleryIndicator = null;
+  const galleryContainerOf = (pos) => {
+    if (editor.isDestroyed) return null;
+    try {
+      const $pos = editor.state.doc.resolve(pos);
+      const parent = $pos.parent;
+      if (parent.type.name !== "imageGallery" || $pos.depth === 0) return null;
+      return { node: parent, pos: $pos.before() };
+    } catch {
+      return null;
+    }
+  };
+  function clearGalleryDrag() {
+    galleryDrag = null;
+    if (galleryIndicator) {
+      galleryIndicator.remove();
+      galleryIndicator = null;
+    }
+    document.removeEventListener("mousemove", onGalleryMove, true);
+    document.removeEventListener("mouseup", onGalleryUp, true);
+    frame.classList.remove("is-gallery-dragging");
+    document.documentElement.style.cursor = "";
+  }
+  function showIndicator(x, top, height) {
+    if (!galleryIndicator) {
+      galleryIndicator = document.createElement("div");
+      galleryIndicator.className = "ywiki-gallery-drop-line";
+      galleryIndicator.setAttribute("aria-hidden", "true");
+      const accent = getComputedStyle(frame).getPropertyValue("--color-accent").trim() || getComputedStyle(document.documentElement).getPropertyValue("--color-accent").trim() || "#2f6feb";
+      galleryIndicator.style.background = accent;
+      galleryIndicator.style.width = "3px";
+      galleryIndicator.style.borderRadius = "999px";
+      galleryIndicator.style.border = "1px solid rgba(255, 255, 255, 0.9)";
+      galleryIndicator.style.boxShadow = "0 0 0 1px rgba(0, 0, 0, 0.06), 0 2px 10px rgba(0, 0, 0, 0.18)";
+      imageDragLayer().appendChild(galleryIndicator);
+    }
+    galleryIndicator.style.left = `${Math.round(x) - 1}px`;
+    galleryIndicator.style.top = `${Math.round(top)}px`;
+    galleryIndicator.style.height = `${Math.round(height)}px`;
+    galleryIndicator.style.opacity = "1";
+  }
+  const onGalleryMove = (event) => {
+    const drag = galleryDrag;
+    if (!drag) return;
+    drag.lastX = event.clientX;
+    drag.lastY = event.clientY;
+    const container = frame.closest(".ywiki-image-gallery");
+    if (!(container instanceof HTMLElement)) return;
+    const rect = container.getBoundingClientRect();
+    const children = Array.from(container.children).filter((el) => el instanceof HTMLElement && el !== galleryIndicator);
+    drag.outside = event.clientX < rect.left - 24 || event.clientX > rect.right + 24 || event.clientY < rect.top - 24 || event.clientY > rect.bottom + 24;
+    if (drag.outside) {
+      if (galleryIndicator) galleryIndicator.style.opacity = "0";
+      return;
+    }
+    const others = children.filter((el) => el !== frame);
+    let dropIndex = others.length;
+    for (let i = 0; i < others.length; i += 1) {
+      const childRect = others[i].getBoundingClientRect();
+      if (event.clientX < childRect.left + childRect.width / 2) {
+        dropIndex = i;
+        break;
+      }
+    }
+    drag.dropIndex = drag.index <= dropIndex ? dropIndex + 1 : dropIndex;
+    const reference = others[Math.min(dropIndex, others.length - 1)];
+    let x = rect.left;
+    if (reference) {
+      const refRect = reference.getBoundingClientRect();
+      x = dropIndex >= others.length ? refRect.right : refRect.left;
+    }
+    showIndicator(x, rect.top, rect.height);
+  };
+  const onGalleryUp = () => {
+    const drag = galleryDrag;
+    clearGalleryDrag();
+    if (!drag || !editor.isEditable) return;
+    const pos = typeof getPos === "function" ? getPos() : null;
+    if (pos === null || pos === void 0) return;
+    const container = galleryContainerOf(pos);
+    if (!container) return;
+    const node2 = editor.state.doc.nodeAt(pos);
+    if (!node2 || node2.type.name !== "image") return;
+    if (!drag.outside && drag.dropIndex === drag.index) return;
+    const tr = editor.state.tr;
+    const gallery = container.node;
+    const imageType = editor.schema.nodes.image;
+    const galleryType = editor.schema.nodes.imageGallery;
+    if (!imageType || !galleryType) return;
+    const children = [];
+    gallery.forEach((child) => {
+      children.push(child);
+    });
+    if (children.length !== drag.childPositions.length) return;
+    const galleryStart = container.pos;
+    const galleryEnd = galleryStart + gallery.nodeSize;
+    if (drag.outside) {
+      const hit = imageHitTest(drag.lastX, drag.lastY);
+      if (hit && hit.pos !== galleryStart) {
+        if (hit.kind === "image") {
+          const merged = mergeIntoStandalone(galleryStart, gallery, node2, drag.index, hit);
+          if (merged) return;
+        } else if (moveImageIntoGalleryAt(galleryStart, gallery, node2, drag.index, hit, { x: drag.lastX, y: drag.lastY })) {
+          return;
+        }
+      }
+      children.splice(drag.index, 1);
+      const replacement = children.length >= 2 ? [galleryType.create(gallery.attrs, Fragment.fromArray(children)), node2] : children.length === 1 ? [children[0], node2] : [node2];
+      tr.replaceWith(galleryStart, galleryEnd, Fragment.fromArray(replacement));
+      editor.view.dispatch(tr);
+      editor.commands.focus();
+      return;
+    }
+    const from = drag.index;
+    const to = drag.dropIndex > from ? drag.dropIndex - 1 : drag.dropIndex;
+    if (to === from) return;
+    const [moved] = children.splice(from, 1);
+    children.splice(to, 0, moved);
+    tr.replaceWith(galleryStart, galleryEnd, galleryType.create(gallery.attrs, Fragment.fromArray(children)));
+    editor.view.dispatch(tr);
+    editor.commands.focus();
+  };
+  function startGalleryDrag(event) {
+    if (event.button !== 0 || !editor.isEditable || event.altKey) return;
+    const pos = typeof getPos === "function" ? getPos() : null;
+    if (pos === null || pos === void 0) return;
+    const container = galleryContainerOf(pos);
+    if (!container) return;
+    const childPositions = [];
+    container.node.forEach((child, offset) => {
+      childPositions.push(container.pos + 1 + offset);
+    });
+    const index = childPositions.indexOf(pos);
+    if (index < 0) return;
+    const startX = event.clientX;
+    const startY = event.clientY;
+    let armed = false;
+    const arm = (moveEvent) => {
+      if (armed) return;
+      const dx = moveEvent.clientX - startX;
+      const dy = moveEvent.clientY - startY;
+      if (Math.hypot(dx, dy) < 32) return;
+      armed = true;
+      document.removeEventListener("mousemove", arm, true);
+      frame.classList.add("is-gallery-dragging");
+      document.documentElement.style.cursor = "grabbing";
+      galleryDrag = {
+        galleryPos: container.pos,
+        galleryEnd: container.pos + container.node.nodeSize,
+        childPositions,
+        index,
+        dropIndex: index,
+        outside: false,
+        element: frame,
+        lastX: event.clientX,
+        lastY: event.clientY
+      };
+      document.addEventListener("mousemove", onGalleryMove, true);
+      document.addEventListener("mouseup", onGalleryUp, true);
+    };
+    const blockNativeDrag = (dragEvent) => {
+      dragEvent.preventDefault();
+    };
+    frame.addEventListener("dragstart", blockNativeDrag, true);
+    const stopBlockingDrag = () => {
+      frame.removeEventListener("dragstart", blockNativeDrag, true);
+      document.removeEventListener("mouseup", stopBlockingDrag, true);
+    };
+    document.addEventListener("mouseup", stopBlockingDrag, true);
+    document.addEventListener("mousemove", arm, true);
+    const cancelArm = () => {
+      document.removeEventListener("mousemove", arm, true);
+      document.removeEventListener("mouseup", cancelArm, true);
+    };
+    document.addEventListener("mouseup", cancelArm, true);
+  }
+  frame.addEventListener("mousedown", (event) => {
+    if (!inImageGallery()) return;
+    const gallery = frame.closest(".ywiki-image-gallery");
+    if (gallery instanceof HTMLElement && (gallery.classList.contains("is-block-selected") || gallery.classList.contains("is-block-image-selected"))) return;
+    startGalleryDrag(event);
+  });
+  const ownPos = () => {
+    const value = typeof getPos === "function" ? getPos() : null;
+    return typeof value === "number" ? value : null;
+  };
+  const visibleRect = () => {
+    const target = inner.getBoundingClientRect();
+    return target.width > 1 && target.height > 1 ? target : frame.getBoundingClientRect();
+  };
+  const dropAfter = (event) => {
+    const rect = visibleRect();
+    return event.clientX >= rect.left + rect.width / 2;
+  };
+  const showMergeHint = (event) => {
+    const rect = visibleRect();
+    frame.classList.add("is-image-drop-target");
+    let indicator = document.getElementById("ywiki-image-drop-line");
+    if (!indicator) {
+      indicator = document.createElement("div");
+      indicator.id = "ywiki-image-drop-line";
+      indicator.className = "ywiki-image-drop-line";
+      indicator.setAttribute("aria-hidden", "true");
+      const accent = getComputedStyle(frame).getPropertyValue("--color-accent").trim() || getComputedStyle(document.documentElement).getPropertyValue("--color-accent").trim() || "#2f6feb";
+      indicator.style.background = accent;
+      indicator.style.width = "3px";
+      indicator.style.borderRadius = "999px";
+      indicator.style.border = "1px solid rgba(255, 255, 255, 0.9)";
+      indicator.style.boxShadow = "0 0 0 1px rgba(0, 0, 0, 0.06), 0 2px 10px rgba(0, 0, 0, 0.18)";
+      imageDragLayer().appendChild(indicator);
+    }
+    const after = dropAfter(event);
+    indicator.style.top = `${Math.round(rect.top)}px`;
+    indicator.style.height = `${Math.round(rect.height)}px`;
+    indicator.style.left = `${Math.round(after ? rect.right + 4 : rect.left - 4)}px`;
+    indicator.style.opacity = "1";
+  };
+  const hideMergeHint = () => {
+    var _a2;
+    frame.classList.remove("is-image-drop-target");
+    (_a2 = document.getElementById("ywiki-image-drop-line")) == null ? void 0 : _a2.remove();
+  };
+  function imageHitTest(x, y) {
+    if (editor.isDestroyed) return null;
+    const pointerEvents = frame.style.pointerEvents;
+    frame.style.pointerEvents = "none";
+    const element = document.elementFromPoint(x, y);
+    frame.style.pointerEvents = pointerEvents;
+    if (!(element instanceof Element)) return null;
+    const hitFrame = element.closest(".ywiki-image-frame");
+    if (!(hitFrame instanceof HTMLElement) || hitFrame === frame) return null;
+    const ownGallery = frame.closest(".ywiki-image-gallery");
+    const galleryEl = hitFrame.closest(".ywiki-image-gallery");
+    if (galleryEl instanceof HTMLElement) {
+      if (galleryEl === ownGallery) return null;
+      let found = null;
+      editor.state.doc.descendants((node3, offset) => {
+        if (found || node3.type.name !== "imageGallery") return;
+        try {
+          if (editor.view.nodeDOM(offset) === galleryEl) found = { kind: "gallery", pos: offset, node: node3 };
+        } catch {
+        }
+      });
+      return found;
+    }
+    const imageEl = hitFrame.querySelector("img");
+    if (!imageEl) return null;
+    let pos = null;
+    try {
+      const raw = editor.view.posAtDOM(hitFrame, 0);
+      const candidates = [raw, raw - 1, raw + 1].filter((value) => value >= 0 && value <= editor.state.doc.content.size);
+      for (const candidate of candidates) {
+        const node3 = editor.state.doc.nodeAt(candidate);
+        if ((node3 == null ? void 0 : node3.type.name) === "image") {
+          pos = candidate;
+          break;
+        }
+      }
+    } catch (err) {
+      pos = null;
+    }
+    if (pos === null) return null;
+    const node2 = editor.state.doc.nodeAt(pos);
+    return node2 ? { kind: "image", pos, node: node2 } : null;
+  }
+  function moveImageIntoGalleryAt(galleryStart, gallery, moved, movedIndex, target, pointer) {
+    const { state } = editor;
+    const galleryType = state.schema.nodes.imageGallery;
+    if (!galleryType) return false;
+    if (target.pos === galleryStart) return false;
+    if (target.node.content.childCount >= IMAGE_GALLERY_MAX_IMAGES) return false;
+    const targetChildren = [];
+    target.node.forEach((child) => {
+      targetChildren.push(child);
+    });
+    const targetDom = editor.view.nodeDOM(target.pos);
+    const domFrames = targetDom instanceof HTMLElement ? [...targetDom.querySelectorAll(".ywiki-image-frame")] : [];
+    let childIndex = targetChildren.length - 1;
+    for (let index = 0; index < domFrames.length && index < targetChildren.length; index += 1) {
+      const r = domFrames[index].getBoundingClientRect();
+      if (pointer.x < r.left + r.width / 2) {
+        childIndex = index;
+        break;
+      }
+      childIndex = index + 1;
+    }
+    const insertAt = Math.max(0, Math.min(childIndex, targetChildren.length));
+    targetChildren.splice(insertAt, 0, moved);
+    const remaining = [];
+    gallery.forEach((child, _offset, index) => {
+      if (index !== movedIndex) remaining.push(child);
+    });
+    const sourceReplacement = remaining.length >= 2 ? [galleryType.create(gallery.attrs, Fragment.fromArray(remaining))] : remaining.length === 1 ? [remaining[0]] : [];
+    const sourceTop = topLevelIndexOf(galleryStart);
+    const targetTop = topLevelIndexOf(target.pos);
+    if (sourceTop < 0 || targetTop < 0) return false;
+    return replaceTopLevelBlocks(
+      sourceTop,
+      sourceReplacement,
+      targetTop,
+      [galleryType.create(target.node.attrs, Fragment.fromArray(targetChildren))]
+    );
+  }
+  function mergeIntoStandalone(galleryStart, gallery, moved, movedIndex, target) {
+    const { state } = editor;
+    const galleryType = state.schema.nodes.imageGallery;
+    if (!galleryType) return false;
+    if (target.pos === galleryStart) return false;
+    const remaining = [];
+    gallery.forEach((child, _offset, index) => {
+      if (index !== movedIndex) remaining.push(child);
+    });
+    const sourceReplacement = remaining.length >= 2 ? [galleryType.create(gallery.attrs, Fragment.fromArray(remaining))] : remaining.length === 1 ? [remaining[0]] : [];
+    const pair = galleryType.create(
+      { height: IMAGE_GALLERY_DEFAULT_HEIGHT },
+      Fragment.fromArray([target.node, moved])
+    );
+    const sourceTop = topLevelIndexOf(galleryStart);
+    const targetTop = topLevelIndexOf(target.pos);
+    if (sourceTop < 0 || targetTop < 0) return false;
+    return replaceTopLevelBlocks(sourceTop, sourceReplacement, targetTop, [pair]);
+  }
+  function topLevelIndexOf(pos) {
+    let cursor = 0;
+    let index = 0;
+    let found = -1;
+    editor.state.doc.forEach((child) => {
+      if (found < 0 && cursor === pos) found = index;
+      cursor += child.nodeSize;
+      index += 1;
+    });
+    return found;
+  }
+  function replaceTopLevelBlocks(sourceIndex, sourceNodes, targetIndex, targetNodes) {
+    const { state } = editor;
+    const top = [];
+    state.doc.forEach((child) => {
+      top.push(child);
+    });
+    if (sourceIndex < 0 || sourceIndex >= top.length) return false;
+    if (targetIndex < 0 || targetIndex >= top.length) return false;
+    if (sourceIndex === targetIndex) return false;
+    const rebuilt = [];
+    for (let index = 0; index < top.length; index += 1) {
+      if (index === sourceIndex) rebuilt.push(...sourceNodes);
+      else if (index === targetIndex) rebuilt.push(...targetNodes);
+      else rebuilt.push(top[index]);
+    }
+    const tr = state.tr;
+    try {
+      const jobs = [];
+      if (sourceIndex <= targetIndex) {
+        jobs.push({ index: targetIndex, nodes: targetNodes });
+        jobs.push({ index: sourceIndex, nodes: sourceNodes });
+      } else {
+        jobs.push({ index: sourceIndex, nodes: sourceNodes });
+        jobs.push({ index: targetIndex, nodes: targetNodes });
+      }
+      let starts = [];
+      let cursor = 0;
+      for (const child of top) {
+        starts.push(cursor);
+        cursor += child.nodeSize;
+      }
+      for (const job of jobs) {
+        const from = tr.mapping.map(starts[job.index], 1);
+        const to = tr.mapping.map(starts[job.index] + top[job.index].nodeSize, -1);
+        tr.replaceWith(from, Math.max(from, to), Fragment.fromArray(job.nodes));
+      }
+      editor.view.dispatch(tr);
+    } catch {
+      return false;
+    }
+    editor.commands.focus();
+    return true;
+  }
+  function mergeTwoImages(sourcePos, targetPos, after) {
+    const { state } = editor;
+    const source = state.doc.nodeAt(sourcePos);
+    const target = state.doc.nodeAt(targetPos);
+    if (!source || !target || source.type.name !== "image" || target.type.name !== "image") return false;
+    const galleryType = state.schema.nodes.imageGallery;
+    if (!galleryType) return false;
+    const pair = after ? [target, source] : [source, target];
+    const earlier = Math.min(sourcePos, targetPos);
+    const later = Math.max(sourcePos, targetPos);
+    const earlierNode = earlier === sourcePos ? source : target;
+    const laterNode = later === sourcePos ? source : target;
+    const middle = state.doc.slice(earlier + earlierNode.nodeSize, later).content;
+    const gallery = galleryType.create({ height: IMAGE_GALLERY_DEFAULT_HEIGHT }, Fragment.fromArray(pair));
+    const tr = state.tr.replaceWith(
+      earlier,
+      later + laterNode.nodeSize,
+      Fragment.fromArray([gallery]).append(middle)
+    );
+    editor.view.dispatch(tr);
+    editor.commands.focus();
+    return true;
+  }
+  function insertIntoGallery(sourcePos, galleryPos, galleryNode, dropIndex) {
+    const { state } = editor;
+    const source = state.doc.nodeAt(sourcePos);
+    if (!source || source.type.name !== "image") return false;
+    const galleryType = state.schema.nodes.imageGallery;
+    if (!galleryType) return false;
+    const children = galleryNode.content.content.slice();
+    if (children.length >= IMAGE_GALLERY_MAX_IMAGES) return false;
+    const shift = sourcePos < galleryPos ? source.nodeSize : 0;
+    const children_ = [];
+    galleryNode.forEach((child) => {
+      children_.push(child);
+    });
+    children_.splice(dropIndex, 0, source);
+    const tr = state.tr;
+    tr.delete(sourcePos, sourcePos + source.nodeSize);
+    const target = galleryPos - shift;
+    tr.replaceWith(
+      target,
+      target + galleryNode.nodeSize,
+      galleryType.create(galleryNode.attrs, Fragment.fromArray(children_))
+    );
+    editor.view.dispatch(tr);
+    editor.commands.focus();
+    return true;
+  }
+  frame.addEventListener("dragstart", (event) => {
+    var _a2, _b2;
+    if (inImageGallery()) return;
+    const pos = ownPos();
+    if (pos === null || !editor.isEditable) return;
+    const current = editor.state.doc.nodeAt(pos);
+    if (!current || current.type.name !== "image") return;
+    standaloneImageDrag = { pos, node: current };
+    (_a2 = event.dataTransfer) == null ? void 0 : _a2.setData("text/plain", "");
+    if (event.dataTransfer) event.dataTransfer.effectAllowed = "move";
+    try {
+      (_b2 = event.dataTransfer) == null ? void 0 : _b2.setDragImage(dom, dom.width / 2, Math.min(dom.height / 2, 40));
+    } catch {
+    }
+  });
+  frame.addEventListener("dragend", () => {
+    standaloneImageDrag = null;
+    hideMergeHint();
+    clearImageDropTargets();
+    queueMicrotask(clearImageDropTargets);
+  });
+  frame.addEventListener("dragover", (event) => {
+    if (!standaloneImageDrag) return;
+    const pos = ownPos();
+    if (pos === null || standaloneImageDrag.pos === pos) return;
+    event.preventDefault();
+    event.stopPropagation();
+    if (event.dataTransfer) event.dataTransfer.dropEffect = "move";
+    showMergeHint(event);
+  });
+  frame.addEventListener("dragleave", (event) => {
+    if (!standaloneImageDrag) return;
+    const next = event.relatedTarget;
+    if (next instanceof Node && frame.contains(next)) return;
+    hideMergeHint();
+  });
+  frame.addEventListener("drop", (event) => {
+    var _a2;
+    const source = standaloneImageDrag;
+    if (!source) return;
+    const pos = ownPos();
+    if (pos === null) return;
+    hideMergeHint();
+    clearImageDropTargets();
+    standaloneImageDrag = null;
+    queueMicrotask(clearImageDropTargets);
+    if (source.pos === pos) {
+      return;
+    }
+    event.preventDefault();
+    event.stopPropagation();
+    const container = galleryContainerOf(pos);
+    if (container) {
+      const children_ = [];
+      container.node.forEach((child) => {
+        children_.push(child);
+      });
+      dropAfter(event) ? children_.length : 0;
+      const frames = [...((_a2 = frame.parentElement) == null ? void 0 : _a2.children) ?? []].filter((el) => el instanceof HTMLElement && el.classList.contains("ywiki-image-frame"));
+      let index = frames.length;
+      for (let i = 0; i < frames.length; i += 1) {
+        const rect = frames[i].getBoundingClientRect();
+        if (event.clientX < rect.left + rect.width / 2) {
+          index = i;
+          break;
+        }
+      }
+      insertIntoGallery(source.pos, container.pos, container.node, index);
+      return;
+    }
+    mergeTwoImages(source.pos, pos, dropAfter(event));
+  });
+  function resizeInGallery(event, sign) {
+    var _a2;
+    const pos = typeof getPos === "function" ? getPos() : null;
+    if (pos === null || pos === void 0) return;
+    const current = editor.state.doc.nodeAt(pos);
+    if (!current || current.type.name !== "image") return;
+    const startX = event.clientX;
+    const startWidth = frame.getBoundingClientRect().width;
+    const startScale = Number((_a2 = current.attrs) == null ? void 0 : _a2.galleryScale) || 1;
+    const prevCursor = document.documentElement.style.cursor;
+    frame.classList.add("is-resizing");
+    document.documentElement.style.cursor = CORNER_CURSOR.nw;
+    document.body.style.userSelect = "none";
+    const clamp = (value) => Math.max(0.25, Math.min(4, value));
+    let nextScale = startScale;
+    const onMove = (moveEvent) => {
+      const dx = (moveEvent.clientX - startX) * sign;
+      const nextWidth = Math.max(24, startWidth + dx);
+      nextScale = clamp(startScale * (nextWidth / Math.max(1, startWidth)));
+      frame.style.setProperty("--ywiki-image-weight", String(nextScale));
+    };
+    const onUp = () => {
+      window.removeEventListener("mousemove", onMove);
+      window.removeEventListener("mouseup", onUp);
+      window.removeEventListener("blur", onUp);
+      frame.classList.remove("is-resizing");
+      document.documentElement.style.cursor = prevCursor;
+      document.body.style.userSelect = "";
+      if (editor.isDestroyed) return;
+      const latest = editor.state.doc.nodeAt(pos);
+      if (!latest || latest.type.name !== "image") return;
+      const rounded = Math.round(nextScale * 1e3) / 1e3;
+      if (Math.abs(rounded - startScale) < 1e-3) {
+        frame.style.removeProperty("--ywiki-image-weight");
+        return;
+      }
+      editor.view.dispatch(editor.state.tr.setNodeMarkup(pos, void 0, {
+        ...latest.attrs,
+        galleryScale: rounded === 1 ? null : rounded
+      }));
+    };
+    window.addEventListener("mousemove", onMove);
+    window.addEventListener("mouseup", onUp);
+    window.addEventListener("blur", onUp);
+  }
+  function startResize(event, corner) {
+    const sign = corner === "nw" || corner === "sw" ? -1 : 1;
+    if (event.button !== 0 || !editor.isEditable) return;
+    event.preventDefault();
+    event.stopPropagation();
+    if (inImageGallery()) {
+      resizeInGallery(event, sign);
+      return;
+    }
+    frame.classList.add("is-resizing");
+    const cursor = CORNER_CURSOR[corner];
+    const prevCursor = document.documentElement.style.cursor;
+    document.documentElement.style.cursor = cursor;
+    const startX = event.clientX;
+    const startWidth = dom.getBoundingClientRect().width;
+    const maxWidth = editor.view.dom.clientWidth || Number.POSITIVE_INFINITY;
+    const onMove = (e) => {
+      const dx = (e.clientX - startX) * sign;
+      const next = Math.max(MIN_WIDTH, Math.min(maxWidth, Math.round(startWidth + dx)));
+      dom.style.width = `${next}px`;
+      frame.setAttribute("data-sized", "true");
+    };
+    const onUp = () => {
+      window.removeEventListener("mousemove", onMove);
+      window.removeEventListener("mouseup", onUp);
+      window.removeEventListener("blur", onUp);
+      frame.classList.remove("is-resizing");
+      document.documentElement.style.cursor = prevCursor;
+      const finalWidth = Math.round(dom.getBoundingClientRect().width);
+      const pos = typeof getPos === "function" ? getPos() : null;
+      if (pos === null || pos === void 0 || editor.isDestroyed) return;
+      const currentNode2 = editor.state.doc.nodeAt(pos);
+      if (!currentNode2 || currentNode2.type.name !== "image") return;
+      if (Number(currentNode2.attrs.width) === finalWidth) return;
+      editor.view.dispatch(
+        editor.state.tr.setNodeMarkup(pos, void 0, {
+          ...currentNode2.attrs,
+          width: finalWidth
+        })
+      );
+    };
+    window.addEventListener("mousemove", onMove);
+    window.addEventListener("mouseup", onUp);
+    window.addEventListener("blur", onUp);
+  }
+  inner.appendChild(dom);
+  frame.appendChild(caption);
+  return {
+    dom: frame,
+    update: (updated) => {
+      var _a2, _b2, _c2, _d2, _e2, _f2, _g2, _h;
+      if (updated.type.name !== "image") return false;
+      const nextAlt = String(((_a2 = updated.attrs) == null ? void 0 : _a2.alt) ?? "");
+      if (nextAlt !== fallbackAlt) {
+        fallbackAlt = nextAlt;
+        if (!dom.getAttribute("data-image-loading")) {
+          dom.alt = fallbackAlt;
+          dom.title = fallbackAlt;
+        }
+      }
+      const nextRatio = (_b2 = updated.attrs) == null ? void 0 : _b2.aspectRatio;
+      const ratioChanged = String(nextRatio ?? "") !== String(((_c2 = currentNode.attrs) == null ? void 0 : _c2.aspectRatio) ?? "");
+      currentNode = updated;
+      applyAspectRatio(nextRatio);
+      if (ratioChanged) {
+        queueMicrotask(backfillAspectRatio);
+      }
+      applyGalleryScale((_d2 = updated.attrs) == null ? void 0 : _d2.galleryScale);
+      applyCaption((_e2 = updated.attrs) == null ? void 0 : _e2.caption);
+      syncGalleryMode();
+      applyWidth((_f2 = updated.attrs) == null ? void 0 : _f2.width);
+      applyAlign((_g2 = updated.attrs) == null ? void 0 : _g2.align);
+      const next = String(((_h = updated.attrs) == null ? void 0 : _h.attachmentId) ?? "");
+      if (next !== attachmentId) {
+        attachmentId = next;
+        load(next);
+      }
+      return true;
+    },
+    // 选中态：PM 在选到该节点时回调（图片是原子块，点击即 NodeSelection）
+    selectNode: () => {
+      setSelected(true);
+      syncGalleryMode();
+    },
+    deselectNode: () => {
+      setSelected(false);
+      syncGalleryMode();
+    },
+    destroy: () => {
+      setSelected(false);
+      attachmentId = "";
+      hideMergeHint();
+      clearImageDropTargets();
+      releaseUrl == null ? void 0 : releaseUrl();
+      stopWatch == null ? void 0 : stopWatch();
+      stopWatch = null;
+    }
+  };
+};
+const createFileAttachmentNodeView = (fetcher = unavailableAttachment, scope) => ({ node }) => {
+  var _a, _b, _c;
+  const dom = document.createElement("div");
+  dom.className = "doc-file-attachment";
+  dom.setAttribute("data-file-attachment", "true");
+  dom.setAttribute("data-block-chrome", "");
+  dom.setAttribute("contenteditable", "false");
+  let attachmentId = String(((_a = node.attrs) == null ? void 0 : _a.attachmentId) ?? "");
+  let mimeType = String(((_b = node.attrs) == null ? void 0 : _b.mimeType) ?? "");
+  let filename = String(((_c = node.attrs) == null ? void 0 : _c.filename) ?? "附件");
+  let stopWatch = null;
+  let releaseUrl;
+  const head = document.createElement("div");
+  head.className = "doc-file-head";
+  const icon = document.createElement("span");
+  icon.className = "doc-file-icon";
+  const name = document.createElement("span");
+  name.className = "doc-file-name";
+  const size = document.createElement("span");
+  size.className = "doc-file-size";
+  const download = document.createElement("button");
+  download.type = "button";
+  download.className = "doc-file-action";
+  download.textContent = "下载";
+  download.addEventListener("click", async (event) => {
+    event.preventDefault();
+    event.stopPropagation();
+    if (!attachmentId || download.disabled) return;
+    const id = attachmentId;
+    download.disabled = true;
+    try {
+      await downloadAttachment(id, filename, fetcher);
+      if (id === attachmentId) download.textContent = "下载";
+    } catch {
+      if (id === attachmentId) download.textContent = "下载失败，重试";
+    } finally {
+      if (id === attachmentId) download.disabled = false;
+    }
+  });
+  head.append(icon, name, size, download);
+  dom.append(head);
+  let media = null;
+  function render() {
+    var _a2;
+    dom.setAttribute("data-attachment-id", attachmentId);
+    icon.textContent = mimeType.startsWith("video/") ? "▶" : mimeType.startsWith("image/") ? "🖼" : "📎";
+    name.textContent = filename;
+    name.title = filename;
+    const bytes = Number(((_a2 = node.attrs) == null ? void 0 : _a2.size) ?? 0);
+    size.textContent = bytes > 0 ? formatBytes(bytes) : "";
+    download.disabled = !attachmentId;
+    download.textContent = "下载";
+    media == null ? void 0 : media.remove();
+    media = null;
+    releaseUrl == null ? void 0 : releaseUrl();
+    stopWatch == null ? void 0 : stopWatch();
+    stopWatch = null;
+    if (!attachmentId) return;
+    if (mimeType.startsWith("video/")) {
+      const video = document.createElement("video");
+      video.className = "doc-file-video";
+      video.controls = true;
+      video.preload = "metadata";
+      media = video;
+      dom.append(video);
+    } else if (mimeType.startsWith("image/")) {
+      const img = document.createElement("img");
+      img.className = "doc-file-image";
+      img.alt = filename;
+      media = img;
+      dom.append(img);
+    } else {
+      return;
+    }
+    const id = attachmentId;
+    stopWatch = whenNearViewport(dom, () => {
+      releaseUrl == null ? void 0 : releaseUrl();
+      releaseUrl = attachmentObjectUrl(id, (url) => {
+        if (id !== attachmentId || !media) return;
+        media.setAttribute("src", url);
+      }, fetcher, void 0, scope);
+    });
+  }
+  render();
+  return {
+    dom,
+    update: (updated) => {
+      var _a2, _b2, _c2, _d;
+      if (updated.type.name !== "fileAttachment") return false;
+      node = updated;
+      const bytes = Number(((_a2 = updated.attrs) == null ? void 0 : _a2.size) ?? 0);
+      size.textContent = bytes > 0 ? formatBytes(bytes) : "";
+      const nextId = String(((_b2 = updated.attrs) == null ? void 0 : _b2.attachmentId) ?? "");
+      const nextMime = String(((_c2 = updated.attrs) == null ? void 0 : _c2.mimeType) ?? "");
+      const nextName = String(((_d = updated.attrs) == null ? void 0 : _d.filename) ?? "附件");
+      if (nextId !== attachmentId || nextMime !== mimeType || nextName !== filename) {
+        attachmentId = nextId;
+        mimeType = nextMime;
+        filename = nextName;
+        render();
+      }
+      return true;
+    },
+    destroy: () => {
+      attachmentId = "";
+      media = null;
+      releaseUrl == null ? void 0 : releaseUrl();
+      stopWatch == null ? void 0 : stopWatch();
+      stopWatch = null;
+    },
+    stopEvent: (event) => {
+      var _a2, _b2;
+      return !!((_b2 = (_a2 = event.target) == null ? void 0 : _a2.closest) == null ? void 0 : _b2.call(_a2, "video, audio, button"));
+    }
+  };
+};
+function dispatch(editor, tr) {
+  var _a;
+  const manager = (_a = yUndoPluginKey.getState(editor.state)) == null ? void 0 : _a.undoManager;
+  manager == null ? void 0 : manager.stopCapturing();
+  editor.view.dispatch(closeHistory(tr));
+  manager == null ? void 0 : manager.stopCapturing();
+}
+function patchCallout(editor, pos, attrs) {
+  if (!editor.isEditable || editor.isDestroyed) return false;
+  const node = editor.state.doc.nodeAt(pos);
+  if ((node == null ? void 0 : node.type.name) !== "callout" || !validCalloutAttrs({ ...node.attrs, ...attrs })) return false;
+  dispatch(editor, editor.state.tr.setNodeMarkup(pos, void 0, { ...node.attrs, ...attrs }));
+  return true;
+}
+function unwrapCallout(editor, pos) {
+  if (!editor.isEditable || editor.isDestroyed) return false;
+  const node = editor.state.doc.nodeAt(pos);
+  if ((node == null ? void 0 : node.type.name) !== "callout") return false;
+  const resolved = editor.state.doc.resolve(pos);
+  if (!resolved.parent.canReplace(resolved.index(), resolved.index() + 1, node.content)) return false;
+  dispatch(editor, editor.state.tr.replaceWith(pos, pos + node.nodeSize, node.content));
+  return true;
+}
+const TONE_LABELS = { info: "💡 提示", success: "✅ 成功", warning: "⚠️ 注意", danger: "❗ 警告" };
+const COLOR_NAMES = { gray: "灰", red: "红", orange: "橙", yellow: "黄", green: "绿", blue: "蓝", purple: "紫" };
+function swatchName(value, key2) {
+  if (value === null) return "默认";
+  if (value === "none") return "无";
+  if (key2 !== "backgroundColor") return COLOR_NAMES[value] ?? value;
+  return `${value.endsWith("-strong") ? "浓" : "浅"}${COLOR_NAMES[value.replace("-strong", "")] ?? value}`;
+}
+function CalloutControls({ attrs, editable, portal, onPatch, onUnwrap }) {
+  const [panel, setPanel] = useState("none");
+  const iconTrigger = useRef(null), colorTrigger = useRef(null), toolbarIconTrigger = useRef(null);
+  const value = effectiveCallout(attrs);
+  const anchor = panel === "color" ? colorTrigger.current : panel === "icon" ? iconTrigger.current ?? toolbarIconTrigger.current : null;
+  const sections = [
+    { key: "textColor", label: "字体颜色", values: [null, ...CALLOUT_COLORS] },
+    { key: "borderColor", label: "边框颜色", values: ["none", ...CALLOUT_COLORS] },
+    { key: "backgroundColor", label: "填充颜色", values: [null, "none", ...CALLOUT_FILLS] }
+  ];
+  const selected = (key2, swatch) => (key2 === "borderColor" ? value.borderColor : attrs[key2] ?? null) === swatch;
+  return /* @__PURE__ */ jsxs("div", { className: "callout-controls", contentEditable: false, onPointerDown: (event) => event.stopPropagation(), onKeyDown: (event) => event.stopPropagation(), children: [
+    value.icon && /* @__PURE__ */ jsx(
+      WButton,
+      {
+        ref: iconTrigger,
+        variant: "text",
+        className: "callout-icon callout-icon-button",
+        "aria-label": "更换高亮块图标",
+        "aria-expanded": panel === "icon",
+        disabled: !editable,
+        onClick: () => setPanel(panel === "icon" ? "none" : "icon"),
+        children: value.icon
+      }
+    ),
+    editable && /* @__PURE__ */ jsxs("div", { className: `callout-toolbar${panel !== "none" ? " is-open" : ""}`, "aria-label": "高亮块操作", children: [
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          ref: colorTrigger,
+          type: "button",
+          className: "callout-toolbar-button",
+          "aria-label": "高亮块颜色设置",
+          "aria-expanded": panel === "color",
+          onClick: () => setPanel(panel === "color" ? "none" : "color"),
+          children: /* @__PURE__ */ jsx(WIcon, { name: "palette", size: 20 })
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          ref: toolbarIconTrigger,
+          type: "button",
+          className: "callout-toolbar-button",
+          "aria-label": "高亮块图标设置",
+          "aria-expanded": panel === "icon",
+          onClick: () => setPanel(panel === "icon" ? "none" : "icon"),
+          children: "图标"
+        }
+      ),
+      /* @__PURE__ */ jsxs("select", { "aria-label": "高亮块预设", className: "callout-preset", value: "", onChange: (event) => {
+        if (event.target.value) onPatch({ tone: event.target.value, icon: null, textColor: null, borderColor: null, backgroundColor: null });
+      }, children: [
+        /* @__PURE__ */ jsx("option", { value: "", children: "预设" }),
+        CALLOUT_TONES.map((tone) => /* @__PURE__ */ jsx("option", { value: tone, children: TONE_LABELS[tone] }, tone))
+      ] }),
+      /* @__PURE__ */ jsx("span", { className: "callout-toolbar-divider", "aria-hidden": "true" }),
+      /* @__PURE__ */ jsx("button", { type: "button", className: "callout-toolbar-button", onClick: onUnwrap, children: "取消高亮块" })
+    ] }),
+    panel === "color" && /* @__PURE__ */ jsx(AnchoredPanel, { anchor, portal, label: "高亮块颜色", onClose: () => setPanel("none"), align: "start", prefer: "below", gap: 6, children: /* @__PURE__ */ jsxs("div", { className: "callout-color-panel", role: "group", "aria-label": "高亮块颜色", children: [
+      sections.map((section) => /* @__PURE__ */ jsxs("section", { children: [
+        /* @__PURE__ */ jsx("div", { className: "callout-color-label", children: section.label }),
+        /* @__PURE__ */ jsx("div", { className: "callout-color-grid", role: "group", "aria-label": section.label, children: section.values.map((swatch) => /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            className: `callout-color-choice${selected(section.key, swatch) ? " is-selected" : ""}${swatch === "none" ? " is-none" : ""}`,
+            style: calloutSwatchStyle(section.key, swatch),
+            "aria-label": `${section.label}：${swatchName(swatch, section.key)}`,
+            "aria-pressed": selected(section.key, swatch),
+            onClick: () => onPatch({ [section.key]: swatch }),
+            children: section.key === "textColor" ? /* @__PURE__ */ jsx("span", { className: "callout-font-sample", children: "A" }) : swatch === null ? /* @__PURE__ */ jsx("span", { "aria-hidden": "true", children: "↺" }) : null
+          },
+          swatch ?? "default"
+        )) })
+      ] }, section.key)),
+      /* @__PURE__ */ jsx(WButton, { variant: "outline", block: true, onClick: () => onPatch({ textColor: null, borderColor: null, backgroundColor: null }), children: "恢复默认颜色" })
+    ] }) }),
+    panel === "icon" && /* @__PURE__ */ jsx(AnchoredPanel, { anchor, portal, label: "高亮块图标", onClose: () => setPanel("none"), align: "center", prefer: "below", gap: 6, children: /* @__PURE__ */ jsxs("div", { className: "callout-icon-picker", role: "group", "aria-label": "高亮块图标", children: [
+      /* @__PURE__ */ jsx("div", { className: "callout-icon-grid", children: CALLOUT_ICONS.map((icon) => /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          className: "callout-icon-choice",
+          "aria-label": `高亮块图标：${icon}`,
+          "aria-pressed": value.icon === icon,
+          onClick: () => {
+            onPatch({ icon });
+            setPanel("none");
+          },
+          children: icon
+        },
+        icon
+      )) }),
+      /* @__PURE__ */ jsxs("div", { className: "callout-icon-footer", children: [
+        /* @__PURE__ */ jsx(WButton, { size: "small", variant: "text", onClick: () => {
+          onPatch({ icon: "" });
+          setPanel("none");
+        }, children: "隐藏图标" }),
+        /* @__PURE__ */ jsx(WButton, { size: "small", variant: "text", onClick: () => {
+          onPatch({ icon: null });
+          setPanel("none");
+        }, children: "默认图标" })
+      ] })
+    ] }) })
+  ] });
+}
+function resolvePortal(node) {
+  var _a;
+  const portal = document.querySelector("[data-wendang-portal]");
+  if (portal instanceof HTMLElement) return portal;
+  if (!node.isConnected) return null;
+  const scope = document.createElement("div");
+  scope.className = "wendang-portal wendang";
+  scope.dataset.wendangPortal = "";
+  const theme = (_a = node.closest("[data-wendang-theme]")) == null ? void 0 : _a.getAttribute("data-wendang-theme");
+  if (theme) scope.dataset.wendangTheme = theme;
+  document.body.append(scope);
+  return scope;
+}
+const createCalloutNodeView = () => ({ node, editor, getPos }) => {
+  const dom = document.createElement("div");
+  const controls = document.createElement("div");
+  controls.className = "callout-controls-host";
+  controls.contentEditable = "false";
+  const content = document.createElement("div");
+  content.className = "doc-callout-content";
+  content.dataset.calloutContent = "true";
+  dom.append(controls, content);
+  let current = node, root = createRoot(controls);
+  let lastEditable = editor.isEditable;
+  const position = () => {
+    var _a;
+    const pos = getPos();
+    return typeof pos === "number" && ((_a = editor.state.doc.nodeAt(pos)) == null ? void 0 : _a.type.name) === "callout" ? pos : null;
+  };
+  const paint = () => {
+    const attributes = calloutDOMAttributes(current.attrs);
+    dom.classList.add("doc-callout");
+    for (const key2 of Object.keys(dom.dataset)) if (key2.startsWith("callout") || key2 === "tone" || key2 === "iconHidden") delete dom.dataset[key2];
+    for (const [key2, value] of Object.entries(attributes)) dom.setAttribute(key2, value);
+    root == null ? void 0 : root.render(/* @__PURE__ */ jsx(
+      CalloutControls,
+      {
+        attrs: current.attrs,
+        editable: editor.isEditable,
+        portal: () => resolvePortal(dom),
+        onPatch: (attrs) => {
+          const pos = position();
+          if (pos !== null) patchCallout(editor, pos, attrs);
+        },
+        onUnwrap: () => {
+          const pos = position();
+          if (pos !== null) unwrapCallout(editor, pos);
+        }
+      }
+    ));
+  };
+  paint();
+  const syncEditable = () => {
+    if (editor.isEditable !== lastEditable) {
+      lastEditable = editor.isEditable;
+      paint();
+    }
+  };
+  editor.on("transaction", syncEditable);
+  return {
+    dom,
+    contentDOM: content,
+    update(updated) {
+      if (updated.type.name !== "callout") return false;
+      current = updated;
+      paint();
+      return true;
+    },
+    stopEvent: (event) => controls.contains(event.target),
+    ignoreMutation: (mutation) => mutation.type !== "selection" && !content.contains(mutation.target),
+    // ProseMirror 可能在 React 提交阶段同步销毁节点视图；此时同步 unmount 会与
+    // 正在进行的渲染冲突。延后一拍卸载，容器仍由 ProseMirror 持有。
+    destroy() {
+      editor.off("transaction", syncEditable);
+      const instance = root;
+      root = null;
+      queueMicrotask(() => instance == null ? void 0 : instance.unmount());
+    }
+  };
+};
+function parseLanguage(element) {
+  var _a;
+  const data = element.getAttribute("data-language");
+  if (data) return data;
+  const match = /(?:^|\s)language-([\w+#-]+)/.exec(((_a = element.querySelector("code")) == null ? void 0 : _a.className) || element.className);
+  return match ? match[1] : null;
+}
+const createCodeBlockNodeView = (canCopy, contentContext) => ({ node, editor, getPos, extension }) => {
+  const wrapper = document.createElement("div"), toolbar = document.createElement("div");
+  wrapper.dataset.blockChrome = "";
+  const scroll = document.createElement("div"), numbers = document.createElement("div"), pre = document.createElement("pre"), code = document.createElement("code");
+  toolbar.className = "code-toolbar-host";
+  toolbar.contentEditable = "false";
+  scroll.className = "code-scroll";
+  scroll.setAttribute("aria-label", "代码内容");
+  numbers.className = "code-line-numbers";
+  numbers.contentEditable = "false";
+  numbers.setAttribute("aria-hidden", "true");
+  pre.className = "doc-code";
+  pre.append(code);
+  scroll.append(numbers, pre);
+  wrapper.append(toolbar, scroll);
+  let display = codeBlockDisplay(), current = node, lastText = node.textContent, root = createRoot(toolbar);
+  const paintClass = () => {
+    const classes = ["code-block-wrap", ...codeBlockClass(display)];
+    for (const name of ["code-theme-auto", "code-theme-paper", "code-theme-soft", "code-theme-night", "is-collapsed", "without-line-numbers", "is-unlimited"]) wrapper.classList.toggle(name, classes.includes(name));
+    wrapper.classList.add("code-block-wrap", "ywiki-code-panel");
+    scroll.hidden = display.collapsed;
+    numbers.hidden = !display.lineNumbers;
+  };
+  const chooseLanguage = (value) => {
+    if (!editor.isEditable || editor.isDestroyed) return;
+    const pos = getPos();
+    if (typeof pos !== "number") return;
+    const latest = editor.state.doc.nodeAt(pos);
+    if ((latest == null ? void 0 : latest.type) !== node.type) return;
+    editor.view.dispatch(editor.state.tr.setNodeMarkup(pos, void 0, { ...latest.attrs, language: value || null }));
+  };
+  const paintToolbar = () => {
+    const context = contentContext == null ? void 0 : contentContext();
+    const toolbar2 = /* @__PURE__ */ jsx(
+      CodeToolbar,
+      {
+        text: current.textContent,
+        language: String(current.attrs.language ?? ""),
+        editable: editor.isEditable,
+        canCopy: (canCopy == null ? void 0 : canCopy()) ?? false,
+        display,
+        onLanguage: chooseLanguage,
+        onDisplay: (value) => {
+          display = value;
+          paintClass();
+          paintToolbar();
+        }
+      }
+    );
+    root == null ? void 0 : root.render(context ? /* @__PURE__ */ jsx(ContentContextBridge, { value: context, children: toolbar2 }) : toolbar2);
+  };
+  numbers.textContent = codeLineNumbers(lastText);
+  paintClass();
+  paintToolbar();
+  const syncMode = () => paintToolbar();
+  editor.on("transaction", syncMode);
+  editor.on("update", syncMode);
+  const revealSelection = () => {
+    if (!display.collapsed || !editor.isFocused) return;
+    const pos = getPos();
+    if (typeof pos !== "number") return;
+    const { from, to } = editor.state.selection;
+    if (from > pos && to < pos + current.nodeSize) {
+      display = { ...display, collapsed: false };
+      paintClass();
+      paintToolbar();
+    }
+  };
+  editor.on("selectionUpdate", revealSelection);
+  return {
+    dom: wrapper,
+    contentDOM: code,
+    update(updated) {
+      if (updated.type.name !== "codeBlock") return false;
+      current = updated;
+      if (updated.textContent !== lastText) {
+        lastText = updated.textContent;
+        numbers.textContent = codeLineNumbers(lastText);
+      }
+      paintToolbar();
+      return true;
+    },
+    stopEvent: (event) => toolbar.contains(event.target) || numbers.contains(event.target),
+    ignoreMutation: (mutation) => mutation.type !== "selection" && !code.contains(mutation.target),
+    // 与高亮块一致：延后一拍卸载，避免在 React 提交阶段同步 unmount。
+    destroy() {
+      editor.off("selectionUpdate", revealSelection);
+      editor.off("transaction", syncMode);
+      editor.off("update", syncMode);
+      const instance = root;
+      root = null;
+      queueMicrotask(() => instance == null ? void 0 : instance.unmount());
+    }
+  };
+};
+const YwikiCodeBlock = CodeBlock.extend({
+  addOptions() {
+    var _a;
+    return { ...(_a = this.parent) == null ? void 0 : _a.call(this), canCopy: void 0 };
+  },
+  addAttributes() {
+    var _a;
+    return { ...(_a = this.parent) == null ? void 0 : _a.call(this), language: {
+      default: null,
+      parseHTML: (element) => parseLanguage(element),
+      renderHTML: (attributes) => attributes.language ? { "data-language": attributes.language } : {}
+    } };
+  },
+  addNodeView() {
+    return createCodeBlockNodeView(this.options.canCopy, this.options.contentContext);
+  }
+});
+const imeKey = new PluginKey("ywiki-ime");
+const ImeGuard = Extension.create({
+  name: "ywikiImeGuard",
+  addProseMirrorPlugins() {
+    return [
+      new Plugin({
+        key: imeKey,
+        props: {
+          handleDOMEvents: {
+            compositionstart: () => {
+              beginComposition();
+              return false;
+            },
+            compositionend: () => {
+              endComposition();
+              return false;
+            }
+          }
+        }
+      })
+    ];
+  },
+  onDestroy() {
+    resetCompositionState();
+  }
+});
+function setRenderedHtml(holder, html) {
+  const tpl = document.createElement("template");
+  tpl.innerHTML = html;
+  holder.replaceChildren(tpl.content);
+}
+const mathNodeView = ({ node, editor, getPos }) => {
+  var _a;
+  const isBlock = node.type.name === "mathBlock";
+  const dom = document.createElement(isBlock ? "div" : "span");
+  dom.className = isBlock ? "doc-math-block math-node" : "doc-math-inline math-node";
+  dom.setAttribute("data-math-node", isBlock ? "block" : "inline");
+  if (isBlock) dom.setAttribute("data-block-chrome", "");
+  const holder = document.createElement("span");
+  holder.className = "math-render";
+  dom.appendChild(holder);
+  let latex = String(((_a = node.attrs) == null ? void 0 : _a.latex) ?? "");
+  let input = null;
+  let closing = false;
+  let destroyed = false;
+  let renderVersion = 0;
+  function paint() {
+    const version = ++renderVersion;
+    holder.replaceChildren();
+    dom.classList.remove("doc-math-error", "doc-math-pending");
+    dom.removeAttribute("title");
+    if (!latex) {
+      holder.textContent = "空公式";
+      return;
+    }
+    holder.textContent = isBlock ? `$$${latex}$$` : `$${latex}$`;
+    dom.classList.add("doc-math-pending");
+    void renderMathAsync(latex, isBlock).then((res) => {
+      if (destroyed || version !== renderVersion) return;
+      dom.classList.remove("doc-math-pending");
+      if (res.html && !res.error) setRenderedHtml(holder, res.html);
+      else {
+        dom.classList.add("doc-math-error");
+        dom.title = res.error || "公式渲染失败";
+        holder.textContent = isBlock ? `$$${latex}$$` : `$${latex}$`;
+        const hint = document.createElement("span");
+        hint.className = "doc-math-error-hint";
+        hint.textContent = "（公式渲染失败）";
+        holder.appendChild(hint);
+      }
+    });
+  }
+  function closeEdit() {
+    if (closing) return;
+    closing = true;
+    const field = input;
+    input = null;
+    field == null ? void 0 : field.remove();
+    dom.classList.remove("is-editing");
+    holder.style.display = "";
+    closing = false;
+  }
+  function commit() {
+    var _a2;
+    if (closing) return;
+    if (!input || destroyed || !editor.isEditable) {
+      closeEdit();
+      return;
+    }
+    const value = input.value;
+    const pos = typeof getPos === "function" ? getPos() : void 0;
+    closeEdit();
+    if (value === latex) return;
+    latex = value;
+    if (typeof pos !== "number" || ((_a2 = editor.state.doc.nodeAt(pos)) == null ? void 0 : _a2.type) !== node.type) {
+      paint();
+      return;
+    }
+    editor.view.dispatch(
+      editor.view.state.tr.setNodeMarkup(pos, void 0, { ...node.attrs, latex: value })
+    );
+    paint();
+  }
+  function beginEdit() {
+    if (!editor.isEditable || input) return;
+    input = document.createElement("input");
+    input.type = "text";
+    input.className = "math-latex-input";
+    input.value = latex;
+    input.spellcheck = false;
+    input.setAttribute("aria-label", "编辑公式");
+    input.addEventListener("keydown", (e) => {
+      e.stopPropagation();
+      if (shouldIgnoreForIme(e)) return;
+      if (e.key === "Enter") {
+        e.preventDefault();
+        commit();
+      } else if (e.key === "Escape") {
+        e.preventDefault();
+        closeEdit();
+      }
+    });
+    input.addEventListener("blur", () => commit());
+    input.addEventListener("mousedown", (e) => e.stopPropagation());
+    holder.style.display = "none";
+    dom.classList.add("is-editing");
+    dom.appendChild(input);
+    void ensureKatexCss();
+    setTimeout(() => input == null ? void 0 : input.focus(), 0);
+  }
+  dom.addEventListener("click", (e) => {
+    if (!editor.isEditable) return;
+    e.preventDefault();
+    beginEdit();
+  });
+  paint();
+  void ensureKatexCss();
+  return {
+    dom,
+    // atom 节点没有 contentDOM
+    update: (updated) => {
+      var _a2;
+      if (updated.type.name !== node.type.name) return false;
+      node = updated;
+      const next = String(((_a2 = updated.attrs) == null ? void 0 : _a2.latex) ?? "");
+      if (next !== latex) {
+        latex = next;
+        paint();
+      }
+      return true;
+    },
+    // 输入框相关的交互全部由本 nodeView 处理，不交给 ProseMirror
+    stopEvent: (event) => {
+      var _a2;
+      const t = event.target;
+      return !!((_a2 = t == null ? void 0 : t.classList) == null ? void 0 : _a2.contains("math-latex-input"));
+    },
+    ignoreMutation: () => true,
+    destroy: () => {
+      destroyed = true;
+      renderVersion += 1;
+      closeEdit();
+    }
+  };
+};
+const TEXT_ALIGNS = ["left", "center", "right", "justify"];
+const MAX_INDENT = 6;
+const INDENT_STEP_PX = 24;
+const BlockFormat = Extension.create({
+  name: "blockFormat",
+  addOptions() {
+    return { types: ["paragraph", "heading"] };
+  },
+  addGlobalAttributes() {
+    const types = this.options.types ?? ["paragraph", "heading"];
+    return [
+      {
+        types,
+        attributes: {
+          textAlign: {
+            default: null,
+            /** 从 DOM 读回时同样限定取值，防止粘贴内容塞入任意值 */
+            parseHTML: (el) => {
+              const v = el.getAttribute("data-text-align") ?? el.style.textAlign;
+              return TEXT_ALIGNS.includes(v) ? v : null;
+            },
+            renderHTML: (attrs) => {
+              const v = attrs.textAlign;
+              if (!v || !TEXT_ALIGNS.includes(v)) return {};
+              return { "data-text-align": v, style: `text-align: ${v}` };
+            }
+          },
+          indent: {
+            default: 0,
+            parseHTML: (el) => {
+              const raw = el.getAttribute("data-indent");
+              const n = Number(raw);
+              return Number.isFinite(n) && n > 0 ? Math.min(Math.floor(n), MAX_INDENT) : 0;
+            },
+            renderHTML: (attrs) => {
+              const n = Number(attrs.indent ?? 0);
+              if (!Number.isFinite(n) || n <= 0) return {};
+              return {
+                "data-indent": String(Math.min(Math.floor(n), MAX_INDENT)),
+                style: `margin-left: ${Math.min(Math.floor(n), MAX_INDENT) * INDENT_STEP_PX}px`
+              };
+            }
+          }
+        }
+      }
+    ];
+  },
+  addCommands() {
+    return {
+      setTextAlign: (align) => ({ tr, state, dispatch: dispatch2 }) => {
+        const types = this.options.types ?? ["paragraph", "heading"];
+        const { from, to } = state.selection;
+        let changed = false;
+        state.doc.nodesBetween(from, to, (node, pos) => {
+          if (!types.includes(node.type.name)) return;
+          if (dispatch2) {
+            tr.setNodeMarkup(pos, void 0, { ...node.attrs, textAlign: align });
+          }
+          changed = true;
+        });
+        if (!changed) return false;
+        dispatch2 == null ? void 0 : dispatch2(tr);
+        return true;
+      },
+      setIndent: (level) => ({ tr, state, dispatch: dispatch2 }) => {
+        const types = this.options.types ?? ["paragraph", "heading"];
+        const next = Math.max(0, Math.min(Math.floor(level), MAX_INDENT));
+        const { from, to } = state.selection;
+        let changed = false;
+        state.doc.nodesBetween(from, to, (node, pos) => {
+          if (!types.includes(node.type.name)) return;
+          const cur = Number(node.attrs.indent ?? 0);
+          if (cur === next) return;
+          if (dispatch2) {
+            tr.setNodeMarkup(pos, void 0, { ...node.attrs, indent: next });
+          }
+          changed = true;
+        });
+        if (!changed) return false;
+        dispatch2 == null ? void 0 : dispatch2(tr);
+        return true;
+      },
+      indentBlock: () => ({ tr, state, dispatch: dispatch2 }) => {
+        const types = this.options.types ?? ["paragraph", "heading"];
+        const { from, to } = state.selection;
+        let changed = false;
+        state.doc.nodesBetween(from, to, (node, pos) => {
+          if (!types.includes(node.type.name)) return;
+          const cur = Number(node.attrs.indent ?? 0);
+          if (cur >= MAX_INDENT) return;
+          if (dispatch2) {
+            tr.setNodeMarkup(pos, void 0, { ...node.attrs, indent: cur + 1 });
+          }
+          changed = true;
+        });
+        if (!changed) return false;
+        dispatch2 == null ? void 0 : dispatch2(tr);
+        return true;
+      },
+      outdentBlock: () => ({ tr, state, dispatch: dispatch2 }) => {
+        const types = this.options.types ?? ["paragraph", "heading"];
+        const { from, to } = state.selection;
+        let changed = false;
+        state.doc.nodesBetween(from, to, (node, pos) => {
+          if (!types.includes(node.type.name)) return;
+          const cur = Number(node.attrs.indent ?? 0);
+          if (cur <= 0) return;
+          if (dispatch2) {
+            tr.setNodeMarkup(pos, void 0, { ...node.attrs, indent: cur - 1 });
+          }
+          changed = true;
+        });
+        if (!changed) return false;
+        dispatch2 == null ? void 0 : dispatch2(tr);
+        return true;
+      }
+    };
+  }
+});
+const blockSelectionKey = new PluginKey("ywikiBlockSelection");
+const GUTTER_MIN_PX = 48;
+const SELECT_PAD_Y = 5;
+function blockSelectionBand(view) {
+  const dom = view.dom;
+  if (!dom || typeof dom.getBoundingClientRect !== "function") return { left: 0, right: 0 };
+  const prose = dom.getBoundingClientRect();
+  const rect = blockSelectionBandRect(view);
+  return {
+    // 取并集：宿主容器比正文还窄时（正文铺满容器）仍保留最小留白
+    left: Math.min((rect == null ? void 0 : rect.left) ?? prose.left, prose.left - GUTTER_MIN_PX),
+    right: Math.max((rect == null ? void 0 : rect.right) ?? prose.right, prose.right + GUTTER_MIN_PX)
+  };
+}
+function blockSelectionBandRect(view) {
+  var _a, _b;
+  const dom = view.dom;
+  if (!dom || typeof dom.getBoundingClientRect !== "function") return null;
+  const marked = (_a = dom.closest) == null ? void 0 : _a.call(dom, "[data-block-select-band]");
+  const host = (marked instanceof HTMLElement ? marked : null) ?? ((_b = dom.closest) == null ? void 0 : _b.call(dom, ".editor-shell")) ?? null;
+  return (host == null ? void 0 : host.getBoundingClientRect()) ?? null;
+}
+function bandSide(x, proseLeft, proseRight, band) {
+  if (x >= proseLeft && x <= proseRight) return null;
+  if (x < proseLeft) return x >= band.left ? "left" : null;
+  return x <= band.right ? "right" : null;
+}
+function scrollParentOf(element) {
+  let node = (element == null ? void 0 : element.parentElement) ?? null;
+  while (node) {
+    const style = typeof getComputedStyle === "function" ? getComputedStyle(node) : null;
+    if (/(auto|scroll)/.test((style == null ? void 0 : style.overflowY) ?? "")) return node;
+    node = node.parentElement;
+  }
+  return null;
+}
+function autoScrollDelta(pointerY, top, bottom, edge = 60, maxSpeed = 16) {
+  if (!Number.isFinite(pointerY) || bottom <= top) return 0;
+  if (pointerY < top + edge) {
+    const depth = Math.min(edge, top + edge - pointerY);
+    return -Math.ceil(depth / edge * maxSpeed);
+  }
+  if (pointerY > bottom - edge) {
+    const depth = Math.min(edge, pointerY - (bottom - edge));
+    return Math.ceil(depth / edge * maxSpeed);
+  }
+  return 0;
+}
+function expandParts(doc, parts) {
+  const out = [];
+  for (const part of parts) {
+    if (part.kind === "block") {
+      out.push(new SelectionRange(doc.resolve(part.from), doc.resolve(part.to)));
+      continue;
+    }
+    for (const range of part.images) {
+      out.push(new SelectionRange(doc.resolve(range.from), doc.resolve(range.to)));
+    }
+  }
+  return out;
+}
+class BlockRangeSelection extends Selection {
+  constructor($from, $to, parts) {
+    super($from, $to, (parts == null ? void 0 : parts.length) ? expandParts($from.doc, parts) : void 0);
+    __publicField(this, "parts");
+    __publicField(this, "visible", false);
+    this.parts = parts;
+  }
+  content() {
+    const parts = this.parts;
+    if (!(parts == null ? void 0 : parts.length)) return this.$from.doc.slice(this.from, this.to);
+    const doc = this.$from.doc;
+    const nodes = [];
+    for (const part of parts) {
+      if (part.kind === "block") {
+        const node = doc.nodeAt(part.from);
+        if (node) nodes.push(node);
+        continue;
+      }
+      const gallery = doc.nodeAt(part.from);
+      if (!gallery) continue;
+      const picked = [];
+      gallery.forEach((child, offset) => {
+        const abs = part.from + 1 + offset;
+        if (part.images.some((range) => abs >= range.from && abs < range.to)) picked.push(child);
+      });
+      if (picked.length >= 2) {
+        nodes.push(gallery.type.create(gallery.attrs, Fragment.fromArray(picked)));
+      } else if (picked.length === 1) {
+        nodes.push(picked[0]);
+      }
+    }
+    return new Slice(Fragment.fromArray(nodes), 0, 0);
+  }
+  /** 删除：按容器重建，图片行剩一张时还原成独立图片，避免 PM 补空白占位图。 */
+  replace(tr, content = Slice.empty) {
+    var _a;
+    if (!((_a = this.parts) == null ? void 0 : _a.length) || content.size > 0) {
+      super.replace(tr, content);
+      return;
+    }
+    const parts = [...this.parts].sort((a, b) => b.from - a.from);
+    let caret = null;
+    for (const part of parts) {
+      if (part.kind === "block") {
+        tr.delete(part.from, part.to);
+        caret = part.from;
+        continue;
+      }
+      const gallery = tr.doc.nodeAt(part.from);
+      if (!gallery) continue;
+      const remaining = [];
+      gallery.forEach((child, offset) => {
+        const abs = part.from + 1 + offset;
+        if (!part.images.some((range) => abs >= range.from && abs < range.to)) remaining.push(child);
+      });
+      if (remaining.length >= 2) {
+        tr.replaceWith(part.from, part.to, gallery.type.create(gallery.attrs, Fragment.fromArray(remaining)));
+      } else if (remaining.length === 1) {
+        tr.replaceWith(part.from, part.to, remaining[0]);
+      } else {
+        tr.delete(part.from, part.to);
+      }
+      caret = part.from;
+    }
+    if (caret !== null) {
+      const pos = Math.max(0, Math.min(caret, tr.doc.content.size));
+      tr.setSelection(Selection.near(tr.doc.resolve(pos), 1));
+    }
+  }
+  eq(other) {
+    return other.toJSON().type === "ywikiBlockRange" && other.from === this.from && other.to === this.to && JSON.stringify(other.parts ?? null) === JSON.stringify(this.parts ?? null);
+  }
+  map(doc, mapping) {
+    return Selection.near(doc.resolve(mapping.map(this.from, 1)));
+  }
+  toJSON() {
+    return { type: "ywikiBlockRange", from: this.from, to: this.to, parts: this.parts };
+  }
+  static fromJSON(doc, json) {
+    return new BlockRangeSelection(doc.resolve(json.from), doc.resolve(json.to), json.parts);
+  }
+  getBookmark() {
+    return Selection.near(this.$from).getBookmark();
+  }
+}
+try {
+  Selection.jsonID("ywikiBlockRange", BlockRangeSelection);
+} catch (err) {
+  if (!(err instanceof RangeError) || err.message !== "Duplicate use of selection JSON ID ywikiBlockRange") throw err;
+}
+function blockAtY(view, y) {
+  const candidates = [];
+  view.state.doc.forEach((node, offset) => {
+    const dom = view.nodeDOM(offset);
+    if (!(dom instanceof HTMLElement)) return;
+    const r = dom.getBoundingClientRect();
+    candidates.push({ pos: offset, node, top: r.top, bottom: r.bottom });
+  });
+  if (candidates.length === 0) return null;
+  for (const c of candidates) {
+    if (y >= c.top && y <= c.bottom) {
+      return { pos: c.pos, node: c.node };
+    }
+  }
+  let best = candidates[0];
+  let bestDist = Number.POSITIVE_INFINITY;
+  for (const c of candidates) {
+    const dist = y < c.top ? c.top - y : y - c.bottom;
+    if (dist < bestDist) {
+      bestDist = dist;
+      best = c;
+    }
+  }
+  return bestDist > 48 ? null : { pos: best.pos, node: best.node };
+}
+function gutterAreaHit(view, event) {
+  const domRect = view.dom.getBoundingClientRect();
+  if (event.clientY < domRect.top || event.clientY > domRect.bottom) return null;
+  if (!bandSide(event.clientX, domRect.left, domRect.right, blockSelectionBand(view))) return null;
+  return blockAtY(view, event.clientY);
+}
+function coveredBlocks(doc, aPos, bPos) {
+  const lo = Math.min(aPos, bPos);
+  const hi = Math.max(aPos, bPos);
+  const out = [];
+  doc.forEach((node, offset) => {
+    const end = offset + node.nodeSize;
+    if (end > lo && offset <= hi) out.push({ from: offset, to: end });
+  });
+  return out;
+}
+function rectsIntersect(a, b) {
+  return a.right > b.left && a.left < b.right && a.bottom > b.top && a.top < b.bottom;
+}
+function marqueeImageRanges(galleryFrom, sizes, childRects, marquee) {
+  const picked = [];
+  let offset = 0;
+  for (let index = 0; index < sizes.length; index += 1) {
+    const from = galleryFrom + 1 + offset;
+    offset += sizes[index];
+    const rect = childRects[index];
+    if (rect && rectsIntersect(marquee, rect)) picked.push({ from, to: from + sizes[index] });
+  }
+  return picked;
+}
+function selectionPartsForRange(view, doc, aPos, bPos, marquee) {
+  const out = [];
+  for (const block of coveredBlocks(doc, aPos, bPos)) {
+    const node = doc.nodeAt(block.from);
+    if ((node == null ? void 0 : node.type.name) === "imageGallery") {
+      const galleryEl = typeof view.nodeDOM === "function" ? view.nodeDOM(block.from) : null;
+      if (galleryEl instanceof HTMLElement) {
+        const galleryRect = galleryEl.getBoundingClientRect();
+        const enteredRow = rectsIntersect(marquee, {
+          left: galleryRect.left,
+          top: galleryRect.top,
+          right: galleryRect.right,
+          bottom: galleryRect.bottom
+        });
+        if (enteredRow) {
+          const sizes = [];
+          node.forEach((child) => sizes.push(child.nodeSize));
+          const childRects = [];
+          let offset = 0;
+          node.forEach((child) => {
+            const childPos = block.from + 1 + offset;
+            offset += child.nodeSize;
+            const dom = typeof view.nodeDOM === "function" ? view.nodeDOM(childPos) : null;
+            if (!(dom instanceof HTMLElement)) {
+              childRects.push(null);
+              return;
+            }
+            const r = dom.getBoundingClientRect();
+            childRects.push({ left: r.left, top: r.top, right: r.right, bottom: r.bottom });
+          });
+          const picked = marqueeImageRanges(block.from, sizes, childRects, marquee);
+          if (picked.length === 0) continue;
+          if (picked.length === sizes.length) out.push({ kind: "block", ...block });
+          else out.push({ kind: "images", ...block, images: picked });
+          continue;
+        }
+      }
+    }
+    out.push({ kind: "block", ...block });
+  }
+  return out;
+}
+function marqueeBox(startX, startY, x, y, hostLeft, hostTop) {
+  return {
+    left: Math.min(startX, x) - hostLeft,
+    top: Math.min(startY, y) - hostTop,
+    width: Math.abs(x - startX),
+    height: Math.abs(y - startY)
+  };
+}
+function clampMarqueeBand(bandLeft, bandRight, hostLeft, hostRight, viewportRight = Number.POSITIVE_INFINITY) {
+  const left = Math.max(bandLeft, hostLeft);
+  const right = Math.min(bandRight, hostRight, viewportRight);
+  if (right > left) return { left, right };
+  return { left: hostLeft, right: Math.max(hostLeft, Math.min(hostRight, viewportRight)) };
+}
+const BLOCK_SELECT_SLOP_PX = 8;
+function isBlockSelectGesture(dx, dy) {
+  return Math.max(Math.abs(dx), Math.abs(dy)) >= BLOCK_SELECT_SLOP_PX;
+}
+function gutterClickCaretPos(doc, pos) {
+  if (!Number.isInteger(pos) || pos < 0 || pos >= doc.content.size) return null;
+  const node = doc.nodeAt(pos);
+  if (!node) return null;
+  return node.isTextblock ? Math.min(pos + 1, doc.content.size) : pos;
+}
+function shouldSuppressNativeHighlight(blocks) {
+  return ((blocks == null ? void 0 : blocks.length) ?? 0) > 0;
+}
+const MIN_BAND_GAP = 6;
+function selectionPadding(rects) {
+  if (rects.length === 0) return [];
+  let smallest = Number.POSITIVE_INFINITY;
+  for (let i = 1; i < rects.length; i += 1) {
+    const gap = rects[i].top - rects[i - 1].bottom;
+    if (gap > 0) smallest = Math.min(smallest, gap);
+  }
+  const budget = Number.isFinite(smallest) ? Math.max(0, (smallest - MIN_BAND_GAP) / 2) : SELECT_PAD_Y;
+  const pad = Math.max(0, Math.min(SELECT_PAD_Y, budget));
+  return rects.map(() => ({ top: pad, bottom: pad }));
+}
+function measureBlocksPadding(view, blocks) {
+  if (blocks.length === 0) return [];
+  if (typeof view.nodeDOM !== "function") return [];
+  const rects = [];
+  for (const block of blocks) {
+    const element = view.nodeDOM(block.from);
+    if (!(element instanceof HTMLElement)) return [];
+    const rect = element.getBoundingClientRect();
+    rects.push({ top: rect.top, bottom: rect.bottom });
+  }
+  return selectionPadding(rects);
+}
+function setBlockRangeSelection(view, anchorPos, targetPos, marquee) {
+  const { doc } = view.state;
+  const parts = marquee ? selectionPartsForRange(view, doc, anchorPos, targetPos, marquee) : coveredBlocks(doc, anchorPos, targetPos).map(
+    (block) => ({ kind: "block", ...block })
+  );
+  if (parts.length === 0) {
+    clearBlockRangeSelection(view);
+    return false;
+  }
+  const first = parts[0];
+  const last = parts[parts.length - 1];
+  const sel = new BlockRangeSelection(doc.resolve(first.from), doc.resolve(last.to), parts);
+  const tr = view.state.tr.setSelection(sel);
+  const wholeBlocks = parts.filter(
+    (part) => part.kind === "block"
+  );
+  const padding = measureBlocksPadding(view, wholeBlocks);
+  let paddingIndex = 0;
+  tr.setMeta(blockSelectionKey, {
+    blocks: parts.map((part) => {
+      if (part.kind === "images") return { from: part.from, to: part.to, images: part.images };
+      const measured = padding[paddingIndex];
+      paddingIndex += 1;
+      return { from: part.from, to: part.to, padding: measured };
+    })
+  });
+  view.dispatch(tr);
+  return true;
+}
+function clearBlockRangeSelection(view) {
+  const tr = view.state.tr.setMeta(blockSelectionKey, { blocks: [] });
+  view.dispatch(tr);
+}
+function setImageRangeSelection(view, galleryPos, imageRanges) {
+  const { doc } = view.state;
+  const gallery = doc.nodeAt(galleryPos);
+  if (!gallery || gallery.type.name !== "imageGallery" || imageRanges.length === 0) return false;
+  const parts = imageRanges.length === gallery.childCount ? [{ kind: "block", from: galleryPos, to: galleryPos + gallery.nodeSize }] : [{
+    kind: "images",
+    from: galleryPos,
+    to: galleryPos + gallery.nodeSize,
+    images: imageRanges
+  }];
+  const first = parts[0];
+  const last = parts[parts.length - 1];
+  const sel = new BlockRangeSelection(doc.resolve(first.from), doc.resolve(last.to), parts);
+  const tr = view.state.tr.setSelection(sel);
+  const padding = measureBlocksPadding(
+    view,
+    parts.filter(
+      (part) => part.kind === "block"
+    )
+  );
+  tr.setMeta(blockSelectionKey, {
+    blocks: parts.map((part) => part.kind === "images" ? { from: part.from, to: part.to, images: part.images } : { from: part.from, to: part.to, padding: padding[0] })
+  });
+  view.dispatch(tr);
+  return true;
+}
+function getSelectedBlocks(view) {
+  var _a;
+  return ((_a = blockSelectionKey.getState(view.state)) == null ? void 0 : _a.blocks) ?? [];
+}
+function hasPartialImageSelection(view) {
+  var _a;
+  const sel = view.state.selection;
+  return sel instanceof BlockRangeSelection && !!((_a = sel.parts) == null ? void 0 : _a.some((part) => part.kind === "images"));
+}
+function replacePartialWithText(view, text) {
+  if (!hasPartialImageSelection(view)) return false;
+  const sel = view.state.selection;
+  const tr = view.state.tr;
+  sel.replace(tr);
+  const schema = view.state.schema;
+  const insertAt = tr.selection.from;
+  if (tr.selection.$from.parent.inlineContent) {
+    if (text) tr.insertText(text, insertAt);
+    tr.setSelection(TextSelection.create(tr.doc, insertAt + text.length));
+  } else if (schema.nodes.paragraph) {
+    tr.insert(
+      insertAt,
+      schema.nodes.paragraph.create(null, text ? schema.text(text) : void 0)
+    );
+    tr.setSelection(TextSelection.create(tr.doc, insertAt + 1 + text.length));
+  } else {
+    return false;
+  }
+  tr.setMeta(blockSelectionKey, { blocks: [] });
+  view.dispatch(tr.scrollIntoView());
+  return true;
+}
+const BlockSelection = Extension.create({
+  name: "ywikiBlockSelection",
+  /**
+   * 高于默认（100）：本扩展要在**输入/删除快捷键**之前拿到事件。
+   *
+   * Tiptap 的 `deleteSelection` 命令不是调用 `tr.deleteSelection()`，而是自己
+   * 遍历 `selection.ranges` 逐个 `deleteRange`——不经过选区类的 `replace()`。
+   * 图片行部分选中时那样删，会把行里删到只剩一张，PM 随后补一个**空白图片
+   * 节点**占位（`image{2,10}` 的下限），留下看不见但真实存在的脏图（实测）。
+   * 因此 Backspace/Delete 由本扩展先接管，走选区自己的重建逻辑。
+   */
+  priority: 1e3,
+  addKeyboardShortcuts() {
+    const remove = () => {
+      var _a;
+      const view = this.editor.view;
+      const sel = view.state.selection;
+      if (!(sel instanceof BlockRangeSelection) || !((_a = sel.parts) == null ? void 0 : _a.length)) return false;
+      const tr = view.state.tr;
+      sel.replace(tr);
+      if (!tr.docChanged) return false;
+      tr.setMeta(blockSelectionKey, { blocks: [] });
+      view.dispatch(tr.scrollIntoView());
+      return true;
+    };
+    return {
+      Backspace: remove,
+      Delete: remove,
+      "Mod-Backspace": remove,
+      "Mod-Delete": remove,
+      "Shift-Backspace": remove,
+      "Ctrl-h": remove,
+      "Ctrl-d": remove,
+      "Alt-Backspace": remove,
+      "Alt-Delete": remove,
+      "Ctrl-Alt-Backspace": remove,
+      "Alt-d": remove
+    };
+  },
+  addProseMirrorPlugins() {
+    return [
+      new Plugin({
+        key: blockSelectionKey,
+        state: {
+          init: () => ({ blocks: [] }),
+          apply: (tr, value) => {
+            const meta = tr.getMeta(blockSelectionKey);
+            if (meta) return meta;
+            if (tr.selectionSet || tr.docChanged) return { blocks: [] };
+            return value;
+          }
+        },
+        props: {
+          /**
+           * 输入替换**图片行部分选中**。
+           *
+           * ## 三个入口都要接，缺一个就会多删图
+           *
+           * PM 对非 TextSelection 的输入只处理 `ranges[0]`，而且中英文输入走的
+           * 是不同路径：
+           *  - 普通按键 → `handleTextInput`；
+           *  - 浏览器直接派发 input/beforeinput → DOM 变化被 PM 的 observer
+           *    读到后按 DOM 区间替换，会连带吃掉相邻的图（实测：中文输入
+           *    "替换测试"删掉了 3 张，而只选中 2 张）；
+           *  - 输入法 → composition 系列，既不经过 `handleTextInput`，
+           *    DOM 变化还与组合文本混在一起。
+           *
+           * 因此三处都收敛到 `replacePartialWithText`：先删掉被框住的子图，
+           * 再把文字落成段落并把光标放在文字后面。composition 是在
+           * `compositionstart` 里先删再让输入法正常输入，不再自造文本。
+           */
+          handleTextInput(view, _from, _to, text) {
+            return replacePartialWithText(view, text);
+          },
+          handleDOMEvents: {
+            beforeinput(view, event) {
+              const input = event;
+              if (input.inputType !== "insertText" || input.data === null) return false;
+              if (!hasPartialImageSelection(view)) return false;
+              input.preventDefault();
+              replacePartialWithText(view, input.data);
+              return true;
+            },
+            compositionstart(view) {
+              if (!hasPartialImageSelection(view)) return false;
+              replacePartialWithText(view, "");
+              return false;
+            }
+          },
+          decorations(state) {
+            var _a;
+            const value = blockSelectionKey.getState(state);
+            if (!value || value.blocks.length === 0) return null;
+            const decorations = [];
+            for (const b of value.blocks) {
+              if ((_a = b.images) == null ? void 0 : _a.length) {
+                decorations.push(
+                  Decoration.node(b.from, b.to, { class: "is-block-image-selected" })
+                );
+                for (const range of b.images) {
+                  decorations.push(
+                    Decoration.node(range.from, range.to, { class: "is-block-selected-image" })
+                  );
+                }
+                continue;
+              }
+              decorations.push(
+                Decoration.node(b.from, b.to, {
+                  class: "is-block-selected",
+                  /**
+                   * 外扩量按实测值写成 CSS 变量，交给样式里的 `::before` 消费。
+                   * 未测到（布局不可用）时留空，样式回退到 `SELECT_PAD_*` 的默认值。
+                   */
+                  style: b.padding ? `--block-select-pad-top:${b.padding.top}px;--block-select-pad-bottom:${b.padding.bottom}px` : ""
+                })
+              );
+            }
+            return DecorationSet.create(state.doc, decorations);
+          }
+        },
+        view: (editorView) => {
+          let anchorPos = null;
+          const applyBlockSelection = (targetPos) => {
+            if (anchorPos === null) return;
+            setBlockRangeSelection(
+              editorView,
+              anchorPos,
+              targetPos,
+              marqueeRect(pointerX, pointerY)
+            );
+          };
+          let moved = false;
+          let startX = 0;
+          let startY = 0;
+          const marqueeHost = editorView.dom.closest(".editor-shell") ?? editorView.dom.parentElement;
+          let marqueeEl = null;
+          const updateMarquee = (x, y) => {
+            if (!marqueeHost) return;
+            if (!marqueeEl) {
+              marqueeEl = document.createElement("div");
+              marqueeEl.className = "block-marquee";
+              marqueeHost.appendChild(marqueeEl);
+            }
+            const hostRect = marqueeHost.getBoundingClientRect();
+            const declared = blockSelectionBand(editorView);
+            const limit = blockSelectionBandRect(editorView) ?? hostRect;
+            const band = clampMarqueeBand(
+              declared.left,
+              declared.right,
+              limit.left,
+              limit.right,
+              typeof document !== "undefined" ? document.documentElement.clientWidth : void 0
+            );
+            const clampX = (v) => Math.max(band.left, Math.min(v, band.right));
+            const clampY = (v) => Math.max(hostRect.top, Math.min(v, hostRect.bottom));
+            const box = marqueeBox(
+              clampX(startX),
+              clampY(startY),
+              clampX(x),
+              clampY(y),
+              hostRect.left,
+              hostRect.top
+            );
+            marqueeEl.style.left = `${box.left}px`;
+            marqueeEl.style.top = `${box.top}px`;
+            marqueeEl.style.width = `${box.width}px`;
+            marqueeEl.style.height = `${box.height}px`;
+          };
+          const clearMarquee = () => {
+            marqueeEl == null ? void 0 : marqueeEl.remove();
+            marqueeEl = null;
+          };
+          const marqueeRect = (x, y) => ({
+            left: Math.min(startX, x),
+            top: Math.min(startY, y),
+            right: Math.max(startX, x),
+            bottom: Math.max(startY, y)
+          });
+          let scrollFrame = 0;
+          let pointerX = 0;
+          let pointerY = 0;
+          let scrollParent = null;
+          let lastFrameAt = 0;
+          const stopAutoScroll = () => {
+            if (scrollFrame) cancelAnimationFrame(scrollFrame);
+            scrollFrame = 0;
+            scrollParent = null;
+            lastFrameAt = 0;
+          };
+          const tickAutoScroll = (now = performance.now()) => {
+            scrollFrame = 0;
+            if (anchorPos === null || !moved) return;
+            const target = scrollParent;
+            if (!target) return;
+            const elapsed = lastFrameAt ? Math.min(now - lastFrameAt, 50) : 16.7;
+            lastFrameAt = now;
+            const rect = target.getBoundingClientRect();
+            const delta = autoScrollDelta(pointerY, rect.top, rect.bottom);
+            if (delta === 0) {
+              lastFrameAt = 0;
+              return;
+            }
+            const scaled = Math.round(delta * elapsed / 16.7);
+            const before = target.scrollTop;
+            target.scrollTop = before + (scaled === 0 ? Math.sign(delta) : scaled);
+            if (target.scrollTop === before) return;
+            const hit = blockAtY(editorView, pointerY);
+            if (hit) applyBlockSelection(hit.pos);
+            updateMarquee(pointerX, pointerY);
+            scrollFrame = requestAnimationFrame(tickAutoScroll);
+          };
+          const startAutoScroll = () => {
+            if (scrollFrame) return;
+            scrollFrame = requestAnimationFrame(tickAutoScroll);
+          };
+          const onMouseMove = (event) => {
+            if (anchorPos === null) return;
+            if (!moved && !isBlockSelectGesture(event.clientX - startX, event.clientY - startY)) {
+              return;
+            }
+            pointerX = event.clientX;
+            pointerY = event.clientY;
+            if (!moved) {
+              moved = true;
+              applyBlockSelection(anchorPos);
+            }
+            scrollParent ?? (scrollParent = scrollParentOf(editorView.dom));
+            updateMarquee(event.clientX, event.clientY);
+            const target = blockAtY(editorView, event.clientY);
+            if (target) applyBlockSelection(target.pos);
+            if (scrollParent) {
+              const rect = scrollParent.getBoundingClientRect();
+              if (autoScrollDelta(event.clientY, rect.top, rect.bottom) !== 0) startAutoScroll();
+            }
+            event.preventDefault();
+          };
+          const finish = (event) => {
+            const wasClick = (event == null ? void 0 : event.type) === "mouseup" && !moved && anchorPos !== null;
+            const pos = anchorPos;
+            anchorPos = null;
+            moved = false;
+            stopAutoScroll();
+            clearMarquee();
+            window.removeEventListener("mousemove", onMouseMove);
+            window.removeEventListener("mouseup", finish, true);
+            window.removeEventListener("blur", finish);
+            window.removeEventListener("pointercancel", finish);
+            window.removeEventListener("keydown", onKeydown, true);
+            if (wasClick && pos !== null) {
+              const caret = gutterClickCaretPos(editorView.state.doc, pos);
+              if (caret !== null) {
+                const tr = editorView.state.tr.setSelection(
+                  TextSelection.near(editorView.state.doc.resolve(caret), 1)
+                );
+                tr.setMeta(blockSelectionKey, { blocks: [] });
+                editorView.dispatch(tr);
+                editorView.focus();
+              }
+            }
+          };
+          const onKeydown = (event) => {
+            if (event.key !== "Escape" || event.isComposing) return;
+            event.preventDefault();
+            finish();
+            if (!editorView.isDestroyed) {
+              editorView.dispatch(editorView.state.tr.setSelection(
+                Selection.near(editorView.state.doc.resolve(editorView.state.selection.from))
+              ));
+            }
+          };
+          const onMouseDown = (event) => {
+            var _a, _b;
+            if (event.button !== 0 || !editorView.editable || editorView.composing) return;
+            const target = event.target;
+            const area = editorView.dom.closest(".edit-workspace") ?? marqueeHost;
+            if (!target || !area || !area.contains(target) && !target.contains(area)) return;
+            if ((_a = target == null ? void 0 : target.closest) == null ? void 0 : _a.call(
+              target,
+              'button, input, textarea, select, a, img, video, audio, [contenteditable="false"], .math-node, .code-lang-menu, .block-grip, .block-plus, .block-chip, .insert-picker, .tbl-handle, .sel-toolbar, .tbl-menu, .tbl-ctx, .block-anchor, .slash-anchor'
+            )) {
+              return;
+            }
+            if ((_b = target == null ? void 0 : target.closest) == null ? void 0 : _b.call(target, "table")) return;
+            if (target.closest(".is-block-selected") && editorView.dom.contains(target)) return;
+            const hit = gutterAreaHit(editorView, event);
+            if (!hit) return;
+            event.preventDefault();
+            event.stopPropagation();
+            editorView.focus();
+            anchorPos = hit.pos;
+            startX = event.clientX;
+            startY = event.clientY;
+            moved = false;
+            window.addEventListener("mousemove", onMouseMove);
+            window.addEventListener("mouseup", finish, true);
+            window.addEventListener("blur", finish);
+            window.addEventListener("pointercancel", finish);
+            window.addEventListener("keydown", onKeydown, true);
+          };
+          document.addEventListener("mousedown", onMouseDown, true);
+          const onGlobalKeydown = (event) => {
+            if (event.key !== "Escape" || event.isComposing) return;
+            if (!getSelectedBlocks(editorView).length) return;
+            event.preventDefault();
+            event.stopPropagation();
+            const { state } = editorView;
+            const tr = state.tr.setSelection(
+              Selection.near(state.doc.resolve(state.selection.from))
+            );
+            tr.setMeta(blockSelectionKey, { blocks: [] });
+            editorView.dispatch(tr);
+            editorView.focus();
+          };
+          window.addEventListener("keydown", onGlobalKeydown, true);
+          const syncNativeHighlight = (view) => {
+            const state = blockSelectionKey.getState(view.state);
+            view.dom.classList.toggle(
+              "is-block-selecting",
+              shouldSuppressNativeHighlight(state == null ? void 0 : state.blocks)
+            );
+          };
+          syncNativeHighlight(editorView);
+          return {
+            update: (view, prevState) => {
+              if (anchorPos !== null && !view.state.doc.eq(prevState.doc)) finish();
+              syncNativeHighlight(view);
+            },
+            destroy: () => {
+              document.removeEventListener("mousedown", onMouseDown, true);
+              window.removeEventListener("keydown", onGlobalKeydown, true);
+              stopAutoScroll();
+              clearMarquee();
+              editorView.dom.classList.remove("is-block-selecting");
+              finish();
+            }
+          };
+        }
+      })
+    ];
+  }
+});
+const blockMenuHighlightKey = new PluginKey("ywikiBlockMenuHighlight");
+const BlockMenuHighlight = Extension.create({
+  name: "ywikiBlockMenuHighlight",
+  addProseMirrorPlugins() {
+    return [
+      new Plugin({
+        key: blockMenuHighlightKey,
+        state: {
+          init: () => null,
+          apply(tr, pos) {
+            const requested = tr.getMeta(blockMenuHighlightKey);
+            if (requested !== void 0) return requested;
+            if (pos === null || !tr.docChanged) return pos;
+            const mapped = tr.mapping.mapResult(pos);
+            return mapped.deleted ? null : mapped.pos;
+          }
+        },
+        props: {
+          decorations(state) {
+            const pos = blockMenuHighlightKey.getState(state);
+            if (pos === null || pos === void 0) return null;
+            const node = state.doc.nodeAt(pos);
+            if (!node) return null;
+            return DecorationSet.create(state.doc, [
+              Decoration.node(pos, pos + node.nodeSize, { class: "is-block-menu-target" })
+            ]);
+          }
+        }
+      })
+    ];
+  }
+});
+function highlightMenuBlock(view, pos) {
+  if (!view.isDestroyed && blockMenuHighlightKey.getState(view.state) !== pos) {
+    view.dispatch(view.state.tr.setMeta(blockMenuHighlightKey, pos));
+  }
+}
+const key = new PluginKey("ywikiCodeHighlight");
+function decorate(doc) {
+  const decorations = [];
+  doc.descendants((node, pos) => {
+    if (node.type.name !== "codeBlock") return;
+    for (const token of codeTokens(node.textContent, node.attrs.language)) {
+      decorations.push(Decoration.inline(pos + 1 + token.from, pos + 1 + token.to, { class: token.classes }));
+    }
+    return false;
+  });
+  return DecorationSet.create(doc, decorations);
+}
+const CodeHighlight = Extension.create({
+  name: "ywikiCodeHighlight",
+  addProseMirrorPlugins() {
+    return [new Plugin({
+      key,
+      state: {
+        init: (_, state) => decorate(state.doc),
+        apply: (tr, value) => tr.docChanged || tr.getMeta(key) ? decorate(tr.doc) : value
+      },
+      props: { decorations: (state) => key.getState(state) },
+      view(view) {
+        let disposed = false;
+        let requested = false;
+        const load = () => {
+          if (requested) return;
+          let hasCode = false;
+          view.state.doc.descendants((node) => {
+            if (node.type.name === "codeBlock") hasCode = true;
+          });
+          if (!hasCode) return;
+          requested = true;
+          void ensureCodeHighlight().then((ready) => {
+            if (ready && !disposed) view.dispatch(view.state.tr.setMeta(key, true).setMeta("addToHistory", false));
+          });
+        };
+        load();
+        return { update: load, destroy: () => {
+          disposed = true;
+        } };
+      }
+    })];
+  }
+});
+const ALLOWED_ATTR = {
+  a: ["href", "title"],
+  img: ["src", "alt", "title", "width", "height", "data-width", "data-align", "data-attachment-id"],
+  td: ["colspan", "rowspan", "colwidth", "data-align", "data-cell-background"],
+  th: ["colspan", "rowspan", "colwidth", "data-align", "data-cell-background"],
+  code: ["class"],
+  pre: ["class", "data-language"],
+  ol: ["start", "data-type"],
+  ul: ["data-type"],
+  li: ["data-type", "data-checked"],
+  div: [
+    "data-video-embed",
+    "data-provider",
+    "data-video-id",
+    "data-page",
+    "data-start-seconds",
+    "data-topic-meta",
+    "data-branch-style",
+    "data-mind-map",
+    "data-map-id",
+    "data-root-id",
+    "data-format-version",
+    "data-layout",
+    "data-theme",
+    "data-height",
+    "data-mind-topic",
+    "data-topic-id",
+    "data-parent-id",
+    "data-order",
+    "data-file-attachment",
+    "data-attachment-id",
+    "attachmentid",
+    "filename",
+    "mimetype",
+    "size",
+    "data-math-block",
+    "data-latex",
+    "data-columns",
+    "data-column",
+    "data-callout",
+    "data-tone",
+    "data-callout-content",
+    "data-callout-icon",
+    "data-callout-textcolor",
+    "data-callout-bordercolor",
+    "data-callout-backgroundcolor"
+  ],
+  span: [
+    "data-mind-description",
+    "data-mind-note",
+    "data-mind-relation",
+    "data-id",
+    "data-source",
+    "data-target",
+    "data-kind",
+    "data-label",
+    "data-page-link",
+    "data-page-id",
+    "pageid",
+    "label",
+    "data-mention",
+    "data-user-id",
+    "userid",
+    "data-math-inline",
+    "data-latex",
+    "data-text-color",
+    "data-color"
+  ],
+  mark: ["data-highlight", "data-color"],
+  p: ["data-indent", "data-text-align"],
+  h1: ["data-indent", "data-text-align"],
+  h2: ["data-indent", "data-text-align"],
+  h3: ["data-indent", "data-text-align"],
+  h4: ["data-indent", "data-text-align"],
+  h5: ["data-indent", "data-text-align"],
+  h6: ["data-indent", "data-text-align"]
+};
+const DROP_TAGS = /* @__PURE__ */ new Set([
+  "style",
+  "script",
+  "meta",
+  "link",
+  "iframe",
+  "object",
+  "embed",
+  "form",
+  "input",
+  "button"
+]);
+function sanitizeElement(el) {
+  for (const child of Array.from(el.children)) {
+    if (child.hasAttribute("data-callout-decoration")) {
+      child.remove();
+      continue;
+    }
+    if (DROP_TAGS.has(child.tagName.toLowerCase())) {
+      child.remove();
+      continue;
+    }
+    child.removeAttribute("style");
+    const languageClass = /(?:^|\s)(language-[\w+#-]+)/.exec(child.className);
+    child.removeAttribute("class");
+    if (["code", "pre"].includes(child.tagName.toLowerCase()) && languageClass) {
+      child.setAttribute("class", languageClass[1]);
+    }
+    child.removeAttribute("id");
+    for (const attr of Array.from(child.attributes)) {
+      const name = attr.name.toLowerCase();
+      if (name.startsWith("on")) {
+        child.removeAttribute(attr.name);
+        continue;
+      }
+      const allowed = ALLOWED_ATTR[child.tagName.toLowerCase()];
+      if (!allowed || !allowed.includes(name)) {
+        child.removeAttribute(attr.name);
+      }
+    }
+    if (child.tagName.toLowerCase() === "a") {
+      const href = child.getAttribute("href") ?? "";
+      const low = href.trim().toLowerCase();
+      if (low.startsWith("javascript:") || low.startsWith("data:") || low.startsWith("vbscript:")) {
+        child.removeAttribute("href");
+      }
+    }
+    sanitizeElement(child);
+  }
+}
+const PasteSanitizer = Extension.create({
+  name: "ywikiPasteSanitizer",
+  addProseMirrorPlugins() {
+    return [
+      new Plugin({
+        props: {
+          transformPastedHTML(html) {
+            const container = document.createElement("div");
+            container.innerHTML = html;
+            sanitizeElement(container);
+            return container.innerHTML;
+          }
+        }
+      })
+    ];
+  }
+});
+function pastedImageFiles(event) {
+  var _a;
+  const items = (_a = event.clipboardData) == null ? void 0 : _a.items;
+  if (!items) return [];
+  const files = [];
+  for (const item of Array.from(items)) {
+    if (item.kind === "file" && item.type.startsWith("image/")) {
+      const f = item.getAsFile();
+      if (f) files.push(f);
+    }
+  }
+  return files;
+}
+function pastedRemoteImageUrls(event) {
+  var _a;
+  const html = ((_a = event.clipboardData) == null ? void 0 : _a.getData("text/html")) ?? "";
+  if (!html) return [];
+  const container = document.createElement("div");
+  container.innerHTML = html;
+  const urls = /* @__PURE__ */ new Set();
+  for (const img of Array.from(container.querySelectorAll("img"))) {
+    const src = (img.getAttribute("src") ?? "").trim();
+    if (/^https?:\/\//i.test(src)) urls.add(src);
+  }
+  return [...urls];
+}
+const inlineCommentPluginKey = new PluginKey(
+  "ywikiInlineComments"
+);
+function textNodePositions(doc) {
+  const positions = [];
+  doc.descendants((node, pos) => {
+    var _a;
+    if (node.isText && (((_a = node.text) == null ? void 0 : _a.length) ?? 0) > 0) positions.push(pos);
+  });
+  return positions;
+}
+function buildDecorations(doc, comments, activeId) {
+  const { marks } = resolveInlineComments(
+    doc.toJSON(),
+    comments
+  );
+  if (marks.length === 0) return DecorationSet.empty;
+  const positions = textNodePositions(doc);
+  const decorations = [];
+  for (const mark of marks) {
+    const base = positions[mark.textIndex];
+    if (base === void 0) continue;
+    const from = base + mark.from;
+    const to = base + mark.to;
+    if (to <= from) {
+      decorations.push(
+        Decoration.widget(from, () => {
+          const el = document.createElement("span");
+          el.className = "doc-inline-comment is-editor is-shifted";
+          el.setAttribute("data-comment-id", mark.commentId);
+          el.setAttribute("data-comment-hint", "此处有讨论（原文已改动）");
+          return el;
+        })
+      );
+      continue;
+    }
+    const classes = ["doc-inline-comment", "is-editor"];
+    if (mark.hasReplies) classes.push("has-replies");
+    if (activeId === mark.commentId) classes.push("is-active");
+    decorations.push(
+      Decoration.inline(from, to, {
+        class: classes.join(" "),
+        "data-comment-id": mark.commentId,
+        // 同上：不用原生 title（浏览器灰框、样式不可控）
+        "data-comment-hint": "点击查看该处讨论"
+      })
+    );
+  }
+  return DecorationSet.create(doc, decorations);
+}
+const InlineCommentHighlight = Extension.create({
+  name: "ywikiInlineCommentHighlight",
+  addProseMirrorPlugins() {
+    const options = this.options;
+    return [
+      new Plugin({
+        key: inlineCommentPluginKey,
+        state: {
+          init: () => ({ comments: options.getComments() }),
+          apply: (tr, value) => {
+            const meta = tr.getMeta(inlineCommentPluginKey);
+            return meta ?? value;
+          }
+        },
+        props: {
+          decorations(state) {
+            var _a;
+            const value = inlineCommentPluginKey.getState(state);
+            if (!value || value.comments.length === 0) return null;
+            return buildDecorations(
+              state.doc,
+              value.comments,
+              ((_a = options.getActiveId) == null ? void 0 : _a.call(options)) ?? null
+            );
+          },
+          /**
+           * 点击高亮 → 定位下方讨论。
+           * decoration 不是 mark，`resolve(pos)` 里查不到它，因此从事件目标
+           * 上读 `data-comment-id`（这个属性由上面的 decoration 生成）。
+           */
+          handleClick(_view, _pos, event) {
+            var _a;
+            const target = event.target;
+            const el = target == null ? void 0 : target.closest("[data-comment-id]");
+            const id = el == null ? void 0 : el.getAttribute("data-comment-id");
+            if (!id) return false;
+            hideCommentHint();
+            (_a = options.onMarkClick) == null ? void 0 : _a.call(options, id);
+            return true;
+          },
+          /**
+           * 悬停评论标记 → 自绘提示。
+           *
+           * 不用原生 `title`：浏览器绘制的灰框圆角在浅色文档里很突兀，
+           * 也无法统一主题（用户实测反馈："这个提示不用 Tooltip 用的啥？"）。
+           * decoration 是运行时插入的 DOM，Vue 的 `WTooltip` 包不住每一处
+           * 标记，因此按 `data-comment-hint` 自绘（见 shared/comment-hint）。
+           */
+          handleDOMEvents: {
+            mouseover(_view, event) {
+              const mouse = event;
+              const target = mouse.target;
+              const el = target == null ? void 0 : target.closest("[data-comment-hint]");
+              if (!(el instanceof HTMLElement)) return false;
+              const text = el.getAttribute("data-comment-hint");
+              if (text) showCommentHint(el, text);
+              return false;
+            },
+            mouseout(_view, event) {
+              const mouse = event;
+              const target = mouse.target;
+              const el = target == null ? void 0 : target.closest("[data-comment-hint]");
+              if (!el) return false;
+              const related = mouse.relatedTarget;
+              if (related && el.contains(related)) return false;
+              hideCommentHint();
+              return false;
+            }
+          }
+        }
+      })
+    ];
+  }
+});
+function refreshInlineComments(editor, comments) {
+  const tr = editor.state.tr.setMeta(inlineCommentPluginKey, { comments });
+  editor.view.dispatch(tr);
+}
+new PluginKey("ywiki-collab-cursor");
+function buildCursor(user) {
+  const color = user.color || "#2f6feb";
+  const name = user.name || "匿名";
+  const cursor = document.createElement("span");
+  cursor.classList.add("ProseMirror-yjs-cursor");
+  cursor.style.setProperty("--yjs-cursor-color", color);
+  const caret = document.createElement("span");
+  caret.classList.add("ywiki-collab-caret");
+  caret.style.backgroundColor = color;
+  const label = document.createElement("span");
+  label.classList.add("ywiki-collab-caret-label");
+  label.style.backgroundColor = color;
+  label.style.color = readableTextColor(color);
+  label.textContent = name;
+  cursor.appendChild(caret);
+  cursor.appendChild(label);
+  return cursor;
+}
+const CollabCursor = Extension.create({
+  name: "collabCursor",
+  addOptions() {
+    return { awareness: null };
+  },
+  addProseMirrorPlugins() {
+    if (!this.options.awareness) return [];
+    return [
+      yCursorPlugin(this.options.awareness, {
+        cursorBuilder: (user) => buildCursor(user)
+      })
+    ];
+  }
+});
+const SlashKey = new PluginKey("ywiki-slash");
+function dismissSlash(view) {
+  const { $from } = view.state.selection;
+  const index = $from.parent.textBetween(0, $from.parentOffset).lastIndexOf("/");
+  view.dispatch(view.state.tr.setMeta(SlashKey, {
+    dismissedFrom: index >= 0 ? $from.start() + index : null
+  }));
+}
+const SlashCommand = Extension.create({
+  name: "ywikiSlashCommand",
+  addOptions() {
+    return {
+      onOpen: () => void 0,
+      onUpdate: () => void 0,
+      onClose: () => void 0
+    };
+  },
+  addProseMirrorPlugins() {
+    const options = this.options;
+    return [
+      new Plugin({
+        key: SlashKey,
+        state: {
+          init: () => ({ dismissedFrom: null }),
+          apply: (tr, value) => {
+            const meta = tr.getMeta(SlashKey);
+            if (meta) return meta;
+            if (value.dismissedFrom === null) return value;
+            const result = tr.mapping.mapResult(value.dismissedFrom, 1);
+            return { dismissedFrom: result.deleted ? null : result.pos };
+          }
+        },
+        view: () => {
+          let openFrom = null;
+          return {
+            update: (view, prevState) => {
+              var _a;
+              if (shouldIgnoreForIme({ isComposing: false })) return;
+              if (view.state.doc.eq(prevState.doc) && view.state.selection.eq(prevState.selection) && SlashKey.getState(view.state) === SlashKey.getState(prevState)) {
+                return;
+              }
+              const { $from, empty } = view.state.selection;
+              if (!view.editable || view.composing || !empty || $from.parent.type.spec.code) {
+                if (openFrom !== null) {
+                  openFrom = null;
+                  options.onClose();
+                }
+                return;
+              }
+              const textBefore = $from.parent.textBetween(
+                0,
+                $from.parentOffset,
+                void 0,
+                ""
+              );
+              const slashIndex = textBefore.lastIndexOf("/");
+              const isSlashAtBoundary = slashIndex >= 0 && (slashIndex === 0 || /\s/.test(textBefore[slashIndex - 1]));
+              if (isSlashAtBoundary) {
+                const from = $from.start() + slashIndex;
+                const query = textBefore.slice(slashIndex + 1);
+                if (((_a = SlashKey.getState(view.state)) == null ? void 0 : _a.dismissedFrom) === from) {
+                  if (openFrom !== null) options.onClose();
+                  openFrom = null;
+                  return;
+                }
+                if (/\s/.test(query)) {
+                  if (openFrom !== null) {
+                    openFrom = null;
+                    options.onClose();
+                  }
+                  return;
+                }
+                if (openFrom !== from) {
+                  openFrom = from;
+                  options.onOpen({ from, query });
+                } else {
+                  options.onUpdate(query);
+                }
+              } else if (openFrom !== null) {
+                openFrom = null;
+                options.onClose();
+              }
+            },
+            destroy: () => {
+              if (openFrom !== null) {
+                openFrom = null;
+                options.onClose();
+              }
+            }
+          };
+        },
+        props: {
+          handleKeyDown(_view, event) {
+            if (shouldIgnoreForIme(event)) return false;
+            return false;
+          }
+        }
+      })
+    ];
+  }
+});
+function isEmptyLineBlock(typeName, contentSize) {
+  return contentSize === 0 && (typeName === "paragraph" || typeName === "heading");
+}
+const BlockHandleKey = new PluginKey("ywiki-block-handle");
+const HANDLE_GUTTER_PX = 64;
+function resolveTopLevelBlock(view, event, host) {
+  const contentRoot = view.dom;
+  let blockPos = null;
+  let blockNode = null;
+  let blockEl = null;
+  let el = event.target instanceof HTMLElement ? event.target : null;
+  while (el && el.parentElement && el.parentElement !== contentRoot) {
+    el = el.parentElement;
+  }
+  if (el && el.parentElement === contentRoot) {
+    try {
+      const inside = view.posAtDOM(el, 0);
+      const $inside = view.state.doc.resolve(inside);
+      const start = $inside.depth > 0 ? $inside.before(1) : inside;
+      const node = view.state.doc.nodeAt(start);
+      if (node) {
+        blockPos = start;
+        blockNode = node;
+        blockEl = el;
+      }
+    } catch {
+    }
+  }
+  if (blockPos === null || !blockNode) {
+    const coords = view.posAtCoords({ left: event.clientX, top: event.clientY });
+    if (!coords) return null;
+    const raw = coords.pos;
+    if (typeof raw !== "number" || raw < 0) return null;
+    const pos = Math.min(raw, view.state.doc.content.size);
+    view.state.doc.forEach((node, offset) => {
+      if (blockPos !== null) return;
+      if (pos >= offset && pos < offset + node.nodeSize) {
+        blockPos = offset;
+        blockNode = node;
+      }
+    });
+    if (blockPos === null && view.state.doc.childCount > 0) {
+      const last = view.state.doc.lastChild;
+      blockPos = view.state.doc.content.size - last.nodeSize;
+      blockNode = last;
+    }
+    if (blockPos === null || !blockNode) return null;
+  }
+  const HANDLE_HEIGHT = 26;
+  const hostRect = host.getBoundingClientRect();
+  let top = event.clientY;
+  let contentLeft = contentRoot.getBoundingClientRect().left - hostRect.left;
+  try {
+    const dom = blockEl ?? view.nodeDOM(blockPos);
+    if (dom instanceof HTMLElement) {
+      const domRect = dom.getBoundingClientRect();
+      let firstTop = domRect.top;
+      let firstHeight = domRect.height;
+      try {
+        const range = document.createRange();
+        range.selectNodeContents(dom);
+        const lines = Array.from(range.getClientRects()).filter(
+          (r) => r.height > 0.5
+        );
+        if (lines.length > 0) {
+          firstTop = lines[0].top;
+          firstHeight = lines[0].height;
+        }
+      } catch {
+      }
+      top = firstTop + firstHeight / 2 - HANDLE_HEIGHT / 2 - hostRect.top;
+    }
+  } catch {
+    top = event.clientY - hostRect.top;
+  }
+  return {
+    pos: blockPos,
+    type: blockNode.type.name,
+    top,
+    /** 块内容左缘（相对容器）：供 EditorPane 把手柄精确贴在正文左侧 */
+    contentLeft,
+    isEmpty: isEmptyLineBlock(blockNode.type.name, blockNode.content.size)
+  };
+}
+const BlockHandle = Extension.create({
+  name: "ywikiBlockHandle",
+  addOptions() {
+    return { onHover: () => void 0 };
+  },
+  addProseMirrorPlugins() {
+    const options = this.options;
+    return [
+      new Plugin({
+        key: BlockHandleKey,
+        view: (editorView) => {
+          let lastPos = null;
+          let lastTop = Number.NaN;
+          const host = editorView.dom.closest(".editor-shell") ?? editorView.dom.parentElement;
+          const report = (info) => {
+            if (!info) {
+              if (lastPos !== null) {
+                lastPos = null;
+                lastTop = Number.NaN;
+                options.onHover(null);
+              }
+              return;
+            }
+            if (info.pos !== lastPos || Math.abs(info.top - lastTop) > 0.5) {
+              lastPos = info.pos;
+              lastTop = info.top;
+              options.onHover(info);
+            }
+          };
+          const onMove = (event) => {
+            if (!editorView.editable) {
+              report(null);
+              return;
+            }
+            if (!host) return;
+            const rect = editorView.dom.getBoundingClientRect();
+            const inContent = event.clientX >= rect.left && event.clientX <= rect.right;
+            const inGutter = event.clientX < rect.left && event.clientX >= rect.left - HANDLE_GUTTER_PX;
+            const inRows = event.clientY >= rect.top - 8 && event.clientY <= rect.bottom + 8;
+            if (!inContent && !inGutter || !inRows) {
+              report(null);
+              return;
+            }
+            let info = null;
+            try {
+              info = resolveTopLevelBlock(editorView, event, host);
+            } catch {
+              info = null;
+            }
+            if (inGutter && !info) return;
+            report(info);
+          };
+          const onLeave = () => {
+            report(null);
+          };
+          document.addEventListener("mousemove", onMove);
+          document.addEventListener("mouseleave", onLeave);
+          return {
+            destroy: () => {
+              document.removeEventListener("mousemove", onMove);
+              document.removeEventListener("mouseleave", onLeave);
+            }
+          };
+        }
+      })
+    ];
+  }
+});
+function insertUploadedBlock(tr, pos, node) {
+  const $pos = tr.doc.resolve(pos);
+  if (node.isBlock && $pos.depth > 0 && $pos.parent.type.name === "paragraph" && $pos.parent.content.size === 0) {
+    const from = $pos.before(), to = $pos.after();
+    tr.replaceWith(from, to, node);
+    return { replacedEmpty: true, nextPos: from + node.nodeSize };
+  }
+  tr.insert(pos, node);
+  return { replacedEmpty: false, nextPos: tr.mapping.map(pos, 1) };
+}
+const uploadPlaceholderKey = new PluginKey(
+  "ywikiUploadPlaceholder"
+);
+function blockStartAt(doc, index) {
+  let start = 0;
+  for (let i = 0; i < index && i < doc.childCount; i += 1) start += doc.child(i).nodeSize;
+  return start;
+}
+function anchorAt(doc, pos) {
+  const clamped = Math.max(0, Math.min(pos, doc.content.size));
+  let blockIndex = -1;
+  let blockStart = 0;
+  doc.forEach((node, offset, index) => {
+    if (blockIndex >= 0) return;
+    if (clamped >= offset && clamped < offset + node.nodeSize) {
+      blockIndex = index;
+      blockStart = offset;
+    }
+  });
+  if (blockIndex < 0 && doc.childCount > 0) {
+    blockIndex = doc.childCount - 1;
+    blockStart = doc.content.size - doc.child(doc.childCount - 1).nodeSize;
+  }
+  if (blockIndex < 0) {
+    return { pos: clamped, blockIndex: 0, offset: 0, blockText: "", blockCount: doc.childCount, blockJSON: "", relative: 0 };
+  }
+  const block = doc.child(blockIndex);
+  return {
+    pos: clamped,
+    blockIndex,
+    offset: Math.max(0, clamped - (blockStart + 1)),
+    blockText: block.textContent,
+    blockCount: doc.childCount,
+    blockJSON: JSON.stringify(block.toJSON()),
+    relative: clamped - blockStart
+  };
+}
+function resolveAnchor(doc, anchor) {
+  if (doc.childCount === 0) return null;
+  const matches = [];
+  doc.forEach((node2, _offset, index) => {
+    if (JSON.stringify(node2.toJSON()) === anchor.blockJSON) matches.push(index);
+  });
+  if (matches.length !== 1) return null;
+  const start = blockStartAt(doc, matches[0]);
+  const node = doc.child(matches[0]);
+  return start + Math.max(0, Math.min(anchor.relative, node.nodeSize));
+}
+function advancePlaceholders(doc, items, mapping, recoverDeleted = false) {
+  const next = [];
+  const lost = [];
+  for (const item of items) {
+    const res = mapping.mapResult(item.anchor.pos, 1);
+    if (!res.deleted) {
+      next.push({ ...item, anchor: anchorAt(doc, res.pos) });
+      continue;
+    }
+    const resolved = recoverDeleted ? resolveAnchor(doc, item.anchor) : null;
+    if (resolved === null) {
+      lost.push(item.id);
+      continue;
+    }
+    next.push({ ...item, anchor: anchorAt(doc, resolved) });
+  }
+  return { items: next, lost };
+}
+const livePreviewUrls = /* @__PURE__ */ new Set();
+function releasePreview(url) {
+  if (!url || !livePreviewUrls.delete(url)) return;
+  if (typeof URL.revokeObjectURL === "function") URL.revokeObjectURL(url);
+}
+function releaseAllPreviews() {
+  for (const url of [...livePreviewUrls]) releasePreview(url);
+}
+function createPreview(file, kind) {
+  if (!file || kind !== "image" || typeof URL.createObjectURL !== "function") return void 0;
+  try {
+    const url = URL.createObjectURL(file);
+    livePreviewUrls.add(url);
+    return url;
+  } catch {
+    return void 0;
+  }
+}
+function placeholderDom(item, options) {
+  const el = document.createElement("span");
+  el.className = "ywiki-upload-placeholder";
+  el.setAttribute("data-upload-id", item.id);
+  const spinner = document.createElement("span");
+  spinner.className = "ywiki-upload-spinner";
+  spinner.setAttribute("aria-hidden", "true");
+  const label = document.createElement("span");
+  label.className = "ywiki-upload-label";
+  label.textContent = item.kind === "image" ? `正在上传图片：${item.label}` : `正在上传：${item.label}`;
+  const cancel = document.createElement("button");
+  cancel.type = "button";
+  cancel.className = "ywiki-upload-cancel";
+  cancel.title = "取消上传";
+  cancel.setAttribute("aria-label", "取消上传");
+  cancel.textContent = "×";
+  cancel.addEventListener("mousedown", (e) => {
+    e.preventDefault();
+    e.stopPropagation();
+  });
+  cancel.addEventListener("click", (e) => {
+    var _a;
+    e.preventDefault();
+    e.stopPropagation();
+    (_a = options.onCancel) == null ? void 0 : _a.call(options, item.id);
+  });
+  if (item.previewUrl) {
+    el.classList.add("has-preview");
+    const preview = document.createElement("img");
+    preview.className = "ywiki-upload-preview";
+    preview.setAttribute("alt", "");
+    preview.setAttribute("aria-hidden", "true");
+    preview.setAttribute("draggable", "false");
+    preview.src = item.previewUrl;
+    el.title = item.label;
+    el.append(preview, spinner, cancel);
+    return el;
+  }
+  el.append(spinner, label, cancel);
+  return el;
+}
+const UploadPlaceholderExtension = Extension.create({
+  name: "ywikiUploadPlaceholder",
+  addOptions() {
+    return { onLost: () => void 0, onCancel: () => void 0 };
+  },
+  addProseMirrorPlugins() {
+    const options = this.options;
+    return [
+      new Plugin({
+        key: uploadPlaceholderKey,
+        state: {
+          init: () => ({ items: [] }),
+          apply: (tr, value) => {
+            var _a;
+            const meta = tr.getMeta(uploadPlaceholderKey);
+            if (meta == null ? void 0 : meta.clear) {
+              for (const item of value.items) releasePreview(item.previewUrl);
+              return { items: [] };
+            }
+            const removed = /* @__PURE__ */ new Set([...(meta == null ? void 0 : meta.remove) ? [meta.remove] : [], ...(meta == null ? void 0 : meta.removeMany) ?? []]);
+            const remaining = removed.size === 0 ? value.items : value.items.filter((i) => !removed.has(i.id));
+            if (removed.size > 0) {
+              for (const item of value.items) {
+                if (removed.has(item.id)) releasePreview(item.previewUrl);
+              }
+            }
+            const moved = (meta == null ? void 0 : meta.reanchor) ? remaining.filter(
+              (i) => i.anchor.pos === meta.reanchor.from
+            ).map((i) => ({ ...i, anchor: anchorAt(tr.doc, meta.reanchor.to) })) : [];
+            const unmoved = remaining.filter((i) => !(meta == null ? void 0 : meta.reanchor) || i.anchor.pos !== meta.reanchor.from);
+            const advanced = tr.docChanged ? advancePlaceholders(tr.doc, unmoved, tr.mapping, !!tr.getMeta("y-sync$")) : { items: unmoved, lost: [] };
+            advanced.items.push(...moved);
+            for (const id of advanced.lost) {
+              const lost = value.items.find((i) => i.id === id);
+              releasePreview(lost == null ? void 0 : lost.previewUrl);
+              (_a = options.onLost) == null ? void 0 : _a.call(options, id);
+            }
+            if (meta) {
+              if (meta.add) return { items: [...advanced.items, meta.add] };
+            }
+            return { items: advanced.items };
+          }
+        },
+        view: () => ({
+          destroy: () => releaseAllPreviews()
+        }),
+        props: {
+          decorations(state) {
+            const value = uploadPlaceholderKey.getState(state);
+            if (!value || value.items.length === 0) return null;
+            return DecorationSet.create(
+              state.doc,
+              value.items.map((item) => {
+                const widget = Decoration.widget(item.anchor.pos, () => placeholderDom(item, options), {
+                  key: item.id,
+                  side: 1
+                });
+                return widget;
+              })
+            );
+          }
+        }
+      })
+    ];
+  }
+});
+function addUploadPlaceholder(view, item) {
+  const anchor = anchorAt(view.state.doc, item.pos);
+  const previewUrl = createPreview(item.file, item.kind);
+  view.dispatch(
+    view.state.tr.setMeta(uploadPlaceholderKey, {
+      add: {
+        id: item.id,
+        label: item.label,
+        kind: item.kind,
+        anchor,
+        ...previewUrl ? { previewUrl } : {}
+      }
+    })
+  );
+}
+function removeUploadPlaceholder(view, id) {
+  const value = uploadPlaceholderKey.getState(view.state);
+  if (!(value == null ? void 0 : value.items.some((i) => i.id === id))) return;
+  view.dispatch(view.state.tr.setMeta(uploadPlaceholderKey, { remove: id }));
+}
+function replacePlaceholderWithNode(view, id, node) {
+  const pos = currentPlaceholderPos(view, id);
+  if (pos === null || !view.editable || view.isDestroyed) return false;
+  const nodeType = view.state.schema.nodes[node.type];
+  if (!nodeType) return false;
+  const created = nodeType.create(node.attrs ?? null);
+  const tr = view.state.tr;
+  let reanchor;
+  try {
+    const inserted = insertUploadedBlock(tr, pos, created);
+    if (inserted.replacedEmpty) reanchor = { from: pos, to: inserted.nextPos };
+  } catch {
+    tr.setMeta(uploadPlaceholderKey, { remove: id });
+    view.dispatch(tr);
+    return false;
+  }
+  tr.setMeta(uploadPlaceholderKey, { remove: id, reanchor });
+  view.dispatch(tr);
+  return true;
+}
+function currentPlaceholderPos(view, id) {
+  const value = uploadPlaceholderKey.getState(view.state);
+  const item = value == null ? void 0 : value.items.find((i) => i.id === id);
+  return item ? item.anchor.pos : null;
+}
+function selectTableCell(view, pos) {
+  var _a, _b;
+  if (pos < 0 || pos >= view.state.doc.content.size || !["cell", "header_cell"].includes(((_a = view.state.doc.nodeAt(pos)) == null ? void 0 : _a.type.spec.tableRole) ?? "")) return;
+  const sel = view.state.selection;
+  let included = false;
+  (_b = sel.forEachCell) == null ? void 0 : _b.call(sel, (_node, cellPos) => {
+    if (cellPos === pos) included = true;
+  });
+  if (!included) view.dispatch(view.state.tr.setSelection(
+    Selection.near(view.state.doc.resolve(pos + 1))
+  ));
+}
+function cellPositionAtDOM(view, cell) {
+  try {
+    const $pos = view.state.doc.resolve(view.posAtDOM(cell, 0));
+    for (let d = $pos.depth; d > 0; d -= 1) {
+      if (["cell", "header_cell"].includes($pos.node(d).type.spec.tableRole ?? "")) {
+        return $pos.before(d);
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function selectTableAxis(view, cellPos, axis, index) {
+  if (!view.editable) return false;
+  try {
+    const $cell = view.state.doc.resolve(cellPos);
+    const table = $cell.node(-1);
+    if (table.type.spec.tableRole !== "table") return false;
+    const start = $cell.start(-1);
+    const map = TableMap.get(table);
+    const rect = map.findCell(cellPos - start);
+    if (index !== void 0) {
+      const limit = axis === "row" ? map.height : map.width;
+      if (!Number.isInteger(index) || index < 0 || index >= limit) return false;
+      if (axis === "row") {
+        rect.top = index;
+        rect.bottom = index + 1;
+      }
+      if (axis === "column") {
+        rect.left = index;
+        rect.right = index + 1;
+      }
+    }
+    const first = axis === "row" ? rect.top * map.width : axis === "column" ? rect.left : 0;
+    const last = axis === "row" ? (rect.bottom - 1) * map.width + map.width - 1 : axis === "column" ? (map.height - 1) * map.width + rect.right - 1 : map.map.length - 1;
+    const selection = CellSelection.create(view.state.doc, start + map.map[first], start + map.map[last]);
+    view.dispatch(view.state.tr.setSelection(selection));
+    view.focus();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function tablePositionAtCell(view, cellPos) {
+  try {
+    const $cell = view.state.doc.resolve(cellPos);
+    return $cell.node(-1).type.spec.tableRole === "table" ? $cell.before(-1) : null;
+  } catch {
+    return null;
+  }
+}
+function currentTableCellPosition(view) {
+  const selection = view.state.selection;
+  if (selection instanceof CellSelection) return selection.$anchorCell.pos;
+  for (let depth = selection.$from.depth; depth > 0; depth -= 1) {
+    if (["cell", "header_cell"].includes(selection.$from.node(depth).type.spec.tableRole ?? "")) {
+      return selection.$from.before(depth);
+    }
+  }
+  return null;
+}
+function insertTableBoundary(editor, cellPos, axis, index) {
+  if (!editor.isEditable) return false;
+  const pos = tablePositionAtCell(editor.view, cellPos);
+  if (pos === null) return false;
+  const table = editor.state.doc.nodeAt(pos);
+  const map = TableMap.get(table);
+  const limit = axis === "row" ? map.height : map.width;
+  if (!Number.isInteger(index) || index < 0 || index > limit) return false;
+  const rect = { map, table, tableStart: pos + 1, left: 0, top: 0, right: map.width, bottom: map.height };
+  const tr = editor.state.tr.setSelection(Selection.near(editor.state.doc.resolve(cellPos + 1)));
+  if (axis === "row") addRow(tr, rect, index);
+  else addColumn(tr, rect, index);
+  editor.view.dispatch(tr);
+  editor.view.focus();
+  return true;
+}
+function tableSelectionMarkActive(editor, name) {
+  const mark = editor.state.schema.marks[name];
+  const selection = editor.state.selection;
+  if (!mark || !(selection instanceof CellSelection)) return false;
+  let hasText = false;
+  let allMarked = true;
+  selection.forEachCell((cell) => cell.descendants((node) => {
+    if (node.isText) {
+      hasText = true;
+      if (!mark.isInSet(node.marks)) allMarked = false;
+    }
+  }));
+  return hasText && allMarked;
+}
+function setTableSelectionMark(editor, name, attrs) {
+  const mark = editor.state.schema.marks[name];
+  const selection = editor.state.selection;
+  if (!editor.isEditable || !mark || !(selection instanceof CellSelection)) return false;
+  const tr = editor.state.tr;
+  selection.forEachCell((cell, pos) => {
+    const from = pos + 1, to = pos + cell.nodeSize - 1;
+    if (attrs === null) tr.removeMark(from, to, mark);
+    else tr.addMark(from, to, mark.create(attrs));
+  });
+  if (!tr.docChanged) return false;
+  editor.view.dispatch(tr);
+  return true;
+}
+function findTable(editor) {
+  const { $from } = editor.state.selection;
+  for (let d = $from.depth; d > 0; d -= 1) {
+    const node = $from.node(d);
+    if (node.type.spec.tableRole === "table") {
+      return { node, pos: $from.before(d) };
+    }
+  }
+  return null;
+}
+function tableHeaderActive(editor, axis) {
+  const table = findTable(editor);
+  if (!table) return false;
+  const map = TableMap.get(table.node);
+  const positions = map.cellsInRect({
+    left: 0,
+    top: 0,
+    right: axis === "row" ? map.width : 1,
+    bottom: axis === "column" ? map.height : 1
+  });
+  return positions.length > 0 && positions.every((pos) => {
+    var _a;
+    return ((_a = table.node.nodeAt(pos)) == null ? void 0 : _a.type.spec.tableRole) === "header_cell";
+  });
+}
+function distributeTableColumns(editor, availableWidth) {
+  const table = findTable(editor);
+  if (!editor.isEditable || !table || !Number.isFinite(availableWidth) || availableWidth <= 0) return false;
+  const map = TableMap.get(table.node);
+  const width = Math.max(TABLE_CELL_MIN_WIDTH, Math.min(2e3, Math.floor(availableWidth / map.width)));
+  const tr = editor.state.tr;
+  for (const relative of new Set(map.map)) {
+    const pos = table.pos + 1 + relative;
+    const cell = editor.state.doc.nodeAt(pos);
+    tr.setNodeMarkup(pos, void 0, {
+      ...cell.attrs,
+      colwidth: Array(Number(cell.attrs.colspan)).fill(width)
+    });
+  }
+  editor.view.dispatch(tr);
+  return true;
+}
+function setTableHeaderBackground(editor, backgroundColor) {
+  const table = findTable(editor);
+  const header = Object.values(editor.state.schema.nodes).find((type) => type.spec.tableRole === "header_cell");
+  if (!editor.isEditable || !table || !header || !(backgroundColor === null || CELL_BACKGROUNDS.some((color) => color.value === backgroundColor))) return false;
+  const map = TableMap.get(table.node);
+  const tr = editor.state.tr;
+  for (const relative of new Set(map.map.slice(0, map.width))) {
+    const pos = table.pos + 1 + relative;
+    const cell = editor.state.doc.nodeAt(pos);
+    tr.setNodeMarkup(pos, header, { ...cell.attrs, backgroundColor });
+  }
+  editor.view.dispatch(tr);
+  return true;
+}
+function currentCellRect(editor) {
+  try {
+    const rect = selectedRect(editor.state);
+    return { row: rect.top, col: rect.left };
+  } catch {
+    return null;
+  }
+}
+function setColumnWidth(editor, colIndex, px) {
+  const table = findTable(editor);
+  if (!table) return false;
+  const map = TableMap.get(table.node);
+  if (colIndex < 0 || colIndex >= map.width) return false;
+  const { state, view } = editor;
+  if (!editor.isEditable || !Number.isFinite(px) || px < 40 || px > 2e3) return false;
+  const tr = state.tr;
+  const seen = /* @__PURE__ */ new Set();
+  let touched = 0;
+  for (let row = 0; row < map.height; row += 1) {
+    const relative = map.map[row * map.width + colIndex];
+    if (seen.has(relative)) continue;
+    seen.add(relative);
+    const cellPos = table.pos + 1 + relative;
+    const cell = state.doc.nodeAt(cellPos);
+    if (!cell) continue;
+    const widths = [...cell.attrs.colwidth ?? Array(Number(cell.attrs.colspan ?? 1)).fill(0)];
+    widths[colIndex - map.findCell(relative).left] = px;
+    tr.setNodeMarkup(cellPos, void 0, { ...cell.attrs, colwidth: widths });
+    touched += 1;
+  }
+  if (touched > 0) view.dispatch(tr);
+  return touched > 0;
+}
+function autoFitColumn(editor, colIndex) {
+  var _a;
+  const table = findTable(editor);
+  if (!table) return false;
+  const map = TableMap.get(table.node);
+  if (colIndex < 0 || colIndex >= map.width) return false;
+  const { state, view } = editor;
+  if (!editor.isEditable) return false;
+  const tr = state.tr;
+  const seen = /* @__PURE__ */ new Set();
+  let touched = 0;
+  for (let row = 0; row < map.height; row += 1) {
+    const relative = map.map[row * map.width + colIndex];
+    if (seen.has(relative)) continue;
+    seen.add(relative);
+    const cellPos = table.pos + 1 + relative;
+    const cell = state.doc.nodeAt(cellPos);
+    if (!cell) continue;
+    if (((_a = cell.attrs) == null ? void 0 : _a.colwidth) == null) continue;
+    const widths = [...cell.attrs.colwidth];
+    widths[colIndex - map.findCell(relative).left] = 0;
+    tr.setNodeMarkup(cellPos, void 0, {
+      ...cell.attrs,
+      colwidth: widths.some((w) => w > 0) ? widths : null
+    });
+    touched += 1;
+  }
+  if (touched > 0) view.dispatch(tr);
+  return touched > 0;
+}
+function readTableGeometry(view, cellPos, pointer) {
+  var _a, _b;
+  try {
+    const $cell = view.state.doc.resolve(cellPos);
+    const node = $cell.node(-1);
+    if (node.type.spec.tableRole !== "table") return null;
+    const start = $cell.start(-1);
+    const map = TableMap.get(node);
+    const element = view.nodeDOM(cellPos);
+    if (!(element instanceof HTMLElement)) return null;
+    const table = element.closest("table");
+    const shell = view.dom.closest(".editor-shell");
+    if (!table || !shell) return null;
+    const hostRect = shell.getBoundingClientRect();
+    const tableRect = table.getBoundingClientRect();
+    const clip = (table.closest(".tableWrapper") ?? table).getBoundingClientRect();
+    const left = Math.max(tableRect.left, clip.left);
+    const right = Math.min(tableRect.right, clip.right);
+    if (right <= left) return null;
+    const rows = Array.from(table.rows).map((row, index) => {
+      const rect = row.getBoundingClientRect();
+      return {
+        index,
+        cellPos: start + map.map[index * map.width],
+        start: rect.top - hostRect.top,
+        size: rect.height
+      };
+    });
+    const cols = Array.from(table.querySelectorAll(":scope > colgroup > col"));
+    const columns = cols.map((col, index) => {
+      const rect = col.getBoundingClientRect();
+      return {
+        index,
+        cellPos: start + map.map[index],
+        start: rect.left - hostRect.left,
+        size: rect.width
+      };
+    });
+    if (rows.length !== map.height || columns.length !== map.width) return null;
+    const cellRect = map.findCell(cellPos - start);
+    const rowIndex = pointer ? ((_a = rows.find((row) => pointer.y >= row.start + hostRect.top && pointer.y < row.start + hostRect.top + row.size)) == null ? void 0 : _a.index) ?? cellRect.top : cellRect.top;
+    const colIndex = pointer ? ((_b = columns.find((col) => pointer.x >= col.start + hostRect.left && pointer.x < col.start + hostRect.left + col.size)) == null ? void 0 : _b.index) ?? cellRect.left : cellRect.left;
+    return {
+      cellPos,
+      rowIndex,
+      colIndex,
+      rowTop: rows[rowIndex].start,
+      rowHeight: rows[rowIndex].size,
+      colLeft: columns[colIndex].start,
+      colWidth: columns[colIndex].size,
+      tableWidth: right - left,
+      tableHeight: tableRect.height,
+      tableTop: tableRect.top - hostRect.top,
+      tableLeft: left - hostRect.left,
+      contentLeft: view.dom.getBoundingClientRect().left - hostRect.left,
+      rows,
+      columns
+    };
+  } catch {
+    return null;
+  }
+}
+function clippedTableSelection(rects, clip) {
+  if (!rects.length) return null;
+  const left = Math.max(clip.left, Math.min(...rects.map((rect) => rect.left)));
+  const right = Math.min(clip.right, Math.max(...rects.map((rect) => rect.right)));
+  const top = Math.min(...rects.map((rect) => rect.top));
+  const bottom = Math.max(...rects.map((rect) => rect.bottom));
+  return right > left && bottom > top ? { left, right, top, bottom } : null;
+}
+const TableInteractionKey = new PluginKey("ywiki-table-interaction");
+const TableInteraction = Extension.create({
+  name: "ywikiTableInteraction",
+  addOptions() {
+    return { onHover: () => void 0 };
+  },
+  addProseMirrorPlugins() {
+    const options = this.options;
+    return [new Plugin({
+      key: TableInteractionKey,
+      view: (view) => {
+        const shell = view.dom.closest(".editor-shell") ?? view.dom;
+        let cell = null;
+        let pointer;
+        let lastKey = "";
+        let frame = 0;
+        const clear = () => {
+          cell = null;
+          pointer = void 0;
+          if (lastKey) options.onHover(null);
+          lastKey = "";
+        };
+        const report = () => {
+          if (!(cell == null ? void 0 : cell.isConnected) || !view.editable) {
+            clear();
+            return;
+          }
+          const pos = cellPositionAtDOM(view, cell);
+          const geometry = pos === null ? null : readTableGeometry(view, pos, pointer);
+          if (!geometry) {
+            clear();
+            return;
+          }
+          const key2 = JSON.stringify(geometry);
+          if (key2 !== lastKey) {
+            lastKey = key2;
+            options.onHover(geometry);
+          }
+        };
+        const schedule = () => {
+          if (!frame) frame = requestAnimationFrame(() => {
+            frame = 0;
+            report();
+          });
+        };
+        const move = (event) => {
+          var _a;
+          const mouse = event;
+          const target = mouse.target instanceof Element ? mouse.target : null;
+          if (target == null ? void 0 : target.closest(".tbl-ui-host")) return;
+          const next = target == null ? void 0 : target.closest("td,th");
+          if (next && view.dom.contains(next)) {
+            cell = next;
+            pointer = { x: mouse.clientX, y: mouse.clientY };
+            schedule();
+            return;
+          }
+          const rect = (_a = cell == null ? void 0 : cell.closest("table")) == null ? void 0 : _a.getBoundingClientRect();
+          if (rect && mouse.clientX >= rect.left - 64 && mouse.clientX <= rect.right + 24 && mouse.clientY >= rect.top - 32 && mouse.clientY <= rect.bottom + 24) return;
+          clear();
+        };
+        shell.addEventListener("mousemove", move);
+        shell.addEventListener("mouseleave", clear);
+        window.addEventListener("scroll", schedule, true);
+        window.addEventListener("resize", schedule);
+        const observer = new ResizeObserver(schedule);
+        observer.observe(view.dom);
+        return {
+          update: schedule,
+          destroy: () => {
+            cancelAnimationFrame(frame);
+            observer.disconnect();
+            shell.removeEventListener("mousemove", move);
+            shell.removeEventListener("mouseleave", clear);
+            window.removeEventListener("scroll", schedule, true);
+            window.removeEventListener("resize", schedule);
+          }
+        };
+      }
+    })];
+  }
+});
+const COLLAB_FIELD = "default";
+function coreExtensions(options = {}) {
+  const list = [
+    StarterKit.configure({ heading: { levels: [1, 2, 3, 4, 5, 6] }, undoRedo: options.collabDoc ? false : {}, link: false, codeBlock: false, trailingNode: false, dropcursor: false }),
+    YwikiCodeBlock.configure({ canCopy: () => {
+      var _a;
+      return ((_a = options.canCopyCode) == null ? void 0 : _a.call(options)) ?? false;
+    }, contentContext: options.contentContext }),
+    CodeHighlight,
+    Link.configure({ openOnClick: false, protocols: ["http", "https", "mailto"], HTMLAttributes: { rel: "noopener noreferrer nofollow" } }),
+    YwikiImage.configure({ inline: false, allowBase64: false }).extend({ addNodeView: () => createImageNodeView(options.attachmentFetcher, options.attachmentScope) }),
+    FileAttachment.extend({ addNodeView: () => createFileAttachmentNodeView(options.attachmentFetcher, options.attachmentScope) }),
+    ImageGallery,
+    Table.configure({ resizable: true, cellMinWidth: 120, allowTableNodeSelection: true }),
+    TableRow,
+    AlignedTableCell,
+    AlignedTableHeader,
+    TaskList,
+    TaskItem.configure({ nested: true }),
+    Columns,
+    Column,
+    PageLink,
+    Mention,
+    MathInline.extend({ addNodeView: () => mathNodeView }),
+    MathBlock.extend({ addNodeView: () => mathNodeView }),
+    VideoEmbed.configure({ renderer: options.videoRenderer }),
+    MindMap.configure({ renderer: options.mindMapRenderer }),
+    Callout.configure({ renderer: createCalloutNodeView() }),
+    MindMapTopic,
+    MindMapDescription,
+    MindMapNote,
+    MindMapRelation,
+    TextStyle,
+    Highlight,
+    BlockFormat,
+    BlockSelection,
+    BlockMenuHighlight,
+    ImeGuard,
+    PasteSanitizer
+  ];
+  if (options.placeholder) list.push(Placeholder.configure({ placeholder: options.placeholder }));
+  if (options.inlineComments) list.push(InlineCommentHighlight.configure(options.inlineComments));
+  if (options.slash) list.push(SlashCommand.configure(options.slash));
+  if (options.blockHandle) list.push(BlockHandle.configure(options.blockHandle));
+  if (options.tableInteraction) list.push(TableInteraction.configure(options.tableInteraction));
+  if (options.uploadPlaceholder) list.push(UploadPlaceholderExtension.configure(options.uploadPlaceholder));
+  if (options.collabDoc) list.push(Collaboration.configure({ document: options.collabDoc, field: options.collabField ?? COLLAB_FIELD }));
+  if (options.collabDoc && options.collabAwareness) list.push(CollabCursor.configure({ awareness: options.collabAwareness }));
+  return list;
+}
+export {
+  coreExtensions as A,
+  BlockRangeSelection as B,
+  COLLAB_FIELD as C,
+  refreshInlineComments as D,
+  addUploadPlaceholder as E,
+  currentPlaceholderPos as F,
+  insertUploadedBlock as G,
+  removeUploadPlaceholder as H,
+  replacePlaceholderWithNode as I,
+  TEXT_ALIGNS as T,
+  tablePositionAtCell as a,
+  buildColumnsJson as b,
+  currentTableCellPosition as c,
+  dismissSlash as d,
+  CELL_ALIGNS as e,
+  cellPositionAtDOM as f,
+  selectTableCell as g,
+  highlightMenuBlock as h,
+  insertTableBoundary as i,
+  clippedTableSelection as j,
+  tableSelectionMarkActive as k,
+  setTableSelectionMark as l,
+  setTableHeaderBackground as m,
+  currentCellRect as n,
+  setColumnWidth as o,
+  autoFitColumn as p,
+  distributeTableColumns as q,
+  readTableGeometry as r,
+  selectTableAxis as s,
+  tableHeaderActive as t,
+  unwrapCallout as u,
+  getSelectedBlocks as v,
+  setBlockRangeSelection as w,
+  setImageRangeSelection as x,
+  pastedImageFiles as y,
+  pastedRemoteImageUrls as z
+};