wysimark-lite 0.25.4 → 0.25.5

package/dist/index.mjs

@@ -13,7 +13,7 @@ import { createRoot } from "react-dom/client";
 // src/entry/index.tsx
 import throttle3 from "lodash.throttle";
 import { useCallback as useCallback18, useRef as useRef14, useState as useState13 } from "react";
-import { Editor as Editor66, Transforms as Transforms48 } from "slate";
+import { Editor as Editor67, Transforms as Transforms49 } from "slate";
 import { ReactEditor as ReactEditor18, Slate as Slate2 } from "slate-react";
 
 // src/convert/parse/index.ts
@@ -137,12 +137,8 @@ function escapeUrlSlashes(text) {
     return `__MARKDOWN_LINK_${linkIndex++}__`;
   });
   const htmlBlocks = [];
-  let htmlIndex = 0;
-  const htmlBlockPattern = /<[a-zA-Z][^>]*>[\s\S]*?<\/[a-zA-Z]+>|<[a-zA-Z][^>]*\/?>|<\/[a-zA-Z]+>/g;
-  result = result.replace(htmlBlockPattern, (match) => {
-    htmlBlocks.push(match);
-    return `__HTML_BLOCK_${htmlIndex++}__`;
-  });
+  const masked = maskHtmlBlocks(result, htmlBlocks);
+  result = masked;
   const urlPattern = /(https?:\/\/[^\s]+)/g;
   result = result.replace(urlPattern, (url) => {
     return url.replace(/\//g, "\\/");
@@ -156,10 +152,179 @@ function escapeUrlSlashes(text) {
   return result;
 }
 function unescapeUrlSlashes(text) {
-  return text.replace(/\\(.)/g, (match, char) => {
+  return text.replace(/\\(.)/g, (_match, char) => {
     return char;
   });
 }
+var RAW_TEXT_TAGS = /* @__PURE__ */ new Set(["script", "style"]);
+function maskHtmlBlocks(text, htmlBlocks) {
+  let output = "";
+  let index = 0;
+  while (index < text.length) {
+    const ltIndex = text.indexOf("<", index);
+    if (ltIndex === -1) {
+      output += text.slice(index);
+      break;
+    }
+    output += text.slice(index, ltIndex);
+    if (text.startsWith("<!--", ltIndex)) {
+      const end = text.indexOf("-->", ltIndex + 4);
+      if (end === -1) {
+        output += text.slice(ltIndex);
+        break;
+      }
+      const block2 = text.slice(ltIndex, end + 3);
+      htmlBlocks.push(block2);
+      output += `__HTML_BLOCK_${htmlBlocks.length - 1}__`;
+      index = end + 3;
+      continue;
+    }
+    if (text.startsWith("<![CDATA[", ltIndex)) {
+      const end = text.indexOf("]]>", ltIndex + 9);
+      if (end === -1) {
+        output += text.slice(ltIndex);
+        break;
+      }
+      const block2 = text.slice(ltIndex, end + 3);
+      htmlBlocks.push(block2);
+      output += `__HTML_BLOCK_${htmlBlocks.length - 1}__`;
+      index = end + 3;
+      continue;
+    }
+    const tag = parseTag(text, ltIndex);
+    if (!tag) {
+      output += "<";
+      index = ltIndex + 1;
+      continue;
+    }
+    const blockIndex = htmlBlocks.length;
+    const placeholder = `__HTML_BLOCK_${blockIndex}__`;
+    if (!tag.name) {
+      const block2 = text.slice(ltIndex, tag.endIndex + 1);
+      htmlBlocks.push(block2);
+      output += placeholder;
+      index = tag.endIndex + 1;
+      continue;
+    }
+    const tagName = tag.name.toLowerCase();
+    if (tag.isClosing || tag.isSelfClosing) {
+      const block2 = text.slice(ltIndex, tag.endIndex + 1);
+      htmlBlocks.push(block2);
+      output += placeholder;
+      index = tag.endIndex + 1;
+      continue;
+    }
+    if (RAW_TEXT_TAGS.has(tagName)) {
+      const closeStart = text.toLowerCase().indexOf(`</${tagName}`, tag.endIndex + 1);
+      if (closeStart !== -1) {
+        const closeTag = parseTag(text, closeStart);
+        if (closeTag) {
+          const block2 = text.slice(ltIndex, closeTag.endIndex + 1);
+          htmlBlocks.push(block2);
+          output += placeholder;
+          index = closeTag.endIndex + 1;
+          continue;
+        }
+      }
+    }
+    const closingTagEnd = findClosingTagEnd(text, tagName, tag.endIndex + 1);
+    if (closingTagEnd !== null) {
+      const block2 = text.slice(ltIndex, closingTagEnd + 1);
+      htmlBlocks.push(block2);
+      output += placeholder;
+      index = closingTagEnd + 1;
+      continue;
+    }
+    const block = text.slice(ltIndex, tag.endIndex + 1);
+    htmlBlocks.push(block);
+    output += placeholder;
+    index = tag.endIndex + 1;
+  }
+  return output;
+}
+function parseTag(text, startIndex) {
+  if (text[startIndex] !== "<")
+    return null;
+  const endIndex = findTagEnd(text, startIndex);
+  if (endIndex === -1)
+    return null;
+  let cursor = startIndex + 1;
+  if (cursor >= text.length)
+    return null;
+  const firstChar = text[cursor];
+  if (firstChar === "!" || firstChar === "?") {
+    return {
+      name: null,
+      endIndex,
+      isClosing: false,
+      isSelfClosing: true
+    };
+  }
+  let isClosing = false;
+  if (firstChar === "/") {
+    isClosing = true;
+    cursor += 1;
+  }
+  const nameMatch = /^[A-Za-z][A-Za-z0-9-]*/.exec(text.slice(cursor));
+  if (!nameMatch)
+    return null;
+  const name = nameMatch[0];
+  const tagText = text.slice(startIndex, endIndex + 1);
+  const isSelfClosing = /\/\s*>$/.test(tagText);
+  return {
+    name,
+    endIndex,
+    isClosing,
+    isSelfClosing
+  };
+}
+function findTagEnd(text, startIndex) {
+  let quote = null;
+  for (let i = startIndex + 1; i < text.length; i++) {
+    const char = text[i];
+    if (quote) {
+      if (char === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      continue;
+    }
+    if (char === ">") {
+      return i;
+    }
+  }
+  return -1;
+}
+function findClosingTagEnd(text, tagName, startIndex) {
+  let depth = 1;
+  let cursor = startIndex;
+  const lowerTag = tagName.toLowerCase();
+  while (cursor < text.length) {
+    const ltIndex = text.indexOf("<", cursor);
+    if (ltIndex === -1)
+      return null;
+    const tag = parseTag(text, ltIndex);
+    if (!tag || !tag.name) {
+      cursor = ltIndex + 1;
+      continue;
+    }
+    if (tag.name.toLowerCase() === lowerTag) {
+      if (tag.isClosing) {
+        depth -= 1;
+      } else if (!tag.isSelfClosing) {
+        depth += 1;
+      }
+      if (depth === 0) {
+        return tag.endIndex;
+      }
+    }
+    cursor = tag.endIndex + 1;
+  }
+  return null;
+}
 function assert(pass, message) {
   if (!pass)
     throw new Error(`${message}`);
@@ -348,71 +513,36 @@ function sortMarks(marks) {
 }
 
 // src/convert/serialize/serialize-line/utils/text-utils.ts
-var ESCAPES = [
+var INLINE_ESCAPES = [
   "\\",
-  // escape
+  // escape character
   "`",
-  // code
+  // inline code
   "*",
-  // bold/italic/hr
+  // emphasis/bold
   "_",
-  // bold/italic/hr
+  // emphasis/bold
   "[",
-  // link/list
+  // link start
   "]",
-  // link/list
-  "(",
-  // link
-  ")",
-  // link
-  "#",
-  // headings
-  "+",
-  // list
-  "-",
-  // hr/list
-  ".",
-  // numbered list
-  "!",
-  // image
-  "|",
-  // table
-  "^",
-  // sup
+  // link end
   "~",
-  // sub/strikethrough
-  "<",
-  // link/html
-  ">",
-  // link/html
-  /**
-   * Includes all the characters in the list of Backslash escapes in the example
-   * for GitHub Flavored Markdown.
-   *
-   * https://github.github.com/gfm/#backslash-escapes
-   */
-  "{",
-  "}",
-  "=",
-  ":",
-  ";",
-  "$",
-  "%",
-  "&",
-  "?",
-  '"',
-  "'",
-  ",",
-  "\\",
-  "/",
-  "@"
+  // strikethrough (GFM)
+  "|",
+  // table cell (GFM)
+  "<"
+  // HTML tag
 ];
-var ESCAPES_REGEXP = new RegExp(
-  `(${ESCAPES.map((symbol) => `\\${symbol}`).join("|")})`,
+var INLINE_ESCAPES_REGEXP = new RegExp(
+  `(${INLINE_ESCAPES.map((symbol) => `\\${symbol}`).join("|")})`,
   "g"
 );
 function escapeText(s) {
-  return s.replace(ESCAPES_REGEXP, (s2) => `\\${s2}`);
+  let result = s.replace(INLINE_ESCAPES_REGEXP, (s2) => `\\${s2}`);
+  result = result.replace(/^(#{1,6})(\s)/m, "\\$1$2");
+  result = result.replace(/^(\d+)([.)]\s)/m, "$1\\$2");
+  result = result.replace(/^([-+>])\s/m, "\\$1 ");
+  return result;
 }
 
 // src/convert/parse/parse-phrasing-content/normalize-segment.ts
@@ -465,7 +595,7 @@ function parseGenericImage(image) {
 }
 
 // src/convert/parseUrl.ts
-var URL_REGEX = /^(\/[^?#]*)(?:\?([^#]*))?(#.*)?$/;
+var URL_REGEX = /^([^?#]*)(?:\?([^#]*))?(#.*)?$/;
 function parseUrl(url) {
   try {
     const urlData = new URL(url);
@@ -499,8 +629,8 @@ function parseSize(s) {
   if (sizeMatch === null)
     return null;
   return {
-    width: parseInt(sizeMatch[1]),
-    height: parseInt(sizeMatch[2])
+    width: parseInt(sizeMatch[1], 10),
+    height: parseInt(sizeMatch[2], 10)
   };
 }
 
@@ -524,8 +654,8 @@ function parsePortiveImage(image) {
     alt: image.alt || void 0,
     width: size.width,
     height: size.height,
-    srcWidth: parseInt(srcSizeMatch[1]),
-    srcHeight: parseInt(srcSizeMatch[2])
+    srcWidth: parseInt(srcSizeMatch[1], 10),
+    srcHeight: parseInt(srcSizeMatch[2], 10)
   };
 }
 
@@ -1059,7 +1189,7 @@ function mergeAdjacentSpaces({
 }) {
   if (!isText(node) || !isPlainSpace(node) || node.code)
     return false;
-  if (!isText(nextNode) || !isPlainSpace(nextNode) || node.code)
+  if (!isText(nextNode) || !isPlainSpace(nextNode) || nextNode.code)
     return false;
   nodes.splice(index, 2, { text: `${node.text}${nextNode.text}` });
   return true;
@@ -1455,7 +1585,7 @@ function serializeTableCell(element) {
       element.children
     )}`
   );
-  return element.children.map(serializeTableContent).join();
+  return element.children.map(serializeTableContent).join("");
 }
 function serializeTableContent(element) {
   assertElementType(element, "table-content");
@@ -1470,7 +1600,7 @@ function serializeElement(element, orders) {
       return `[${serializeLine(element.children)}](${element.href})`;
     case "block-quote": {
       const lines = serializeElements(element.children);
-      return `${lines.split("\n").map((line) => `> ${line}`.trim()).join("\n")}
+      return `${lines.split("\n").map((line) => line ? `> ${line}` : ">").join("\n")}
 
 `;
     }
@@ -1517,6 +1647,8 @@ function serializeElement(element, orders) {
     }
     case "image-block":
       return serializeImageBlock(element);
+    case "image-inline":
+      return `![${element.alt || ""}](${element.url})`;
     case "code-block":
       return serializeCodeBlock(element);
     case "code-block-line":
@@ -1555,17 +1687,7 @@ function serializeElements(elements) {
   const joined = segments.join("");
   if (joined.trim() === "")
     return "";
-  return replaceConsecutiveNewlines(replaceLeadingNewlines(joined)).trim();
-}
-function replaceLeadingNewlines(input) {
-  return input.replace(/^\n\n/g, "\\\n\n");
-}
-function replaceConsecutiveNewlines(input) {
-  return input.replace(/(\n{4,})/g, (match) => {
-    const newlineCount = match.length;
-    const count = Math.floor((newlineCount - 2) / 2);
-    return "\n\n" + Array(count).fill("\\").join("\n\n") + "\n\n";
-  });
+  return joined.replace(/^\n+/, "").trim();
 }
 
 // src/convert/serialize/index.ts
@@ -1618,6 +1740,7 @@ var translations = {
     switchToRawMarkdown: "\u30DE\u30FC\u30AF\u30C0\u30A6\u30F3\u8868\u793A\u306B\u5207\u308A\u66FF\u3048",
     codeBlock: "\u30B3\u30FC\u30C9\u30D6\u30ED\u30C3\u30AF",
     increaseQuoteDepth: "\u5F15\u7528\u3092\u91CD\u306D\u308B",
+    horizontalRule: "\u533A\u5207\u308A\u7DDA",
     register: "\u767B\u9332",
     imageSourceUrl: "URL",
     imageSourceFile: "\u30D5\u30A1\u30A4\u30EB",
@@ -1670,6 +1793,7 @@ var translations = {
     switchToRawMarkdown: "Switch to raw markdown",
     codeBlock: "Code Block",
     increaseQuoteDepth: "Increase Quote Depth",
+    horizontalRule: "Horizontal Rule",
     register: "Register",
     imageSourceUrl: "URL",
     imageSourceFile: "File",
@@ -1875,7 +1999,7 @@ function SinkEditable(originalProps) {
   const editor = useSlateStatic();
   useEffect(() => {
     Editor.normalize(editor, { force: true });
-  }, []);
+  }, [editor]);
   const { plugins: plugins2 } = editor.sink;
   const nextProps = useMemo(
     () => ({
@@ -1898,7 +2022,19 @@ function SinkEditable(originalProps) {
       onPaste: createOnPaste(originalProps.onPaste, plugins2),
       onDrop: createOnDrop(originalProps.onDrop, plugins2)
     }),
-    Object.values(originalProps)
+    [
+      originalProps.decorate,
+      originalProps.renderElement,
+      originalProps.renderLeaf,
+      originalProps.renderPlaceholder,
+      originalProps.onKeyDown,
+      originalProps.onKeyUp,
+      originalProps.onPaste,
+      originalProps.onDrop,
+      originalProps.placeholder,
+      originalProps.className,
+      plugins2
+    ]
   );
   const NextEditable = useMemo(() => createEditable(plugins2), [plugins2]);
   return /* @__PURE__ */ jsx2(NextEditable, { ...nextProps });
@@ -2357,7 +2493,7 @@ function editLink(editor, { href, title, text }, { at }) {
 }
 
 // src/anchor-plugin/methods/insertLink.ts
-import { Editor as Editor15, Range as Range3, Text as Text2, Transforms as Transforms8 } from "slate";
+import { Editor as Editor15, Element as Element9, Range as Range3, Text as Text2, Transforms as Transforms8 } from "slate";
 function insertLink(editor, href, text = href, { select = true, title } = {}) {
   const selection = editor.selection || {
     anchor: Editor15.start(editor, [0]),
@@ -2384,7 +2520,7 @@ function insertLink(editor, href, text = href, { select = true, title } = {}) {
       { type: "anchor", href, title, children: [] },
       {
         split: true,
-        match: (node) => Text2.isText(node) || Editor15.isInline(editor, node)
+        match: (node) => Text2.isText(node) || Element9.isElement(node) && Editor15.isInline(editor, node)
       }
     );
   }
@@ -2410,16 +2546,16 @@ function createAnchorMethods(editor) {
 }
 
 // src/anchor-plugin/normalize-node/index.ts
-import { Element as Element9, Transforms as Transforms10 } from "slate";
+import { Element as Element10, Transforms as Transforms10 } from "slate";
 function normalizeNode(editor, entry) {
-  if (!Element9.isElement(entry[0]))
+  if (!Element10.isElement(entry[0]))
     return false;
   if (entry[0].type !== "anchor")
     return false;
   const children = entry[0].children;
   for (let i = 0; i < children.length; i++) {
     const child = children[i];
-    if (!Element9.isElement(child) || child.type !== "anchor")
+    if (!Element10.isElement(child) || child.type !== "anchor")
       continue;
     Transforms10.unwrapNodes(editor, { at: [...entry[1], i] });
     return true;
@@ -2718,15 +2854,18 @@ import { useEffect as useEffect2 } from "react";
 
 // src/use-reposition/hooks/use-throttled-refresh.ts
 import throttle from "lodash.throttle";
-import { useState as useState2 } from "react";
+import { useMemo as useMemo2, useState as useState2 } from "react";
 function useThrottledRefresh(intervalInMs = 100) {
   const [counter, setState] = useState2(0);
-  const refresh = throttle(
-    () => {
-      setState((counter2) => counter2 + 1);
-    },
-    intervalInMs,
-    { trailing: true }
+  const refresh = useMemo2(
+    () => throttle(
+      () => {
+        setState((counter2) => counter2 + 1);
+      },
+      intervalInMs,
+      { trailing: true }
+    ),
+    [intervalInMs]
   );
   return Object.assign(refresh, { counter });
 }
@@ -3094,6 +3233,8 @@ function Menu({
   const editor = useSlateStatic2();
   const ref = useRef2(null);
   const style = useAbsoluteReposition({ src: ref, dest }, ({ dest: dest2 }) => {
+    if (!dest2)
+      return { left: 0, top: 0 };
     return { left: dest2.left - 8, top: dest2.top + dest2.height };
   });
   return /* @__PURE__ */ jsxs3(Fragment2, { children: [
@@ -3778,7 +3919,7 @@ var AnchorPlugin = createPlugin(
 import { Editor as Editor19, Transforms as Transforms11 } from "slate";
 
 // src/atomic-delete-plugin/is-safe-delete.ts
-import { Element as Element10, Path as Path6 } from "slate";
+import { Element as Element11, Path as Path6 } from "slate";
 function isSafeDelete(editor, a, b) {
   if (!a || !b)
     return true;
@@ -3786,13 +3927,13 @@ function isSafeDelete(editor, a, b) {
     return true;
   const masterEntryA = findElementUp(
     editor,
-    (el) => Element10.isElement(el) && editor.isMaster(el),
+    (el) => Element11.isElement(el) && editor.isMaster(el),
     { at: a[1] }
   );
   const masterEntryB = findElementUp(
     editor,
     (el) => {
-      return Element10.isElement(el) && editor.isMaster(el);
+      return Element11.isElement(el) && editor.isMaster(el);
     },
     { at: b[1] }
   );
@@ -4149,7 +4290,7 @@ function resizeInBounds(size, bounds) {
   }
   return size;
 }
-function resizeInPreset(size, srcSize, preset) {
+function resizeInPreset(_size, srcSize, preset) {
   switch (preset.type) {
     case "bounds":
       return resizeInBounds(srcSize, preset);
@@ -4163,7 +4304,7 @@ function resizeInPreset(size, srcSize, preset) {
 function getEditorWidth(editor) {
   const element = ReactEditor4.toDOMNode(editor, editor);
   const computed = getComputedStyle(element);
-  const padding = parseInt(computed.paddingLeft) + parseInt(computed.paddingRight);
+  const padding = parseInt(computed.paddingLeft, 10) + parseInt(computed.paddingRight, 10);
   return element.clientWidth - padding;
 }
 
@@ -4567,7 +4708,7 @@ import { useCallback as useCallback9 } from "react";
 import { useSlateStatic as useSlateStatic8 } from "slate-react";
 
 // src/image-plugin/render-element/image-with-controls/image-toolbar/image-type-buttons/convert-to-block-image.tsx
-import { Editor as Editor23, Text as Text3, Transforms as Transforms16 } from "slate";
+import { Editor as Editor23, Element as Element12, Text as Text3, Transforms as Transforms16 } from "slate";
 import { ReactEditor as ReactEditor8 } from "slate-react";
 function convertToBlockImage(editor, element) {
   if (!element.width || !element.height || !element.srcWidth || !element.srcHeight)
@@ -4590,7 +4731,7 @@ function convertToBlockImage(editor, element) {
     );
     const parentEntry = findElementUp(
       editor,
-      (node) => Editor23.isBlock(editor, node) && node.type !== "image-block"
+      (node) => Element12.isElement(node) && Editor23.isBlock(editor, node) && node.type !== "image-block"
     );
     if (!parentEntry)
       throw new Error("This shouldn't happen");
@@ -4918,7 +5059,7 @@ var ImagePlugin = (
 );
 
 // src/block-quote-plugin/index.tsx
-import { Editor as Editor25, Element as Element11, Transforms as Transforms18 } from "slate";
+import { Editor as Editor25, Element as Element13, Transforms as Transforms18 } from "slate";
 
 // src/block-quote-plugin/styles.tsx
 import styled23 from "@emotion/styled";
@@ -4934,7 +5075,7 @@ var $BlockQuote = styled23("blockquote")`
 // src/block-quote-plugin/index.tsx
 import { jsx as jsx29 } from "react/jsx-runtime";
 function matchBlockQuoteSafe(node) {
-  return Element11.isElement(node) && /**
+  return Element13.isElement(node) && /**
    * TODO:
    *
    * This is probably:
@@ -4962,13 +5103,13 @@ var BlockQuotePlugin = createPlugin(
       },
       isActive: () => {
         const [match] = Editor25.nodes(editor, {
-          match: (n) => Element11.isElement(n) && n.type === "block-quote"
+          match: (n) => Element13.isElement(n) && n.type === "block-quote"
         });
         return !!match;
       },
       increaseDepth: () => {
         const [match] = Editor25.nodes(editor, {
-          match: (n) => Element11.isElement(n) && n.type === "block-quote"
+          match: (n) => Element13.isElement(n) && n.type === "block-quote"
         });
         if (!match)
           return;
@@ -4984,7 +5125,7 @@ var BlockQuotePlugin = createPlugin(
       },
       decreaseDepth: () => {
         const [match] = Editor25.nodes(editor, {
-          match: (n) => Element11.isElement(n) && n.type === "block-quote"
+          match: (n) => Element13.isElement(n) && n.type === "block-quote"
         });
         if (!match)
           return;
@@ -4992,24 +5133,24 @@ var BlockQuotePlugin = createPlugin(
           return;
         const [node, path] = match;
         const children = node.children;
-        if (children.length === 1 && Element11.isElement(children[0]) && children[0].type === "block-quote") {
+        if (children.length === 1 && Element13.isElement(children[0]) && children[0].type === "block-quote") {
           Transforms18.unwrapNodes(editor, {
             at: [...path, 0],
             // Path to the nested block-quote
-            match: (n) => Element11.isElement(n) && n.type === "block-quote"
+            match: (n) => Element13.isElement(n) && n.type === "block-quote"
           });
         }
       },
       canIncreaseDepth: () => {
         const [match] = Editor25.nodes(editor, {
-          match: (n) => Element11.isElement(n) && n.type === "block-quote"
+          match: (n) => Element13.isElement(n) && n.type === "block-quote"
         });
         if (!match)
           return false;
         const [node] = match;
         let depth = 0;
         let current = node;
-        while (current.children.length === 1 && Element11.isElement(current.children[0]) && current.children[0] && current.children[0] && current.children[0].type === "block-quote") {
+        while (current.children.length === 1 && Element13.isElement(current.children[0]) && current.children[0] && current.children[0] && current.children[0].type === "block-quote") {
           depth++;
           current = current.children[0];
         }
@@ -5017,12 +5158,12 @@ var BlockQuotePlugin = createPlugin(
       },
       canDecreaseDepth: () => {
         const [match] = Editor25.nodes(editor, {
-          match: (n) => Element11.isElement(n) && n.type === "block-quote"
+          match: (n) => Element13.isElement(n) && n.type === "block-quote"
         });
         if (!match)
           return false;
         const [node] = match;
-        return node.children.length === 1 && Element11.isElement(node.children[0]) && node.children[0] && node.children[0].type === "block-quote";
+        return node.children.length === 1 && Element13.isElement(node.children[0]) && node.children[0] && node.children[0].type === "block-quote";
       }
     };
     return {
@@ -5030,12 +5171,12 @@ var BlockQuotePlugin = createPlugin(
       editor: {
         normalizeNode(entry) {
           const [node, path] = entry;
-          if (!Element11.isElement(node))
+          if (!Element13.isElement(node))
             return false;
           if (node.type !== "block-quote")
             return false;
           return normalizeSiblings(editor, [node, path], (a, b) => {
-            if (Element11.isElement(a[0]) && Element11.isElement(b[0]) && a[0].type === "block-quote" && b[0].type === "block-quote") {
+            if (Element13.isElement(a[0]) && Element13.isElement(b[0]) && a[0].type === "block-quote" && b[0].type === "block-quote") {
               Transforms18.mergeNodes(editor, { at: b[1] });
             }
             return true;
@@ -5058,11 +5199,11 @@ var BlockQuotePlugin = createPlugin(
 );
 
 // src/code-block-plugin/index.tsx
-import { Editor as Editor28, Element as Element15, Transforms as Transforms21 } from "slate";
+import { Editor as Editor28, Element as Element17, Transforms as Transforms21 } from "slate";
 
 // src/code-block-plugin/decorate.tsx
 import Prism from "prismjs";
-import { Element as Element12, Node as Node8 } from "slate";
+import { Element as Element14, Node as Node8 } from "slate";
 var { languages, tokenize } = Prism;
 function getLineOffsets(lines) {
   let offset = 0;
@@ -5075,7 +5216,7 @@ function getLineOffsets(lines) {
 }
 function decorate(nodeEntry) {
   const [node, path] = nodeEntry;
-  if (!Element12.isElement(node))
+  if (!Element14.isElement(node))
     return [];
   if (node.type !== "code-block")
     return [];
@@ -5129,11 +5270,11 @@ function createCodeBlock(editor, { language }) {
 }
 
 // src/code-block-plugin/methods/setCodeBlockLanguage.ts
-import { Element as Element13, Transforms as Transforms19 } from "slate";
+import { Element as Element15, Transforms as Transforms19 } from "slate";
 function setCodeBlockLanguage(editor, language, options = {}) {
   const entry = findElementUp(
     editor,
-    (el) => Element13.isElement(el) && el.type === "code-block",
+    (el) => Element15.isElement(el) && el.type === "code-block",
     { at: options.at }
   );
   if (!entry)
@@ -5205,13 +5346,13 @@ var LanguageList = [
 ];
 
 // src/code-block-plugin/normalizeNode.tsx
-import { Element as Element14, Node as Node9, Transforms as Transforms20 } from "slate";
+import { Element as Element16, Node as Node9, Transforms as Transforms20 } from "slate";
 function normalizeNode3(editor, entry) {
-  if (!Element14.isElement(entry[0]))
+  if (!Element16.isElement(entry[0]))
     return false;
   if (entry[0].type === "code-block-line") {
     for (const [child, path] of Node9.children(editor, entry[1])) {
-      if (!Element14.isElement(child))
+      if (!Element16.isElement(child))
         continue;
       if (editor.isVoid(child)) {
         Transforms20.removeNodes(editor, { at: path });
@@ -5224,7 +5365,7 @@ function normalizeNode3(editor, entry) {
   }
   if (entry[0].type === "code-block") {
     for (const [child, path] of Node9.children(editor, entry[1])) {
-      if (!Element14.isElement(child))
+      if (!Element16.isElement(child))
         continue;
       if (child.type === "code-block-line")
         continue;
@@ -5404,7 +5545,7 @@ function renderElement2({
 }
 
 // src/code-block-plugin/index.tsx
-import { jsx as jsx34 } from "react/jsx-runtime";
+import { Fragment as Fragment4, jsx as jsx34 } from "react/jsx-runtime";
 var CodeBlockPlugin = createPlugin(
   (editor, _options, { createPolicy }) => {
     editor.codeBlock = createCodeBlockMethods(editor);
@@ -5432,7 +5573,7 @@ var CodeBlockPlugin = createPlugin(
             return false;
         },
         isVoid(element) {
-          if (element.type === "code-block" || element.type == "code-block-line")
+          if (element.type === "code-block" || element.type === "code-block-line")
             return false;
         },
         isMaster(element) {
@@ -5448,7 +5589,7 @@ var CodeBlockPlugin = createPlugin(
           "mod+a": () => {
             const entry = findElementUp(
               editor,
-              (el) => Element15.isElement(el) && el.type === "code-block"
+              (el) => Element17.isElement(el) && el.type === "code-block"
             );
             if (!entry)
               return false;
@@ -5460,7 +5601,7 @@ var CodeBlockPlugin = createPlugin(
         renderLeaf: ({ leaf, children }) => {
           const style = leaf.prismToken ? tokenStyles[leaf.prismToken] || null : null;
           if (style === null) {
-            return children;
+            return /* @__PURE__ */ jsx34(Fragment4, { children });
           } else {
             return /* @__PURE__ */ jsx34("span", { style, children });
           }
@@ -5565,12 +5706,12 @@ var HtmlBlockPlugin = createPlugin(
 import { Editor as Editor32 } from "slate";
 
 // src/collapsible-paragraph-plugin/normalize-node/index.ts
-import { Element as Element18 } from "slate";
+import { Element as Element20 } from "slate";
 
 // src/collapsible-paragraph-plugin/normalize-node/normalize-sibling-paragraphs.ts
-import { Element as Element16, Transforms as Transforms23 } from "slate";
+import { Element as Element18, Transforms as Transforms23 } from "slate";
 function isParagraph(node) {
-  return Element16.isElement(node) && node.type === "paragraph";
+  return Element18.isElement(node) && node.type === "paragraph";
 }
 function normalizeSiblingParagraphs(editor, entry) {
   return normalizeSiblings(editor, entry, (a, b) => {
@@ -5585,9 +5726,9 @@ function normalizeSiblingParagraphs(editor, entry) {
 }
 
 // src/collapsible-paragraph-plugin/normalize-node/normalize-sibling-walls.ts
-import { Element as Element17, Transforms as Transforms24 } from "slate";
+import { Element as Element19, Transforms as Transforms24 } from "slate";
 function isWall(editor, node) {
-  if (!Element17.isElement(node))
+  if (!Element19.isElement(node))
     return false;
   return editor.isVoid(node) || editor.isMaster(node);
 }
@@ -5613,7 +5754,7 @@ function normalizeSiblingWalls(editor, entry) {
 // src/collapsible-paragraph-plugin/normalize-node/index.ts
 function normalizeNode4(editor, entry) {
   const [node, path] = entry;
-  if (!Element18.isElement(node))
+  if (!Element20.isElement(node))
     return false;
   if (normalizeSiblingWalls(editor, [node, path]))
     return true;
@@ -5758,7 +5899,7 @@ function addConvertElementType(editor, type) {
 }
 
 // src/convert-element-plugin/methods/convert-elements.ts
-import { Editor as Editor33, Element as Element20, Node as Node13, Point, Range as Range5, Transforms as Transforms25 } from "slate";
+import { Editor as Editor33, Element as Element22, Node as Node13, Point, Range as Range5, Transforms as Transforms25 } from "slate";
 function getOffsetInElement(editor, point, elementPath) {
   try {
     const elementStart = Editor33.start(editor, elementPath);
@@ -5775,7 +5916,7 @@ function getOffsetInElement(editor, point, elementPath) {
 function restoreSelectionInElement(editor, elementPath, offset) {
   try {
     const element = Node13.get(editor, elementPath);
-    if (!Element20.isElement(element))
+    if (!Element22.isElement(element))
       return;
     const text = Node13.string(element);
     const safeOffset = Math.min(offset, text.length);
@@ -5908,7 +6049,7 @@ function convertElements(editor, matchForToggle, targetElement, allowToggle) {
   const isCollapsed2 = Range5.isCollapsed(selection);
   const entries = Array.from(
     Editor33.nodes(editor, {
-      match: (node) => Element20.isElement(node) && editor.convertElement.isConvertibleElement(node)
+      match: (node) => Element22.isElement(node) && editor.convertElement.isConvertibleElement(node)
     })
   );
   if (entries.length > 0) {
@@ -5938,7 +6079,7 @@ function convertElements(editor, matchForToggle, targetElement, allowToggle) {
   const updatedEntries = allPaths.map((path) => {
     try {
       const node = Node13.get(editor, path);
-      if (Element20.isElement(node)) {
+      if (Element22.isElement(node)) {
         return [node, path];
       }
       return null;
@@ -5969,7 +6110,7 @@ function convertElements(editor, matchForToggle, targetElement, allowToggle) {
     } else if (savedFocusOffset >= 0) {
       try {
         const element = Node13.get(editor, firstPath);
-        if (Element20.isElement(element)) {
+        if (Element22.isElement(element)) {
           const text = Node13.string(element);
           const safeAnchorOffset = Math.min(savedAnchorOffset, text.length);
           const safeFocusOffset = Math.min(savedFocusOffset, text.length);
@@ -6237,11 +6378,37 @@ function HorizontalRule({
 }
 
 // src/horizontal-rule-plugin/methods/index.ts
+import { Editor as Editor36, Element as Element23, Path as Path10, Transforms as Transforms27 } from "slate";
 function insertHorizontalRule(editor) {
-  return insertRootElement(editor, {
+  const { selection } = editor;
+  if (!selection)
+    return false;
+  const entry = findElementUp(
+    editor,
+    (node) => Element23.isElement(node) && editor.isMaster(node)
+  );
+  const hrElement = {
     type: "horizontal-rule",
     children: [{ text: "" }]
-  });
+  };
+  const paragraphElement = {
+    type: "paragraph",
+    children: [{ text: "" }]
+  };
+  if (entry == null) {
+    Editor36.withoutNormalizing(editor, () => {
+      Transforms27.insertNodes(editor, [hrElement, paragraphElement]);
+      Transforms27.move(editor);
+    });
+  } else {
+    const nextPath = Path10.next(entry[1]);
+    Editor36.withoutNormalizing(editor, () => {
+      Transforms27.insertNodes(editor, [hrElement, paragraphElement], { at: nextPath });
+      const paragraphPath = Path10.next(nextPath);
+      Transforms27.select(editor, Editor36.start(editor, paragraphPath));
+    });
+  }
+  return true;
 }
 function createHorizontalRuleMethods(editor) {
   return {
@@ -6346,7 +6513,7 @@ var InlineCodePlugin = createPlugin(
 );
 
 // src/list-plugin/index.tsx
-import { Editor as Editor40, Path as Path10 } from "slate";
+import { Editor as Editor41, Path as Path11 } from "slate";
 
 // src/list-plugin/methods/convert-list-item.ts
 function convertOrderedList(editor, allowToggle) {
@@ -6430,36 +6597,36 @@ function indent(editor) {
 }
 
 // src/list-plugin/methods/insert-break.ts
-import { Editor as Editor36, Transforms as Transforms27 } from "slate";
+import { Editor as Editor37, Transforms as Transforms28 } from "slate";
 function insertBreak2(editor) {
   const entry = findElementUp(editor, isListItem);
   if (!entry)
     return false;
   const [element, path] = entry;
-  if (Editor36.isEmpty(editor, element)) {
+  if (Editor37.isEmpty(editor, element)) {
     if (element.depth > 0) {
-      Transforms27.setNodes(editor, { depth: element.depth - 1 }, { at: path });
+      Transforms28.setNodes(editor, { depth: element.depth - 1 }, { at: path });
       return true;
     } else {
       rewrapElement(editor, { type: "paragraph" }, path);
       return true;
     }
   }
-  Transforms27.splitNodes(editor, { always: true });
+  Transforms28.splitNodes(editor, { always: true });
   const nextEntry = findElementUp(editor, isListItem);
   if (!nextEntry)
     return true;
   if (nextEntry[0].type === "task-list-item" && nextEntry[0].checked === true) {
-    Transforms27.setNodes(editor, { checked: false }, { at: nextEntry[1] });
+    Transforms28.setNodes(editor, { checked: false }, { at: nextEntry[1] });
   }
   return true;
 }
 
 // src/list-plugin/methods/outdent.ts
-import { Editor as Editor37 } from "slate";
+import { Editor as Editor38 } from "slate";
 function outdent(editor) {
   const entries = Array.from(
-    Editor37.nodes(editor, {
+    Editor38.nodes(editor, {
       match: isListItem
     })
   );
@@ -6477,7 +6644,7 @@ function outdent(editor) {
 }
 
 // src/list-plugin/methods/toggleTaskListItem.ts
-import { Transforms as Transforms28 } from "slate";
+import { Transforms as Transforms29 } from "slate";
 function toggleTaskListItem(editor, { at = editor.selection } = {}) {
   const taskListItem = findElementUp(
     editor,
@@ -6487,7 +6654,7 @@ function toggleTaskListItem(editor, { at = editor.selection } = {}) {
   if (!taskListItem)
     return false;
   const nextChecked = !taskListItem[0].checked;
-  Transforms28.setNodes(
+  Transforms29.setNodes(
     editor,
     { checked: nextChecked },
     { at: taskListItem[1] }
@@ -6513,20 +6680,20 @@ function createListMethods(editor) {
 }
 
 // src/list-plugin/normalize-node/normalize-ordered-first-at-depth.ts
-import { Element as Element21, Transforms as Transforms29 } from "slate";
+import { Element as Element24, Transforms as Transforms30 } from "slate";
 var isOrderedListItem = createIsElementType([
   "ordered-list-item"
 ]);
 function normalizeOrderedFirstAtDepth(editor, entry) {
   const [node, path] = entry;
-  if (!Element21.isElement(node))
+  if (!Element24.isElement(node))
     return false;
   return normalizeSiblings(editor, [node, path], (a, b) => {
     if (!isOrderedListItem(b[0]))
       return false;
     const __firstAtDepth = isOrderedListItem(a[0]) ? b[0].depth > a[0].depth : isListItem(a[0]) ? b[0].depth > a[0].depth : true;
     if (b[0].__firstAtDepth !== __firstAtDepth) {
-      Transforms29.setNodes(editor, { __firstAtDepth }, { at: b[1] });
+      Transforms30.setNodes(editor, { __firstAtDepth }, { at: b[1] });
       return true;
     }
     return false;
@@ -6766,12 +6933,12 @@ var ListPlugin = createPlugin(
           if (!listItem)
             return false;
           const listItemPath = listItem[1];
-          if (!Path10.hasPrevious(listItemPath)) {
+          if (!Path11.hasPrevious(listItemPath)) {
             editor.collapsibleParagraph.convertParagraph();
             return true;
           }
-          const prevElementPath = Path10.previous(listItemPath);
-          const prevElementEntry = Editor40.node(editor, prevElementPath);
+          const prevElementPath = Path11.previous(listItemPath);
+          const prevElementEntry = Editor41.node(editor, prevElementPath);
           if (isListItem(prevElementEntry[0]))
             return false;
           editor.collapsibleParagraph.convertParagraph();
@@ -6781,7 +6948,7 @@ var ListPlugin = createPlugin(
       editableProps: {
         renderElement: renderElement3,
         onKeyDown(e) {
-          if (!Editor40.nodes(editor, { match: isListItem }))
+          if (!Editor41.nodes(editor, { match: isListItem }))
             return false;
           return hotkeyHandler(e);
         }
@@ -6792,15 +6959,15 @@ var ListPlugin = createPlugin(
 
 // src/marks-plugin/index.tsx
 import { clsx as clsx7 } from "clsx";
-import { Editor as Editor43, Point as Point3, Range as Range8 } from "slate";
+import { Editor as Editor44, Range as Range8 } from "slate";
 
 // src/marks-plugin/methods/removeMarks.ts
-import { Editor as Editor41, Text as Text4, Transforms as Transforms30 } from "slate";
+import { Editor as Editor42, Text as Text4, Transforms as Transforms31 } from "slate";
 function removeMarks(editor, { at = editor.selection } = {}) {
   if (at == null)
     return;
   const nodeEntries = [
-    ...Editor41.nodes(editor, {
+    ...Editor42.nodes(editor, {
       match: (n) => Text4.isText(n),
       at
     })
@@ -6813,7 +6980,7 @@ function removeMarks(editor, { at = editor.selection } = {}) {
       setter[key2] = null;
     }
   }
-  Transforms30.setNodes(editor, setter, {
+  Transforms31.setNodes(editor, setter, {
     match: (n) => Text4.isText(n),
     split: true,
     at
@@ -6821,14 +6988,14 @@ function removeMarks(editor, { at = editor.selection } = {}) {
 }
 
 // src/marks-plugin/methods/toggle-mark.ts
-import { Editor as Editor42, Point as Point2, Range as Range7 } from "slate";
+import { Editor as Editor43, Point as Point2, Range as Range7 } from "slate";
 function toggleMark(editor, markKey, unsetKey, { at = editor.selection } = {}) {
   if (at == null)
     return;
   const point = Range7.isRange(at) ? at.focus : at;
-  const isAtLineEnd = Point2.isPoint(point) && (Editor42.after(editor, point) === null || Editor42.isEnd(editor, point, Editor42.end(editor, [])));
+  const isAtLineEnd = Point2.isPoint(point) && (Editor43.after(editor, point) === null || Editor43.isEnd(editor, point, Editor43.end(editor, [])));
   const validMarkKey = markKey;
-  const marks = Editor42.marks(editor) || {};
+  const marks = Editor43.marks(editor) || {};
   const isActive = marks[validMarkKey] === true;
   if (isAtLineEnd) {
     if (!isActive) {
@@ -6842,12 +7009,12 @@ function toggleMark(editor, markKey, unsetKey, { at = editor.selection } = {}) {
     }
   }
   if (isActive) {
-    Editor42.removeMark(editor, validMarkKey);
+    Editor43.removeMark(editor, validMarkKey);
   } else {
-    Editor42.addMark(editor, validMarkKey, true);
+    Editor43.addMark(editor, validMarkKey, true);
   }
   if (typeof unsetKey === "string") {
-    Editor42.removeMark(editor, unsetKey);
+    Editor43.removeMark(editor, unsetKey);
   }
 }
 
@@ -6919,13 +7086,11 @@ var MarksPlugin = createPlugin((editor) => {
   const { removeMarks: removeMarks2 } = editor.marksPlugin;
   editor.marksPlugin.removeMarks = () => {
     removeMarks2();
-    if (editor.selection) {
-      const point = Range8.isRange(editor.selection) ? editor.selection.focus : editor.selection;
-      if (Point3.isPoint(point)) {
-        const isAtLineEnd = Editor43.after(editor, point) === null || Editor43.isEnd(editor, point, Editor43.end(editor, []));
-        if (isAtLineEnd) {
-          editor.activeMarks = {};
-        }
+    if (editor.selection && Range8.isRange(editor.selection)) {
+      const point = editor.selection.focus;
+      const isAtLineEnd = Editor44.after(editor, point) === null || Editor44.isEnd(editor, point, Editor44.end(editor, []));
+      if (isAtLineEnd) {
+        editor.activeMarks = {};
       }
     }
   };
@@ -6957,11 +7122,11 @@ var MarksPlugin = createPlugin((editor) => {
 });
 
 // src/normalize-after-delete-plugin/index.tsx
-import { Editor as Editor44, Point as Point4 } from "slate";
+import { Editor as Editor45, Point as Point3 } from "slate";
 function forceNormalizeNearestElement(editor) {
   if (!editor.selection)
     return;
-  const entry = Editor44.parent(editor, editor.selection);
+  const entry = Editor45.parent(editor, editor.selection);
   forceNormalizePath(editor, entry[1]);
 }
 var NormalizeAfterDeletePlugin = createPlugin((editor) => {
@@ -6972,9 +7137,9 @@ var NormalizeAfterDeletePlugin = createPlugin((editor) => {
       deleteBackward() {
         if (!editor.selection)
           return false;
-        const entry = Editor44.parent(editor, editor.selection);
-        const isStart = Point4.equals(
-          Editor44.start(editor, entry[1]),
+        const entry = Editor45.parent(editor, editor.selection);
+        const isStart = Point3.equals(
+          Editor45.start(editor, entry[1]),
           editor.selection.anchor
         );
         if (!isStart)
@@ -6986,9 +7151,9 @@ var NormalizeAfterDeletePlugin = createPlugin((editor) => {
       deleteForward() {
         if (!editor.selection)
           return false;
-        const entry = Editor44.parent(editor, editor.selection);
-        const isEnd = Point4.equals(
-          Editor44.end(editor, entry[1]),
+        const entry = Editor45.parent(editor, editor.selection);
+        const isEnd = Point3.equals(
+          Editor45.end(editor, entry[1]),
           editor.selection.anchor
         );
         if (!isEnd)
@@ -7003,15 +7168,15 @@ var NormalizeAfterDeletePlugin = createPlugin((editor) => {
 });
 
 // src/table-plugin/index.tsx
-import { Element as Element23 } from "slate";
+import { Element as Element26 } from "slate";
 
 // src/table-plugin/delete-fragment/index.ts
-import { Editor as Editor46, Path as Path12, Transforms as Transforms31 } from "slate";
+import { Editor as Editor47, Path as Path13, Transforms as Transforms32 } from "slate";
 
 // src/table-plugin/delete-fragment/get-reversed-delete-safe-ranges.ts
-import { Editor as Editor45, Path as Path11 } from "slate";
+import { Editor as Editor46, Path as Path12 } from "slate";
 function getReversedDeleteSafeRanges(editor, deleteRange, protectedTypes) {
-  const positions = [...Editor45.positions(editor, { at: deleteRange })];
+  const positions = [...Editor46.positions(editor, { at: deleteRange })];
   const deleteSafeRanges = [];
   let startPos, prevPos, startTdPath;
   startPos = prevPos = positions[0];
@@ -7022,7 +7187,7 @@ function getReversedDeleteSafeRanges(editor, deleteRange, protectedTypes) {
     const tdPath = findElementUpPath(editor, protectedTypes, {
       at: pos
     });
-    if (startTdPath && tdPath && Path11.equals(startTdPath, tdPath) || startTdPath == void 0 && tdPath == void 0) {
+    if (startTdPath && tdPath && Path12.equals(startTdPath, tdPath) || startTdPath == void 0 && tdPath == void 0) {
       prevPos = pos;
     } else {
       const range2 = { anchor: startPos, focus: prevPos };
@@ -7041,7 +7206,7 @@ function getReversedDeleteSafeRanges(editor, deleteRange, protectedTypes) {
 function deleteFragmentWithProtectedTypes(editor, protectedTypes) {
   if (editor.selection == null)
     return false;
-  const [start, end] = Editor46.edges(editor, editor.selection);
+  const [start, end] = Editor47.edges(editor, editor.selection);
   const startProtectedPath = findElementUpPath(editor, protectedTypes, {
     at: start
   });
@@ -7051,7 +7216,7 @@ function deleteFragmentWithProtectedTypes(editor, protectedTypes) {
   if (!startProtectedPath && !endProtectedPath) {
     return false;
   }
-  if (startProtectedPath && endProtectedPath && Path12.equals(startProtectedPath, endProtectedPath)) {
+  if (startProtectedPath && endProtectedPath && Path13.equals(startProtectedPath, endProtectedPath)) {
     return false;
   }
   const reversedRanges = getReversedDeleteSafeRanges(
@@ -7059,17 +7224,17 @@ function deleteFragmentWithProtectedTypes(editor, protectedTypes) {
     editor.selection,
     protectedTypes
   );
-  Editor46.withoutNormalizing(editor, () => {
+  Editor47.withoutNormalizing(editor, () => {
     for (const range of reversedRanges) {
-      Transforms31.delete(editor, { at: range });
+      Transforms32.delete(editor, { at: range });
     }
-    Transforms31.collapse(editor, { edge: "start" });
+    Transforms32.collapse(editor, { edge: "start" });
   });
   return true;
 }
 
 // src/table-plugin/methods/index.ts
-import { Transforms as Transforms40 } from "slate";
+import { Transforms as Transforms41 } from "slate";
 
 // src/table-plugin/methods/get-table-info.ts
 function getTableInfo(editor, { at = editor.selection } = {}) {
@@ -7107,10 +7272,10 @@ function getTableInfo(editor, { at = editor.selection } = {}) {
 }
 
 // src/table-plugin/methods/insert-column.ts
-import { Editor as Editor47, Transforms as Transforms32 } from "slate";
+import { Editor as Editor48, Transforms as Transforms33 } from "slate";
 
 // src/table-plugin/methods/utils.ts
-function createCell(index, children = [
+function createCell(_index, children = [
   {
     type: "table-content",
     children: [{ text: "" }]
@@ -7129,13 +7294,14 @@ function insertColumn(editor, { offset = 0, at = editor.selection } = {}) {
     return false;
   const { tableElement, tablePath, cellIndex } = t2;
   const nextCellIndex = cellIndex + offset;
-  Editor47.withoutNormalizing(editor, () => {
+  Editor48.withoutNormalizing(editor, () => {
     const { columns } = tableElement;
     const nextColumns = [...columns];
-    nextColumns.splice(nextCellIndex, 0, columns[nextCellIndex]);
-    Transforms32.setNodes(editor, { columns: nextColumns }, { at: tablePath });
-    tableElement.children.forEach((rowElement, i) => {
-      Transforms32.insertNodes(editor, createCell(nextCellIndex), {
+    const sourceIndex = Math.min(nextCellIndex, columns.length - 1);
+    nextColumns.splice(nextCellIndex, 0, columns[sourceIndex]);
+    Transforms33.setNodes(editor, { columns: nextColumns }, { at: tablePath });
+    tableElement.children.forEach((_rowElement, i) => {
+      Transforms33.insertNodes(editor, createCell(nextCellIndex), {
         at: [...tablePath, i, nextCellIndex]
       });
     });
@@ -7144,7 +7310,7 @@ function insertColumn(editor, { offset = 0, at = editor.selection } = {}) {
 }
 
 // src/table-plugin/methods/insert-row.ts
-import { Transforms as Transforms33 } from "slate";
+import { Transforms as Transforms34 } from "slate";
 function createRow(columnCount) {
   return {
     type: "table-row",
@@ -7156,7 +7322,7 @@ function insertRow(editor, { at = editor.selection, offset = 0 } = {}) {
   if (!t2)
     return false;
   const nextRowElement = createRow(t2.tableElement.columns.length);
-  Transforms33.insertNodes(editor, nextRowElement, {
+  Transforms34.insertNodes(editor, nextRowElement, {
     at: [...t2.tablePath, t2.rowIndex + offset]
   });
   return true;
@@ -7166,7 +7332,7 @@ function insertRowBelow(editor, { at } = {}) {
 }
 
 // src/table-plugin/methods/insert-table.ts
-import { Editor as Editor49, Element as Element22, Path as Path13, Transforms as Transforms34 } from "slate";
+import { Editor as Editor50, Element as Element25, Path as Path14, Transforms as Transforms35 } from "slate";
 function createRange(size) {
   return [...Array(size).keys()];
 }
@@ -7195,29 +7361,29 @@ function insertRootElement2(editor, element, { at = editor.selection } = {}) {
     return false;
   const entry = findElementUp(
     editor,
-    (node) => Element22.isElement(node) && editor.isMaster(node)
+    (node) => Element25.isElement(node) && editor.isMaster(node)
   );
   if (entry == null) {
     const selection = editor.selection;
-    Editor49.withoutNormalizing(editor, () => {
-      Transforms34.insertNodes(editor, element, { at });
+    Editor50.withoutNormalizing(editor, () => {
+      Transforms35.insertNodes(editor, element, { at });
       if (selection) {
-        Transforms34.select(editor, selection);
-        Transforms34.move(editor);
+        Transforms35.select(editor, selection);
+        Transforms35.move(editor);
       }
     });
   } else {
-    const nextPath = Path13.next(entry[1]);
-    Editor49.withoutNormalizing(editor, () => {
-      Transforms34.insertNodes(editor, element, { at: nextPath });
-      Transforms34.select(editor, Editor49.start(editor, nextPath));
+    const nextPath = Path14.next(entry[1]);
+    Editor50.withoutNormalizing(editor, () => {
+      Transforms35.insertNodes(editor, element, { at: nextPath });
+      Transforms35.select(editor, Editor50.start(editor, nextPath));
     });
   }
   return true;
 }
 
 // src/table-plugin/methods/navigation/select-element.ts
-import { Path as Path14 } from "slate";
+import { Path as Path15 } from "slate";
 function selectElementBelow(editor, t2) {
   const { cellIndex, rowIndex, rowCount, tablePath } = t2;
   if (rowIndex < rowCount - 1) {
@@ -7225,7 +7391,7 @@ function selectElementBelow(editor, t2) {
     return true;
   }
   try {
-    selectStartOfElement(editor, Path14.next(tablePath));
+    selectStartOfElement(editor, Path15.next(tablePath));
     return true;
   } catch {
     return false;
@@ -7238,7 +7404,7 @@ function selectElementAbove(editor, t2) {
     return true;
   }
   try {
-    selectEndOfElement(editor, Path14.previous(tablePath));
+    selectEndOfElement(editor, Path15.previous(tablePath));
     return true;
   } catch {
     return false;
@@ -7290,15 +7456,15 @@ function up(editor) {
 }
 
 // src/table-plugin/methods/remove-column.ts
-import { Editor as Editor52, Transforms as Transforms36 } from "slate";
+import { Editor as Editor53, Transforms as Transforms37 } from "slate";
 
 // src/table-plugin/methods/remove-table.ts
-import { Transforms as Transforms35 } from "slate";
+import { Transforms as Transforms36 } from "slate";
 function removeTable(editor) {
   const t2 = editor.tablePlugin.getTableInfo();
   if (t2 === void 0)
     return false;
-  Transforms35.removeNodes(editor, { at: t2.tablePath });
+  Transforms36.removeNodes(editor, { at: t2.tablePath });
   return true;
 }
 
@@ -7311,26 +7477,26 @@ function removeColumn(editor, { at = editor.selection } = {}) {
   if (cellCount === 1) {
     return removeTable(editor);
   }
-  Editor52.withoutNormalizing(editor, () => {
+  Editor53.withoutNormalizing(editor, () => {
     const columns = [...tableElement.columns];
     columns.splice(cellIndex, 1);
-    Transforms36.setNodes(editor, { columns }, { at: tablePath });
-    tableElement.children.forEach((rowElement, rowIndex2) => {
-      Transforms36.removeNodes(editor, {
+    Transforms37.setNodes(editor, { columns }, { at: tablePath });
+    tableElement.children.forEach((_rowElement, rowIndex2) => {
+      Transforms37.removeNodes(editor, {
         at: [...tablePath, rowIndex2, cellIndex]
       });
     });
-    const selection = Editor52.start(editor, [
+    const selection = Editor53.start(editor, [
       ...tablePath,
       rowIndex,
       Math.min(cellIndex, cellCount - 2)
     ]);
-    Transforms36.select(editor, selection);
+    Transforms37.select(editor, selection);
   });
 }
 
 // src/table-plugin/methods/remove-row.ts
-import { Editor as Editor53, Transforms as Transforms37 } from "slate";
+import { Editor as Editor54, Transforms as Transforms38 } from "slate";
 function removeRow(editor, { at = editor.selection } = {}) {
   const t2 = getTableInfo(editor, { at });
   if (t2 === void 0)
@@ -7339,11 +7505,11 @@ function removeRow(editor, { at = editor.selection } = {}) {
     removeTable(editor);
     return true;
   }
-  Editor53.withoutNormalizing(editor, () => {
-    Transforms37.removeNodes(editor, { at: t2.rowPath });
-    Transforms37.select(
+  Editor54.withoutNormalizing(editor, () => {
+    Transforms38.removeNodes(editor, { at: t2.rowPath });
+    Transforms38.select(
       editor,
-      Editor53.start(editor, [
+      Editor54.start(editor, [
         ...t2.tablePath,
         Math.min(t2.rowIndex, t2.rowCount - 2),
         t2.cellIndex
@@ -7354,7 +7520,7 @@ function removeRow(editor, { at = editor.selection } = {}) {
 }
 
 // src/table-plugin/methods/setTableColumnAlign.ts
-import { Transforms as Transforms38 } from "slate";
+import { Transforms as Transforms39 } from "slate";
 function setTableColumnAlign(editor, options) {
   const t2 = getTableInfo(editor);
   if (t2 === void 0)
@@ -7362,12 +7528,12 @@ function setTableColumnAlign(editor, options) {
   const { tableElement, tablePath, cellIndex } = t2;
   const nextColumns = tableElement.columns.slice();
   nextColumns.splice(cellIndex, 1, { align: options.align });
-  Transforms38.setNodes(editor, { columns: nextColumns }, { at: tablePath });
+  Transforms39.setNodes(editor, { columns: nextColumns }, { at: tablePath });
   return true;
 }
 
 // src/table-plugin/methods/tab.ts
-import { Path as Path15, Transforms as Transforms39 } from "slate";
+import { Path as Path16, Transforms as Transforms40 } from "slate";
 function tabForward(editor) {
   const t2 = getTableInfo(editor);
   if (!t2)
@@ -7381,8 +7547,8 @@ function tabForward(editor) {
     selectStartOfElement(editor, [...tablePath, rowIndex + 1, 0]);
     return true;
   }
-  const nextPath = Path15.next(tablePath);
-  Transforms39.insertNodes(
+  const nextPath = Path16.next(tablePath);
+  Transforms40.insertNodes(
     editor,
     { type: "paragraph", children: [{ text: "" }] },
     { at: nextPath }
@@ -7446,12 +7612,12 @@ function selectCell(editor, { at = editor.selection } = {}) {
   if (t2 === void 0)
     return false;
   const { cellPath } = t2;
-  Transforms40.select(editor, cellPath);
+  Transforms41.select(editor, cellPath);
   return true;
 }
 
 // src/table-plugin/normalize/normalize-table.ts
-import { Transforms as Transforms41 } from "slate";
+import { Transforms as Transforms42 } from "slate";
 function normalizeTableIndexes(editor, entry) {
   let isTransformed = false;
   const rowElements = entry[0].children;
@@ -7459,7 +7625,7 @@ function normalizeTableIndexes(editor, entry) {
     const cellElements = rowElement.children;
     cellElements.forEach((cellElement, x) => {
       if (cellElement.x !== x || cellElement.y !== y) {
-        Transforms41.setNodes(editor, { x, y }, { at: [...entry[1], y, x] });
+        Transforms42.setNodes(editor, { x, y }, { at: [...entry[1], y, x] });
         isTransformed = true;
       }
     });
@@ -7468,14 +7634,14 @@ function normalizeTableIndexes(editor, entry) {
 }
 
 // src/table-plugin/normalize/normalize-table-cell.ts
-import { Editor as Editor58, Transforms as Transforms42 } from "slate";
+import { Editor as Editor59, Transforms as Transforms43 } from "slate";
 function normalizeTableCell(editor, entry) {
   const [node, path] = entry;
   if (node.children.length === 1 && node.children[0].type === "table-content") {
     return false;
   }
-  Editor58.withoutNormalizing(editor, () => {
-    Transforms42.insertNodes(
+  Editor59.withoutNormalizing(editor, () => {
+    Transforms43.insertNodes(
       editor,
       {
         type: "table-content",
@@ -7484,9 +7650,9 @@ function normalizeTableCell(editor, entry) {
       { at: [...entry[1], 0] }
     );
     for (let i = node.children.length; i >= 0; i--) {
-      Transforms42.mergeNodes(editor, { at: [...path, i] });
+      Transforms43.mergeNodes(editor, { at: [...path, i] });
     }
-    Transforms42.delete(editor, {
+    Transforms43.delete(editor, {
       at: { path: [...path, 0, 0], offset: 0 },
       unit: "character"
     });
@@ -7763,7 +7929,7 @@ var AlignCenter = () => /* @__PURE__ */ jsx50(TablerIcon, { children: /* @__PURE
 var AlignRight = () => /* @__PURE__ */ jsx50(TablerIcon, { children: /* @__PURE__ */ jsx50("path", { d: "M4 6h16M10 12h10M6 18h14" }) });
 
 // src/table-plugin/render-element/table-cell/column-menu/index.tsx
-import { Fragment as Fragment4, jsx as jsx51, jsxs as jsxs23 } from "react/jsx-runtime";
+import { Fragment as Fragment5, jsx as jsx51, jsxs as jsxs23 } from "react/jsx-runtime";
 function ColumnMenu({ cellElement }) {
   const editor = useSlateStatic14();
   const menu = useLayer("column-menu");
@@ -7816,7 +7982,7 @@ function ColumnMenu({ cellElement }) {
       onMouseLeave,
       children: [
         /* @__PURE__ */ jsx51($ColumnMenuTile, { className: "--tile", children: /* @__PURE__ */ jsx51(BarsIcon, {}) }),
-        hover ? /* @__PURE__ */ jsxs23(Fragment4, { children: [
+        hover ? /* @__PURE__ */ jsxs23(Fragment5, { children: [
           /* @__PURE__ */ jsx51(
             $RemoveMenuButton,
             {
@@ -7854,7 +8020,7 @@ function ColumnMenu({ cellElement }) {
 // src/table-plugin/render-element/table-cell/row-menu/index.tsx
 import { useState as useState7 } from "react";
 import { useSlateStatic as useSlateStatic15 } from "slate-react";
-import { Fragment as Fragment5, jsx as jsx52, jsxs as jsxs24 } from "react/jsx-runtime";
+import { Fragment as Fragment6, jsx as jsx52, jsxs as jsxs24 } from "react/jsx-runtime";
 function RowMenu({ cellElement }) {
   const editor = useSlateStatic15();
   const [hover, setHover] = useState7(false);
@@ -7866,7 +8032,7 @@ function RowMenu({ cellElement }) {
       onMouseLeave: () => setHover(false),
       children: [
         /* @__PURE__ */ jsx52($RowMenuTile, { className: "--tile", children: /* @__PURE__ */ jsx52(BarsIcon, {}) }),
-        hover ? /* @__PURE__ */ jsxs24(Fragment5, { children: [
+        hover ? /* @__PURE__ */ jsxs24(Fragment6, { children: [
           /* @__PURE__ */ jsx52(
             $RemoveMenuButton,
             {
@@ -8047,7 +8213,7 @@ var TablePlugin = createPlugin(
         },
         normalizeNode: (entry) => {
           const [node] = entry;
-          if (!Element23.isElement(node))
+          if (!Element26.isElement(node))
             return false;
           switch (node.type) {
             case "table":
@@ -8158,14 +8324,14 @@ var globalStyles = css2`
 `;
 
 // src/theme-plugin/index.tsx
-import { Fragment as Fragment6, jsx as jsx58, jsxs as jsxs26 } from "react/jsx-runtime";
+import { Fragment as Fragment7, jsx as jsx58, jsxs as jsxs26 } from "react/jsx-runtime";
 var ThemePlugin = createPlugin((editor) => {
   editor.theme = true;
   return {
     name: "theme",
     editor: {},
     renderEditable: ({ attributes, Editable: Editable3 }) => {
-      return /* @__PURE__ */ jsxs26(Fragment6, { children: [
+      return /* @__PURE__ */ jsxs26(Fragment7, { children: [
         /* @__PURE__ */ jsx58(Global, { styles: globalStyles }),
         /* @__PURE__ */ jsx58(Editable3, { ...attributes })
       ] });
@@ -8177,7 +8343,7 @@ var ThemePlugin = createPlugin((editor) => {
 // src/toolbar-plugin/render-editable/index.tsx
 import { clsx as clsx10 } from "clsx";
 import { useCallback as useCallback17, useRef as useRef13 } from "react";
-import { Editor as Editor62, Transforms as Transforms44 } from "slate";
+import { Editor as Editor63, Transforms as Transforms45 } from "slate";
 import { ReactEditor as ReactEditor16, useFocused, useSlateStatic as useSlateStatic21 } from "slate-react";
 
 // src/toolbar-plugin/components/dialog/table-dialog.tsx
@@ -8209,7 +8375,7 @@ var $TableDialogGridCell = styled35("div")`
 `;
 
 // src/toolbar-plugin/components/dialog/table-dialog.tsx
-import { Fragment as Fragment7, jsx as jsx59, jsxs as jsxs27 } from "react/jsx-runtime";
+import { Fragment as Fragment8, jsx as jsx59, jsxs as jsxs27 } from "react/jsx-runtime";
 function createRange2(size) {
   return [...Array(size).keys()];
 }
@@ -8221,6 +8387,8 @@ function TableDialog({
   const editor = useSlateStatic16();
   const ref = useRef8(null);
   const style = useAbsoluteReposition({ src: ref, dest }, ({ dest: dest2 }) => {
+    if (!dest2)
+      return { left: 0, top: 0 };
     return { left: dest2.left - 8, top: dest2.top + dest2.height };
   });
   const rows = createRange2(5).map((i) => i + 1);
@@ -8239,7 +8407,7 @@ function TableDialog({
     },
     [editor]
   );
-  return /* @__PURE__ */ jsxs27(Fragment7, { children: [
+  return /* @__PURE__ */ jsxs27(Fragment8, { children: [
     /* @__PURE__ */ jsx59(CloseMask, { close }),
     /* @__PURE__ */ jsx59($TableDialog, { ref, style, children: /* @__PURE__ */ jsx59($TableDialogGrid, { onMouseLeave: () => hoverCell(0, 0), children: rows.map((y) => {
       return cols.map((x) => {
@@ -8312,6 +8480,7 @@ var Highlight = () => /* @__PURE__ */ jsxs28(TablerIcon, { children: [
   /* @__PURE__ */ jsx60("path", { d: "M13.5 6.5l4 4" }),
   /* @__PURE__ */ jsx60("path", { d: "m14 19 6-6M18 15l2 2M5 21h4" })
 ] });
+var HorizontalRule2 = () => /* @__PURE__ */ jsx60(TablerIcon, { children: /* @__PURE__ */ jsx60("path", { d: "M5 12h14" }) });
 
 // src/toolbar-plugin/items/block-items.tsx
 var listDepthItems = [
@@ -8384,13 +8553,13 @@ var $FileDialog = styled36($Panel)`
 `;
 
 // src/toolbar-plugin/components/dialog/image-url-dialog.tsx
-import { Fragment as Fragment8, jsx as jsx61, jsxs as jsxs29 } from "react/jsx-runtime";
+import { Fragment as Fragment9, jsx as jsx61, jsxs as jsxs29 } from "react/jsx-runtime";
 function ImageUrlDialog({
   dest,
   close
 }) {
   const editor = useSlateStatic17();
-  const ref = useRef9(void 0);
+  const ref = useRef9(null);
   const fileInputRef = useRef9(null);
   const [dragOffset, setDragOffset] = useState9({ x: 0, y: 0 });
   const handleDrag = useCallback14((deltaX, deltaY) => {
@@ -8469,7 +8638,6 @@ function ImageUrlDialog({
       const resultUrl = await editor.wysimark.onImageChange(file);
       setUploadedUrl(resultUrl);
     } catch (error) {
-      console.error("Failed to upload image:", error);
     } finally {
       setIsUploading(false);
     }
@@ -8478,7 +8646,7 @@ function ImageUrlDialog({
     fileInputRef.current?.click();
   }
   const isSubmitDisabled = imageSource === "file" ? uploadedUrl.trim() === "" || isUploading : url.trim() === "";
-  return /* @__PURE__ */ jsxs29(Fragment8, { children: [
+  return /* @__PURE__ */ jsxs29(Fragment9, { children: [
     /* @__PURE__ */ jsx61(CloseMask, { close }),
     /* @__PURE__ */ jsxs29($FileDialog, { ref, style, children: [
       /* @__PURE__ */ jsx61(DraggableHeader, { onDrag: handleDrag }),
@@ -8659,11 +8827,11 @@ function ImageUrlDialog({
 import { isHotkey as isHotkey3 } from "is-hotkey";
 import {
   useCallback as useCallback15,
-  useMemo as useMemo2,
+  useMemo as useMemo3,
   useRef as useRef10,
   useState as useState10
 } from "react";
-import { Editor as Editor59, Range as Range10 } from "slate";
+import { Editor as Editor60, Range as Range10 } from "slate";
 import { ReactEditor as ReactEditor14, useSlateStatic as useSlateStatic18 } from "slate-react";
 
 // src/toolbar-plugin/styles/dialog-shared-styles.ts
@@ -8701,7 +8869,7 @@ var $DialogHint = styled37("div")`
 `;
 
 // src/toolbar-plugin/components/dialog/anchor-dialog.tsx
-import { Fragment as Fragment9, jsx as jsx62, jsxs as jsxs30 } from "react/jsx-runtime";
+import { Fragment as Fragment10, jsx as jsx62, jsxs as jsxs30 } from "react/jsx-runtime";
 var isEnter = isHotkey3("enter");
 function AnchorDialog2({
   dest,
@@ -8716,6 +8884,8 @@ function AnchorDialog2({
   const baseStyle = useAbsoluteReposition(
     { src: ref, dest },
     ({ src, dest: dest2 }, viewport) => {
+      if (!src || !dest2)
+        return { left: 0, top: 0 };
       return positionInside(
         src,
         viewport,
@@ -8732,10 +8902,10 @@ function AnchorDialog2({
     left: baseStyle.left + dragOffset.x,
     top: baseStyle.top + dragOffset.y
   };
-  const initialText = useMemo2(() => {
+  const initialText = useMemo3(() => {
     const { selection } = editor;
     if (selection && !Range10.isCollapsed(selection)) {
-      return Editor59.string(editor, selection);
+      return Editor60.string(editor, selection);
     }
     return "";
   }, []);
@@ -8780,7 +8950,7 @@ function AnchorDialog2({
     e.stopPropagation();
     insertLink2();
   };
-  return /* @__PURE__ */ jsxs30(Fragment9, { children: [
+  return /* @__PURE__ */ jsxs30(Fragment10, { children: [
     /* @__PURE__ */ jsx62(CloseMask, { close }),
     /* @__PURE__ */ jsxs30($AnchorDialog, { ref, style, children: [
       /* @__PURE__ */ jsx62(DraggableHeader, { onDrag: handleDrag }),
@@ -8849,6 +9019,12 @@ var dialogItems = [
     title: t("insertTable"),
     more: true,
     Component: TableDialog
+  },
+  {
+    icon: HorizontalRule2,
+    title: t("horizontalRule"),
+    hotkey: "super+-",
+    action: (editor) => editor.horizontalRule.insertHorizontalRule()
   }
 ];
 var expandedDialogItems = dialogItems;
@@ -8863,9 +9039,9 @@ var smallDialogItems = [
 ];
 
 // src/toolbar-plugin/items/mark-items.tsx
-import { Editor as Editor60 } from "slate";
+import { Editor as Editor61 } from "slate";
 function getMarks(editor) {
-  const marks = Editor60.marks(editor);
+  const marks = Editor61.marks(editor);
   return {
     bold: marks?.bold || false,
     italic: marks?.italic || false,
@@ -8963,7 +9139,7 @@ var compactListItems = [
 ];
 
 // src/toolbar-plugin/items/quote-items.tsx
-import { Editor as Editor61, Transforms as Transforms43 } from "slate";
+import { Editor as Editor62, Transforms as Transforms44 } from "slate";
 var quoteItemsList = [
   {
     icon: Quote,
@@ -8992,9 +9168,9 @@ var quoteItemsList = [
       const codeBlockEntry = findElementUp(editor, "code-block");
       if (codeBlockEntry) {
         const [, path] = codeBlockEntry;
-        const textContent = Editor61.string(editor, path);
-        Transforms43.removeNodes(editor, { at: path });
-        Transforms43.insertNodes(
+        const textContent = Editor62.string(editor, path);
+        Transforms44.removeNodes(editor, { at: path });
+        Transforms44.insertNodes(
           editor,
           {
             type: "paragraph",
@@ -9009,9 +9185,9 @@ var quoteItemsList = [
         return;
       }
       if (selection && (selection.anchor.offset !== selection.focus.offset || JSON.stringify(selection.anchor.path) !== JSON.stringify(selection.focus.path))) {
-        const selectedText = Editor61.string(editor, selection);
-        Transforms43.delete(editor);
-        Transforms43.insertNodes(
+        const selectedText = Editor62.string(editor, selection);
+        Transforms44.delete(editor);
+        Transforms44.insertNodes(
           editor,
           {
             type: "code-block",
@@ -9236,7 +9412,7 @@ function renderEditable({ attributes, Editable: Editable3 }) {
     (e) => {
       if (e.target !== e.currentTarget)
         return;
-      Transforms44.select(editor, Editor62.end(editor, []));
+      Transforms45.select(editor, Editor63.end(editor, []));
       ReactEditor16.focus(editor);
     },
     [editor]
@@ -9286,7 +9462,7 @@ var ToolbarPlugin = createPlugin(
 );
 
 // src/trailing-block-plugin/index.tsx
-import { Editor as Editor63, Node as Node15, Path as Path16, Transforms as Transforms45 } from "slate";
+import { Editor as Editor64, Node as Node15, Path as Path17, Transforms as Transforms46 } from "slate";
 var TrailingBlockPlugin = createPlugin(
   (editor) => {
     editor.allowTrailingBlock = true;
@@ -9294,19 +9470,19 @@ var TrailingBlockPlugin = createPlugin(
       name: "trailing-block",
       editor: {
         normalizeNode: (entry) => {
-          if (!Editor63.isEditor(entry[0]))
+          if (!Editor64.isEditor(entry[0]))
             return false;
           const lastPath = [editor.children.length - 1];
           const lastElement = Node15.child(
             editor,
             editor.children.length - 1
           );
-          if (Editor63.hasBlocks(editor, lastElement) || Editor63.isVoid(editor, lastElement)) {
-            Transforms45.insertNodes(
+          if (Editor64.hasBlocks(editor, lastElement) || Editor64.isVoid(editor, lastElement)) {
+            Transforms46.insertNodes(
               editor,
               { type: "paragraph", children: [{ text: "" }] },
               {
-                at: Path16.next(lastPath)
+                at: Path17.next(lastPath)
               }
             );
           }
@@ -9318,11 +9494,11 @@ var TrailingBlockPlugin = createPlugin(
 );
 
 // src/paste-markdown-plugin/methods/index.ts
-import { Transforms as Transforms46 } from "slate";
+import { Transforms as Transforms47 } from "slate";
 function pasteMarkdown(editor, markdown) {
   const escapedMarkdown = escapeUrlSlashes(markdown);
   const fragment = parse(escapedMarkdown);
-  Transforms46.insertNodes(editor, fragment);
+  Transforms47.insertNodes(editor, fragment);
 }
 function createPasteMarkdownMethods(editor) {
   return {
@@ -9408,7 +9584,7 @@ var { withSink, SinkEditable: SinkEditable2 } = Sink;
 
 // src/entry/useEditor.tsx
 import { useState as useState12 } from "react";
-import { createEditor, Editor as Editor65, Transforms as Transforms47 } from "slate";
+import { createEditor, Editor as Editor66, Transforms as Transforms48 } from "slate";
 import { withHistory } from "slate-history";
 import { withReact } from "slate-react";
 function useEditor({
@@ -9454,7 +9630,7 @@ function useEditor({
       const documentValue = parse(escapedMarkdown);
       editor2.children = documentValue;
       editor2.selection = null;
-      Transforms47.select(editor2, Editor65.start(editor2, [0]));
+      Transforms48.select(editor2, Editor66.start(editor2, [0]));
     };
     return nextEditor;
   });
@@ -9482,6 +9658,8 @@ function Editable2({
   const initialValueRef = useRef14(void 0);
   const prevValueRef = useRef14(void 0);
   const pendingRawTextRef = useRef14(null);
+  const onChangeRef = useRef14(onChange);
+  onChangeRef.current = onChange;
   const onThrottledSlateChange = useCallback18(
     throttle3(
       () => {
@@ -9490,12 +9668,13 @@ function Editable2({
           markdown,
           children: editor.children
         };
-        onChange(markdown);
+        onChangeRef.current(markdown);
       },
       throttleInMs,
       { leading: false, trailing: true }
     ),
-    [editor, onChange, throttleInMs]
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [editor, throttleInMs]
   );
   const onSlateChange = useCallback18(() => {
     if (prevValueRef.current === editor.children) {
@@ -9526,7 +9705,7 @@ function Editable2({
         const documentValue = parse(valueToProcess);
         editor.children = documentValue;
         editor.selection = null;
-        Transforms48.select(editor, Editor66.start(editor, [0]));
+        Transforms49.select(editor, Editor67.start(editor, [0]));
       }
     }
   }