@blankdotpage/cake 0.1.6 → 0.1.7

package/dist/index.cjs

@@ -3,7 +3,6 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require$$0 = require("react");
 const lucideReact = require("lucide-react");
 const TurndownService = require("turndown");
-const state = require("@codemirror/state");
 var jsxRuntime = { exports: {} };
 var reactJsxRuntime_production_min = {};
 /**
@@ -1305,14 +1304,14 @@ function createRuntime(extensions) {
       runtime
     };
   }
-  function applyEdit(command, state2) {
+  function applyEdit(command, state) {
     while (true) {
       let delegated = false;
       for (const extension of extensions) {
         if (!extension.onEdit) {
           continue;
         }
-        const result = extension.onEdit(command, state2);
+        const result = extension.onEdit(command, state);
         if (!result) {
           continue;
         }
@@ -1327,12 +1326,12 @@ function createRuntime(extensions) {
         break;
       }
     }
-    const selection = normalizeSelection$1(state2.selection);
+    const selection = normalizeSelection$1(state.selection);
     if (isStructuralEdit(command)) {
-      const structural = applyStructuralEdit(command, state2.doc, selection);
+      const structural = applyStructuralEdit(command, state.doc, selection);
       if (!structural) {
         if (command.type === "delete-backward" || command.type === "delete-forward") {
-          const cursorLength = state2.map.cursorLength;
+          const cursorLength = state.map.cursorLength;
           const cursorStart = Math.max(
             0,
             Math.min(cursorLength, Math.min(selection.start, selection.end))
@@ -1343,22 +1342,22 @@ function createRuntime(extensions) {
           );
           if (cursorStart === cursorEnd) {
             if (command.type === "delete-backward" && cursorStart === 0) {
-              return state2;
+              return state;
             }
             if (command.type === "delete-forward" && cursorStart === cursorLength) {
-              return state2;
+              return state;
             }
           }
           const range = cursorStart === cursorEnd ? command.type === "delete-backward" ? { start: cursorStart - 1, end: cursorStart } : { start: cursorStart, end: cursorStart + 1 } : { start: cursorStart, end: cursorEnd };
           const fullDocDelete = range.start === 0 && range.end === cursorLength;
-          const from = fullDocDelete ? 0 : state2.map.cursorToSource(range.start, "backward");
-          const to = fullDocDelete ? state2.source.length : state2.map.cursorToSource(range.end, "forward");
-          const fromClamped = Math.max(0, Math.min(from, state2.source.length));
+          const from = fullDocDelete ? 0 : state.map.cursorToSource(range.start, "backward");
+          const to = fullDocDelete ? state.source.length : state.map.cursorToSource(range.end, "forward");
+          const fromClamped = Math.max(0, Math.min(from, state.source.length));
           const toClamped = Math.max(
             fromClamped,
-            Math.min(to, state2.source.length)
+            Math.min(to, state.source.length)
           );
-          const nextSource = state2.source.slice(0, fromClamped) + state2.source.slice(toClamped);
+          const nextSource = state.source.slice(0, fromClamped) + state.source.slice(toClamped);
           const next2 = createState(nextSource);
           const caretCursor2 = next2.map.sourceToCursor(fromClamped, "forward");
           return {
@@ -1371,7 +1370,7 @@ function createRuntime(extensions) {
           };
         }
         if (command.type === "insert" || command.type === "insert-line-break") {
-          const cursorLength = state2.map.cursorLength;
+          const cursorLength = state.map.cursorLength;
           const cursorStart = Math.max(
             0,
             Math.min(cursorLength, Math.min(selection.start, selection.end))
@@ -1382,15 +1381,15 @@ function createRuntime(extensions) {
           );
           const range = { start: cursorStart, end: cursorEnd };
           const fullDocReplace = range.start === 0 && range.end === cursorLength;
-          const from = fullDocReplace ? 0 : state2.map.cursorToSource(range.start, "backward");
-          const to = fullDocReplace ? state2.source.length : state2.map.cursorToSource(range.end, "forward");
-          const fromClamped = Math.max(0, Math.min(from, state2.source.length));
+          const from = fullDocReplace ? 0 : state.map.cursorToSource(range.start, "backward");
+          const to = fullDocReplace ? state.source.length : state.map.cursorToSource(range.end, "forward");
+          const fromClamped = Math.max(0, Math.min(from, state.source.length));
           const toClamped = Math.max(
             fromClamped,
-            Math.min(to, state2.source.length)
+            Math.min(to, state.source.length)
           );
           const insertText = command.type === "insert" ? command.text : "\n";
-          const nextSource = state2.source.slice(0, fromClamped) + insertText + state2.source.slice(toClamped);
+          const nextSource = state.source.slice(0, fromClamped) + insertText + state.source.slice(toClamped);
           const next2 = createState(nextSource);
           const caretSource2 = fromClamped + insertText.length;
           const caretCursor2 = next2.map.sourceToCursor(caretSource2, "forward");
@@ -1403,7 +1402,7 @@ function createRuntime(extensions) {
             }
           };
         }
-        return state2;
+        return state;
       }
       const interim = createStateFromDoc(structural.doc);
       const interimAffinity = structural.nextAffinity ?? "forward";
@@ -1423,15 +1422,15 @@ function createRuntime(extensions) {
       };
     }
     if (command.type === "indent" || command.type === "outdent") {
-      return state2;
+      return state;
     }
     if (command.type === "toggle-bullet-list" || command.type === "toggle-numbered-list") {
-      return state2;
+      return state;
     }
     if (command.type === "toggle-inline") {
-      return applyInlineToggle(state2, command.marker);
+      return applyInlineToggle(state, command.marker);
     }
-    return state2;
+    return state;
   }
   function applyStructuralEdit(command, doc, selection) {
     var _a;
@@ -2210,16 +2209,16 @@ function createRuntime(extensions) {
     }
     return true;
   }
-  function applyInlineToggle(state2, marker) {
-    const selection = normalizeSelection$1(state2.selection);
-    const source = state2.source;
-    const map = state2.map;
+  function applyInlineToggle(state, marker) {
+    const selection = normalizeSelection$1(state.selection);
+    const source = state.source;
+    const map = state.map;
     if (selection.start === selection.end) {
       const caret = selection.start;
       const markerLen2 = marker.length;
       const markerKind2 = toggleMarkerToKind.get(marker) ?? null;
       if (markerKind2) {
-        const around = marksAroundCursor(state2.doc, caret);
+        const around = marksAroundCursor(state.doc, caret);
         if (isMarksPrefix(around.right, around.left) && around.left.length > around.right.length) {
           const exiting = around.left.slice(around.right.length);
           if (exiting.some((mark) => mark.kind === markerKind2)) {
@@ -2249,7 +2248,7 @@ function createRuntime(extensions) {
               }
             }
             return {
-              ...state2,
+              ...state,
               selection: {
                 start: caret,
                 end: caret,
@@ -2295,12 +2294,12 @@ function createRuntime(extensions) {
     const selectedText = source.slice(from, to);
     const markerLen = marker.length;
     const markerKind = toggleMarkerToKind.get(marker) ?? null;
-    const linesForSelection = flattenDocToLines(state2.doc);
+    const linesForSelection = flattenDocToLines(state.doc);
     const commonMarks = markerKind ? commonMarksAcrossSelection(
       linesForSelection,
       cursorStart,
       cursorEnd,
-      state2.doc
+      state.doc
     ) : [];
     const hasCommonMark = markerKind !== null && commonMarks.some((mark) => mark.kind === markerKind);
     const canUnwrap = markerKind ? hasCommonMark : true;
@@ -2375,7 +2374,7 @@ function createRuntime(extensions) {
         }
       }
       if (edits.length === 0) {
-        return state2;
+        return state;
       }
       edits.sort((a, b) => b.from - a.from);
       let newSource2 = source;
@@ -2417,15 +2416,15 @@ function createRuntime(extensions) {
       }
     };
   }
-  function updateSelection(state2, selection, options) {
+  function updateSelection(state, selection, options) {
     const normalized = normalizeSelection$1(selection);
-    const cursorLength = state2.map.cursorLength;
+    const cursorLength = state.map.cursorLength;
     const start = Math.max(0, Math.min(cursorLength, normalized.start));
     const end = Math.max(0, Math.min(cursorLength, normalized.end));
     const kind = (options == null ? void 0 : options.kind) ?? "programmatic";
     let affinity = normalized.affinity ?? "forward";
     if (start === end) {
-      const around = marksAroundCursor(state2.doc, start);
+      const around = marksAroundCursor(state.doc, start);
       if (kind === "keyboard") {
         affinity = preferredTypingAffinityAtGap(
           around.left,
@@ -2444,13 +2443,13 @@ function createRuntime(extensions) {
       }
     }
     return {
-      ...state2,
+      ...state,
       selection: { start, end, affinity }
     };
   }
-  function serializeSelection(state2, selection) {
+  function serializeSelection(state, selection) {
     const normalized = normalizeSelection$1(selection);
-    const lines = flattenDocToLines(state2.doc);
+    const lines = flattenDocToLines(state.doc);
     const docCursorLength = cursorLengthForLines(lines);
     const cursorStart = Math.max(
       0,
@@ -2471,7 +2470,7 @@ function createRuntime(extensions) {
       if (!line) {
         continue;
       }
-      const block = getBlockAtPath(state2.doc.blocks, line.path);
+      const block = getBlockAtPath(state.doc.blocks, line.path);
       if (!block || block.type !== "paragraph") {
         continue;
       }
@@ -2483,7 +2482,7 @@ function createRuntime(extensions) {
       const paragraph = { type: "paragraph", content };
       if (line.path.length > 1) {
         const wrapperPath = line.path.slice(0, -1);
-        const wrapper = getBlockAtPath(state2.doc.blocks, wrapperPath);
+        const wrapper = getBlockAtPath(state.doc.blocks, wrapperPath);
         if (wrapper && wrapper.type === "block-wrapper") {
           blocks.push({
             type: "block-wrapper",
@@ -2526,9 +2525,9 @@ function createRuntime(extensions) {
     }
     return html;
   }
-  function serializeSelectionToHtml(state2, selection) {
+  function serializeSelectionToHtml(state, selection) {
     const normalized = normalizeSelection$1(selection);
-    const lines = flattenDocToLines(state2.doc);
+    const lines = flattenDocToLines(state.doc);
     const docCursorLength = cursorLengthForLines(lines);
     const cursorStart = Math.max(
       0,
@@ -2564,7 +2563,7 @@ function createRuntime(extensions) {
       if (!line) {
         continue;
       }
-      const block = getBlockAtPath(state2.doc.blocks, line.path);
+      const block = getBlockAtPath(state.doc.blocks, line.path);
       if (!block || block.type !== "paragraph") {
         continue;
       }
@@ -2576,7 +2575,7 @@ function createRuntime(extensions) {
       let wrapperData;
       if (line.path.length > 1) {
         const wrapperPath = line.path.slice(0, -1);
-        const wrapper = getBlockAtPath(state2.doc.blocks, wrapperPath);
+        const wrapper = getBlockAtPath(state.doc.blocks, wrapperPath);
         if (wrapper && wrapper.type === "block-wrapper") {
           wrapperKind = wrapper.kind;
           wrapperData = wrapper.data;
@@ -3375,10 +3374,16 @@ const boldExtension = defineExtension({
   name: "bold",
   toggleInline: { kind: BOLD_KIND$1, markers: ["**"] },
   keybindings: [
-    { key: "b", meta: true, command: { type: "toggle-inline", marker: "**" } },
-    { key: "b", ctrl: true, command: { type: "toggle-inline", marker: "**" } }
+    { key: "b", meta: true, command: { type: "toggle-bold" } },
+    { key: "b", ctrl: true, command: { type: "toggle-bold" } }
   ],
   inlineWrapperAffinity: [{ kind: BOLD_KIND$1, inclusive: true }],
+  onEdit(command) {
+    if (command.type === "toggle-bold") {
+      return { type: "toggle-inline", marker: "**" };
+    }
+    return null;
+  },
   parseInline(source, start, end, context) {
     if (source.slice(start, start + 3) === "***") {
       const close2 = source.indexOf("***", start + 3);
@@ -3559,14 +3564,14 @@ function CakeLinkPopover(params) {
   const anchorRef = require$$0.useRef(null);
   const popoverRef = require$$0.useRef(null);
   const inputRef = require$$0.useRef(null);
-  const [state2, setState] = require$$0.useState({ status: "closed" });
-  const isEditing = state2.status === "open" ? state2.isEditing : false;
+  const [state, setState] = require$$0.useState({ status: "closed" });
+  const isEditing = state.status === "open" ? state.isEditing : false;
   const close = require$$0.useCallback(() => {
     anchorRef.current = null;
     setState({ status: "closed" });
   }, []);
   const reposition = require$$0.useCallback(() => {
-    if (state2.status !== "open") {
+    if (state.status !== "open") {
       return;
     }
     const anchor = anchorRef.current;
@@ -3583,7 +3588,7 @@ function CakeLinkPopover(params) {
         position: getPopoverPosition({ anchor, toOverlayRect })
       };
     });
-  }, [close, state2.status, toOverlayRect]);
+  }, [close, state.status, toOverlayRect]);
   const openForLink = require$$0.useCallback(
     (link, options) => {
       anchorRef.current = link;
@@ -3599,18 +3604,18 @@ function CakeLinkPopover(params) {
     [toOverlayRect]
   );
   require$$0.useEffect(() => {
-    if (state2.status !== "open") {
+    if (state.status !== "open") {
       return;
     }
     reposition();
-  }, [reposition, state2.status, isEditing]);
+  }, [reposition, state.status, isEditing]);
   require$$0.useEffect(() => {
     var _a;
-    if (state2.status !== "open" || !isEditing) {
+    if (state.status !== "open" || !isEditing) {
       return;
     }
     (_a = inputRef.current) == null ? void 0 : _a.focus();
-  }, [state2.status, isEditing]);
+  }, [state.status, isEditing]);
   require$$0.useEffect(() => {
     function handleContentClick(event) {
       const link = getLinkFromEventTarget(event.target);
@@ -3653,7 +3658,7 @@ function CakeLinkPopover(params) {
     };
   }, [contentRoot, openForLink]);
   require$$0.useEffect(() => {
-    if (state2.status !== "open") {
+    if (state.status !== "open") {
       return;
     }
     container.addEventListener("scroll", close, { passive: true });
@@ -3662,7 +3667,7 @@ function CakeLinkPopover(params) {
       container.removeEventListener("scroll", close);
       window.removeEventListener("resize", reposition);
     };
-  }, [close, container, reposition, state2.status]);
+  }, [close, container, reposition, state.status]);
   const handleMouseDown = require$$0.useCallback(
     (event) => {
       event.stopPropagation();
@@ -3673,10 +3678,10 @@ function CakeLinkPopover(params) {
     },
     []
   );
-  if (state2.status !== "open") {
+  if (state.status !== "open") {
     return null;
   }
-  const displayUrl = ensureHttpsProtocol(state2.url);
+  const displayUrl = ensureHttpsProtocol(state.url);
   const handleEdit = () => {
     setState((current) => {
       if (current.status !== "open") {
@@ -3695,10 +3700,10 @@ function CakeLinkPopover(params) {
   };
   const handleSave = () => {
     var _a;
-    if (state2.status !== "open") {
+    if (state.status !== "open") {
       return;
     }
-    const draftValue = ((_a = inputRef.current) == null ? void 0 : _a.value) ?? state2.draftUrl;
+    const draftValue = ((_a = inputRef.current) == null ? void 0 : _a.value) ?? state.draftUrl;
     const trimmed = draftValue.trim();
     if (!trimmed) {
       close();
@@ -3712,7 +3717,7 @@ function CakeLinkPopover(params) {
       url: nextUrl,
       isEditing: false,
       draftUrl: nextUrl,
-      position: state2.position
+      position: state.position
     });
   };
   const handleOpen = () => {
@@ -3744,13 +3749,13 @@ function CakeLinkPopover(params) {
       ref: popoverRef,
       style: {
         position: "absolute",
-        top: state2.position.top,
-        left: state2.position.left,
+        top: state.position.top,
+        left: state.position.left,
         pointerEvents: "auto"
       },
       onMouseDown: handleMouseDown,
       onClick: (event) => event.stopPropagation(),
-      children: state2.isEditing ? /* @__PURE__ */ jsxRuntimeExports.jsxs(
+      children: state.isEditing ? /* @__PURE__ */ jsxRuntimeExports.jsxs(
         "form",
         {
           className: "cake-link-editor",
@@ -3764,7 +3769,7 @@ function CakeLinkPopover(params) {
               {
                 className: "cake-link-input",
                 type: "text",
-                value: state2.draftUrl,
+                value: state.draftUrl,
                 ref: inputRef,
                 onChange: (event) => {
                   setState((current) => {
@@ -4036,8 +4041,8 @@ const linkExtension = defineExtension({
       key: "u",
       meta: true,
       shift: true,
-      command: (state2) => {
-        if (state2.selection.start === state2.selection.end) {
+      command: (state) => {
+        if (state.selection.start === state.selection.end) {
           return null;
         }
         return { type: "wrap-link", openPopover: true };
@@ -4047,19 +4052,19 @@ const linkExtension = defineExtension({
       key: "u",
       ctrl: true,
       shift: true,
-      command: (state2) => {
-        if (state2.selection.start === state2.selection.end) {
+      command: (state) => {
+        if (state.selection.start === state.selection.end) {
           return null;
         }
         return { type: "wrap-link", openPopover: true };
       }
     }
   ],
-  onEdit(command, state2) {
+  onEdit(command, state) {
     if (command.type === "unlink") {
       const cursorPos = command.start;
-      const sourcePos = state2.map.cursorToSource(cursorPos, "forward");
-      const source = state2.source;
+      const sourcePos = state.map.cursorToSource(cursorPos, "forward");
+      const source = state.source;
       let linkStart = sourcePos;
       while (linkStart > 0 && source[linkStart] !== "[") {
         linkStart--;
@@ -4077,7 +4082,7 @@ const linkExtension = defineExtension({
       }
       const label2 = source.slice(linkStart + 1, labelClose);
       const nextSource2 = source.slice(0, linkStart) + label2 + source.slice(urlClose + 1);
-      const newState = state2.runtime.createState(nextSource2);
+      const newState = state.runtime.createState(nextSource2);
       const labelEndSource = linkStart + label2.length;
       const newCursor = newState.map.sourceToCursor(labelEndSource, "forward");
       return {
@@ -4092,21 +4097,21 @@ const linkExtension = defineExtension({
     if (command.type !== "wrap-link") {
       return null;
     }
-    const selection = state2.selection;
+    const selection = state.selection;
     const cursorStart = Math.min(selection.start, selection.end);
     const cursorEnd = Math.max(selection.start, selection.end);
     if (cursorStart === cursorEnd) {
       return null;
     }
-    const from = state2.map.cursorToSource(cursorStart, "forward");
-    const to = state2.map.cursorToSource(cursorEnd, "backward");
+    const from = state.map.cursorToSource(cursorStart, "forward");
+    const to = state.map.cursorToSource(cursorEnd, "backward");
     if (from === to) {
       return null;
     }
-    const label = state2.source.slice(from, to);
+    const label = state.source.slice(from, to);
     const url = command.url ?? "";
     const linkMarkdown = `[${label}](${url})`;
-    const nextSource = state2.source.slice(0, from) + linkMarkdown + state2.source.slice(to);
+    const nextSource = state.source.slice(0, from) + linkMarkdown + state.source.slice(to);
     return {
       source: nextSource,
       selection: {
@@ -4116,16 +4121,16 @@ const linkExtension = defineExtension({
       }
     };
   },
-  onPasteText(text, state2) {
+  onPasteText(text, state) {
     if (!isUrl(text)) {
       return null;
     }
     const url = ensureHttpsProtocol(text.trim());
-    const selection = state2.selection;
+    const selection = state.selection;
     const start = Math.min(selection.start, selection.end);
     const end = Math.max(selection.start, selection.end);
     if (start !== end) {
-      const lines = getDocLines(state2.doc);
+      const lines = getDocLines(state.doc);
       const visibleText = getVisibleText(lines);
       const visibleStart = cursorOffsetToVisibleOffset(lines, start);
       const visibleEnd = cursorOffsetToVisibleOffset(lines, end);
@@ -4297,8 +4302,61 @@ const pipeLinkExtension = defineExtension({
 });
 const BLOCKQUOTE_KIND = "blockquote";
 const PREFIX = "> ";
+const BLOCKQUOTE_PATTERN = /^> /;
+function findLineStartInSource$1(source, sourceOffset) {
+  let lineStart = sourceOffset;
+  while (lineStart > 0 && source[lineStart - 1] !== "\n") {
+    lineStart--;
+  }
+  return lineStart;
+}
+function handleToggleBlockquote(state) {
+  const { source, selection, map, runtime } = state;
+  const cursorPos = Math.min(selection.start, selection.end);
+  const sourcePos = map.cursorToSource(
+    cursorPos,
+    selection.affinity ?? "forward"
+  );
+  const lineStart = findLineStartInSource$1(source, sourcePos);
+  let lineEnd = source.indexOf("\n", lineStart);
+  if (lineEnd === -1) {
+    lineEnd = source.length;
+  }
+  const lineContent = source.slice(lineStart, lineEnd);
+  const blockquoteMatch = lineContent.match(BLOCKQUOTE_PATTERN);
+  let newSource;
+  let newCursorOffset;
+  if (blockquoteMatch) {
+    newSource = source.slice(0, lineStart) + lineContent.slice(PREFIX.length) + source.slice(lineEnd);
+    const cursorLineOffset = sourcePos - lineStart;
+    if (cursorLineOffset >= PREFIX.length) {
+      newCursorOffset = sourcePos - PREFIX.length;
+    } else {
+      newCursorOffset = lineStart;
+    }
+  } else {
+    newSource = source.slice(0, lineStart) + PREFIX + lineContent + source.slice(lineEnd);
+    newCursorOffset = sourcePos + PREFIX.length;
+  }
+  const next = runtime.createState(newSource);
+  const caretCursor = next.map.sourceToCursor(newCursorOffset, "forward");
+  return {
+    source: newSource,
+    selection: {
+      start: caretCursor.cursorOffset,
+      end: caretCursor.cursorOffset,
+      affinity: "forward"
+    }
+  };
+}
 const blockquoteExtension = defineExtension({
   name: "blockquote",
+  onEdit(command, state) {
+    if (command.type === "toggle-blockquote") {
+      return handleToggleBlockquote(state);
+    }
+    return null;
+  },
   parseBlock(source, start, context) {
     if (source.slice(start, start + PREFIX.length) !== PREFIX) {
       return null;
@@ -4361,6 +4419,7 @@ const blockquoteExtension = defineExtension({
       return null;
     }
     const element = document.createElement("blockquote");
+    element.setAttribute("data-block-wrapper", BLOCKQUOTE_KIND);
     for (const node of context.renderBlocks(block.blocks)) {
       element.append(node);
     }
@@ -4372,10 +4431,16 @@ const italicExtension = defineExtension({
   name: "italic",
   toggleInline: { kind: ITALIC_KIND, markers: ["*", "_"] },
   keybindings: [
-    { key: "i", meta: true, command: { type: "toggle-inline", marker: "*" } },
-    { key: "i", ctrl: true, command: { type: "toggle-inline", marker: "*" } }
+    { key: "i", meta: true, command: { type: "toggle-italic" } },
+    { key: "i", ctrl: true, command: { type: "toggle-italic" } }
   ],
   inlineWrapperAffinity: [{ kind: ITALIC_KIND, inclusive: true }],
+  onEdit(command) {
+    if (command.type === "toggle-italic") {
+      return { type: "toggle-inline", marker: "*" };
+    }
+    return null;
+  },
   parseInline(source, start, end, context) {
     const char = source[start];
     if (char !== "_" && char !== "*") {
@@ -4448,8 +4513,8 @@ function findLineStartInSource(source, sourceOffset) {
   }
   return lineStart;
 }
-function handleDeleteBackward$1(state2) {
-  const { source, selection, map } = state2;
+function handleDeleteBackward$1(state) {
+  const { source, selection, map } = state;
   if (selection.start !== selection.end) {
     return null;
   }
@@ -4476,8 +4541,8 @@ function handleDeleteBackward$1(state2) {
     }
   };
 }
-function handleMultilineInsertInHeading(state2, text) {
-  const { source, selection, map, runtime } = state2;
+function handleMultilineInsertInHeading(state, text) {
+  const { source, selection, map, runtime } = state;
   const normalizedText = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
   if (!normalizedText.includes("\n")) {
     return null;
@@ -4518,8 +4583,8 @@ function handleMultilineInsertInHeading(state2, text) {
     }
   };
 }
-function shouldExitHeadingOnLineBreak(state2) {
-  const { source, selection, map } = state2;
+function shouldExitHeadingOnLineBreak(state) {
+  const { source, selection, map } = state;
   if (selection.start !== selection.end) {
     return false;
   }
@@ -4539,20 +4604,78 @@ function shouldExitHeadingOnLineBreak(state2) {
   const contentStart = lineStart + marker.length;
   return sourcePos >= contentStart && sourcePos <= lineEnd;
 }
+function handleToggleHeading(state, targetLevel) {
+  const { source, selection, map, runtime } = state;
+  const cursorPos = Math.min(selection.start, selection.end);
+  const sourcePos = map.cursorToSource(
+    cursorPos,
+    selection.affinity ?? "forward"
+  );
+  const lineStart = findLineStartInSource(source, sourcePos);
+  let lineEnd = source.indexOf("\n", lineStart);
+  if (lineEnd === -1) {
+    lineEnd = source.length;
+  }
+  const lineContent = source.slice(lineStart, lineEnd);
+  const headingMatch = lineContent.match(HEADING_PATTERN);
+  let newSource;
+  let newCursorOffset;
+  if (headingMatch) {
+    const currentLevel = headingMatch[1].length;
+    const existingMarker = headingMatch[0];
+    if (currentLevel === targetLevel) {
+      newSource = source.slice(0, lineStart) + lineContent.slice(existingMarker.length) + source.slice(lineEnd);
+      const cursorLineOffset = sourcePos - lineStart;
+      if (cursorLineOffset >= existingMarker.length) {
+        newCursorOffset = sourcePos - existingMarker.length;
+      } else {
+        newCursorOffset = lineStart;
+      }
+    } else {
+      const newMarker = "#".repeat(targetLevel) + " ";
+      newSource = source.slice(0, lineStart) + newMarker + lineContent.slice(existingMarker.length) + source.slice(lineEnd);
+      const markerDiff = newMarker.length - existingMarker.length;
+      const cursorLineOffset = sourcePos - lineStart;
+      if (cursorLineOffset >= existingMarker.length) {
+        newCursorOffset = sourcePos + markerDiff;
+      } else {
+        newCursorOffset = lineStart + newMarker.length;
+      }
+    }
+  } else {
+    const newMarker = "#".repeat(targetLevel) + " ";
+    newSource = source.slice(0, lineStart) + newMarker + lineContent + source.slice(lineEnd);
+    newCursorOffset = sourcePos + newMarker.length;
+  }
+  const next = runtime.createState(newSource);
+  const caretCursor = next.map.sourceToCursor(newCursorOffset, "forward");
+  return {
+    source: newSource,
+    selection: {
+      start: caretCursor.cursorOffset,
+      end: caretCursor.cursorOffset,
+      affinity: "forward"
+    }
+  };
+}
 const headingExtension = defineExtension({
   name: "heading",
-  onEdit(command, state2) {
+  onEdit(command, state) {
+    if (command.type === "toggle-heading") {
+      const level = command.level ?? 1;
+      return handleToggleHeading(state, level);
+    }
     if (command.type === "delete-backward") {
-      return handleDeleteBackward$1(state2);
+      return handleDeleteBackward$1(state);
     }
     if (command.type === "insert-line-break") {
-      if (shouldExitHeadingOnLineBreak(state2)) {
+      if (shouldExitHeadingOnLineBreak(state)) {
         return { type: "exit-block-wrapper" };
       }
       return null;
     }
     if (command.type === "insert") {
-      const multiline = handleMultilineInsertInHeading(state2, command.text);
+      const multiline = handleMultilineInsertInHeading(state, command.text);
       if (multiline) {
         return multiline;
       }
@@ -4560,7 +4683,7 @@ const headingExtension = defineExtension({
     if (command.type !== "insert" || command.text !== " ") {
       return null;
     }
-    const { source, selection, map } = state2;
+    const { source, selection, map } = state;
     if (selection.start !== selection.end) {
       return null;
     }
@@ -4795,13 +4918,13 @@ const imageExtension = defineExtension({
     return element;
   }
 });
-const LIST_LINE_REGEX$2 = /^(\s*)([-*+]|\d+\.)( )(.*)$/;
+const LIST_LINE_REGEX$1 = /^(\s*)([-*+]|\d+\.)( )(.*)$/;
 const INDENT_SIZE = 2;
 function parseMarkerType(marker) {
   return /^\d+\.$/.test(marker) ? "numbered" : "bullet";
 }
 function parseLine(line) {
-  const match = line.match(LIST_LINE_REGEX$2);
+  const match = line.match(LIST_LINE_REGEX$1);
   if (!match) {
     return { type: "plain", content: line };
   }
@@ -4881,14 +5004,14 @@ function getLineInfo(source, offset) {
   };
 }
 function getListPrefixLength(line) {
-  const match = line.match(LIST_LINE_REGEX$2);
+  const match = line.match(LIST_LINE_REGEX$1);
   if (!match) {
     return null;
   }
   return match[1].length + match[2].length + match[3].length;
 }
 function isListLine(line) {
-  return LIST_LINE_REGEX$2.test(line);
+  return LIST_LINE_REGEX$1.test(line);
 }
 function parseListItem(line) {
   const parsed = parseLine(line);
@@ -4908,9 +5031,9 @@ function countNumberedItemsBefore(source, beforeLineIndex) {
   }
   return count;
 }
-const LIST_LINE_REGEX$1 = /^(\s*)([-*+]|\d+\.)( )(.*)$/;
+const LIST_LINE_REGEX = /^(\s*)([-*+]|\d+\.)( )(.*)$/;
 function matchListLine(line) {
-  const match = line.match(LIST_LINE_REGEX$1);
+  const match = line.match(LIST_LINE_REGEX);
   if (!match) {
     return null;
   }
@@ -4989,8 +5112,8 @@ function getSelectionLineRange(source, selection) {
   );
   return { startLine: startInfo.lineIndex, endLine: endInfo.lineIndex };
 }
-function handleInsertLineBreak(state2) {
-  const { source, selection, map, runtime } = state2;
+function handleInsertLineBreak(state) {
+  const { source, selection, map, runtime } = state;
   let workingSource = source;
   let cursorPos = selection.start;
   let cursorSourcePos = map.cursorToSource(cursorPos, "forward");
@@ -5110,8 +5233,8 @@ function handleInsertLineBreak(state2) {
     }
   };
 }
-function handleDeleteBackward(state2) {
-  const { source, selection, map, runtime } = state2;
+function handleDeleteBackward(state) {
+  const { source, selection, map, runtime } = state;
   const resultAtSource = (nextSource, sourceOffset, bias = "forward") => {
     const next = runtime.createState(nextSource);
     const cursor = next.map.sourceToCursor(sourceOffset, bias);
@@ -5165,9 +5288,14 @@ function handleDeleteBackward(state2) {
   if (cursorPos === 0) {
     return null;
   }
-  const cursorSourcePos = map.cursorToSource(cursorPos, "backward");
-  const lineInfo = getLineInfo(source, cursorSourcePos);
-  const prefixLength = getListPrefixLength(lineInfo.line);
+  const cursorSourcePosBackward = map.cursorToSource(cursorPos, "backward");
+  const cursorSourcePosForward = map.cursorToSource(cursorPos, "forward");
+  const lineInfoBackward = getLineInfo(source, cursorSourcePosBackward);
+  const lineInfoForward = getLineInfo(source, cursorSourcePosForward);
+  const forwardPrefixLength = getListPrefixLength(lineInfoForward.line);
+  const backwardPrefixLength = getListPrefixLength(lineInfoBackward.line);
+  const lineInfo = forwardPrefixLength !== null && lineInfoForward.offsetInLine === forwardPrefixLength ? lineInfoForward : lineInfoBackward;
+  const prefixLength = lineInfo === lineInfoForward ? forwardPrefixLength : backwardPrefixLength;
   if (prefixLength === null) {
     if (lineInfo.offsetInLine === 0 && lineInfo.lineIndex > 0) {
       const lines = source.split("\n");
@@ -5261,8 +5389,8 @@ function handleDeleteBackward(state2) {
   }
   return null;
 }
-function handleDeleteForward(state2) {
-  const { source, selection, map, runtime } = state2;
+function handleDeleteForward(state) {
+  const { source, selection, map, runtime } = state;
   if (selection.start !== selection.end) {
     return null;
   }
@@ -5304,8 +5432,8 @@ function handleDeleteForward(state2) {
   }
   return null;
 }
-function handleIndent(state2) {
-  const { source, selection } = state2;
+function handleIndent(state) {
+  const { source, selection } = state;
   const { startLine, endLine } = getSelectionLineRange(source, selection);
   const lines = getSourceLines(source);
   let hasListLine = false;
@@ -5339,8 +5467,8 @@ function handleIndent(state2) {
     selection: { start: newStart, end: newEnd, affinity: "forward" }
   };
 }
-function handleOutdent(state2) {
-  const { source, selection } = state2;
+function handleOutdent(state) {
+  const { source, selection } = state;
   const { startLine, endLine } = getSelectionLineRange(source, selection);
   const lines = getSourceLines(source);
   let hasListLine = false;
@@ -5413,8 +5541,8 @@ function handleOutdent(state2) {
     selection: { start: newStart, end: newEnd, affinity: "forward" }
   };
 }
-function handleToggleList(state2, isBullet) {
-  const { source, selection } = state2;
+function handleToggleList(state, isBullet) {
+  const { source, selection } = state;
   const { startLine, endLine } = getSelectionLineRange(source, selection);
   const lines = getSourceLines(source);
   const bulletPattern = /^(\s*)([-*+])( )/;
@@ -5502,8 +5630,8 @@ function handleToggleList(state2, isBullet) {
     }
   };
 }
-function handleInsertListMarkerWithSelection(state2, marker) {
-  const { source, selection } = state2;
+function handleInsertListMarkerWithSelection(state, marker) {
+  const { source, selection } = state;
   if (selection.start === selection.end) {
     return null;
   }
@@ -5557,14 +5685,14 @@ function handleInsertListMarkerWithSelection(state2, marker) {
     selection: { start: cursorPos, end: cursorPos, affinity: "forward" }
   };
 }
-function handleMarkerSwitch(state2, insertedChar) {
-  const { source, selection } = state2;
+function handleMarkerSwitch(state, insertedChar) {
+  const { source, selection } = state;
   if (selection.start !== selection.end) {
     const { startLine, endLine } = getSelectionLineRange(source, selection);
     if (startLine !== endLine && (insertedChar === "-" || insertedChar === "*" || insertedChar === "+")) {
       return { type: "toggle-bullet-list" };
     }
-    return handleInsertListMarkerWithSelection(state2, insertedChar);
+    return handleInsertListMarkerWithSelection(state, insertedChar);
   }
   if (insertedChar !== "-" && insertedChar !== "*" && insertedChar !== "+") {
     return null;
@@ -5641,30 +5769,30 @@ const listExtension = defineExtension({
       command: { type: "toggle-numbered-list" }
     }
   ],
-  onEdit(command, state2) {
+  onEdit(command, state) {
     if (command.type === "insert-line-break") {
-      return handleInsertLineBreak(state2);
+      return handleInsertLineBreak(state);
     }
     if (command.type === "delete-backward") {
-      return handleDeleteBackward(state2);
+      return handleDeleteBackward(state);
     }
     if (command.type === "delete-forward") {
-      return handleDeleteForward(state2);
+      return handleDeleteForward(state);
     }
     if (command.type === "indent") {
-      return handleIndent(state2);
+      return handleIndent(state);
     }
     if (command.type === "outdent") {
-      return handleOutdent(state2);
+      return handleOutdent(state);
     }
     if (command.type === "toggle-bullet-list") {
-      return handleToggleList(state2, true);
+      return handleToggleList(state, true);
     }
     if (command.type === "toggle-numbered-list") {
-      return handleToggleList(state2, false);
+      return handleToggleList(state, false);
     }
     if (command.type === "insert" && command.text.length === 1) {
-      return handleMarkerSwitch(state2, command.text);
+      return handleMarkerSwitch(state, command.text);
     }
     return null;
   },
@@ -5710,7 +5838,7 @@ const THUMB_MIN_HEIGHT = 30;
 const SCROLL_HIDE_DELAY = 500;
 const TRACK_PADDING = 8;
 function ScrollbarOverlay({ container }) {
-  const [state2, setState] = require$$0.useState({
+  const [state, setState] = require$$0.useState({
     scrollTop: 0,
     scrollHeight: 0,
     clientHeight: 0
@@ -5723,7 +5851,7 @@ function ScrollbarOverlay({ container }) {
     null
   );
   const scrollTimeoutRef = require$$0.useRef(null);
-  const { scrollTop, scrollHeight, clientHeight } = state2;
+  const { scrollTop, scrollHeight, clientHeight } = state;
   const hasOverflow = scrollHeight > clientHeight;
   const trackHeight = clientHeight - TRACK_PADDING * 2;
   const rawThumbHeight = hasOverflow ? clientHeight / scrollHeight * trackHeight : 0;
@@ -5957,16 +6085,22 @@ const strikethroughExtension = defineExtension({
       key: "x",
       meta: true,
       shift: true,
-      command: { type: "toggle-inline", marker: "~~" }
+      command: { type: "toggle-strikethrough" }
     },
     {
       key: "x",
       ctrl: true,
       shift: true,
-      command: { type: "toggle-inline", marker: "~~" }
+      command: { type: "toggle-strikethrough" }
     }
   ],
   inlineWrapperAffinity: [{ kind: STRIKE_KIND, inclusive: true }],
+  onEdit(command) {
+    if (command.type === "toggle-strikethrough") {
+      return { type: "toggle-inline", marker: "~~" };
+    }
+    return null;
+  },
   parseInline(source, start, end, context) {
     if (source.slice(start, start + 2) !== "~~") {
       return null;
@@ -6065,27 +6199,23 @@ function mergeDomRects(rects) {
   });
   return new DOMRect(left, top, right - left, bottom - top);
 }
-function rectsOverlapVertically(a, b) {
-  const aBottom = a.top + a.height;
-  const bBottom = b.top + b.height;
-  return a.top < bBottom && b.top < aBottom;
-}
 function groupDomRectsByRow(rects) {
   if (rects.length === 0) {
     return [];
   }
+  const ROW_TOP_EPS_PX = 1;
   const sorted = [...rects].sort(
     (a, b) => a.top === b.top ? a.left - b.left : a.top - b.top
   );
   const grouped = [];
-  sorted.forEach((rect) => {
+  for (const rect of sorted) {
     const last = grouped[grouped.length - 1];
-    if (last && rectsOverlapVertically(last, rect)) {
+    if (last && Math.abs(rect.top - last.top) <= ROW_TOP_EPS_PX) {
       grouped[grouped.length - 1] = mergeDomRects([last, rect]) ?? last;
-      return;
+      continue;
     }
     grouped.push(rect);
-  });
+  }
   return grouped;
 }
 function cursorOffsetToCodeUnit(cursorToCodeUnit, offset) {
@@ -6149,11 +6279,26 @@ function measureCharacterRect(params) {
   );
   const startPosition = params.resolveDomPosition(startCodeUnit);
   const endPosition = params.resolveDomPosition(endCodeUnit);
-  params.range.setStart(startPosition.node, startPosition.offset);
-  params.range.setEnd(endPosition.node, endPosition.offset);
+  if (startPosition.node !== endPosition.node && startPosition.node instanceof Text && endPosition.node instanceof Text && startPosition.offset === startPosition.node.length && endPosition.offset > 0) {
+    params.range.setStart(endPosition.node, 0);
+    params.range.setEnd(endPosition.node, endPosition.offset);
+  } else {
+    params.range.setStart(startPosition.node, startPosition.offset);
+    params.range.setEnd(endPosition.node, endPosition.offset);
+  }
   const rects = params.range.getClientRects();
   if (rects.length > 0) {
-    return rects[0] ?? null;
+    const list = Array.from(rects);
+    let best = list[0] ?? null;
+    let bestArea = best ? best.width * best.height : 0;
+    for (const rect2 of list) {
+      const area = rect2.width * rect2.height;
+      if (area > bestArea) {
+        best = rect2;
+        bestArea = area;
+      }
+    }
+    return bestArea > 0 ? best : list[0] ?? null;
   }
   const rect = params.range.getBoundingClientRect();
   if (rect.width === 0 && rect.height === 0) {
@@ -6185,7 +6330,9 @@ function measureLineRows(params) {
   const fullLineEnd = resolvePosition(params.codeUnitLength);
   scratchRange.setStart(fullLineStart.node, fullLineStart.offset);
   scratchRange.setEnd(fullLineEnd.node, fullLineEnd.offset);
-  const fullLineRects = groupDomRectsByRow(Array.from(scratchRange.getClientRects()));
+  const fullLineRects = groupDomRectsByRow(
+    Array.from(scratchRange.getClientRects())
+  );
   if (fullLineRects.length === 0) {
     return [
       {
@@ -6195,7 +6342,15 @@ function measureLineRows(params) {
       }
     ];
   }
+  const rowRects = fullLineRects.map((rect, index) => {
+    var _a2;
+    const nextTop = ((_a2 = fullLineRects[index + 1]) == null ? void 0 : _a2.top) ?? params.lineRect.bottom;
+    const bottom = Math.max(rect.top, nextTop);
+    const height = Math.max(0, bottom - rect.top);
+    return new DOMRect(rect.left, rect.top, rect.width, height);
+  });
   function offsetToTop(offset) {
+    var _a2;
     if (topCache.has(offset)) {
       return topCache.get(offset) ?? null;
     }
@@ -6207,7 +6362,22 @@ function measureLineRows(params) {
       resolveDomPosition: resolvePosition,
       range: scratchRange
     });
-    const top = rect ? rect.top : null;
+    let top = rect ? rect.top : null;
+    if (top === null) {
+      const codeUnitOffset = cursorOffsetToCodeUnit(params.cursorToCodeUnit, offset);
+      const position = resolvePosition(codeUnitOffset);
+      scratchRange.setStart(position.node, position.offset);
+      scratchRange.setEnd(position.node, position.offset);
+      const rects = scratchRange.getClientRects();
+      if (rects.length > 0) {
+        top = ((_a2 = rects[0]) == null ? void 0 : _a2.top) ?? null;
+      } else {
+        const caretRect = scratchRange.getBoundingClientRect();
+        if (!(caretRect.width === 0 && caretRect.height === 0)) {
+          top = caretRect.top;
+        }
+      }
+    }
     topCache.set(offset, top);
     return top;
   }
@@ -6275,7 +6445,7 @@ function measureLineRows(params) {
   while (currentRowStart < params.lineLength) {
     const nextRowStart = findNextRowStartOffset(searchFrom, currentRowTop);
     const currentRowEnd = nextRowStart ?? params.lineLength;
-    const domRect = fullLineRects[rowIndex] ?? params.lineRect;
+    const domRect = rowRects[rowIndex] ?? params.lineRect;
     rows.push({
       startOffset: currentRowStart,
       endOffset: currentRowEnd,
@@ -6462,6 +6632,249 @@ function createOffsetToXMeasurer(params) {
 function cursorOffsetToDomOffset(cursorToCodeUnit, offset) {
   return cursorOffsetToCodeUnit(cursorToCodeUnit, offset);
 }
+function hitTestFromLayout(params) {
+  const { clientX, clientY, root, container, lines } = params;
+  const layout = measureLayoutModelFromDom({ lines, root, container });
+  if (!layout || layout.lines.length === 0) {
+    return null;
+  }
+  const containerRect = container.getBoundingClientRect();
+  const scroll = { top: container.scrollTop, left: container.scrollLeft };
+  const relativeX = clientX - containerRect.left + scroll.left;
+  const relativeY = clientY - containerRect.top + scroll.top;
+  const allRows = [];
+  for (const lineLayout of layout.lines) {
+    for (const row2 of lineLayout.rows) {
+      const centerY = row2.rect.top + row2.rect.height / 2;
+      allRows.push({
+        lineIndex: lineLayout.lineIndex,
+        lineStartOffset: lineLayout.lineStartOffset,
+        row: row2,
+        centerY
+      });
+    }
+  }
+  if (allRows.length === 0) {
+    return null;
+  }
+  let targetRowInfo = allRows[0];
+  let smallestCenterDistance = Math.abs(relativeY - targetRowInfo.centerY);
+  for (let i = 1; i < allRows.length; i++) {
+    const rowInfo = allRows[i];
+    const distance = Math.abs(relativeY - rowInfo.centerY);
+    if (distance < smallestCenterDistance) {
+      smallestCenterDistance = distance;
+      targetRowInfo = rowInfo;
+    }
+  }
+  const { lineIndex, lineStartOffset, row } = targetRowInfo;
+  const lineInfo = lines[lineIndex];
+  if (!lineInfo) {
+    return null;
+  }
+  const lineElement = getLineElement(root, lineIndex);
+  if (!lineElement) {
+    return null;
+  }
+  const resolvePosition = createDomPositionResolver(lineElement);
+  const scratchRange = document.createRange();
+  const rowTop = row.rect.top;
+  const approximateX = (cursorOffsetInLine) => {
+    const clamped = Math.max(
+      row.startOffset,
+      Math.min(cursorOffsetInLine, row.endOffset)
+    );
+    const rowLength = row.endOffset - row.startOffset;
+    if (rowLength <= 0) {
+      return row.rect.left;
+    }
+    const fraction = (clamped - row.startOffset) / rowLength;
+    return row.rect.left + row.rect.width * fraction;
+  };
+  const measureCaretXOnRow = (cursorOffsetInLine) => {
+    const maxRowTopDelta = Math.max(2, row.rect.height / 2);
+    const measureCharEdgeX = (from, to, edge) => {
+      const fromCodeUnit = cursorOffsetToCodeUnit(lineInfo.cursorToCodeUnit, from);
+      const toCodeUnit = cursorOffsetToCodeUnit(lineInfo.cursorToCodeUnit, to);
+      const fromPos = resolvePosition(fromCodeUnit);
+      const toPos = resolvePosition(toCodeUnit);
+      if (fromPos.node !== toPos.node && fromPos.node instanceof Text && toPos.node instanceof Text && fromPos.offset === fromPos.node.length && toPos.offset > 0) {
+        scratchRange.setStart(toPos.node, 0);
+        scratchRange.setEnd(toPos.node, toPos.offset);
+      } else {
+        scratchRange.setStart(fromPos.node, fromPos.offset);
+        scratchRange.setEnd(toPos.node, toPos.offset);
+      }
+      const rects2 = scratchRange.getClientRects();
+      const list = rects2.length > 0 ? Array.from(rects2) : (() => {
+        const rect = scratchRange.getBoundingClientRect();
+        return rect.width === 0 && rect.height === 0 ? [] : [rect];
+      })();
+      if (list.length === 0) {
+        return null;
+      }
+      const DIST_EPS = 0.01;
+      let bestTopDistance = Number.POSITIVE_INFINITY;
+      const candidates2 = [];
+      for (const rect of list) {
+        const top = rect.top - containerRect.top + scroll.top;
+        const distance = Math.abs(top - rowTop);
+        if (distance + DIST_EPS < bestTopDistance) {
+          bestTopDistance = distance;
+          candidates2.length = 0;
+          candidates2.push(rect);
+        } else if (Math.abs(distance - bestTopDistance) <= DIST_EPS) {
+          candidates2.push(rect);
+        }
+      }
+      if (candidates2.length === 0 || bestTopDistance > maxRowTopDelta) {
+        return null;
+      }
+      if (edge === "left") {
+        let left = candidates2[0].left;
+        for (const rect of candidates2) {
+          left = Math.min(left, rect.left);
+        }
+        return left - containerRect.left + scroll.left;
+      }
+      let right = candidates2[0].right;
+      for (const rect of candidates2) {
+        right = Math.max(right, rect.right);
+      }
+      return right - containerRect.left + scroll.left;
+    };
+    const prevChar = cursorOffsetInLine > 0 ? lineInfo.text[cursorOffsetInLine - 1] ?? "" : "";
+    const preferNextForPrevWhitespace = cursorOffsetInLine > row.startOffset && cursorOffsetInLine < row.endOffset && /\s/.test(prevChar);
+    if (preferNextForPrevWhitespace) {
+      const xNext = measureCharEdgeX(
+        cursorOffsetInLine,
+        cursorOffsetInLine + 1,
+        "left"
+      );
+      if (xNext !== null) {
+        return xNext;
+      }
+    }
+    if (cursorOffsetInLine > row.startOffset) {
+      const xPrev = measureCharEdgeX(
+        cursorOffsetInLine - 1,
+        cursorOffsetInLine,
+        "right"
+      );
+      if (xPrev !== null) {
+        return xPrev;
+      }
+    }
+    if (cursorOffsetInLine < row.endOffset) {
+      const xNext = measureCharEdgeX(
+        cursorOffsetInLine,
+        cursorOffsetInLine + 1,
+        "left"
+      );
+      if (xNext !== null) {
+        return xNext;
+      }
+    }
+    const codeUnitOffset = cursorOffsetToCodeUnit(
+      lineInfo.cursorToCodeUnit,
+      cursorOffsetInLine
+    );
+    const position = resolvePosition(codeUnitOffset);
+    scratchRange.setStart(position.node, position.offset);
+    scratchRange.setEnd(position.node, position.offset);
+    const rects = scratchRange.getClientRects();
+    const candidates = rects.length > 0 ? Array.from(rects) : [scratchRange.getBoundingClientRect()];
+    if (candidates.length === 0) {
+      return null;
+    }
+    let best = candidates[0];
+    let bestDistance = Number.POSITIVE_INFINITY;
+    for (const rect of candidates) {
+      const top = rect.top - containerRect.top + scroll.top;
+      const distance = Math.abs(top - rowTop);
+      if (distance < bestDistance) {
+        bestDistance = distance;
+        best = rect;
+      }
+    }
+    if (bestDistance > maxRowTopDelta) {
+      return null;
+    }
+    if (best.height <= 0) {
+      return null;
+    }
+    return best.left - containerRect.left + scroll.left;
+  };
+  const caretX = (cursorOffsetInLine) => {
+    return measureCaretXOnRow(cursorOffsetInLine) ?? approximateX(cursorOffsetInLine);
+  };
+  let low = row.startOffset;
+  let high = row.endOffset;
+  while (low < high) {
+    const mid = low + high >>> 1;
+    const xMid = caretX(mid);
+    if (xMid < relativeX) {
+      low = mid + 1;
+    } else {
+      high = mid;
+    }
+  }
+  const candidateA = Math.max(row.startOffset, Math.min(low, row.endOffset));
+  const candidateB = Math.max(
+    row.startOffset,
+    Math.min(candidateA - 1, row.endOffset)
+  );
+  const xA = caretX(candidateA);
+  const xB = caretX(candidateB);
+  const distA = Math.abs(relativeX - xA);
+  const distB = Math.abs(relativeX - xB);
+  const DIST_EPS_PX = 0.5;
+  let closestOffset = (() => {
+    if (distB + DIST_EPS_PX < distA) {
+      return candidateB;
+    }
+    if (distA + DIST_EPS_PX < distB) {
+      return candidateA;
+    }
+    const mid = (xA + xB) / 2;
+    return relativeX >= mid ? candidateA : candidateB;
+  })();
+  const endX = caretX(row.endOffset);
+  {
+    const baseMeasuredX = measureCaretXOnRow(closestOffset);
+    if (baseMeasuredX !== null) {
+      const baseCodeUnit = cursorOffsetToCodeUnit(
+        lineInfo.cursorToCodeUnit,
+        closestOffset
+      );
+      const COLLAPSE_EPS_PX = 0.25;
+      while (closestOffset > row.startOffset) {
+        const prev = closestOffset - 1;
+        const prevCodeUnit = cursorOffsetToCodeUnit(lineInfo.cursorToCodeUnit, prev);
+        if (prevCodeUnit !== baseCodeUnit) {
+          break;
+        }
+        const prevMeasuredX = measureCaretXOnRow(prev);
+        if (prevMeasuredX === null) {
+          break;
+        }
+        if (Math.abs(prevMeasuredX - baseMeasuredX) > COLLAPSE_EPS_PX) {
+          break;
+        }
+        closestOffset = prev;
+      }
+    }
+  }
+  const boundaryX = caretX(closestOffset);
+  const choseRightEdge = closestOffset > row.startOffset && relativeX < boundaryX - 0.01;
+  const isEndOfLine = row.endOffset === lineInfo.cursorLength;
+  const atLineEnd = closestOffset === row.endOffset && isEndOfLine;
+  const pastRowEnd = !atLineEnd && choseRightEdge || !atLineEnd && closestOffset === row.endOffset && row.endOffset < lineInfo.cursorLength && relativeX > endX + 0.5;
+  return {
+    cursorOffset: lineStartOffset + closestOffset,
+    pastRowEnd
+  };
+}
 function rectRight$1(rect) {
   return rect.left + rect.width;
 }
@@ -6771,7 +7184,14 @@ function getCaretRect(params) {
       backRange.setEnd(backEnd.node, backEnd.offset);
       const backRects = backRange.getClientRects();
       if (backRects.length > 0) {
-        backwardRect = backRects[backRects.length - 1];
+        let bestRect = backRects[backRects.length - 1];
+        for (let i = 0; i < backRects.length; i += 1) {
+          const rect = backRects[i];
+          if (rect.width > 0 && (bestRect.width === 0 || rect.top < bestRect.top)) {
+            bestRect = rect;
+          }
+        }
+        backwardRect = bestRect;
       }
     }
     if (canProbeForward) {
@@ -6788,7 +7208,14 @@ function getCaretRect(params) {
       fwdRange.setEnd(fwdEnd.node, fwdEnd.offset);
       const fwdRects = fwdRange.getClientRects();
       if (fwdRects.length > 0) {
-        forwardRect = fwdRects[0];
+        let bestRect = fwdRects[0];
+        for (let i = 1; i < fwdRects.length; i += 1) {
+          const rect = fwdRects[i];
+          if (rect.width > 0 && (bestRect.width === 0 || rect.top > bestRect.top)) {
+            bestRect = rect;
+          }
+        }
+        forwardRect = bestRect;
       }
     }
     const atWrapBoundary = backwardRect && forwardRect && Math.abs(backwardRect.top - forwardRect.top) > 5;
@@ -6796,8 +7223,43 @@ function getCaretRect(params) {
     let useRightEdge = false;
     if (atWrapBoundary) {
       if (affinity === "backward" && backwardRect) {
-        probeRect = backwardRect;
-        useRightEdge = true;
+        if (forwardRect) {
+          const startPos = resolveDomPosition(
+            lineElement,
+            cursorOffsetToDomOffset(lineInfo.cursorToCodeUnit, 0)
+          );
+          const endPos = resolveDomPosition(
+            lineElement,
+            cursorOffsetToDomOffset(lineInfo.cursorToCodeUnit, lineInfo.cursorLength)
+          );
+          const lineRange = document.createRange();
+          lineRange.setStart(startPos.node, startPos.offset);
+          lineRange.setEnd(endPos.node, endPos.offset);
+          const rowRects = groupDomRectsByRow(Array.from(lineRange.getClientRects()));
+          const ROW_EPS_PX = 1;
+          let previousRow = null;
+          for (const rowRect of rowRects) {
+            if (rowRect.top < forwardRect.top - ROW_EPS_PX) {
+              previousRow = rowRect;
+            } else {
+              break;
+            }
+          }
+          if (previousRow) {
+            caretRect = new DOMRect(
+              previousRow.right,
+              previousRow.top,
+              0,
+              previousRow.height
+            );
+          } else {
+            probeRect = backwardRect;
+            useRightEdge = true;
+          }
+        } else {
+          probeRect = backwardRect;
+          useRightEdge = true;
+        }
       } else if (forwardRect) {
         probeRect = forwardRect;
         useRightEdge = false;
@@ -6818,6 +7280,37 @@ function getCaretRect(params) {
       const left = useRightEdge ? probeRect.right : probeRect.left;
       caretRect = new DOMRect(left, probeRect.top, 0, probeRect.height);
     }
+    if (affinity === "backward" && forwardRect) {
+      const startPos = resolveDomPosition(
+        lineElement,
+        cursorOffsetToDomOffset(lineInfo.cursorToCodeUnit, 0)
+      );
+      const endPos = resolveDomPosition(
+        lineElement,
+        cursorOffsetToDomOffset(lineInfo.cursorToCodeUnit, lineInfo.cursorLength)
+      );
+      const lineRange = document.createRange();
+      lineRange.setStart(startPos.node, startPos.offset);
+      lineRange.setEnd(endPos.node, endPos.offset);
+      const rowRects = groupDomRectsByRow(Array.from(lineRange.getClientRects()));
+      const ROW_EPS_PX = 1;
+      let previousRow = null;
+      for (const rowRect of rowRects) {
+        if (rowRect.top < forwardRect.top - ROW_EPS_PX) {
+          previousRow = rowRect;
+        } else {
+          break;
+        }
+      }
+      if (previousRow && caretRect.top >= forwardRect.top - ROW_EPS_PX) {
+        caretRect = new DOMRect(
+          previousRow.right,
+          previousRow.top,
+          0,
+          previousRow.height
+        );
+      }
+    }
   }
   if (caretRect.height === 0 && lineRect.height === 0) {
     return null;
@@ -7656,6 +8149,8 @@ class CakeEngine {
     this.handleCompositionStartBound = this.handleCompositionStart.bind(this);
     this.handleCompositionEndBound = this.handleCompositionEnd.bind(this);
     this.handleSelectionChangeBound = this.handleSelectionChange.bind(this);
+    this.handleFocusInBound = this.handleFocusIn.bind(this);
+    this.handleFocusOutBound = this.handleFocusOut.bind(this);
     this.handleScrollBound = this.handleScroll.bind(this);
     this.handleResizeBound = this.handleResize.bind(this);
     this.handleClickBound = this.handleClick.bind(this);
@@ -7753,6 +8248,9 @@ class CakeEngine {
   getContentRoot() {
     return this.contentRoot;
   }
+  getLines() {
+    return getDocLines(this.state.doc);
+  }
   getOverlayRoot() {
     return this.ensureExtensionsRoot();
   }
@@ -7872,7 +8370,7 @@ class CakeEngine {
   canRedo() {
     return this.history.redoStack.length > 0;
   }
-  executeCommand(command) {
+  executeCommand(command, options) {
     var _a;
     const shouldOpenLinkPopover = "openPopover" in command && command.openPopover === true;
     const nextState = this.runtime.applyEdit(command, this.state);
@@ -7885,10 +8383,13 @@ class CakeEngine {
     (_a = this.onChange) == null ? void 0 : _a.call(this, this.state.source, this.state.selection);
     this.scheduleScrollCaretIntoView();
     if (shouldOpenLinkPopover) {
-      queueMicrotask(() => {
+      window.requestAnimationFrame(() => {
         this.openLinkPopoverForSelection(true);
       });
     }
+    if (options == null ? void 0 : options.restoreFocus) {
+      this.focus();
+    }
     return true;
   }
   attachListeners() {
@@ -7902,6 +8403,8 @@ class CakeEngine {
       "compositionend",
       this.handleCompositionEndBound
     );
+    this.container.addEventListener("focusin", this.handleFocusInBound);
+    this.container.addEventListener("focusout", this.handleFocusOutBound);
     document.addEventListener(
       "selectionchange",
       this.handleSelectionChangeBound
@@ -7958,6 +8461,8 @@ class CakeEngine {
       "compositionend",
       this.handleCompositionEndBound
     );
+    this.container.removeEventListener("focusin", this.handleFocusInBound);
+    this.container.removeEventListener("focusout", this.handleFocusOutBound);
     document.removeEventListener(
       "selectionchange",
       this.handleSelectionChangeBound
@@ -7982,6 +8487,16 @@ class CakeEngine {
     this.container.removeEventListener("pointerup", this.handlePointerUpBound);
     this.detachDragListeners();
   }
+  handleFocusIn() {
+    queueMicrotask(() => {
+      this.scheduleOverlayUpdate();
+    });
+  }
+  handleFocusOut() {
+    queueMicrotask(() => {
+      this.scheduleOverlayUpdate();
+    });
+  }
   render() {
     const perfEnabled = this.container.dataset.cakePerf === "1";
     let perfStart = 0;
@@ -8037,7 +8552,7 @@ class CakeEngine {
       this.contentRoot
     );
     const existingChildren = Array.from(this.contentRoot.childNodes);
-    const isManagedChild = (node) => node instanceof Element && node.hasAttribute("data-line-index");
+    const isManagedChild = (node) => node instanceof Element && (node.hasAttribute("data-line-index") || node.hasAttribute("data-block-wrapper"));
     const existingManagedChildren = existingChildren.filter(isManagedChild);
     const preservedChildren = existingChildren.filter((node) => !isManagedChild(node));
     const needsUpdate = content.length !== existingManagedChildren.length || content.some((node, i) => node !== existingManagedChildren[i]);
@@ -8283,7 +8798,7 @@ class CakeEngine {
     };
   }
   handleClick(event) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e;
     if (this.isComposing) {
       return;
     }
@@ -8338,6 +8853,29 @@ class CakeEngine {
         }, 0);
         return;
       }
+      if (!pendingHit) {
+        const hit2 = this.hitTestFromClientPoint(event.clientX, event.clientY);
+        if (!hit2) {
+          return;
+        }
+        const newSelection = {
+          start: hit2.cursorOffset,
+          end: hit2.cursorOffset,
+          affinity: hit2.affinity
+        };
+        this.pendingClickHit = null;
+        this.suppressSelectionChange = true;
+        this.state = this.runtime.updateSelection(this.state, newSelection, {
+          kind: "dom"
+        });
+        this.applySelection(this.state.selection);
+        (_c = this.onSelectionChange) == null ? void 0 : _c.call(this, this.state.selection);
+        this.scheduleOverlayUpdate();
+        setTimeout(() => {
+          this.suppressSelectionChange = false;
+        }, 0);
+        return;
+      }
       this.pendingClickHit = null;
       setTimeout(() => {
         this.suppressSelectionChange = false;
@@ -8373,7 +8911,7 @@ class CakeEngine {
         kind: "dom"
       });
       this.applySelection(this.state.selection);
-      (_c = this.onSelectionChange) == null ? void 0 : _c.call(this, this.state.selection);
+      (_d = this.onSelectionChange) == null ? void 0 : _d.call(this, this.state.selection);
       this.suppressSelectionChange = false;
       return;
     }
@@ -8397,7 +8935,7 @@ class CakeEngine {
         kind: "dom"
       });
       this.applySelection(this.state.selection);
-      (_d = this.onSelectionChange) == null ? void 0 : _d.call(this, this.state.selection);
+      (_e = this.onSelectionChange) == null ? void 0 : _e.call(this, this.state.selection);
       this.suppressSelectionChange = false;
     }
   }
@@ -8622,13 +9160,15 @@ class CakeEngine {
     }
   }
   resolveExtensionKeybinding(event) {
+    const eventKey = event.key.length === 1 ? event.key.toLowerCase() : event.key;
     for (const extension of this.extensions) {
       const bindings = extension.keybindings;
       if (!bindings) {
         continue;
       }
       for (const binding of bindings) {
-        if (binding.key !== event.key) {
+        const bindingKey = binding.key.length === 1 ? binding.key.toLowerCase() : binding.key;
+        if (bindingKey !== eventKey) {
           continue;
         }
         if (binding.meta !== void 0 && binding.meta !== event.metaKey) {
@@ -10103,78 +10643,22 @@ class CakeEngine {
     }
   }
   hitTestFromClientPoint(clientX, clientY) {
-    var _a, _b;
-    let node = null;
-    let offset = 0;
-    let pastRowEnd = false;
-    const position = caretPositionFromPoint(clientX, clientY);
-    if (position) {
-      node = position.offsetNode;
-      offset = position.offset;
-    } else {
-      const range = caretRangeFromPoint(clientX, clientY);
-      if (range) {
-        node = range.startContainer;
-        offset = range.startOffset;
-      }
-    }
-    if (!node || !this.container.contains(node)) {
-      const closestLine = this.findClosestLineByY(clientY);
-      const textNode = closestLine ? findFirstTextNode(closestLine) : null;
-      if (textNode) {
-        node = textNode;
-        const hit = findOffsetInTextNode(textNode, clientX, clientY);
-        offset = hit.offset;
-        pastRowEnd = hit.pastRowEnd;
-      }
-    }
-    if (!node || !this.container.contains(node)) {
+    if (!this.contentRoot) {
       return null;
     }
-    const lineElement = node instanceof Element ? node.closest(".cake-line") : (_a = node.parentElement) == null ? void 0 : _a.closest(".cake-line");
-    if (lineElement) {
-      const lineRect = lineElement.getBoundingClientRect();
-      const isClickOutsideLine = clientY < lineRect.top || clientY > lineRect.bottom;
-      if (isClickOutsideLine) {
-        const closestLine = this.findClosestLineByY(clientY);
-        if (closestLine && closestLine !== lineElement) {
-          const textNode = findFirstTextNode(closestLine);
-          if (textNode) {
-            node = textNode;
-            const hit = findOffsetInTextNode(textNode, clientX, clientY);
-            offset = hit.offset;
-            pastRowEnd = hit.pastRowEnd;
-          }
-        }
-      }
-    }
-    if (node instanceof Element) {
-      const resolved = resolveTextPoint(node, offset);
-      if (resolved) {
-        node = resolved.node;
-        offset = resolved.offset;
-      }
-    }
-    if (node instanceof Text) {
-      const hit = findOffsetInTextNode(node, clientX, clientY);
-      offset = hit.offset;
-      pastRowEnd = hit.pastRowEnd;
-    }
-    if (!pastRowEnd) {
-      const lineElement2 = node instanceof Element ? node.closest(".cake-line") : (_b = node.parentElement) == null ? void 0 : _b.closest(".cake-line");
-      if (lineElement2) {
-        const lineRect = lineElement2.getBoundingClientRect();
-        pastRowEnd = clientX > lineRect.right;
-      }
-    }
-    const cursor = this.cursorFromDom(node, offset);
-    if (!cursor) {
+    const lines = getDocLines(this.state.doc);
+    const hit = hitTestFromLayout({
+      clientX,
+      clientY,
+      root: this.contentRoot,
+      container: this.container,
+      lines
+    });
+    if (!hit) {
       return null;
     }
-    if (!pastRowEnd) {
-      return cursor;
-    }
-    return { cursorOffset: cursor.cursorOffset, affinity: "backward" };
+    const affinity = hit.pastRowEnd ? "backward" : "forward";
+    return { cursorOffset: hit.cursorOffset, affinity };
   }
   handlePointerDown(event) {
     var _a, _b, _c;
@@ -10886,178 +11370,6 @@ function findTextNodeAtOrAfter(nodes, start) {
   }
   return null;
 }
-function findOffsetInTextNode(textNode, clientX, clientY) {
-  const text = textNode.textContent ?? "";
-  if (text.length === 0) {
-    return { offset: 0, pastRowEnd: false };
-  }
-  let closestOffset = 0;
-  let closestDistance = Infinity;
-  let closestYDistance = Infinity;
-  let closestCaretX = 0;
-  let selectedViaRightEdge = false;
-  const rowInfo = /* @__PURE__ */ new Map();
-  const range = document.createRange();
-  let lastCharRect = null;
-  for (let i = 0; i <= text.length; i += 1) {
-    if (i < text.length) {
-      range.setStart(textNode, i);
-      range.setEnd(textNode, i + 1);
-    } else {
-      range.setStart(textNode, i);
-      range.setEnd(textNode, i);
-    }
-    let rects = range.getClientRects();
-    if (rects.length === 0 && i === text.length && lastCharRect) {
-      const syntheticRect = new DOMRect(
-        lastCharRect.right,
-        lastCharRect.top,
-        0,
-        lastCharRect.height
-      );
-      rects = [syntheticRect];
-    }
-    if (rects.length === 0) {
-      continue;
-    }
-    if (i < text.length) {
-      lastCharRect = rects[0];
-    }
-    let bestRect = rects[0];
-    for (let r = 1; r < rects.length; r += 1) {
-      const rect = rects[r];
-      const bestCenterY = bestRect.top + bestRect.height / 2;
-      const rectCenterY = rect.top + rect.height / 2;
-      if (Math.abs(clientY - rectCenterY) < Math.abs(clientY - bestCenterY)) {
-        bestRect = rect;
-      }
-    }
-    const rowKey = Math.round(bestRect.top);
-    if (!rowInfo.has(rowKey)) {
-      rowInfo.set(rowKey, {
-        startOffset: i,
-        endOffset: i,
-        left: bestRect.left,
-        right: bestRect.right,
-        top: bestRect.top,
-        bottom: bestRect.bottom
-      });
-    } else {
-      const row = rowInfo.get(rowKey);
-      if (row) {
-        row.startOffset = Math.min(row.startOffset, i);
-        row.endOffset = Math.max(row.endOffset, i);
-        row.left = Math.min(row.left, bestRect.left);
-        row.right = Math.max(row.right, bestRect.right);
-        row.top = Math.min(row.top, bestRect.top);
-        row.bottom = Math.max(row.bottom, bestRect.bottom);
-      }
-    }
-    const centerY = bestRect.top + bestRect.height / 2;
-    const yDistance = Math.abs(clientY - centerY);
-    const isWithinRowBounds = clientY >= bestRect.top && clientY <= bestRect.bottom;
-    const isSameRow = isWithinRowBounds;
-    const caretX = bestRect.left;
-    const xDistance = Math.abs(clientX - caretX);
-    if (isSameRow) {
-      if (xDistance <= closestDistance) {
-        closestDistance = xDistance;
-        closestOffset = i;
-        closestCaretX = caretX;
-        bestRect.top;
-        closestYDistance = yDistance;
-        selectedViaRightEdge = false;
-      }
-      if (i < text.length) {
-        const rightEdgeX = bestRect.right;
-        const rightEdgeDistance = Math.abs(clientX - rightEdgeX);
-        if (rightEdgeDistance < closestDistance) {
-          closestDistance = rightEdgeDistance;
-          closestOffset = i + 1;
-          closestCaretX = rightEdgeX;
-          bestRect.top;
-          closestYDistance = yDistance;
-          selectedViaRightEdge = true;
-        }
-      }
-    } else if (yDistance < closestYDistance || yDistance === closestYDistance && xDistance < closestDistance) {
-      closestYDistance = yDistance;
-      closestDistance = xDistance;
-      closestOffset = i;
-      closestCaretX = caretX;
-      bestRect.top;
-    }
-  }
-  let closestRow = null;
-  for (const row of rowInfo.values()) {
-    if (clientY >= row.top && clientY <= row.bottom) {
-      closestRow = row;
-      break;
-    }
-  }
-  if (!closestRow) {
-    let smallestDistance = Infinity;
-    for (const row of rowInfo.values()) {
-      const centerY = row.top + (row.bottom - row.top) / 2;
-      const distance = Math.abs(clientY - centerY);
-      if (distance < smallestDistance) {
-        smallestDistance = distance;
-        closestRow = row;
-      }
-    }
-  }
-  if (closestRow) {
-    if (clientX < closestRow.left) {
-      closestOffset = closestRow.startOffset;
-      closestCaretX = closestRow.left;
-      closestRow.top;
-    } else if (clientX > closestRow.right) {
-      closestOffset = Math.min(closestRow.endOffset + 1, text.length);
-      closestCaretX = closestRow.right;
-      closestRow.top;
-    } else if (clientY < closestRow.top || clientY > closestRow.bottom) {
-      let bestXDistance = Infinity;
-      const range2 = document.createRange();
-      for (let i = closestRow.startOffset; i <= closestRow.endOffset; i += 1) {
-        if (i < text.length) {
-          range2.setStart(textNode, i);
-          range2.setEnd(textNode, i + 1);
-        } else {
-          range2.setStart(textNode, i);
-          range2.setEnd(textNode, i);
-        }
-        const rects = range2.getClientRects();
-        if (rects.length === 0) continue;
-        const rect = rects[0];
-        const xDist = Math.abs(clientX - rect.left);
-        if (xDist <= bestXDistance) {
-          bestXDistance = xDist;
-          closestOffset = i;
-          closestCaretX = rect.left;
-          closestRow.top;
-        }
-      }
-    }
-  }
-  const pastRowEnd = selectedViaRightEdge || closestRow !== null && clientX > closestRow.right;
-  if (Math.abs(clientX - closestCaretX) <= 2 && closestOffset < text.length && text[closestOffset] === "\n") {
-    closestOffset = Math.max(0, closestOffset - 1);
-  }
-  return { offset: closestOffset, pastRowEnd };
-}
-function caretPositionFromPoint(x, y) {
-  const doc = document;
-  if (typeof doc.caretPositionFromPoint === "function") {
-    return doc.caretPositionFromPoint(x, y);
-  }
-  return null;
-}
-function caretRangeFromPoint(x, y) {
-  if (typeof document.caretRangeFromPoint === "function") {
-    return document.caretRangeFromPoint(x, y);
-  }
-  return null;
-}
 function getVisualRowBoundaries(params) {
   const { lines, layout, offset, affinity } = params;
   if (!layout || layout.lines.length === 0) {
@@ -11152,302 +11464,6 @@ function findTextNodeAtOrBefore(nodes, start) {
   }
   return null;
 }
-const toggleBold = ({ state: state$1, dispatch }) => {
-  const changes = state$1.changeByRange((range) => {
-    const isBoldBefore = state$1.sliceDoc(range.from - 2, range.from) === "**";
-    const isBoldAfter = state$1.sliceDoc(range.to, range.to + 2) === "**";
-    const changes2 = [];
-    changes2.push(
-      isBoldBefore ? {
-        from: range.from - 2,
-        to: range.from,
-        insert: ""
-      } : {
-        from: range.from,
-        insert: "**"
-      }
-    );
-    changes2.push(
-      isBoldAfter ? {
-        from: range.to,
-        to: range.to + 2,
-        insert: ""
-      } : {
-        from: range.to,
-        insert: "**"
-      }
-    );
-    const extendBefore = isBoldBefore ? -2 : 2;
-    const extendAfter = isBoldAfter ? -2 : 2;
-    return {
-      changes: changes2,
-      range: state.EditorSelection.range(
-        range.from + extendBefore,
-        range.to + extendAfter
-      )
-    };
-  });
-  dispatch(
-    state$1.update(changes, {
-      scrollIntoView: true,
-      annotations: state.Transaction.userEvent.of("input")
-    })
-  );
-  return true;
-};
-const toggleItalic = ({ state: state$1, dispatch }) => {
-  const changes = state$1.changeByRange((range) => {
-    const isItalicBefore = state$1.sliceDoc(range.from - 1, range.from) === "*";
-    const isItalicAfter = state$1.sliceDoc(range.to, range.to + 1) === "*";
-    const changes2 = [];
-    changes2.push(
-      isItalicBefore ? {
-        from: range.from - 1,
-        to: range.from,
-        insert: ""
-      } : {
-        from: range.from,
-        insert: "*"
-      }
-    );
-    changes2.push(
-      isItalicAfter ? {
-        from: range.to,
-        to: range.to + 1,
-        insert: ""
-      } : {
-        from: range.to,
-        insert: "*"
-      }
-    );
-    const extendBefore = isItalicBefore ? -1 : 1;
-    const extendAfter = isItalicAfter ? -1 : 1;
-    return {
-      changes: changes2,
-      range: state.EditorSelection.range(
-        range.from + extendBefore,
-        range.to + extendAfter
-      )
-    };
-  });
-  dispatch(
-    state$1.update(changes, {
-      scrollIntoView: true,
-      annotations: state.Transaction.userEvent.of("input")
-    })
-  );
-  return true;
-};
-const toggleStrikethrough = ({ state: state$1, dispatch }) => {
-  const changes = state$1.changeByRange((range) => {
-    const isStrikethroughBefore = state$1.sliceDoc(range.from - 2, range.from) === "~~";
-    const isStrikethroughAfter = state$1.sliceDoc(range.to, range.to + 2) === "~~";
-    const changes2 = [];
-    changes2.push(
-      isStrikethroughBefore ? {
-        from: range.from - 2,
-        to: range.from,
-        insert: ""
-      } : {
-        from: range.from,
-        insert: "~~"
-      }
-    );
-    changes2.push(
-      isStrikethroughAfter ? {
-        from: range.to,
-        to: range.to + 2,
-        insert: ""
-      } : {
-        from: range.to,
-        insert: "~~"
-      }
-    );
-    const extendBefore = isStrikethroughBefore ? -2 : 2;
-    const extendAfter = isStrikethroughAfter ? -2 : 2;
-    return {
-      changes: changes2,
-      range: state.EditorSelection.range(
-        range.from + extendBefore,
-        range.to + extendAfter
-      )
-    };
-  });
-  dispatch(
-    state$1.update(changes, {
-      scrollIntoView: true,
-      annotations: state.Transaction.userEvent.of("input")
-    })
-  );
-  return true;
-};
-const toggleLink = ({ state: state$1, dispatch }) => {
-  const changes = state$1.changeByRange((range) => {
-    const changes2 = [];
-    const selectedText = state$1.sliceDoc(range.from, range.to);
-    const linkRegex = /^\[([^\]]*)\]\(([^)]*)\)$/;
-    const linkMatch = selectedText.match(linkRegex);
-    if (linkMatch) {
-      const linkText = linkMatch[1];
-      changes2.push({
-        from: range.from,
-        to: range.to,
-        insert: linkText
-      });
-      return {
-        changes: changes2,
-        range: state.EditorSelection.range(range.from, range.from + linkText.length)
-      };
-    } else {
-      changes2.push({
-        from: range.from,
-        insert: "["
-      });
-      changes2.push({
-        from: range.to,
-        insert: "]()"
-      });
-      const newCursorPos = range.to + 3;
-      return {
-        changes: changes2,
-        range: state.EditorSelection.cursor(newCursorPos)
-        // Place cursor inside ()
-      };
-    }
-  });
-  dispatch(
-    state$1.update(changes, {
-      scrollIntoView: true,
-      annotations: state.Transaction.userEvent.of("input")
-    })
-  );
-  return true;
-};
-const LIST_LINE_REGEX = /^(\s*)([-*+]|(\d+)\.)(\s+)(.*)/;
-const toggleBulletList = ({ state: state$1, dispatch }) => {
-  const changes = state$1.changeByRange((range) => {
-    const changes2 = [];
-    if (range.from === range.to) {
-      changes2.push({
-        from: range.from,
-        insert: "-"
-      });
-      return {
-        changes: changes2,
-        range: state.EditorSelection.cursor(range.from + 1)
-      };
-    }
-    const startLine = state$1.doc.lineAt(range.from);
-    const endLine = state$1.doc.lineAt(range.to);
-    let rangeDelta = 0;
-    for (let i = startLine.number; i <= endLine.number; i++) {
-      const line = state$1.doc.line(i);
-      const lineText = line.text;
-      const match = lineText.match(LIST_LINE_REGEX);
-      if (match) {
-        const [, indent, , numberPart, space] = match;
-        if (numberPart) {
-          const prefixLength = indent.length + numberPart.length + 1 + space.length;
-          const newPrefix = `${indent}- `;
-          changes2.push({
-            from: line.from,
-            to: line.from + prefixLength,
-            insert: newPrefix
-          });
-          rangeDelta += newPrefix.length - prefixLength;
-        }
-      } else {
-        const indentMatch = lineText.match(/^(\s*)/);
-        const indent = indentMatch ? indentMatch[1] : "";
-        changes2.push({
-          from: line.from + indent.length,
-          insert: "- "
-        });
-        rangeDelta += 2;
-      }
-    }
-    return {
-      changes: changes2,
-      range: state.EditorSelection.range(range.from, range.to + rangeDelta)
-    };
-  });
-  dispatch(
-    state$1.update(changes, {
-      scrollIntoView: true,
-      annotations: state.Transaction.userEvent.of("input")
-    })
-  );
-  return true;
-};
-const toggleNumberedList = ({ state: state$1, dispatch }) => {
-  const changes = state$1.changeByRange((range) => {
-    const changes2 = [];
-    if (range.from === range.to) {
-      changes2.push({
-        from: range.from,
-        insert: "1. "
-      });
-      return {
-        changes: changes2,
-        range: state.EditorSelection.cursor(range.from + 3)
-      };
-    }
-    const startLine = state$1.doc.lineAt(range.from);
-    const endLine = state$1.doc.lineAt(range.to);
-    let listNumber = 1;
-    let rangeDelta = 0;
-    for (let i = startLine.number; i <= endLine.number; i++) {
-      const line = state$1.doc.line(i);
-      const lineText = line.text;
-      const match = lineText.match(LIST_LINE_REGEX);
-      if (match) {
-        const [, indent, bullet, numberPart, space] = match;
-        if (!numberPart) {
-          const prefixLength = indent.length + bullet.length + space.length;
-          const newPrefix = `${indent}${listNumber}. `;
-          changes2.push({
-            from: line.from,
-            to: line.from + prefixLength,
-            insert: newPrefix
-          });
-          rangeDelta += newPrefix.length - prefixLength;
-          listNumber++;
-        } else {
-          const prefixLength = indent.length + numberPart.length + 1 + space.length;
-          const newPrefix = `${indent}${listNumber}. `;
-          changes2.push({
-            from: line.from,
-            to: line.from + prefixLength,
-            insert: newPrefix
-          });
-          rangeDelta += newPrefix.length - prefixLength;
-          listNumber++;
-        }
-      } else {
-        const indentMatch = lineText.match(/^(\s*)/);
-        const indent = indentMatch ? indentMatch[1] : "";
-        const newPrefix = `${listNumber}. `;
-        changes2.push({
-          from: line.from + indent.length,
-          insert: newPrefix
-        });
-        rangeDelta += newPrefix.length;
-        listNumber++;
-      }
-    }
-    return {
-      changes: changes2,
-      range: state.EditorSelection.range(range.from, range.to + rangeDelta)
-    };
-  });
-  dispatch(
-    state$1.update(changes, {
-      scrollIntoView: true,
-      annotations: state.Transaction.userEvent.of("input")
-    })
-  );
-  return true;
-};
 function toEngineSelection(selection) {
   if (!selection) {
     return { start: 0, end: 0, affinity: "forward" };
@@ -11458,30 +11474,6 @@ function toEngineSelection(selection) {
     affinity: selection.affinity
   };
 }
-const BOLD_MARKER = "**";
-const ITALIC_MARKER = "*";
-const STRIKETHROUGH_MARKER = "~~";
-function mapCommandToEditCommand(command) {
-  if (command === toggleBold) {
-    return { type: "toggle-inline", marker: BOLD_MARKER };
-  }
-  if (command === toggleItalic) {
-    return { type: "toggle-inline", marker: ITALIC_MARKER };
-  }
-  if (command === toggleStrikethrough) {
-    return { type: "toggle-inline", marker: STRIKETHROUGH_MARKER };
-  }
-  if (command === toggleLink) {
-    return { type: "wrap-link", openPopover: true };
-  }
-  if (command === toggleBulletList) {
-    return { type: "toggle-bullet-list" };
-  }
-  if (command === toggleNumberedList) {
-    return { type: "toggle-numbered-list" };
-  }
-  return null;
-}
 const CakeEditor = require$$0.forwardRef(
   function CakeEditor2(props, outerRef) {
     const containerRef = require$$0.useRef(null);
@@ -11600,15 +11592,11 @@ const CakeEditor = require$$0.forwardRef(
           var _a;
           (_a = engineRef.current) == null ? void 0 : _a.selectAll();
         },
-        executeCommand: (command) => {
+        executeCommand: (command, options) => {
           if (!engineRef.current) {
             return false;
           }
-          const editCommand = mapCommandToEditCommand(command);
-          if (!editCommand) {
-            return false;
-          }
-          return engineRef.current.executeCommand(editCommand);
+          return engineRef.current.executeCommand(command, options);
         },
         applyUpdate: (update) => {
           if (!engineRef.current) {