@dynatrace/strato-components 3.5.2 → 3.7.0

package/esm/forms/date-time-range-picker/selection-helpers.js

@@ -1,19 +1,31 @@
-import * as styles from "./DateTimeInput.sty.js";
+import { checkIfValueTypeAlignment } from "./helpers.js";
+import { buildTimeframeClipboardText } from "./selection-copy-helpers.js";
 import { getStratoLogger } from "../../core/sdk/sdk-logger.js";
 function warnSelectionFailed(message, error) {
   getStratoLogger("DateTimeRangePicker").warn(message, error);
 }
-function checkIfValueTypeAlignment(textNode) {
-  const closestDateTimeInput = textNode.parentElement?.closest(
-    `.${styles.dateTimeInput}`
-  );
-  const currentValueType = closestDateTimeInput?.getAttribute("data-valuetype");
-  const closestValueTypeElement = textNode.parentElement?.closest("[data-valuetype]");
-  if (closestDateTimeInput === closestValueTypeElement) {
-    return true;
+function safeSetBaseAndExtent(selection, { anchorNode, anchorOffset, focusNode, focusOffset }, warnMessage) {
+  try {
+    selection?.setBaseAndExtent(
+      anchorNode,
+      anchorOffset,
+      focusNode,
+      focusOffset
+    );
+  } catch (error) {
+    warnSelectionFailed(warnMessage, error);
+  }
+}
+function getMultiElementEndpoints(selection) {
+  if (!selection?.anchorNode || !selection.focusNode || selection.toString().length === 0) {
+    return null;
+  }
+  const { anchorNode, anchorOffset, focusNode, focusOffset } = selection;
+  const isSameNode = anchorNode === focusNode;
+  if (isSameNode && !(anchorNode.nodeType === Node.ELEMENT_NODE && anchorOffset !== focusOffset)) {
+    return null;
   }
-  const nodeValueType = closestValueTypeElement?.getAttribute("data-valuetype");
-  return nodeValueType === currentValueType;
+  return { anchorNode, anchorOffset, focusNode, focusOffset };
 }
 function previousTextNode(root, node) {
   const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT, null);
@@ -129,8 +141,25 @@ function findPreviousCharacterPosition(root, node, offset) {
   }
   return { node: prev, offset: prev.nodeValue.length - 1 };
 }
+function isEmptyPlaceholderSpinButton(node) {
+  return node instanceof Element && node.getAttribute("role") === "spinbutton" && node.childNodes.length === 0;
+}
+function createSelectionPositionWalker(root) {
+  return document.createTreeWalker(
+    root,
+    NodeFilter.SHOW_TEXT | NodeFilter.SHOW_ELEMENT,
+    {
+      acceptNode: (node) => {
+        if (node.nodeType === Node.TEXT_NODE) {
+          return NodeFilter.FILTER_ACCEPT;
+        }
+        return isEmptyPlaceholderSpinButton(node) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
+      }
+    }
+  );
+}
 function findFirstCharacterPosition(root) {
-  const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT, null);
+  const walker = createSelectionPositionWalker(root);
   let current = walker.firstChild();
   while (current !== null) {
     if (checkIfValueTypeAlignment(current)) {
@@ -141,11 +170,12 @@ function findFirstCharacterPosition(root) {
   return null;
 }
 function findLastCharacterPosition(root) {
-  const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT, null);
+  const walker = createSelectionPositionWalker(root);
   let current = walker.lastChild();
   while (current !== null) {
     if (checkIfValueTypeAlignment(current)) {
-      return { node: current, offset: current.nodeValue?.length ?? 0 };
+      const offset = current.nodeType === Node.TEXT_NODE ? current.nodeValue?.length ?? 0 : 0;
+      return { node: current, offset };
     }
     current = walker.previousNode();
   }
@@ -155,13 +185,44 @@ function compareSelectionPoints(firstNode, firstOffset, secondNode, secondOffset
   if (firstNode === secondNode) {
     return firstOffset - secondOffset;
   }
+  if (firstNode.getRootNode() !== secondNode.getRootNode()) {
+    return 0;
+  }
   const firstRange = document.createRange();
   firstRange.setStart(firstNode, firstOffset);
   firstRange.collapse(true);
   const secondRange = document.createRange();
   secondRange.setStart(secondNode, secondOffset);
   secondRange.collapse(true);
-  return firstRange.compareBoundaryPoints(Range.START_TO_START, secondRange);
+  try {
+    return firstRange.compareBoundaryPoints(Range.START_TO_START, secondRange);
+  } catch {
+    const pos = firstNode.compareDocumentPosition(secondNode);
+    if (pos & Node.DOCUMENT_POSITION_FOLLOWING) {
+      return -1;
+    }
+    if (pos & Node.DOCUMENT_POSITION_PRECEDING) {
+      return 1;
+    }
+    return 0;
+  }
+}
+function buildDocumentOrderedRange({
+  anchorNode,
+  anchorOffset,
+  focusNode,
+  focusOffset
+}) {
+  const range = document.createRange();
+  const anchorBeforeFocus = compareSelectionPoints(anchorNode, anchorOffset, focusNode, focusOffset) <= 0;
+  if (anchorBeforeFocus) {
+    range.setStart(anchorNode, anchorOffset);
+    range.setEnd(focusNode, focusOffset);
+  } else {
+    range.setStart(focusNode, focusOffset);
+    range.setEnd(anchorNode, anchorOffset);
+  }
+  return range;
 }
 function selectionOverlapsSpinButton(selectionStartNode, selectionStartOffset, selectionEndNode, selectionEndOffset, spinButton) {
   const spinButtonStart = findFirstCharacterPosition(spinButton);
@@ -230,71 +291,64 @@ function consumePreRestoreEndpoints(root) {
   lastPreRestoreEndpoints.delete(root);
   return stash;
 }
+function shouldBypassRestore(e) {
+  if (["Meta", "Control", "Alt", "Shift"].includes(e.key)) {
+    return true;
+  }
+  if ((e.metaKey || e.ctrlKey) && (e.key.toLowerCase() === "c" || e.key.toLowerCase() === "x")) {
+    return true;
+  }
+  return e.shiftKey && ["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown", "Home", "End"].includes(
+    e.key
+  );
+}
+function tryCollapseArrow(e, root) {
+  if (e.shiftKey || e.metaKey || e.ctrlKey || e.altKey || e.key !== "ArrowLeft" && e.key !== "ArrowRight") {
+    return false;
+  }
+  const collapsed = collapseMultiElementSelection(
+    root,
+    e.key === "ArrowLeft" ? "left" : "right"
+  );
+  if (collapsed) {
+    e.preventDefault();
+    e.stopPropagation();
+  }
+  return collapsed;
+}
+function peekPreRestoreEndpoints(root) {
+  return lastPreRestoreEndpoints.get(root);
+}
 function deferContentEditableRestore(root) {
   pendingRestoreSignals.get(root)?.abort();
   const restoreSignal = new AbortController();
   pendingRestoreSignals.set(root, restoreSignal);
   function handler(e) {
+    if (e instanceof MouseEvent && e.button === 2) {
+      return;
+    }
     if (e instanceof KeyboardEvent) {
-      if (["Meta", "Control", "Alt", "Shift"].includes(e.key)) {
-        return;
-      }
-      if ((e.metaKey || e.ctrlKey) && e.key.toLowerCase() === "c") {
+      if (shouldBypassRestore(e)) {
         return;
       }
-      if (e.shiftKey && [
-        "ArrowLeft",
-        "ArrowRight",
-        "ArrowUp",
-        "ArrowDown",
-        "Home",
-        "End"
-      ].includes(e.key)) {
+      if (tryCollapseArrow(e, root)) {
         return;
       }
-      if (!e.shiftKey && !e.metaKey && !e.ctrlKey && !e.altKey && (e.key === "ArrowLeft" || e.key === "ArrowRight")) {
-        const collapsed = collapseMultiElementSelection(
-          root,
-          e.key === "ArrowLeft" ? "left" : "right"
-        );
-        if (collapsed) {
-          e.preventDefault();
-          e.stopPropagation();
-          return;
-        }
-      }
     }
     const selection = globalThis.getSelection();
-    const anchorNode = selection?.anchorNode ?? null;
-    const anchorOffset = selection?.anchorOffset ?? 0;
-    const focusNode = selection?.focusNode ?? null;
-    const focusOffset = selection?.focusOffset ?? 0;
-    const hasMultiElementSelection = selection !== null && anchorNode !== null && focusNode !== null && anchorNode !== focusNode && selection.toString().length > 0;
-    if (hasMultiElementSelection && anchorNode && focusNode) {
-      lastPreRestoreEndpoints.set(root, {
-        anchorNode,
-        anchorOffset,
-        focusNode,
-        focusOffset
-      });
+    const endpoints = getMultiElementEndpoints(selection);
+    if (endpoints !== null && e instanceof KeyboardEvent) {
+      lastPreRestoreEndpoints.set(root, endpoints);
     }
     restoreContentEditableAttributes(root);
     pendingRestoreSignals.delete(root);
     restoreSignal.abort();
-    if (hasMultiElementSelection && anchorNode && focusNode) {
-      try {
-        selection?.setBaseAndExtent(
-          anchorNode,
-          anchorOffset,
-          focusNode,
-          focusOffset
-        );
-      } catch (error) {
-        warnSelectionFailed(
-          "setBaseAndExtent failed when restoring selection after CE re-attach",
-          error
-        );
-      }
+    if (endpoints !== null) {
+      safeSetBaseAndExtent(
+        selection,
+        endpoints,
+        "setBaseAndExtent failed when restoring selection after CE re-attach"
+      );
     }
   }
   document.addEventListener("mousedown", handler, {
@@ -305,6 +359,84 @@ function deferContentEditableRestore(root) {
     signal: restoreSignal.signal,
     capture: true
   });
+  document.addEventListener(
+    "contextmenu",
+    () => {
+      const liveSelection = globalThis.getSelection();
+      const endpoints = getMultiElementEndpoints(liveSelection);
+      if (endpoints !== null) {
+        lastPreRestoreEndpoints.set(root, endpoints);
+      }
+      let stashedClipboardText = null;
+      if (endpoints !== null) {
+        safeSetBaseAndExtent(
+          liveSelection,
+          endpoints,
+          "setBaseAndExtent failed when restoring selection for context menu (pre-CE)"
+        );
+        stashedClipboardText = buildTimeframeClipboardText();
+      }
+      if (endpoints !== null) {
+        root.setAttribute("contenteditable", "true");
+      } else {
+        restoreContentEditableAttributes(root);
+      }
+      pendingRestoreSignals.delete(root);
+      restoreSignal.abort();
+      if (endpoints !== null) {
+        safeSetBaseAndExtent(
+          liveSelection,
+          endpoints,
+          "setBaseAndExtent failed when restoring selection for context menu"
+        );
+        markDragSelectedElements(root, buildDocumentOrderedRange(endpoints));
+      }
+      if (stashedClipboardText !== null) {
+        const copyListenerAbort = new AbortController();
+        const copyHandler = (copyEvent) => {
+          if (!(copyEvent instanceof ClipboardEvent)) {
+            return;
+          }
+          copyEvent.preventDefault();
+          copyEvent.clipboardData?.setData("text/plain", stashedClipboardText);
+          copyListenerAbort.abort();
+        };
+        document.addEventListener("copy", copyHandler, {
+          signal: copyListenerAbort.signal
+        });
+        document.addEventListener("cut", copyHandler, {
+          signal: copyListenerAbort.signal
+        });
+        document.addEventListener(
+          "mousedown",
+          () => copyListenerAbort.abort(),
+          { signal: copyListenerAbort.signal, capture: true, once: true }
+        );
+      }
+      if (endpoints !== null) {
+        const ceCleanupAbort = new AbortController();
+        const restorePerSpinButtonCE = () => {
+          root.removeAttribute("contenteditable");
+          restoreContentEditableAttributes(root);
+          ceCleanupAbort.abort();
+        };
+        document.addEventListener("mousedown", restorePerSpinButtonCE, {
+          signal: ceCleanupAbort.signal,
+          capture: true,
+          once: true
+        });
+        document.addEventListener("cut", restorePerSpinButtonCE, {
+          signal: ceCleanupAbort.signal,
+          once: true
+        });
+        document.addEventListener("copy", restorePerSpinButtonCE, {
+          signal: ceCleanupAbort.signal,
+          once: true
+        });
+      }
+    },
+    { signal: restoreSignal.signal, capture: true }
+  );
 }
 function removeContentEditable(rootElement, removeEventTarget, eventType, customRemovalFn, initialAnchorSpinButton) {
   rootElement.setAttribute("data-restoring-selection", "");
@@ -333,39 +465,33 @@ function removeContentEditable(rootElement, removeEventTarget, eventType, custom
             return;
           }
           const focusNode = sel.focusNode;
-          const focusOffset = sel.focusOffset ?? 0;
           if (!focusNode) {
             return;
           }
+          const focusOffset = sel.focusOffset ?? 0;
           const anchorBeforeFocus = compareSelectionPoints(
             anchorPos.node,
             anchorPos.offset,
             focusNode,
             focusOffset
           ) <= 0;
-          try {
-            sel.removeAllRanges();
-            if (anchorBeforeFocus) {
-              sel.setBaseAndExtent(
-                anchorPos.node,
-                anchorPos.offset,
-                focusNode,
-                focusOffset
-              );
-            } else {
-              sel.setBaseAndExtent(
-                focusNode,
-                focusOffset,
-                anchorPos.node,
-                anchorPos.offset
-              );
-            }
-          } catch (error) {
-            warnSelectionFailed(
-              "selection anchor correction during drag failed",
-              error
-            );
-          }
+          sel.removeAllRanges();
+          const correctedEndpoints = anchorBeforeFocus ? {
+            anchorNode: anchorPos.node,
+            anchorOffset: anchorPos.offset,
+            focusNode,
+            focusOffset
+          } : {
+            anchorNode: focusNode,
+            anchorOffset: focusOffset,
+            focusNode: anchorPos.node,
+            focusOffset: anchorPos.offset
+          };
+          safeSetBaseAndExtent(
+            sel,
+            correctedEndpoints,
+            "selection anchor correction during drag failed"
+          );
         },
         { signal: signal.signal, capture: true }
       );
@@ -386,13 +512,16 @@ function removeContentEditable(rootElement, removeEventTarget, eventType, custom
   removeEventTarget.addEventListener(
     eventType,
     (event) => {
-      const selectionBeforeRestore = globalThis.getSelection();
-      const snapshotAnchorNode = selectionBeforeRestore?.anchorNode ?? null;
-      const snapshotAnchorOffset = selectionBeforeRestore?.anchorOffset ?? 0;
-      const snapshotFocusNode = selectionBeforeRestore?.focusNode ?? null;
-      const snapshotFocusOffset = selectionBeforeRestore?.focusOffset ?? 0;
-      const hasMultiElementSelection = selectionBeforeRestore !== null && selectionBeforeRestore.toString().length > 0 && (snapshotAnchorNode !== snapshotFocusNode || snapshotAnchorNode !== null && snapshotAnchorNode === snapshotFocusNode && snapshotAnchorOffset !== snapshotFocusOffset && snapshotAnchorNode.nodeType === Node.ELEMENT_NODE);
-      if (hasMultiElementSelection && snapshotAnchorNode && snapshotFocusNode) {
+      const multiElementEndpoints = getMultiElementEndpoints(
+        globalThis.getSelection()
+      );
+      if (multiElementEndpoints !== null) {
+        const {
+          anchorNode: snapshotAnchorNode,
+          anchorOffset: snapshotAnchorOffset,
+          focusNode: snapshotFocusNode,
+          focusOffset: snapshotFocusOffset
+        } = multiElementEndpoints;
         const anchorIsElementNode = snapshotAnchorNode.nodeType !== Node.TEXT_NODE;
         const anchorNodeWasInContent = anchorIsElementNode ? initialAnchorSpinButton !== null : isEndpointInsideSpinButtonContent(
           snapshotAnchorNode,
@@ -450,51 +579,28 @@ function removeContentEditable(rootElement, removeEventTarget, eventType, custom
           focusPos = { node: snapshotFocusNode, offset: snapshotFocusOffset };
         }
         if (anchorPos && focusPos) {
-          try {
-            const range = document.createRange();
-            if (anchorBeforeFocus) {
-              range.setStart(anchorPos.node, anchorPos.offset);
-              range.setEnd(focusPos.node, focusPos.offset);
-            } else {
-              range.setStart(focusPos.node, focusPos.offset);
-              range.setEnd(anchorPos.node, anchorPos.offset);
-            }
-            const sel = globalThis.getSelection();
-            sel?.setBaseAndExtent(
-              anchorPos.node,
-              anchorPos.offset,
-              focusPos.node,
-              focusPos.offset
-            );
-            markDragSelectedElements(rootElement, range);
-          } catch (error) {
-            warnSelectionFailed(
-              "setBaseAndExtent failed when restoring drag selection",
-              error
-            );
-          }
+          const dragEndpoints = {
+            anchorNode: anchorPos.node,
+            anchorOffset: anchorPos.offset,
+            focusNode: focusPos.node,
+            focusOffset: focusPos.offset
+          };
+          safeSetBaseAndExtent(
+            globalThis.getSelection(),
+            dragEndpoints,
+            "setBaseAndExtent failed when restoring drag selection"
+          );
+          markDragSelectedElements(
+            rootElement,
+            buildDocumentOrderedRange(dragEndpoints)
+          );
         }
-        customRemovalFn?.(event, hasMultiElementSelection);
+        customRemovalFn?.(event, true);
         rootElement.removeAttribute("data-restoring-selection");
         deferContentEditableRestore(rootElement);
       } else {
         restoreContentEditableAttributes(rootElement);
-        if (snapshotAnchorNode && snapshotFocusNode) {
-          try {
-            globalThis.getSelection()?.setBaseAndExtent(
-              snapshotAnchorNode,
-              snapshotAnchorOffset,
-              snapshotFocusNode,
-              snapshotFocusOffset
-            );
-          } catch (error) {
-            warnSelectionFailed(
-              "setBaseAndExtent failed when restoring single-element selection",
-              error
-            );
-          }
-        }
-        customRemovalFn?.(event, hasMultiElementSelection);
+        customRemovalFn?.(event, false);
         rootElement.removeAttribute("data-restoring-selection");
       }
       signal.abort();
@@ -502,7 +608,7 @@ function removeContentEditable(rootElement, removeEventTarget, eventType, custom
     { signal: signal.signal }
   );
 }
-function findSpinButtonSnappedPosition(root, anchorNode, anchorOffset, focusNode, focusOffset, direction) {
+function findSpinButtonSnappedPosition(root, { anchorNode, anchorOffset, focusNode, focusOffset }, direction) {
   let spinButton = null;
   if (focusNode.nodeType === Node.TEXT_NODE) {
     spinButton = focusNode.parentElement?.closest(
@@ -525,17 +631,36 @@ function findSpinButtonSnappedPosition(root, anchorNode, anchorOffset, focusNode
     if (!nextSB) {
       return null;
     }
-    return isGrowing ? findLastCharacterPosition(nextSB) : findFirstCharacterPosition(nextSB);
+    if (isGrowing) {
+      return findLastCharacterPosition(nextSB) ?? { node: nextSB, offset: 0 };
+    }
+    return findFirstCharacterPosition(nextSB) ?? { node: nextSB, offset: 0 };
   }
   const prevSB = allSBs[idx - 1] ?? null;
   if (!prevSB) {
     return null;
   }
-  return isGrowing ? findFirstCharacterPosition(prevSB) : findLastCharacterPosition(prevSB);
+  if (isGrowing) {
+    return findFirstCharacterPosition(prevSB) ?? { node: prevSB, offset: 0 };
+  }
+  return findLastCharacterPosition(prevSB) ?? { node: prevSB, offset: 0 };
 }
 function extendSelection(key) {
   const selection = globalThis.getSelection();
-  if (selection === null || selection.anchorNode === null || selection.focusNode === null || selection.rangeCount < 1) {
+  if (selection === null) {
+    return;
+  }
+  const activeElement = globalThis.document?.activeElement;
+  const hasMissingEndpoints = selection.anchorNode === null || selection.focusNode === null;
+  if (hasMissingEndpoints && isEmptyPlaceholderSpinButton(activeElement)) {
+    selection.setBaseAndExtent(
+      activeElement,
+      0,
+      activeElement,
+      0
+    );
+  }
+  if (selection.anchorNode === null || selection.focusNode === null || selection.rangeCount < 1) {
     return;
   }
   const anchorNode = selection.anchorNode;
@@ -549,24 +674,16 @@ function extendSelection(key) {
   if (root === null || root === void 0) {
     return;
   }
+  const selEndpoints = {
+    anchorNode,
+    anchorOffset,
+    focusNode,
+    focusOffset
+  };
   if (key === "ArrowLeft") {
-    nextPos = findSpinButtonSnappedPosition(
-      root,
-      anchorNode,
-      anchorOffset,
-      focusNode,
-      focusOffset,
-      "backward"
-    ) ?? findPreviousCharacterPosition(root, focusNode, focusOffset);
+    nextPos = findSpinButtonSnappedPosition(root, selEndpoints, "backward") ?? findPreviousCharacterPosition(root, focusNode, focusOffset);
   } else if (key === "ArrowRight") {
-    nextPos = findSpinButtonSnappedPosition(
-      root,
-      anchorNode,
-      anchorOffset,
-      focusNode,
-      focusOffset,
-      "forward"
-    ) ?? findNextCharacterPosition(root, focusNode, focusOffset);
+    nextPos = findSpinButtonSnappedPosition(root, selEndpoints, "forward") ?? findNextCharacterPosition(root, focusNode, focusOffset);
   } else if (key === "Home") {
     nextPos = findFirstCharacterPosition(root);
   } else if (key === "End") {
@@ -606,7 +723,8 @@ function extendSelection(key) {
   if (crossesBoundary) {
     let resolvedAnchorNode = anchorNode;
     let resolvedAnchorOffset = anchorOffset;
-    if (anchorNode.nodeType !== Node.TEXT_NODE && anchorSB) {
+    const anchorSpinButtonHasContent = anchorSB !== null && anchorSB.childNodes.length > 0;
+    if (anchorNode.nodeType !== Node.TEXT_NODE && anchorSpinButtonHasContent) {
       const anchorBeforeFocus = compareSelectionPoints(
         anchorNode,
         anchorOffset,
@@ -627,62 +745,35 @@ function extendSelection(key) {
       editable.removeAttribute("contenteditable");
       editable.dataset.wascontenteditable = prev;
     }
-    try {
-      selection.setBaseAndExtent(
-        resolvedAnchorNode,
-        resolvedAnchorOffset,
-        nextPos.node,
-        nextPos.offset
-      );
-      const anchorBeforeFocus = compareSelectionPoints(
-        resolvedAnchorNode,
-        resolvedAnchorOffset,
-        nextPos.node,
-        nextPos.offset
-      ) <= 0;
-      const range = document.createRange();
-      if (anchorBeforeFocus) {
-        range.setStart(resolvedAnchorNode, resolvedAnchorOffset);
-        range.setEnd(nextPos.node, nextPos.offset);
-      } else {
-        range.setStart(nextPos.node, nextPos.offset);
-        range.setEnd(resolvedAnchorNode, resolvedAnchorOffset);
-      }
-      markDragSelectedElements(root, range);
-    } catch (error) {
-      warnSelectionFailed(
-        "setBaseAndExtent failed when extending cross-boundary selection",
-        error
-      );
-    }
+    const nextEndpoints = {
+      anchorNode: resolvedAnchorNode,
+      anchorOffset: resolvedAnchorOffset,
+      focusNode: nextPos.node,
+      focusOffset: nextPos.offset
+    };
+    safeSetBaseAndExtent(
+      selection,
+      nextEndpoints,
+      "setBaseAndExtent failed when extending cross-boundary selection"
+    );
+    markDragSelectedElements(root, buildDocumentOrderedRange(nextEndpoints));
     root.removeAttribute("data-restoring-selection");
     deferContentEditableRestore(root);
   } else {
     root.setAttribute("data-restoring-selection", "");
-    try {
-      selection.setBaseAndExtent(
-        anchorNode,
-        anchorOffset,
-        nextPos.node,
-        nextPos.offset
-      );
-    } catch (error) {
-      warnSelectionFailed(
-        "setBaseAndExtent failed when extending selection",
-        error
-      );
-    }
+    const nextEndpoints = {
+      anchorNode,
+      anchorOffset,
+      focusNode: nextPos.node,
+      focusOffset: nextPos.offset
+    };
+    safeSetBaseAndExtent(
+      selection,
+      nextEndpoints,
+      "setBaseAndExtent failed when extending selection"
+    );
     root.removeAttribute("data-restoring-selection");
-    const updatedRange = new Range();
-    const cmp = anchorNode.compareDocumentPosition(nextPos.node);
-    if (cmp & Node.DOCUMENT_POSITION_FOLLOWING || cmp === 0 && anchorOffset <= nextPos.offset) {
-      updatedRange.setStart(anchorNode, anchorOffset);
-      updatedRange.setEnd(nextPos.node, nextPos.offset);
-    } else {
-      updatedRange.setStart(nextPos.node, nextPos.offset);
-      updatedRange.setEnd(anchorNode, anchorOffset);
-    }
-    markDragSelectedElements(root, updatedRange);
+    markDragSelectedElements(root, buildDocumentOrderedRange(nextEndpoints));
   }
   root.setAttribute("data-shift-selection", "");
 }
@@ -709,29 +800,30 @@ function extendSelectionToAll() {
     const prev = editable.getAttribute("contenteditable") ?? "";
     editable.removeAttribute("contenteditable");
     editable.dataset.wascontenteditable = prev;
+    if (editable.hasAttribute("tabindex")) {
+      editable.dataset.wastabindex = editable.getAttribute("tabindex") ?? "";
+      editable.removeAttribute("tabindex");
+    }
   }
-  try {
-    const range = document.createRange();
-    range.setStart(firstPosition.node, firstPosition.offset);
-    range.setEnd(lastPosition.node, lastPosition.offset);
-    selection.setBaseAndExtent(
-      firstPosition.node,
-      firstPosition.offset,
-      lastPosition.node,
-      lastPosition.offset
-    );
-    markDragSelectedElements(root, range, { includeTextboxes: true });
-  } catch (error) {
-    warnSelectionFailed(
-      "setBaseAndExtent failed when extending selection to all",
-      error
-    );
-  }
-  root.removeAttribute("data-restoring-selection");
   root.focus();
+  const allEndpoints = {
+    anchorNode: firstPosition.node,
+    anchorOffset: firstPosition.offset,
+    focusNode: lastPosition.node,
+    focusOffset: lastPosition.offset
+  };
+  safeSetBaseAndExtent(
+    selection,
+    allEndpoints,
+    "setBaseAndExtent failed when extending selection to all"
+  );
+  markDragSelectedElements(root, buildDocumentOrderedRange(allEndpoints), {
+    includeTextboxes: true
+  });
+  root.removeAttribute("data-restoring-selection");
   deferContentEditableRestore(root);
 }
-function getBoundaryNodes(direction, anchorNode, anchorOffset, focusNode, focusOffset) {
+function getBoundaryNodes(direction, { anchorNode, anchorOffset, focusNode, focusOffset }) {
   const anchorBeforeFocus = compareSelectionPoints(anchorNode, anchorOffset, focusNode, focusOffset) <= 0;
   if (direction === "left" && anchorBeforeFocus) {
     return { boundaryNode: anchorNode, boundaryOffset: anchorOffset };
@@ -753,13 +845,12 @@ function collapseMultiElementSelection(rootElement, direction) {
   }
   const anchorOffset = selection.anchorOffset;
   const focusOffset = selection.focusOffset;
-  const { boundaryNode, boundaryOffset } = getBoundaryNodes(
-    direction,
+  const { boundaryNode, boundaryOffset } = getBoundaryNodes(direction, {
     anchorNode,
     anchorOffset,
     focusNode,
     focusOffset
-  );
+  });
   pendingRestoreSignals.get(rootElement)?.abort();
   pendingRestoreSignals.delete(rootElement);
   restoreContentEditableAttributes(rootElement);
@@ -1012,6 +1103,32 @@ function getOffsetWithinExpression(expressionElement, container, offset) {
   range.setEnd(container, offset);
   return range.toString().length;
 }
+function getExpressionCursorOffset(expressionElement) {
+  const sel = window.getSelection();
+  if (!sel?.rangeCount) {
+    return void 0;
+  }
+  const range = sel.getRangeAt(0);
+  if (!expressionElement.contains(range.endContainer)) {
+    return void 0;
+  }
+  return getOffsetWithinExpression(
+    expressionElement,
+    range.endContainer,
+    range.endOffset
+  );
+}
+function restoreExpressionCursorOffset(expressionElement, offset) {
+  const textNode = expressionElement.firstChild;
+  const sel = window.getSelection();
+  if (textNode instanceof Text && sel) {
+    const range = document.createRange();
+    range.setStart(textNode, Math.min(offset, textNode.length));
+    range.collapse(true);
+    sel.removeAllRanges();
+    sel.addRange(range);
+  }
+}
 function deletePartialExpression(selection, expressionElement) {
   const range = selection.getRangeAt(0);
   const text = expressionElement.textContent ?? "";
@@ -1041,18 +1158,15 @@ function deletePartialExpression(selection, expressionElement) {
   expressionElement.dispatchEvent(new InputEvent("input", { bubbles: true }));
 }
 function planBulkClear(selection, inputRefs, endpointsOverride) {
-  const anchorNode = endpointsOverride?.anchorNode ?? selection.anchorNode;
-  const anchorOffset = endpointsOverride?.anchorOffset ?? selection.anchorOffset;
-  const focusNode = endpointsOverride?.focusNode ?? selection.focusNode;
-  const focusOffset = endpointsOverride?.focusOffset ?? selection.focusOffset;
+  const validOverride = endpointsOverride?.anchorNode.isConnected && endpointsOverride?.focusNode.isConnected ? endpointsOverride : void 0;
+  const anchorNode = validOverride?.anchorNode ?? selection.anchorNode;
+  const anchorOffset = validOverride?.anchorOffset ?? selection.anchorOffset;
+  const focusNode = validOverride?.focusNode ?? selection.focusNode;
+  const focusOffset = validOverride?.focusOffset ?? selection.focusOffset;
   const affectedExpressionRefs = inputRefs.filter((ref) => {
     const expressionInputRef = ref.current?.expressionInputRef;
     return expressionInputRef && (expressionInputRef.contains(anchorNode) || expressionInputRef.contains(focusNode));
   });
-  const clearedExpressions = affectedExpressionRefs.map((ref) => ({
-    inputRef: ref,
-    previousText: ref.current?.inputRef?.value ?? ref.current?.expressionInputRef?.textContent ?? ""
-  }));
   const anchorInExpression = affectedExpressionRefs.some(
     (ref) => ref.current?.expressionInputRef?.contains(anchorNode)
   );
@@ -1069,8 +1183,7 @@ function planBulkClear(selection, inputRefs, endpointsOverride) {
   return {
     snapshot,
     affectedExpressionRefs,
-    expressionFallbacks: findExpressionFallbacks(snapshot),
-    clearedExpressions
+    expressionFallbacks: findExpressionFallbacks(snapshot)
   };
 }
 function deleteCrossExpressionPartial(selection, [firstExpressionElement, lastExpressionElement]) {
@@ -1114,7 +1227,6 @@ function restoreFocusAfterBulkClear(firstSpinButtonHandler, focusTarget) {
 }
 export {
   buildSpinButtonSnapshot,
-  checkIfValueTypeAlignment,
   collapseMultiElementSelection,
   consumePreRestoreEndpoints,
   deleteCrossExpressionPartial,
@@ -1125,12 +1237,16 @@ export {
   findFirstExpressionFocusTarget,
   focusExpression,
   getCrossExpressionElements,
+  getExpressionCursorOffset,
   getFirstSnapshotHandler,
   getLastSnapshotHandler,
   getPartialExpressionElement,
+  peekPreRestoreEndpoints,
   planBulkClear,
   removeContentEditable,
+  restoreExpressionCursorOffset,
   restoreFocusAfterBulkClear,
-  restoreSpinButtonSnapshot
+  restoreSpinButtonSnapshot,
+  safeSetBaseAndExtent
 };
 //# sourceMappingURL=selection-helpers.js.map