@haklex/rich-editor 0.0.103 → 0.0.105

package/dist/{SubmitShortcutPlugin-CDqj7KHO.js → SubmitShortcutPlugin-BmTJ4o1C.js}

@@ -6,24 +6,24 @@ import { TabIndentationPlugin } from "@lexical/react/LexicalTabIndentationPlugin
 import { TablePlugin } from "@lexical/react/LexicalTablePlugin";
 import { createLinkMatcherWithRegExp, registerAutoLink, LinkNode, AutoLinkNode } from "@lexical/link";
 import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
-import { useEffect, createContext, use, useRef, useState, useMemo, useCallback } from "react";
+import { useEffect, createContext, use, useRef, useState, useMemo, useCallback, useSyncExternalStore } from "react";
 import { $isQuoteNode, QuoteNode, $createQuoteNode, DRAG_DROP_PASTE } from "@lexical/rich-text";
-import { KEY_ARROW_RIGHT_COMMAND, $getSelection, $isRangeSelection, COMMAND_PRIORITY_CRITICAL, KEY_ARROW_DOWN_COMMAND, $isDecoratorNode, $isElementNode, $isRootNode, $isParagraphNode, $createParagraphNode, KEY_ENTER_COMMAND, $isNodeSelection, KEY_BACKSPACE_COMMAND, COMMAND_PRIORITY_HIGH, KEY_DELETE_COMMAND, KEY_ARROW_UP_COMMAND, $isTextNode, IS_CODE, $createNodeSelection, $setSelection, $getRoot, $getNodeByKey, COMMAND_PRIORITY_EDITOR, COMMAND_PRIORITY_LOW, $createTextNode, $createLineBreakNode, PASTE_COMMAND, $insertNodes, createEditor, $parseSerializedNode, createState, $getState, $addUpdateTag, $setState, $nodesOfType } from "lexical";
-import { b as setCodeBlockCursorIntent, g as getResolvedEditNodes, $ as $createBannerEditNode, d as $createCodeBlockEditNode } from "./node-registry-BOSH1oBi.js";
+import { KEY_ARROW_RIGHT_COMMAND, $getSelection, $isRangeSelection, COMMAND_PRIORITY_CRITICAL, KEY_ARROW_DOWN_COMMAND, $isDecoratorNode, $isElementNode, $isRootNode, $isParagraphNode, $createParagraphNode, KEY_ENTER_COMMAND, $isNodeSelection, KEY_BACKSPACE_COMMAND, COMMAND_PRIORITY_HIGH, KEY_DELETE_COMMAND, KEY_ARROW_UP_COMMAND, $isTextNode, IS_CODE, $createNodeSelection, $setSelection, $getRoot, $getNodeByKey, COMMAND_PRIORITY_EDITOR, COMMAND_PRIORITY_LOW, $createTextNode, $createLineBreakNode, PASTE_COMMAND, $insertNodes, createEditor, $parseSerializedNode, createState, $getState, $addUpdateTag, $setState, $isLineBreakNode, $createRangeSelection, SELECTION_CHANGE_COMMAND, $nodesOfType } from "lexical";
+import { b as setCodeBlockCursorIntent, g as getResolvedEditNodes, $ as $createBannerEditNode, d as $createCodeBlockEditNode } from "./node-registry-CJe4Pjdm.js";
 import { HorizontalRuleNode, $createHorizontalRuleNode, INSERT_HORIZONTAL_RULE_COMMAND } from "@lexical/extension";
 import { HORIZONTAL_RULE_BLOCK_TRANSFORMER as HORIZONTAL_RULE_BLOCK_TRANSFORMER$1, GIT_ALERT_TRANSFORMER as GIT_ALERT_TRANSFORMER$1, COMMENT_TRANSFORMER as COMMENT_TRANSFORMER$1, CONTAINER_TRANSFORMER as CONTAINER_TRANSFORMER$1, FOOTNOTE_TRANSFORMER as FOOTNOTE_TRANSFORMER$1, FOOTNOTE_SECTION_TRANSFORMER as FOOTNOTE_SECTION_TRANSFORMER$1, KATEX_INLINE_TRANSFORMER as KATEX_INLINE_TRANSFORMER$1, KATEX_BLOCK_TRANSFORMER as KATEX_BLOCK_TRANSFORMER$1, MENTION_TRANSFORMER as MENTION_TRANSFORMER$1, RUBY_TRANSFORMER as RUBY_TRANSFORMER$1, SPOILER_TRANSFORMER as SPOILER_TRANSFORMER$1, INSERT_TRANSFORMER, SUPERSCRIPT_TRANSFORMER, SUBSCRIPT_TRANSFORMER, IMAGE_BLOCK_TRANSFORMER, VIDEO_BLOCK_TRANSFORMER, CODE_BLOCK_NODE_TRANSFORMER, LINK_CARD_BLOCK_TRANSFORMER, MERMAID_BLOCK_TRANSFORMER, TABLE_BLOCK_TRANSFORMER } from "@haklex/rich-headless/transformers";
 import { CHECK_LIST, TRANSFORMERS, QUOTE, CODE, $convertFromMarkdownString } from "@lexical/markdown";
