@blankdotpage/cake 0.1.2 → 0.1.4

package/dist/index.js

@@ -997,15 +997,36 @@ class CursorSourceBuilder {
     if (!text) {
       return;
     }
-    for (const segment of graphemeSegments(text)) {
-      this.sourceParts.push(segment.segment);
-      this.sourceLengthValue += segment.segment.length;
-      const sourceLength = this.sourceLengthValue;
-      this.cursorLength += 1;
-      this.boundaries.push({
-        sourceBackward: sourceLength,
-        sourceForward: sourceLength
-      });
+    let isAllAscii = true;
+    for (let i = 0; i < text.length; i++) {
+      if (text.charCodeAt(i) >= 128) {
+        isAllAscii = false;
+        break;
+      }
+    }
+    if (isAllAscii) {
+      for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        this.sourceParts.push(char);
+        this.sourceLengthValue += 1;
+        const sourceLength = this.sourceLengthValue;
+        this.cursorLength += 1;
+        this.boundaries.push({
+          sourceBackward: sourceLength,
+          sourceForward: sourceLength
+        });
+      }
+    } else {
+      for (const segment of graphemeSegments(text)) {
+        this.sourceParts.push(segment.segment);
+        this.sourceLengthValue += segment.segment.length;
+        const sourceLength = this.sourceLengthValue;
+        this.cursorLength += 1;
+        this.boundaries.push({
+          sourceBackward: sourceLength,
+          sourceForward: sourceLength
+        });
+      }
     }
   }
   appendCursorAtom(sourceText, cursorUnits = 1) {
@@ -1055,6 +1076,15 @@ class CursorSourceBuilder {
     };
   }
 }
+function isStructuralEdit(command) {
+  return command.type === "insert" || command.type === "delete-backward" || command.type === "delete-forward" || command.type === "insert-line-break" || command.type === "exit-block-wrapper";
+}
+function isApplyEditCommand(command) {
+  return command.type === "insert" || command.type === "insert-line-break" || command.type === "delete-backward" || command.type === "delete-forward";
+}
+function defineExtension(extension) {
+  return extension;
+}
 const defaultSelection$1 = { start: 0, end: 0, affinity: "forward" };
 function createRuntime(extensions) {
   const toggleMarkerToKind = /* @__PURE__ */ new Map();
@@ -1296,7 +1326,7 @@ function createRuntime(extensions) {
       }
     }
     const selection = normalizeSelection$1(state.selection);
-    if (command.type === "insert" || command.type === "delete-backward" || command.type === "delete-forward" || command.type === "insert-line-break" || command.type === "exit-block-wrapper") {
+    if (isStructuralEdit(command)) {
       const structural = applyStructuralEdit(command, state.doc, selection);
       if (!structural) {
         if (command.type === "delete-backward" || command.type === "delete-forward") {
@@ -1338,6 +1368,39 @@ function createRuntime(extensions) {
             }
           };
         }
+        if (command.type === "insert" || command.type === "insert-line-break") {
+          const cursorLength = state.map.cursorLength;
+          const cursorStart = Math.max(
+            0,
+            Math.min(cursorLength, Math.min(selection.start, selection.end))
+          );
+          const cursorEnd = Math.max(
+            0,
+            Math.min(cursorLength, Math.max(selection.start, selection.end))
+          );
+          const range = { start: cursorStart, end: cursorEnd };
+          const fullDocReplace = range.start === 0 && range.end === cursorLength;
+          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, state.source.length)
+          );
+          const insertText = command.type === "insert" ? command.text : "\n";
+          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");
+          return {
+            ...next2,
+            selection: {
+              start: caretCursor2.cursorOffset,
+              end: caretCursor2.cursorOffset,
+              affinity: caretCursor2.affinity
+            }
+          };
+        }
         return state;
       }
       const interim = createStateFromDoc(structural.doc);
@@ -2580,7 +2643,20 @@ function parseLiteralBlock(source, start, context) {
   return { block: { type: "paragraph", content }, nextPos: end };
 }
 function parseLiteralInline(source, start, end) {
-  const segment = graphemeSegments(source.slice(start, end))[0];
+  const code = source.charCodeAt(start);
+  if (code < 128) {
+    const text2 = source[start] ?? "";
+    return { inline: { type: "text", text: text2 }, nextPos: start + 1 };
+  }
+  if (code >= 55296 && code <= 56319) {
+    const lowCode = source.charCodeAt(start + 1);
+    if (lowCode >= 56320 && lowCode <= 57343) {
+      const segment2 = graphemeSegments(source.slice(start, Math.min(start + 10, end)))[0];
+      const text2 = segment2 ? segment2.segment : source.slice(start, start + 2);
+      return { inline: { type: "text", text: text2 }, nextPos: start + text2.length };
+    }
+  }
+  const segment = graphemeSegments(source.slice(start, Math.min(start + 10, end)))[0];
   const text = segment ? segment.segment : source[start] ?? "";
   return { inline: { type: "text", text }, nextPos: start + text.length };
 }
@@ -2623,29 +2699,66 @@ function normalizeSelection$1(selection) {
     affinity: isRange ? "backward" : selection.affinity
   };
 }