-import { $ as $createAlertQuoteEditNode } from "./AlertQuoteEditNode-C_Cb063D.js";
-import { v as AlertQuoteNode, F as FootnoteNode, y as $createFootnoteNode, k as KaTeXInlineNode, K as KaTeXBlockNode, w as $createKaTeXInlineNode, x as $createKaTeXBlockNode, M as MentionNode, a as $createMentionNode, o as extractTextContent, S as SpoilerNode, q as $createSpoilerNode, $ as $createImageNode, O as OPEN_IMAGE_UPLOAD_DIALOG_COMMAND } from "./theme-CrJbATnf.js";
-import { v as CodeBlockNode, C as CommentNode, w as $createCommentPlaceholderNode, $ as $createCommentNode, q as BannerNode, D as DetailsNode, x as $createDetailsNode, F as FootnoteSectionNode, f as $isFootnoteSectionNode, a as $createFootnoteSectionNode, g as $isGridContainerNode, R as RubyNode, d as $createRubyNode } from "./config-mAejoug-.js";
+import { $ as $createAlertQuoteEditNode } from "./AlertQuoteEditNode-CPb1jFUY.js";
+import { v as AlertQuoteNode, F as FootnoteNode, y as $createFootnoteNode, k as KaTeXInlineNode, K as KaTeXBlockNode, w as $createKaTeXInlineNode, x as $createKaTeXBlockNode, M as MentionNode, a as $createMentionNode, o as extractTextContent, S as SpoilerNode, q as $createSpoilerNode, $ as $createImageNode, O as OPEN_IMAGE_UPLOAD_DIALOG_COMMAND } from "./theme-I0pMTSBW.js";
+import { v as CodeBlockNode, C as CommentNode, w as $createCommentPlaceholderNode, $ as $createCommentNode, q as BannerNode, D as DetailsNode, x as $createDetailsNode, F as FootnoteSectionNode, f as $isFootnoteSectionNode, a as $createFootnoteSectionNode, g as $isGridContainerNode, R as RubyNode, d as $createRubyNode } from "./config-DjJiU65k.js";
 import { $createTableNode, $createTableRowNode, $createTableCellNode, TableCellHeaderStates } from "@lexical/table";
 import { MarkdownShortcutPlugin } from "@lexical/react/LexicalMarkdownShortcutPlugin";
-import { nanoid } from "nanoid";
 import { Dialog, DialogPopup, DialogTitle, SegmentedControl, ActionButton, ActionBar } from "@haklex/rich-editor-ui";
 import { Check, Info, Upload, Link2 } from "lucide-react";
 import { i as computeImageMeta, F as FootnoteDefinitionsProvider } from "./KaTeXRenderer-CQyQzNTJ.js";
 import "./katex.css-Csc-7N7u.js";
 import { g as getHostname, p as probeFavicon, n as normalizeSerializedEditorState } from "./normalizeSerializedEditorState-k5G4xSi9.js";