+const graphemeCache = /* @__PURE__ */ new WeakMap();
 function createTextRun(node, cursorStart) {
-  const segments = graphemeSegments(node.data);
+  const data = node.data;
+  const cached = graphemeCache.get(node);
+  if (cached && cached.data === data) {
+    const segmentCount = Math.max(0, cached.boundaryOffsets.length - 1);
+    return {
+      node,
+      cursorStart,
+      cursorEnd: cursorStart + segmentCount,
+      boundaryOffsets: cached.boundaryOffsets
+    };
+  }
+  const segments = graphemeSegments(data);
   const boundaryOffsets = [0];
   for (const segment of segments) {
     boundaryOffsets.push(segment.index + segment.segment.length);
   }
   const cursorEnd = cursorStart + segments.length;
+  graphemeCache.set(node, { data, boundaryOffsets });
   return { node, cursorStart, cursorEnd, boundaryOffsets };
 }
 function boundaryIndexForOffset(boundaryOffsets, offset) {
   if (offset <= 0) {
     return 0;
   }
-  for (let i = 1; i < boundaryOffsets.length; i += 1) {
-    const boundary = boundaryOffsets[i];
-    if (offset < boundary) {
-      return i - 1;
+  const lastIndex = boundaryOffsets.length - 1;
+  if (lastIndex <= 0) {
+    return 0;
+  }
+  const lastBoundary = boundaryOffsets[lastIndex];
+  if (offset >= lastBoundary) {
+    return lastIndex;
+  }
+  let low = 1;
+  let high = lastIndex;
+  while (low < high) {
+    const mid = low + high >>> 1;
+    const boundary2 = boundaryOffsets[mid];
+    if (boundary2 < offset) {
+      low = mid + 1;
+    } else {
+      high = mid;
     }
-    if (offset === boundary) {
-      return i;
+  }
+  const boundary = boundaryOffsets[low];
+  return boundary === offset ? low : low - 1;
+}
+function firstRunStartingAfterCursor(runs, cursorOffset) {
+  let low = 0;
+  let high = runs.length;
+  while (low < high) {
+    const mid = low + high >>> 1;
+    if (runs[mid].cursorStart <= cursorOffset) {
+      low = mid + 1;
+    } else {
+      high = mid;
     }
   }
-  return boundaryOffsets.length - 1;
+  return low;
 }
 function createDomMap(runs) {
   const runForNode = /* @__PURE__ */ new Map();
@@ -2660,33 +2773,34 @@ function createDomMap(runs) {
     if (runs.length === 0) {
       return null;
     }
-    for (let i = 0; i < runs.length; i += 1) {
-      const run = runs[i];
-      const previous = i > 0 ? runs[i - 1] : null;
-      const next = i + 1 < runs.length ? runs[i + 1] : null;
-      if (cursorOffset < run.cursorStart) {
-        if (!previous) {
-          return { node: run.node, offset: run.boundaryOffsets[0] };
-        }
-        const previousOffset = previous.boundaryOffsets[previous.boundaryOffsets.length - 1];
-        return affinity === "backward" ? { node: previous.node, offset: previousOffset } : { node: run.node, offset: run.boundaryOffsets[0] };
-      }
-      if (cursorOffset === run.cursorStart && previous && affinity === "backward") {
-        return {
-          node: previous.node,
-          offset: previous.boundaryOffsets[previous.boundaryOffsets.length - 1]
-        };
-      }
-      if (cursorOffset <= run.cursorEnd) {
-        if (cursorOffset === run.cursorEnd && affinity === "forward" && next && next.cursorStart === cursorOffset) {
-          return { node: next.node, offset: next.boundaryOffsets[0] };
-        }
-        const index = Math.max(0, cursorOffset - run.cursorStart);
-        const boundedIndex = Math.min(index, run.boundaryOffsets.length - 1);
-        return { node: run.node, offset: run.boundaryOffsets[boundedIndex] };
+    const nextIndex = firstRunStartingAfterCursor(runs, cursorOffset);
+    const runIndex = nextIndex - 1;
+    if (runIndex < 0) {
+      const first = runs[0];
+      return { node: first.node, offset: first.boundaryOffsets[0] };
+    }
+    const run = runs[runIndex];
+    const previous = runIndex > 0 ? runs[runIndex - 1] : null;
+    const next = nextIndex < runs.length ? runs[nextIndex] : null;
+    if (cursorOffset === run.cursorStart && previous && affinity === "backward") {
+      return {
+        node: previous.node,
+        offset: previous.boundaryOffsets[previous.boundaryOffsets.length - 1]
+      };
+    }
+    if (cursorOffset <= run.cursorEnd) {
+      if (cursorOffset === run.cursorEnd && affinity === "forward" && next && next.cursorStart === cursorOffset) {
+        return { node: next.node, offset: next.boundaryOffsets[0] };
       }
+      const index = Math.max(0, cursorOffset - run.cursorStart);
+      const boundedIndex = Math.min(index, run.boundaryOffsets.length - 1);
+      return { node: run.node, offset: run.boundaryOffsets[boundedIndex] };
+    }
+    if (next) {
+      const runEndOffset = run.boundaryOffsets[run.boundaryOffsets.length - 1];
+      return affinity === "backward" ? { node: run.node, offset: runEndOffset } : { node: next.node, offset: next.boundaryOffsets[0] };
     }
-    const last = runs[runs.length - 1];
+    const last = run;
     return {
       node: last.node,
       offset: last.boundaryOffsets[last.boundaryOffsets.length - 1]
@@ -3074,7 +3188,9 @@ function applyDomSelection(selection, map) {
   if (!anchorPoint || !focusPoint) {
     return;
   }
-  domSelection.removeAllRanges();
+  if (domSelection.rangeCount > 0 && domSelection.anchorNode === anchorPoint.node && domSelection.anchorOffset === anchorPoint.offset && domSelection.focusNode === focusPoint.node && domSelection.focusOffset === focusPoint.offset) {
+    return;
+  }
   if (isCollapsed) {
     domSelection.collapse(anchorPoint.node, anchorPoint.offset);
     return;
@@ -3094,6 +3210,7 @@ function applyDomSelection(selection, map) {
     domSelection.extend(focusPoint.node, focusPoint.offset);
     return;
   }
+  domSelection.removeAllRanges();
   const range = document.createRange();
   const rangeStart = isForward ? anchorPoint : focusPoint;
   const rangeEnd = isForward ? focusPoint : anchorPoint;
@@ -3237,7 +3354,7 @@ function findTextNodeAtOrBefore$1(nodes, start) {
   return null;
 }
 const BOLD_KIND$1 = "bold";
-const boldExtension = {
+const boldExtension = defineExtension({
   name: "bold",
   toggleInline: { kind: BOLD_KIND$1, markers: ["**"] },
   keybindings: [
@@ -3320,7 +3437,7 @@ const boldExtension = {
     }
     return element;
   }
-};
+});
 function countSingleAsterisks(source, start, end) {
   let count = 0;
   for (let i = start; i < end; i += 1) {
@@ -3339,7 +3456,7 @@ function countSingleAsterisks(source, start, end) {
 const BOLD_KIND = "bold";
 const ITALIC_KIND$1 = "italic";
 const MARKERS = ["***", "___"];
-const combinedEmphasisExtension = {
+const combinedEmphasisExtension = defineExtension({
   name: "combined-emphasis",
   parseInline(source, start, end, context) {
     const marker = MARKERS.find((m) => source.slice(start, start + 3) === m);
@@ -3373,7 +3490,7 @@ const combinedEmphasisExtension = {
       nextPos: close + 3
     };
   }
-};
+});
 function ensureHttpsProtocol(url) {
   const trimmedUrl = url.trim();
   if (!trimmedUrl) {
@@ -3421,7 +3538,7 @@ function getPopoverPosition(params) {
   };
 }
 function CakeLinkPopover(params) {
-  const { container, contentRoot, toOverlayRect } = params;
+  const { container, contentRoot, toOverlayRect, getSelection, executeCommand } = params;
   const anchorRef = useRef(null);
   const popoverRef = useRef(null);
   const inputRef = useRef(null);
@@ -3585,6 +3702,12 @@ function CakeLinkPopover(params) {
     window.open(displayUrl, "_blank", "noopener,noreferrer");
   };
   const handleUnlink = () => {
+    const selection = getSelection();
+    if (!selection) {
+      close();
+      return;
+    }
+    executeCommand({ type: "unlink", start: selection.start, end: selection.end });
     close();
   };
   const handleInputKeyDown = (event) => {
@@ -3888,7 +4011,7 @@ function cursorOffsetToVisibleOffset(lines, cursorOffset) {
   return codeUnitIndex + (lastLine.cursorToCodeUnit[lastOffset] ?? lastLine.text.length);
 }
 const LINK_KIND = "link";
-const linkExtension = {
+const linkExtension = defineExtension({
   name: "link",
   inlineWrapperAffinity: [{ kind: LINK_KIND, inclusive: false }],
   keybindings: [
@@ -3916,6 +4039,39 @@ const linkExtension = {
     }
   ],
   onEdit(command, state) {
+    if (command.type === "unlink") {
+      const cursorPos = command.start;
+      const sourcePos = state.map.cursorToSource(cursorPos, "forward");
+      const source = state.source;
+      let linkStart = sourcePos;
+      while (linkStart > 0 && source[linkStart] !== "[") {
+        linkStart--;
+      }
+      if (source[linkStart] !== "[") {
+        return null;
+      }
+      const labelClose = source.indexOf("](", linkStart + 1);
+      if (labelClose === -1) {
+        return null;
+      }
+      const urlClose = source.indexOf(")", labelClose + 2);
+      if (urlClose === -1) {
+        return null;
+      }
+      const label2 = source.slice(linkStart + 1, labelClose);
+      const nextSource2 = source.slice(0, linkStart) + label2 + source.slice(urlClose + 1);
+      const newState = state.runtime.createState(nextSource2);
+      const labelEndSource = linkStart + label2.length;
+      const newCursor = newState.map.sourceToCursor(labelEndSource, "forward");
+      return {
+        source: nextSource2,
+        selection: {
+          start: newCursor.cursorOffset,
+          end: newCursor.cursorOffset,
+          affinity: "forward"
+        }
+      };
+    }
     if (command.type !== "wrap-link") {
       return null;
     }
@@ -4042,13 +4198,15 @@ const linkExtension = {
       {
         container: context.container,
         contentRoot: context.contentRoot,
-        toOverlayRect: context.toOverlayRect
+        toOverlayRect: context.toOverlayRect,
+        getSelection: context.getSelection,
+        executeCommand: context.executeCommand
       }
     );
   }
-};
+});
 const PIPE_LINK_KIND = "pipe-link";
-const pipeLinkExtension = {
+const pipeLinkExtension = defineExtension({
   name: "pipe-link",
   parseInline(source, start, end) {
     if (source[start] !== "|") {
@@ -4119,10 +4277,10 @@ const pipeLinkExtension = {
     }
     return element;
   }
-};
+});
 const BLOCKQUOTE_KIND = "blockquote";
 const PREFIX = "> ";
-const blockquoteExtension = {
+const blockquoteExtension = defineExtension({
   name: "blockquote",
   parseBlock(source, start, context) {
     if (source.slice(start, start + PREFIX.length) !== PREFIX) {
@@ -4191,9 +4349,9 @@ const blockquoteExtension = {
     }
     return element;
   }
-};
+});
 const ITALIC_KIND = "italic";
-const italicExtension = {
+const italicExtension = defineExtension({
   name: "italic",
   toggleInline: { kind: ITALIC_KIND, markers: ["*", "_"] },
   keybindings: [
@@ -4263,7 +4421,7 @@ const italicExtension = {
     }
     return element;
   }
-};
+});
 const HEADING_KIND = "heading";
 const HEADING_PATTERN = /^(#{1,3}) /;
 function findLineStartInSource(source, sourceOffset) {
@@ -4364,7 +4522,7 @@ function shouldExitHeadingOnLineBreak(state) {
   const contentStart = lineStart + marker.length;
   return sourcePos >= contentStart && sourcePos <= lineEnd;
 }
-const headingExtension = {
+const headingExtension = defineExtension({
   name: "heading",
   onEdit(command, state) {
     if (command.type === "delete-backward") {
@@ -4505,7 +4663,7 @@ const headingExtension = {
     }
     return lineElement;
   }
-};
+});
 const IMAGE_KIND = "image";
 const IMAGE_PATTERN = /^!\[([^\]]*)\]\(([^)]*)\)$/;
 const UPLOADING_PATTERN = /^!\[uploading:([^\]]+)\]\(\)$/;
@@ -4523,7 +4681,7 @@ function isImageData(data) {
   }
   return false;
 }
-const imageExtension = {
+const imageExtension = defineExtension({
   name: "image",
   parseBlock(source, start) {
     let lineEnd = source.indexOf("\n", start);
@@ -4618,7 +4776,7 @@ const imageExtension = {
     }
     return element;
   }
-};
+});
 const LIST_LINE_REGEX$2 = /^(\s*)([-*+]|\d+\.)( )(.*)$/;
 const INDENT_SIZE = 2;
 function parseMarkerType(marker) {
@@ -5437,7 +5595,7 @@ function getParagraphText(block) {
   }
   return text;
 }
-const listExtension = {
+const listExtension = defineExtension({
   name: "list",
   keybindings: [
     {
@@ -5530,7 +5688,7 @@ const listExtension = {
     }
     return element;
   }
-};
+});
 const THUMB_MIN_HEIGHT = 30;
 const SCROLL_HIDE_DELAY = 500;
 const TRACK_PADDING = 8;
@@ -5767,14 +5925,14 @@ function ScrollbarOverlay({ container }) {
     }
   ) });
 }
-const scrollbarExtension = {
+const scrollbarExtension = defineExtension({
   name: "scrollbar",
   renderOverlay(context) {
     return /* @__PURE__ */ jsxRuntimeExports.jsx(ScrollbarOverlay, { container: context.container });
   }
-};
+});
 const STRIKE_KIND = "strikethrough";
-const strikethroughExtension = {
+const strikethroughExtension = defineExtension({
   name: "strikethrough",
   toggleInline: { kind: STRIKE_KIND, markers: ["~~"] },
   keybindings: [
@@ -5847,8 +6005,8 @@ const strikethroughExtension = {
     }
     return element;
   }
-};
-const bundledExtensions = [
+});
+const bundledExtensionsWithoutImage = [
   blockquoteExtension,
   headingExtension,
   listExtension,
@@ -5857,7 +6015,10 @@ const bundledExtensions = [
   italicExtension,
   strikethroughExtension,
   pipeLinkExtension,
-  linkExtension,
+  linkExtension
+];
+const bundledExtensions = [
+  ...bundledExtensionsWithoutImage,
   imageExtension
 ];
 function toLayoutRect(params) {
@@ -5917,6 +6078,46 @@ function cursorOffsetToCodeUnit(cursorToCodeUnit, offset) {
   const clamped = Math.max(0, Math.min(offset, cursorToCodeUnit.length - 1));
   return cursorToCodeUnit[clamped] ?? 0;
 }
+function createDomPositionResolver(lineElement) {
+  const textNodes = [];
+  const cumulativeEnds = [];
+  const walker = createTextWalker(lineElement);
+  let current = walker.nextNode();
+  let total = 0;
+  while (current) {
+    if (current instanceof Text) {
+      const length = current.data.length;
+      textNodes.push(current);
+      total += length;
+      cumulativeEnds.push(total);
+    }
+    current = walker.nextNode();
+  }
+  if (textNodes.length === 0) {
+    return () => {
+      if (!lineElement.textContent) {
+        return { node: lineElement, offset: 0 };
+      }
+      return { node: lineElement, offset: lineElement.childNodes.length };
+    };
+  }
+  return (offsetInLine) => {
+    const clamped = Math.max(0, Math.min(offsetInLine, total));
+    let low = 0;
+    let high = cumulativeEnds.length - 1;
+    while (low < high) {
+      const mid = low + high >>> 1;
+      if ((cumulativeEnds[mid] ?? 0) < clamped) {
+        low = mid + 1;
+      } else {
+        high = mid;
+      }
+    }
+    const node = textNodes[low] ?? lineElement;
+    const prevEnd = low > 0 ? cumulativeEnds[low - 1] ?? 0 : 0;
+    return { node, offset: clamped - prevEnd };
+  };
+}
 function measureCharacterRect(params) {
   if (params.lineLength <= 0) {
     return null;
@@ -5929,101 +6130,155 @@ function measureCharacterRect(params) {
     params.cursorToCodeUnit,
     Math.min(params.offset + 1, params.lineLength)
   );
-  const startPosition = resolveDomPosition(params.lineElement, startCodeUnit);
-  const endPosition = resolveDomPosition(params.lineElement, endCodeUnit);
-  const range = document.createRange();
-  range.setStart(startPosition.node, startPosition.offset);
-  range.setEnd(endPosition.node, endPosition.offset);
-  const rects = range.getClientRects();
+  const startPosition = params.resolveDomPosition(startCodeUnit);
+  const endPosition = params.resolveDomPosition(endCodeUnit);
+  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 rect = range.getBoundingClientRect();
+  const rect = params.range.getBoundingClientRect();
   if (rect.width === 0 && rect.height === 0) {
     return null;
   }
   return rect;
 }
 function measureLineRows(params) {
+  var _a, _b;
+  const fallbackLineBox = toLayoutRect({
+    rect: params.lineRect,
+    containerRect: params.containerRect,
+    scroll: params.scroll
+  });
   if (params.lineLength === 0) {
-    const lineBox = toLayoutRect({
-      rect: params.lineRect,
-      containerRect: params.containerRect,
-      scroll: params.scroll
-    });
     return [
       {
         startOffset: 0,
         endOffset: 0,
-        rect: { ...lineBox, width: 0 }
+        rect: { ...fallbackLineBox, width: 0 }
       }
     ];
   }
-  const fullLineRange = document.createRange();
-  const fullLineStart = resolveDomPosition(params.lineElement, 0);
-  const fullLineEnd = resolveDomPosition(
-    params.lineElement,
-    params.codeUnitLength
-  );
-  fullLineRange.setStart(fullLineStart.node, fullLineStart.offset);
-  fullLineRange.setEnd(fullLineEnd.node, fullLineEnd.offset);
-  const fullLineRects = groupDomRectsByRow(
-    Array.from(fullLineRange.getClientRects())
-  );
-  const fallbackLineBox = toLayoutRect({
-    rect: params.lineRect,
-    containerRect: params.containerRect,
-    scroll: params.scroll
-  });
-  const charRect = measureCharacterRect({
-    lineElement: params.lineElement,
-    offset: 0,
-    lineLength: params.lineLength,
-    cursorToCodeUnit: params.cursorToCodeUnit
-  });
-  const charWidth = (charRect == null ? void 0 : charRect.width) ?? 0;
-  if (fullLineRects.length === 0 || charWidth <= 0) {
-    const rows2 = [
+  const WRAP_THRESHOLD_PX = 3;
+  const resolvePosition = createDomPositionResolver(params.lineElement);
+  const scratchRange = document.createRange();
+  const topCache = /* @__PURE__ */ new Map();
+  const fullLineStart = resolvePosition(0);
+  const fullLineEnd = resolvePosition(params.codeUnitLength);
+  scratchRange.setStart(fullLineStart.node, fullLineStart.offset);
+  scratchRange.setEnd(fullLineEnd.node, fullLineEnd.offset);
+  const fullLineRects = groupDomRectsByRow(Array.from(scratchRange.getClientRects()));
+  if (fullLineRects.length === 0) {
+    return [
       {
         startOffset: 0,
         endOffset: params.lineLength,
         rect: fallbackLineBox
       }
     ];
-    return rows2.length === 1 ? [
+  }
+  function offsetToTop(offset) {
+    if (topCache.has(offset)) {
+      return topCache.get(offset) ?? null;
+    }
+    const rect = measureCharacterRect({
+      lineElement: params.lineElement,
+      offset,
+      lineLength: params.lineLength,
+      cursorToCodeUnit: params.cursorToCodeUnit,
+      resolveDomPosition: resolvePosition,
+      range: scratchRange
+    });
+    const top = rect ? rect.top : null;
+    topCache.set(offset, top);
+    return top;
+  }
+  function findFirstMeasurableOffset(from) {
+    for (let offset = Math.max(0, from); offset < params.lineLength; offset++) {
+      if (offsetToTop(offset) !== null) {
+        return offset;
+      }
+    }
+    return null;
+  }
+  function findNextRowStartOffset(fromExclusive, rowTop) {
+    const lastIndex = params.lineLength - 1;
+    if (fromExclusive > lastIndex) {
+      return null;
+    }
+    const isNewRowAt = (offset) => {
+      const top = offsetToTop(offset);
+      return top !== null && Math.abs(top - rowTop) > WRAP_THRESHOLD_PX;
+    };
+    let step = 1;
+    let lastSame = fromExclusive - 1;
+    let probe = fromExclusive;
+    while (probe <= lastIndex) {
+      if (isNewRowAt(probe)) {
+        break;
+      }
+      lastSame = probe;
+      probe += step;
+      step *= 2;
+    }
+    if (probe > lastIndex) {
+      probe = lastIndex;
+      if (!isNewRowAt(probe)) {
+        return null;
+      }
+    }
+    let low = Math.max(fromExclusive, lastSame + 1);
+    let high = probe;
+    while (low < high) {
+      const mid = low + high >>> 1;
+      if (isNewRowAt(mid)) {
+        high = mid;
+      } else {
+        low = mid + 1;
+      }
+    }
+    return low < params.lineLength ? low : null;
+  }
+  const rows = [];
+  const firstMeasurable = findFirstMeasurableOffset(0);
+  if (firstMeasurable === null) {
+    return [
       {
-        ...rows2[0],
-        rect: {
-          ...rows2[0].rect,
-          top: fallbackLineBox.top,
-          height: fallbackLineBox.height
-        }
+        startOffset: 0,
+        endOffset: params.lineLength,
+        rect: fallbackLineBox
       }
-    ] : rows2;
+    ];
   }
-  let startOffset = 0;
-  const rows = fullLineRects.map((rect, index) => {
-    const remaining = params.lineLength - startOffset;
-    const isLast = index === fullLineRects.length - 1;
-    const estimatedLength = Math.max(1, Math.round(rect.width / charWidth));
-    const rowLength = isLast ? remaining : Math.min(remaining, estimatedLength);
-    const row = {
-      startOffset,
-      endOffset: startOffset + rowLength,
+  let currentRowStart = 0;
+  let currentRowTop = ((_a = fullLineRects[0]) == null ? void 0 : _a.top) ?? params.lineRect.top;
+  let searchFrom = firstMeasurable + 1;
+  let rowIndex = 0;
+  while (currentRowStart < params.lineLength) {
+    const nextRowStart = findNextRowStartOffset(searchFrom, currentRowTop);
+    const currentRowEnd = nextRowStart ?? params.lineLength;
+    const domRect = fullLineRects[rowIndex] ?? params.lineRect;
+    rows.push({
+      startOffset: currentRowStart,
+      endOffset: currentRowEnd,
       rect: toLayoutRect({
-        rect,
+        rect: domRect,
         containerRect: params.containerRect,
         scroll: params.scroll
       })
-    };
-    startOffset += rowLength;
-    return row;
-  });
-  if (rows.length > 0) {
-    rows[rows.length - 1] = {
-      ...rows[rows.length - 1],
-      endOffset: params.lineLength
-    };
+    });
+    if (nextRowStart === null) {
+      break;
+    }
+    currentRowStart = nextRowStart;
+    rowIndex += 1;
+    const nextMeasurable = findFirstMeasurableOffset(currentRowStart);
+    if (nextMeasurable === null) {
+      break;
+    }
+    currentRowTop = ((_b = fullLineRects[rowIndex]) == null ? void 0 : _b.top) ?? currentRowTop;
+    searchFrom = nextMeasurable + 1;
   }
   if (rows.length === 1) {
     rows[0] = {
@@ -6095,6 +6350,44 @@ function measureLayoutModelFromDom(params) {
   }
   return buildLayoutModel(params.lines, measurer);
 }
+function measureLayoutModelRangeFromDom(params) {
+  const measurer = createDomLayoutMeasurer({
+    root: params.root,
+    container: params.container,
+    lines: params.lines
+  });
+  if (!measurer) {
+    return null;
+  }
+  const clampedStart = Math.max(0, Math.min(params.startLineIndex, params.lines.length - 1));
+  const clampedEnd = Math.max(clampedStart, Math.min(params.endLineIndex, params.lines.length - 1));
+  const lineOffsets = getLineOffsets(params.lines);
+  let lineStartOffset = lineOffsets[clampedStart] ?? 0;
+  const layouts = [];
+  for (let lineIndex = clampedStart; lineIndex <= clampedEnd; lineIndex += 1) {
+    const lineInfo = params.lines[lineIndex];
+    if (!lineInfo) {
+      continue;
+    }
+    const measurement = measurer.measureLine({
+      lineIndex: lineInfo.lineIndex,
+      lineText: lineInfo.text,
+      lineLength: lineInfo.cursorLength,
+      lineHasNewline: lineInfo.hasNewline,
+      top: 0
+    });
+    layouts.push({
+      lineIndex: lineInfo.lineIndex,
+      lineStartOffset,
+      lineLength: lineInfo.cursorLength,
+      lineHasNewline: lineInfo.hasNewline,
+      lineBox: measurement.lineBox,
+      rows: measurement.rows
+    });
+    lineStartOffset += lineInfo.cursorLength + (lineInfo.hasNewline ? 1 : 0);
+  }
+  return { container: measurer.container, lines: layouts };
+}
 function getLineElement(root, lineIndex) {
   return root.querySelector(`[data-line-index="${lineIndex}"]`);
 }
@@ -6310,7 +6603,17 @@ function getSelectionGeometry(params) {
     end: selection.start,
     affinity: selection.affinity
   };
-  const layout = shouldMeasureLayout(normalized) ? measureLayoutModelFromDom({ lines: docLines, root, container }) : null;
+  const layout = shouldMeasureLayout(normalized) ? (() => {
+    const startLine2 = resolveOffsetToLine(docLines, normalized.start);
+    const endLine = resolveOffsetToLine(docLines, normalized.end);
+    return measureLayoutModelRangeFromDom({
+      lines: docLines,
+      root,
+      container,
+      startLineIndex: startLine2.lineIndex,
+      endLineIndex: endLine.lineIndex
+    });
+  })() : null;
   const containerRect = container.getBoundingClientRect();
   const scroll = { top: container.scrollTop, left: container.scrollLeft };
   const startLine = resolveOffsetToLine(docLines, normalized.start);
@@ -7318,10 +7621,13 @@ class CakeEngine {
     this.caretBlinkTimeoutId = null;
     this.overlayUpdateId = null;
     this.scrollCaretIntoViewId = null;
+    this.selectionRectElements = [];
+    this.lastSelectionRects = null;
     this.extensionsRoot = null;
     this.placeholderRoot = null;
     this.lastFocusRect = null;
     this.verticalNavGoalX = null;
+    this.lastRenderPerf = null;
     this.history = {
       undoStack: [],
       redoStack: [],
@@ -7354,6 +7660,7 @@ class CakeEngine {
     this.selectionDragState = null;
     this.pointerDownPosition = null;
     this.hasMovedSincePointerDown = false;
+    this.lastTouchTime = 0;
     this.container = options.container;
     this.extensions = options.extensions ?? bundledExtensions;
     this.runtime = createRuntime(this.extensions);
@@ -7375,6 +7682,9 @@ class CakeEngine {
   set state(value) {
     this._state = value;
   }
+  getLastRenderPerf() {
+    return this.lastRenderPerf;
+  }
   isEventTargetInContentRoot(target) {
     if (target === this.container) {
       return true;
@@ -7411,6 +7721,9 @@ class CakeEngine {
   getSelection() {
     return this.state.selection;
   }
+  getCursorLength() {
+    return this.state.map.cursorLength;
+  }
   getFocusRect() {
     return this.lastFocusRect;
   }
@@ -7465,6 +7778,7 @@ class CakeEngine {
     if (!this.isComposing) {
       this.applySelection(this.state.selection);
     }
+    this.scheduleScrollCaretIntoView();
   }
   setValue({ value, selection }) {
     const valueChanged = value !== this.state.source;
@@ -7540,7 +7854,7 @@ class CakeEngine {
   }
   executeCommand(command) {
     var _a;
-    const shouldOpenLinkPopover = command.type === "wrap-link" && command.openPopover;
+    const shouldOpenLinkPopover = "openPopover" in command && command.openPopover === true;
     const nextState = this.runtime.applyEdit(command, this.state);
     if (nextState === this.state) {
       return false;
@@ -7715,6 +8029,14 @@ class CakeEngine {
     this.patchedCaretRangeFromPoint = null;
   }
   render() {
+    const perfEnabled = this.container.dataset.cakePerf === "1";
+    let perfStart = 0;
+    let renderStart = 0;
+    let renderAndMapMs = 0;
+    let applySelectionMs = 0;
+    if (perfEnabled) {
+      perfStart = performance.now();
+    }
     if (!this.contentRoot) {
       const containerPosition = window.getComputedStyle(
         this.container
@@ -7730,6 +8052,9 @@ class CakeEngine {
       this.container.replaceChildren(this.contentRoot, overlay, extensionsRoot);
       this.attachDragListeners();
     }
+    if (perfEnabled) {
+      renderStart = performance.now();
+    }
     const { content, map } = renderDocContent(
       this.state.doc,
       this.extensions,
@@ -7741,9 +8066,26 @@ class CakeEngine {
       this.contentRoot.replaceChildren(...content);
     }
     this.domMap = map;
-    this.updateExtensionsOverlayPosition();
-    if (!this.isComposing) {
+    if (perfEnabled) {
+      renderAndMapMs = performance.now() - renderStart;
+    }
+    if (!this.isComposing && this.hasFocus()) {
+      const selectionStart = perfEnabled ? performance.now() : 0;
       this.applySelection(this.state.selection);
+      if (perfEnabled) {
+        applySelectionMs = performance.now() - selectionStart;
+      }
+    }
+    if (perfEnabled) {
+      const totalMs = performance.now() - perfStart;
+      this.lastRenderPerf = {
+        totalMs,
+        renderAndMapMs,
+        applySelectionMs,
+        didUpdateDom: needsUpdate,
+        blockCount: this.state.doc.blocks.length,
+        runCount: map.runs.length
+      };
     }
     this.updatePlaceholder();
     this.scheduleOverlayUpdate();
@@ -7993,22 +8335,31 @@ class CakeEngine {
         this.suppressSelectionChange = false;
         return;
       }
-      const hit2 = this.pendingClickHit ?? this.hitTestFromClientPoint(event.clientX, event.clientY);
-      this.pendingClickHit = null;
-      if (hit2) {
+      const pendingHit = this.pendingClickHit;
+      const selection = this.state.selection;
+      if (pendingHit && selection.start !== selection.end) {
         const newSelection = {
-          start: hit2.cursorOffset,
-          end: hit2.cursorOffset,
-          affinity: hit2.affinity
+          start: pendingHit.cursorOffset,
+          end: pendingHit.cursorOffset,
+          affinity: pendingHit.affinity
         };
+        this.pendingClickHit = null;
+        this.suppressSelectionChange = true;
         this.state = this.runtime.updateSelection(this.state, newSelection, {
           kind: "dom"
         });
         this.applySelection(this.state.selection);
         (_b = this.onSelectionChange) == null ? void 0 : _b.call(this, this.state.selection);
         this.scheduleOverlayUpdate();
+        setTimeout(() => {
+          this.suppressSelectionChange = false;
+        }, 0);
+        return;
       }
-      this.suppressSelectionChange = false;
+      this.pendingClickHit = null;
+      setTimeout(() => {
+        this.suppressSelectionChange = false;
+      }, 0);
       return;
     }
     this.pendingClickHit = null;
@@ -8386,7 +8737,7 @@ class CakeEngine {
       if (!command) {
         continue;
       }
-      if (command.type === "insert" || command.type === "insert-line-break" || command.type === "delete-backward" || command.type === "delete-forward") {
+      if (isApplyEditCommand(command)) {
         this.applyEdit(command);
       } else {
         this.executeCommand(command);
@@ -8906,6 +9257,39 @@ class CakeEngine {
       return { start: target, end: target, affinity: direction };
     }
     const currentPos = selection.start;
+    const currentAffinity = selection.affinity ?? "forward";
+    const measurement = this.getLayoutForNavigation();
+    if (measurement) {
+      const { lines, layout } = measurement;
+      const { rowStart, rowEnd } = getVisualRowBoundaries({
+        lines,
+        layout,
+        offset: currentPos,
+        affinity: currentAffinity
+      });
+      if (direction === "backward" && currentPos === rowStart && currentAffinity === "forward" && currentPos > 0) {
+        const prevBoundaries = getVisualRowBoundaries({
+          lines,
+          layout,
+          offset: currentPos,
+          affinity: "backward"
+        });
+        if (prevBoundaries.rowEnd !== rowEnd || prevBoundaries.rowStart !== rowStart) {
+          return { start: currentPos, end: currentPos, affinity: "backward" };
+        }
+      }
+      if (direction === "forward" && currentPos === rowEnd && currentAffinity === "backward" && currentPos < this.state.map.cursorLength) {
+        const nextBoundaries = getVisualRowBoundaries({
+          lines,
+          layout,
+          offset: currentPos,
+          affinity: "forward"
+        });
+        if (nextBoundaries.rowEnd !== rowEnd || nextBoundaries.rowStart !== rowStart) {
+          return { start: currentPos, end: currentPos, affinity: "forward" };
+        }
+      }
+    }
     const nextPos = this.moveOffsetByChar(currentPos, direction);
     if (nextPos === null) {
       return null;
@@ -9595,6 +9979,7 @@ class CakeEngine {
     }
     this.overlayUpdateId = window.requestAnimationFrame(() => {
       this.overlayUpdateId = null;
+      this.updateExtensionsOverlayPosition();
       this.updateSelectionOverlay();
     });
   }
@@ -9624,12 +10009,34 @@ class CakeEngine {
     overlay.style.zIndex = "2";
     const caret = document.createElement("div");
     caret.className = "cake-caret";
+    caret.style.position = "absolute";
     caret.style.display = "none";
     overlay.append(caret);
     this.overlayRoot = overlay;
     this.caretElement = caret;
+    this.selectionRectElements = [];
+    this.lastSelectionRects = null;
     return overlay;
   }
+  selectionRectsEqual(prev, next) {
+    if (!prev) {
+      return false;
+    }
+    if (prev.length !== next.length) {
+      return false;
+    }
+    for (let index = 0; index < prev.length; index += 1) {
+      const a = prev[index];
+      const b = next[index];
+      if (!a || !b) {
+        return false;
+      }
+      if (a.top !== b.top || a.left !== b.left || a.width !== b.width || a.height !== b.height) {
+        return false;
+      }
+    }
+    return true;
+  }
   ensureExtensionsRoot() {
     if (this.extensionsRoot) {
       return this.extensionsRoot;
@@ -9666,6 +10073,14 @@ class CakeEngine {
     if (!this.overlayRoot || !this.contentRoot) {
       return;
     }
+    const isRecentTouch = Date.now() - this.lastTouchTime < 2e3;
+    if (isRecentTouch) {
+      this.contentRoot.classList.add("cake-touch-mode");
+      this.updateCaret(null);
+      this.syncSelectionRects([]);
+      return;
+    }
+    this.contentRoot.classList.remove("cake-touch-mode");
     const lines = getDocLines(this.state.doc);
     const geometry = getSelectionGeometry({
       root: this.contentRoot,
@@ -9690,21 +10105,34 @@ class CakeEngine {
     if (!this.overlayRoot || !this.caretElement) {
       return;
     }
-    const existing = Array.from(
-      this.overlayRoot.querySelectorAll(".cake-selection-rect")
-    );
-    existing.forEach((node) => node.remove());
-    const fragment = document.createDocumentFragment();
-    rects.forEach((rect) => {
-      const element = document.createElement("div");
-      element.className = "cake-selection-rect";
+    if (this.selectionRectsEqual(this.lastSelectionRects, rects)) {
+      return;
+    }
+    this.lastSelectionRects = rects;
+    while (this.selectionRectElements.length > rects.length) {
+      const element = this.selectionRectElements.pop();
+      element == null ? void 0 : element.remove();
+    }
+    if (this.selectionRectElements.length < rects.length) {
+      const fragment = document.createDocumentFragment();
+      while (this.selectionRectElements.length < rects.length) {
+        const element = document.createElement("div");
+        element.className = "cake-selection-rect";
+        fragment.append(element);
+        this.selectionRectElements.push(element);
+      }
+      this.overlayRoot.insertBefore(fragment, this.caretElement);
+    }
+    rects.forEach((rect, index) => {
+      const element = this.selectionRectElements[index];
+      if (!element) {
+        return;
+      }
       element.style.top = `${rect.top}px`;
       element.style.left = `${rect.left}px`;
       element.style.width = `${rect.width}px`;
       element.style.height = `${rect.height}px`;
-      fragment.append(element);
     });
-    this.overlayRoot.insertBefore(fragment, this.caretElement);
   }
   updateCaret(position) {
     if (!this.caretElement) {
@@ -9871,7 +10299,7 @@ class CakeEngine {
     return { cursorOffset: cursor.cursorOffset, affinity: "backward" };
   }
   handlePointerDown(event) {
-    var _a;
+    var _a, _b, _c;
     if (!this.isEventTargetInContentRoot(event.target)) {
       return;
     }
@@ -9888,9 +10316,7 @@ class CakeEngine {
       return;
     }
     if (event.pointerType === "touch") {
-      this.ignoreTouchNativeSelectionUntil = performance.now() + 750;
-      this.suppressSelectionChangeForTick();
-      event.preventDefault();
+      this.lastTouchTime = Date.now();
       return;
     }
     const selection = this.state.selection;
@@ -9936,13 +10362,51 @@ class CakeEngine {
         }
       }
     }
-    if (selection.start === selection.end && !event.shiftKey) {
-      this.suppressSelectionChange = true;
+    if (!event.shiftKey) {
       const hit2 = this.hitTestFromClientPoint(event.clientX, event.clientY);
-      if (hit2) {
+      if (!hit2) {
+        return;
+      }
+      if (selection.start !== selection.end) {
+        const selStart2 = Math.min(selection.start, selection.end);
+        const selEnd2 = Math.max(selection.start, selection.end);
+        const clickedInsideSelection2 = hit2.cursorOffset >= selStart2 && hit2.cursorOffset <= selEnd2;
+        if (clickedInsideSelection2) {
+          this.suppressSelectionChange = false;
+          this.blockTrustedTextDrag = true;
+          this.pendingClickHit = hit2;
+        } else {
+          this.suppressSelectionChange = true;
+          this.pendingClickHit = hit2;
+          const newSelection = {
+            start: hit2.cursorOffset,
+            end: hit2.cursorOffset,
+            affinity: hit2.affinity
+          };
+          this.state = this.runtime.updateSelection(this.state, newSelection, {
+            kind: "dom"
+          });
+          this.applySelection(this.state.selection);
+          (_b = this.onSelectionChange) == null ? void 0 : _b.call(this, this.state.selection);
+          this.scheduleOverlayUpdate();
+          return;
+        }
+      } else {
+        this.suppressSelectionChange = true;
         this.pendingClickHit = hit2;
+        const newSelection = {
+          start: hit2.cursorOffset,
+          end: hit2.cursorOffset,
+          affinity: hit2.affinity
+        };
+        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();
+        return;
       }
-      return;
     }
     this.suppressSelectionChange = false;
     const selStart = Math.min(selection.start, selection.end);
@@ -10054,10 +10518,6 @@ class CakeEngine {
   }
   handlePointerUp(event) {
     this.blockTrustedTextDrag = false;
-    if (this.pendingClickHit) {
-      this.pendingClickHit = null;
-      this.suppressSelectionChange = false;
-    }
     if (this.selectionDragState) {
       if (event.pointerId !== this.selectionDragState.pointerId) {
         return;
@@ -10557,7 +11017,7 @@ function findOffsetInTextNode(textNode, clientX, clientY) {
   let closestDistance = Infinity;
   let closestYDistance = Infinity;
   let closestCaretX = 0;
-  let closestRowTop = 0;
+  let selectedViaRightEdge = false;
   const rowInfo = /* @__PURE__ */ new Map();
   const range = document.createRange();
   let lastCharRect = null;
@@ -10626,15 +11086,28 @@ function findOffsetInTextNode(textNode, clientX, clientY) {
         closestDistance = xDistance;
         closestOffset = i;
         closestCaretX = caretX;
-        closestRowTop = bestRect.top;
+        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;
-      closestRowTop = bestRect.top;
+      bestRect.top;
     }
   }
   let closestRow = null;
@@ -10659,11 +11132,11 @@ function findOffsetInTextNode(textNode, clientX, clientY) {
     if (clientX < closestRow.left) {
       closestOffset = closestRow.startOffset;
       closestCaretX = closestRow.left;
-      closestRowTop = closestRow.top;
+      closestRow.top;
     } else if (clientX > closestRow.right) {
-      closestOffset = closestRow.endOffset;
+      closestOffset = Math.min(closestRow.endOffset + 1, text.length);
       closestCaretX = closestRow.right;
-      closestRowTop = closestRow.top;
+      closestRow.top;
     } else if (clientY < closestRow.top || clientY > closestRow.bottom) {
       let bestXDistance = Infinity;
       const range2 = document.createRange();
@@ -10683,12 +11156,12 @@ function findOffsetInTextNode(textNode, clientX, clientY) {
           bestXDistance = xDist;
           closestOffset = i;
           closestCaretX = rect.left;
-          closestRowTop = closestRow.top;
+          closestRow.top;
         }
       }
     }
   }
-  const pastRowEnd = closestRow !== null && clientX > closestRow.right && Math.abs(clientY - closestRowTop) < 1;
+  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);
   }
@@ -11141,8 +11614,9 @@ const CakeEditor = forwardRef(
     const lastEmittedSelectionRef = useRef(null);
     const [overlayRoot, setOverlayRoot] = useState(null);
     const [contentRoot, setContentRoot] = useState(null);
+    const baseExtensions = props.disableImageExtension ? bundledExtensionsWithoutImage : bundledExtensions;
     const allExtensionsRef = useRef([
-      ...bundledExtensions,
+      ...baseExtensions,
       ...props.extensions ?? []
     ]);
     useEffect(() => {
@@ -11300,6 +11774,10 @@ const CakeEditor = forwardRef(
           }
           return { start: selection.start, end: selection.end };
         },
+        getCursorLength: () => {
+          var _a;
+          return ((_a = engineRef.current) == null ? void 0 : _a.getCursorLength()) ?? 0;
+        },
         insertText: (text) => {
           var _a;
           (_a = engineRef.current) == null ? void 0 : _a.insertText(text);
@@ -11353,6 +11831,10 @@ const CakeEditor = forwardRef(
         }
         const focus = selection.start === selection.end ? selection.start : Math.max(selection.start, selection.end);
         return { start: focus, end: focus };
+      },
+      executeCommand: (command) => {
+        var _a;
+        return ((_a = engineRef.current) == null ? void 0 : _a.executeCommand(command)) ?? false;
       }
     } : null;
     const hasOverlayExtensions = allExtensionsRef.current.some(
@@ -11385,6 +11867,7 @@ export {
   blockquoteExtension,
   boldExtension,
   bundledExtensions,
+  bundledExtensionsWithoutImage,
   combinedEmphasisExtension,
   headingExtension,
   imageExtension,