+import { nanoid } from "nanoid";
 const URL_REGEX = /https?:\/\/(?:www\.)?[\w#%+.:=@~-]{1,256}\.[A-Za-z]{2}[\w#%&()+./:=?@~-]*/;
 const EMAIL_REGEX = /(?:[\w%+.-]+@[\d.a-z-]+\.[a-z]{2,})/i;
 const URL_MATCHER = createLinkMatcherWithRegExp(URL_REGEX);
@@ -1587,6 +1587,644 @@ function LinkFaviconPlugin() {
   }, [editor]);
   return null;
 }
+function areSnapshotsEqual(a, b) {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  return a.text === b.text && a.anchorBlockId === b.anchorBlockId && a.anchorOffset === b.anchorOffset && a.focusBlockId === b.focusBlockId && a.focusOffset === b.focusOffset;
+}
+function createTextSelectionStore(initialState = { snapshot: null }) {
+  let state = initialState;
+  const listeners = /* @__PURE__ */ new Set();
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  return {
+    getState: () => state,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    setSnapshot: (snapshot) => {
+      if (areSnapshotsEqual(state.snapshot, snapshot)) {
+        return;
+      }
+      state = { ...state, snapshot };
+      emit();
+    },
+    clearSnapshot: () => {
+      if (state.snapshot === null) {
+        return;
+      }
+      state = { ...state, snapshot: null };
+      emit();
+    }
+  };
+}
+const TextSelectionStoreContext = createContext(null);
+function TextSelectionStoreProvider({ children }) {
+  const storeRef = useRef(null);
+  if (!storeRef.current) {
+    storeRef.current = createTextSelectionStore();
+  }
+  return /* @__PURE__ */ jsx(TextSelectionStoreContext.Provider, { value: storeRef.current, children });
+}
+function useTextSelectionStore() {
+  const store = use(TextSelectionStoreContext);
+  if (!store) {
+    throw new Error("useTextSelectionStore must be used within TextSelectionStoreProvider");
+  }
+  return store;
+}
+function useTextSelectionSnapshot() {
+  const store = useTextSelectionStore();
+  return useSyncExternalStore(
+    store.subscribe,
+    () => store.getState().snapshot,
+    () => store.getState().snapshot
+  );
+}
+function computeBlockFingerprint(block) {
+  const text = block.getTextContent();
+  const input = text.slice(0, 200) + String(text.length);
+  let hash = 5381;
+  for (let i = 0; i < input.length; i++) {
+    hash = (hash << 5) + hash + (input.codePointAt(i) ?? 0) | 0;
+  }
+  return (hash >>> 0).toString(16);
+}
+function $getRootBlock(node) {
+  const root = $getRoot();
+  let current = node;
+  while (current) {
+    const parent = current.getParent();
+    if (parent === root && "getChildren" in current) {
+      return current;
+    }
+    current = parent;
+  }
+  return null;
+}
+function $resolveSelectionPoint(selection, which) {
+  const point = selection[which];
+  const node = point.getNode();
+  if ($isElementNode(node)) {
+    const children = node.getChildren();
+    if (point.offset < children.length) {
+      return { node: children[point.offset], offset: 0 };
+    }
+    const last = children.at(-1);
+    if (last && $isTextNode(last)) {
+      return { node: last, offset: last.getTextContentSize() };
+    }
+    return { node, offset: 0 };
+  }
+  return { node, offset: point.offset };
+}
+function $getTextOffsetInBlock(block, targetNode, targetOffset) {
+  let offset = 0;
+  function walk(node) {
+    if (node.is(targetNode)) {
+      offset += targetOffset;
+      return true;
+    }
+    if ($isTextNode(node)) {
+      offset += node.getTextContentSize();
+    } else if ($isLineBreakNode(node)) {
+      offset += 1;
+    } else if ($isElementNode(node)) {
+      for (const child of node.getChildren()) {
+        if (walk(child)) return true;
+      }
+    }
+    return false;
+  }
+  for (const child of block.getChildren()) {
+    if (walk(child)) break;
+  }
+  return offset;
+}
+function $buildBlockAnchorData(block) {
+  const blockId = $getState(block, blockIdState);
+  if (!blockId) {
+    return { ok: false, error: "no-block-id" };
+  }
+  return {
+    ok: true,
+    anchor: {
+      mode: "block",
+      blockId,
+      blockType: block.getType(),
+      blockFingerprint: computeBlockFingerprint(block),
+      snapshotText: block.getTextContent().slice(0, 300)
+    }
+  };
+}
+function buildBlockAnchor(editor, blockKey) {
+  return editor.read(() => {
+    if (blockKey) {
+      const node = $getRoot().getChildren().find((c) => c.getKey() === blockKey);
+      if (!node || !("getChildren" in node)) {
+        return { ok: false, error: "not-root-block" };
+      }
+      return $buildBlockAnchorData(node);
+    }
+    const selection = $getSelection();
+    if (!$isRangeSelection(selection)) {
+      return { ok: false, error: "no-selection" };
+    }
+    const anchorNode = selection.anchor.getNode();
+    const block = $getRootBlock(anchorNode);
+    if (!block) {
+      return { ok: false, error: "not-root-block" };
+    }
+    return $buildBlockAnchorData(block);
+  });
+}
+function buildRangeAnchor(editor) {
+  return editor.read(() => {
+    const selection = $getSelection();
+    if (!$isRangeSelection(selection)) {
+      return { ok: false, error: "no-selection" };
+    }
+    if (selection.isCollapsed()) {
+      return { ok: false, error: "collapsed" };
+    }
+    const anchorBlock = $getRootBlock(selection.anchor.getNode());
+    const focusBlock = $getRootBlock(selection.focus.getNode());
+    if (!anchorBlock || !focusBlock) {
+      return { ok: false, error: "not-root-block" };
+    }
+    if (anchorBlock !== focusBlock) {
+      return { ok: false, error: "cross-block" };
+    }
+    const block = anchorBlock;
+    const blockId = $getState(block, blockIdState);
+    if (!blockId) {
+      return { ok: false, error: "no-block-id" };
+    }
+    const anchorPoint = $resolveSelectionPoint(selection, "anchor");
+    const focusPoint = $resolveSelectionPoint(selection, "focus");
+    let startOffset = $getTextOffsetInBlock(block, anchorPoint.node, anchorPoint.offset);
+    let endOffset = $getTextOffsetInBlock(block, focusPoint.node, focusPoint.offset);
+    if (startOffset > endOffset) {
+      [startOffset, endOffset] = [endOffset, startOffset];
+    }
+    const text = block.getTextContent();
+    const quote = text.slice(startOffset, endOffset);
+    const prefix = text.slice(Math.max(0, startOffset - 50), startOffset);
+    const suffix = text.slice(endOffset, endOffset + 50);
+    return {
+      ok: true,
+      anchor: {
+        mode: "range",
+        blockId,
+        blockType: block.getType(),
+        blockFingerprint: computeBlockFingerprint(block),
+        snapshotText: text.slice(0, 300),
+        quote,
+        prefix,
+        suffix,
+        startOffset,
+        endOffset
+      }
+    };
+  });
+}
+const TEXT_SELECTION_HIGHLIGHT_NAME = "rich-editor-text-selection";
+const TEXT_SELECTION_INACTIVE_HIGHLIGHT_NAME = "rich-editor-text-selection-inactive";
+function clampOffset(offset, max) {
+  return Math.max(0, Math.min(offset, max));
+}
+function getTopLevelBlockById(blockId) {
+  for (const child of $getRoot().getChildren()) {
+    if ($getState(child, blockIdState) === blockId && $isElementNode(child)) {
+      return child;
+    }
+  }
+  return null;
+}
+function getTextLengthOfDomNode(node) {
+  if (node.nodeType === Node.TEXT_NODE) {
+    return node.textContent?.length ?? 0;
+  }
+  if (node.nodeType !== Node.ELEMENT_NODE) {
+    return 0;
+  }
+  const element = node;
+  if (element.tagName === "BR") {
+    return 1;
+  }
+  let length = 0;
+  for (const child of node.childNodes) {
+    length += getTextLengthOfDomNode(child);
+  }
+  return length;
+}
+function compareBlockElements(a, b) {
+  if (a === b) return 0;
+  const position = a.compareDocumentPosition(b);
+  if (position & Node.DOCUMENT_POSITION_FOLLOWING) {
+    return -1;
+  }
+  if (position & Node.DOCUMENT_POSITION_PRECEDING) {
+    return 1;
+  }
+  return 0;
+}
+function buildDomRectFromClientRects(rects) {
+  if (!rects.length) return null;
+  let left = rects[0].left;
+  let top = rects[0].top;
+  let right = rects[0].right;
+  let bottom = rects[0].bottom;
+  for (const rect of rects.slice(1)) {
+    left = Math.min(left, rect.left);
+    top = Math.min(top, rect.top);
+    right = Math.max(right, rect.right);
+    bottom = Math.max(bottom, rect.bottom);
+  }
+  return new DOMRect(left, top, right - left, bottom - top);
+}
+function resolveLexicalSelectionTarget(block, requestedOffset) {
+  const offset = clampOffset(requestedOffset, block.getTextContent().length);
+  let remaining = offset;
+  let lastTarget = {
+    key: block.getKey(),
+    offset: block.getChildrenSize(),
+    type: "element"
+  };
+  function walk(node) {
+    if ($isTextNode(node)) {
+      const length = node.getTextContentSize();
+      lastTarget = { key: node.getKey(), offset: length, type: "text" };
+      if (remaining <= length) {
+        return { key: node.getKey(), offset: remaining, type: "text" };
+      }
+      remaining -= length;
+      return null;
+    }
+    if ($isLineBreakNode(node)) {
+      const parent = node.getParent();
+      if (!parent) {
+        return null;
+      }
+      const index = node.getIndexWithinParent();
+      if (remaining === 0) {
+        return { key: parent.getKey(), offset: index, type: "element" };
+      }
+      if (remaining === 1) {
+        return { key: parent.getKey(), offset: index + 1, type: "element" };
+      }
+      remaining -= 1;
+      lastTarget = { key: parent.getKey(), offset: index + 1, type: "element" };
+      return null;
+    }
+    if (!$isElementNode(node)) {
+      return null;
+    }
+    if (node.getChildrenSize() === 0) {
+      lastTarget = { key: node.getKey(), offset: 0, type: "element" };
+      return null;
+    }
+    for (const child of node.getChildren()) {
+      const resolved = walk(child);
+      if (resolved) {
+        return resolved;
+      }
+    }
+    lastTarget = { key: node.getKey(), offset: node.getChildrenSize(), type: "element" };
+    return null;
+  }
+  return walk(block) ?? lastTarget;
+}
+function $captureTextSelectionFromRangeSelection(selection) {
+  if (selection.isCollapsed()) {
+    return null;
+  }
+  const anchorBlock = $getRootBlock(selection.anchor.getNode());
+  const focusBlock = $getRootBlock(selection.focus.getNode());
+  if (!anchorBlock || !focusBlock) {
+    return null;
+  }
+  const anchorBlockId = $getState(anchorBlock, blockIdState);
+  const focusBlockId = $getState(focusBlock, blockIdState);
+  if (!anchorBlockId || !focusBlockId) {
+    return null;
+  }
+  const anchorPoint = $resolveSelectionPoint(selection, "anchor");
+  const focusPoint = $resolveSelectionPoint(selection, "focus");
+  return {
+    text: selection.getTextContent(),
+    anchorBlockId,
+    anchorOffset: $getTextOffsetInBlock(anchorBlock, anchorPoint.node, anchorPoint.offset),
+    focusBlockId,
+    focusOffset: $getTextOffsetInBlock(focusBlock, focusPoint.node, focusPoint.offset)
+  };
+}
+function $captureTextSelection() {
+  const selection = $getSelection();
+  if (!$isRangeSelection(selection)) {
+    return null;
+  }
+  return $captureTextSelectionFromRangeSelection(selection);
+}
+function $restoreTextSelection(snapshot) {
+  const anchorBlock = getTopLevelBlockById(snapshot.anchorBlockId);
+  const focusBlock = getTopLevelBlockById(snapshot.focusBlockId);
+  if (!anchorBlock || !focusBlock) {
+    return false;
+  }
+  const anchor = resolveLexicalSelectionTarget(anchorBlock, snapshot.anchorOffset);
+  const focus = resolveLexicalSelectionTarget(focusBlock, snapshot.focusOffset);
+  const selection = $createRangeSelection();
+  selection.anchor.set(anchor.key, anchor.offset, anchor.type);
+  selection.focus.set(focus.key, focus.offset, focus.type);
+  $setSelection(selection);
+  return true;
+}
+function getTextOffsetFromDOMPoint(container, targetNode, targetOffset) {
+  let offset = 0;
+  function walk(node) {
+    if (node === targetNode) {
+      if (node.nodeType === Node.TEXT_NODE) {
+        offset += Math.min(targetOffset, node.textContent?.length ?? 0);
+        return true;
+      }
+      const childNodes = Array.from(node.childNodes);
+      const boundary = Math.min(targetOffset, childNodes.length);
+      for (let i = 0; i < boundary; i++) {
+        offset += getTextLengthOfDomNode(childNodes[i]);
+      }
+      return true;
+    }
+    if (node.nodeType === Node.TEXT_NODE) {
+      offset += node.textContent?.length ?? 0;
+      return false;
+    }
+    if (node.nodeType !== Node.ELEMENT_NODE) {
+      return false;
+    }
+    const element = node;
+    if (element.tagName === "BR") {
+      offset += 1;
+      return false;
+    }
+    for (const child of node.childNodes) {
+      if (walk(child)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  walk(container);
+  return offset;
+}
+function findDOMPointByTextOffset(container, requestedOffset) {
+  const targetOffset = clampOffset(requestedOffset, getTextLengthOfDomNode(container));
+  let consumed = 0;
+  function walk(node) {
+    if (node.nodeType === Node.TEXT_NODE) {
+      const length = node.textContent?.length ?? 0;
+      if (targetOffset <= consumed + length) {
+        return { node, offset: targetOffset - consumed };
+      }
+      consumed += length;
+      return null;
+    }
+    if (node.nodeType !== Node.ELEMENT_NODE) {
+      return null;
+    }
+    const element = node;
+    if (element.tagName === "BR") {
+      const parent = element.parentNode;
+      if (!parent) {
+        return null;
+      }
+      const index = Array.from(parent.childNodes).indexOf(element);
+      if (targetOffset === consumed) {
+        return { node: parent, offset: index };
+      }
+      if (targetOffset === consumed + 1) {
+        return { node: parent, offset: index + 1 };
+      }
+      consumed += 1;
+      return null;
+    }
+    for (const child of node.childNodes) {
+      const resolved = walk(child);
+      if (resolved) {
+        return resolved;
+      }
+    }
+    return null;
+  }
+  return walk(container) ?? { node: container, offset: container.childNodes.length };
+}
+function getBlockElementById(rootElement, blockId) {
+  return rootElement.querySelector(`[data-block-id="${blockId}"]`);
+}
+function createDOMRangeFromTextSelection(rootElement, snapshot) {
+  const anchorBlock = getBlockElementById(rootElement, snapshot.anchorBlockId);
+  const focusBlock = getBlockElementById(rootElement, snapshot.focusBlockId);
+  if (!anchorBlock || !focusBlock) {
+    return null;
+  }
+  const anchor = findDOMPointByTextOffset(anchorBlock, snapshot.anchorOffset);
+  const focus = findDOMPointByTextOffset(focusBlock, snapshot.focusOffset);
+  if (!anchor || !focus) {
+    return null;
+  }
+  const anchorComesFirst = anchorBlock === focusBlock ? snapshot.anchorOffset <= snapshot.focusOffset : compareBlockElements(anchorBlock, focusBlock) <= 0;
+  const start = anchorComesFirst ? anchor : focus;
+  const end = anchorComesFirst ? focus : anchor;
+  try {
+    const range = document.createRange();
+    range.setStart(start.node, start.offset);
+    range.setEnd(end.node, end.offset);
+    return range;
+  } catch {
+    return null;
+  }
+}
+function getDOMRectFromTextSelection(rootElement, snapshot) {
+  const range = createDOMRangeFromTextSelection(rootElement, snapshot);
+  if (!range) {
+    return null;
+  }
+  const rect = range.getBoundingClientRect();
+  if (rect.width > 0 || rect.height > 0) {
+    return rect;
+  }
+  return buildDomRectFromClientRects(Array.from(range.getClientRects()));
+}
+var nativeSelectionActive = "gr1ebt0";
+var nativeSelectionInactive = "gr1ebt1";
+let activeHighlightOwner = null;
+function getHighlightRegistry() {
+  if (typeof CSS === "undefined" || !("highlights" in CSS) || typeof Highlight === "undefined") {
+    return null;
+  }
+  return CSS.highlights;
+}
+function clearManagedHighlight(rootElement) {
+  if (rootElement && rootElement !== activeHighlightOwner) {
+    rootElement.classList.remove(nativeSelectionActive, nativeSelectionInactive);
+    return;
+  }
+  const registry = getHighlightRegistry();
+  registry?.delete(TEXT_SELECTION_HIGHLIGHT_NAME);
+  registry?.delete(TEXT_SELECTION_INACTIVE_HIGHLIGHT_NAME);
+  activeHighlightOwner?.classList.remove(nativeSelectionActive, nativeSelectionInactive);
+  activeHighlightOwner = null;
+}
+function TextSelectionPlugin() {
+  const [editor] = useLexicalComposerContext();
+  const store = useTextSelectionStore();
+  const snapshot = useTextSelectionSnapshot();
+  const [isEditorFocused, setIsEditorFocused] = useState(false);
+  const frameRef = useRef(null);
+  const focusFrameRef = useRef(null);
+  useEffect(() => {
+    const syncSnapshot = () => {
+      const rootElement2 = editor.getRootElement();
+      if (!rootElement2) {
+        store.clearSnapshot();
+        return;
+      }
+      const nextSnapshot = editor.getEditorState().read(() => $captureTextSelection());
+      store.setSnapshot(nextSnapshot);
+    };
+    const syncFocusState = () => {
+      const rootElement2 = editor.getRootElement();
+      const activeElement = rootElement2?.ownerDocument.activeElement;
+      setIsEditorFocused(
+        Boolean(rootElement2 && activeElement && rootElement2.contains(activeElement))
+      );
+    };
+    const scheduleFocusStateSync = () => {
+      if (focusFrameRef.current !== null) {
+        cancelAnimationFrame(focusFrameRef.current);
+      }
+      focusFrameRef.current = requestAnimationFrame(() => {
+        focusFrameRef.current = null;
+        syncFocusState();
+      });
+    };
+    const unregisterSelectionChange = editor.registerCommand(
+      SELECTION_CHANGE_COMMAND,
+      () => {
+        syncSnapshot();
+        return false;
+      },
+      COMMAND_PRIORITY_LOW
+    );
+    const unregisterUpdate = editor.registerUpdateListener(() => {
+      syncSnapshot();
+    });
+    const rootElement = editor.getRootElement();
+    if (rootElement) {
+      const onFocusIn = (event) => {
+        const target = event.target;
+        if (!target) return;
+        const nestedEditable = target.closest('[contenteditable="true"]');
+        if (nestedEditable && nestedEditable !== rootElement) {
+          store.clearSnapshot();
+          scheduleFocusStateSync();
+          return;
+        }
+        scheduleFocusStateSync();
+        syncSnapshot();
+      };
+      const onFocusOut = () => {
+        scheduleFocusStateSync();
+        syncSnapshot();
+      };
+      rootElement.addEventListener("focusin", onFocusIn);
+      rootElement.addEventListener("focusout", onFocusOut);
+      syncFocusState();
+      syncSnapshot();
+      return () => {
+        unregisterSelectionChange();
+        unregisterUpdate();
+        if (focusFrameRef.current !== null) {
+          cancelAnimationFrame(focusFrameRef.current);
+          focusFrameRef.current = null;
+        }
+        rootElement.removeEventListener("focusin", onFocusIn);
+        rootElement.removeEventListener("focusout", onFocusOut);
+        store.clearSnapshot();
+      };
+    }
+    syncFocusState();
+    syncSnapshot();
+    return () => {
+      unregisterSelectionChange();
+      unregisterUpdate();
+      if (focusFrameRef.current !== null) {
+        cancelAnimationFrame(focusFrameRef.current);
+        focusFrameRef.current = null;
+      }
+      store.clearSnapshot();
+    };
+  }, [editor, store]);
+  useEffect(() => {
+    const registry = getHighlightRegistry();
+    const cancelScheduledSync = () => {
+      if (frameRef.current !== null) {
+        cancelAnimationFrame(frameRef.current);
+        frameRef.current = null;
+      }
+    };
+    const syncManagedHighlight = () => {
+      cancelScheduledSync();
+      frameRef.current = requestAnimationFrame(() => {
+        frameRef.current = null;
+        const rootElement = editor.getRootElement();
+        if (!rootElement) {
+          clearManagedHighlight();
+          return;
+        }
+        if (!snapshot) {
+          clearManagedHighlight(rootElement);
+          return;
+        }
+        if (activeHighlightOwner && activeHighlightOwner !== rootElement) {
+          activeHighlightOwner.classList.remove(
+            nativeSelectionActive,
+            nativeSelectionInactive
+          );
+        }
+        const activeSelectionClass = isEditorFocused ? nativeSelectionActive : nativeSelectionInactive;
+        const inactiveSelectionClass = isEditorFocused ? nativeSelectionInactive : nativeSelectionActive;
+        const highlightName = isEditorFocused ? TEXT_SELECTION_HIGHLIGHT_NAME : TEXT_SELECTION_INACTIVE_HIGHLIGHT_NAME;
+        const staleHighlightName = isEditorFocused ? TEXT_SELECTION_INACTIVE_HIGHLIGHT_NAME : TEXT_SELECTION_HIGHLIGHT_NAME;
+        rootElement.classList.remove(inactiveSelectionClass);
+        rootElement.classList.add(activeSelectionClass);
+        activeHighlightOwner = rootElement;
+        if (!registry) {
+          return;
+        }
+        const range = createDOMRangeFromTextSelection(rootElement, snapshot);
+        if (!range) {
+          clearManagedHighlight(rootElement);
+          return;
+        }
+        registry.delete(staleHighlightName);
+        registry.set(highlightName, new Highlight(range));
+      });
+    };
+    syncManagedHighlight();
+    return () => {
+      cancelScheduledSync();
+      clearManagedHighlight(editor.getRootElement());
+    };
+  }, [editor, isEditorFocused, snapshot]);
+  return null;
+}
 function AutoFocusPlugin() {
   const [editor] = useLexicalComposerContext();
   useEffect(() => {
@@ -1748,6 +2386,7 @@ function SubmitShortcutPlugin({ onSubmit }) {
   return null;
 }
 export {
+  $captureTextSelection as $,
   ALL_TRANSFORMERS as A,
   BlockExitPlugin as B,
   CorePlugins as C,
@@ -1759,6 +2398,7 @@ export {
   MarkdownPastePlugin as M,
   OnChangePlugin as O,
   SubmitShortcutPlugin as S,
+  TextSelectionPlugin as T,
   AutoFocusPlugin as a,
   AutoLinkPlugin as b,
   BlockIdPlugin as c,
@@ -1766,5 +2406,22 @@ export {
   MarkdownShortcutsPlugin as e,
   blockIdState as f,
   defaultImageUpload as g,
-  useImageUpload as u
+  TextSelectionStoreProvider as h,
+  $captureTextSelectionFromRangeSelection as i,
+  $getRootBlock as j,
+  $getTextOffsetInBlock as k,
+  $resolveSelectionPoint as l,
+  $restoreTextSelection as m,
+  TEXT_SELECTION_HIGHLIGHT_NAME as n,
+  buildBlockAnchor as o,
+  buildRangeAnchor as p,
+  createDOMRangeFromTextSelection as q,
+  createTextSelectionStore as r,
+  findDOMPointByTextOffset as s,
+  getBlockElementById as t,
+  useImageUpload as u,
+  getDOMRectFromTextSelection as v,
+  getTextOffsetFromDOMPoint as w,
+  useTextSelectionSnapshot as x,
+  useTextSelectionStore as y
 };