@mx-space/cli 0.1.0

package/dist/LexicalClipboard.dev-CdeeWCIq.mjs

@@ -0,0 +1,496 @@
+import { i as getExtensionDependencyFromEditor, n as LexicalBuilder } from "./LexicalExtension.node-BM0gh8zu.mjs";
+import { $n as safeCast, A as $getCollapsedCaretRange, D as $getChildCaret, Dt as COMMAND_PRIORITY_CRITICAL, H as $getTextPointCaret, Jn as isSelectionWithinEditor, Mn as defineExtension, Mt as COPY_COMMAND, N as $getNearestNodeFromDOMNode, Nn as getDOMSelection, O as $getChildCaretAtIndex, R as $getRoot, T as $getCaretRangeInDirection, Y as $isElementNode, ct as $isTextNode, g as $createTabNode, i as $caretRangeFromSelection, j as $getEditor, lt as $isTextPointCaret, pt as $parseSerializedNode, r as $caretFromPoint, rr as shallowMergeConfig, rt as $isRangeSelection, s as $comparePointCaretNext, vn as SELECTION_INSERT_CLIPBOARD_NODES_COMMAND, w as $getCaretRange, xt as $splitAtPointCaretNext, yt as $setSelectionFromCaretRange, z as $getSelection } from "./Lexical.node-gYNDt_p9.mjs";
+import { n as $generateNodesFromDOM, t as $generateHtmlFromNodes } from "./LexicalHtml.node-DLtAh00E.mjs";
+import { a as $sliceSelectedTextNodeContent, t as $addNodeStyle } from "./LexicalSelection.node-Di7GwBCZ.mjs";
+import { g as objectKlassEquals } from "./LexicalUtils.node-CmK462d1.mjs";
+//#region ../../node_modules/.pnpm/@lexical+clipboard@0.44.0/node_modules/@lexical/clipboard/LexicalClipboard.dev.mjs
+/**
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*
+*/
+/**
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*
+*/
+function formatDevErrorMessage(message) {
+	throw new Error(message);
+}
+/**
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*
+*/
+function caretFromPoint(x, y) {
+	if (typeof document.caretRangeFromPoint !== "undefined") {
+		const range = document.caretRangeFromPoint(x, y);
+		if (range === null) return null;
+		return {
+			node: range.startContainer,
+			offset: range.startOffset
+		};
+	} else if (document.caretPositionFromPoint !== "undefined") {
+		const range = document.caretPositionFromPoint(x, y);
+		if (range === null) return null;
+		return {
+			node: range.offsetNode,
+			offset: range.offset
+		};
+	} else return null;
+}
+/**
+* Returns the *currently selected* Lexical content as an HTML string, relying on the
+* logic defined in the exportDOM methods on the LexicalNode classes. Note that
+* this will not return the HTML content of the entire editor (unless all the content is included
+* in the current selection).
+*
+* @param editor - LexicalEditor instance to get HTML content from
+* @param selection - The selection to use (default is $getSelection())
+* @returns a string of HTML content
+*/
+function $getHtmlContent(editor, selection = $getSelection()) {
+	if (selection == null) formatDevErrorMessage(`Expected valid LexicalSelection`);
+	if ($isRangeSelection(selection) && selection.isCollapsed() || selection.getNodes().length === 0) return "";
+	return $generateHtmlFromNodes(editor, selection);
+}
+/**
+* Returns the *currently selected* Lexical content as a JSON string, relying on the
+* logic defined in the exportJSON methods on the LexicalNode classes. Note that
+* this will not return the JSON content of the entire editor (unless all the content is included
+* in the current selection).
+*
+* @param editor  - LexicalEditor instance to get the JSON content from
+* @param selection - The selection to use (default is $getSelection())
+* @returns
+*/
+function $getLexicalContent(editor, selection = $getSelection()) {
+	if (selection == null) formatDevErrorMessage(`Expected valid LexicalSelection`);
+	if ($isRangeSelection(selection) && selection.isCollapsed() || selection.getNodes().length === 0) return null;
+	return JSON.stringify($generateJSONFromSelectedNodes(editor, selection));
+}
+/**
+* Attempts to insert content of the mime-types text/plain or text/uri-list from
+* the provided DataTransfer object into the editor at the provided selection.
+* text/uri-list is only used if text/plain is not also provided.
+*
+* @param dataTransfer an object conforming to the [DataTransfer interface] (https://html.spec.whatwg.org/multipage/dnd.html#the-datatransfer-interface)
+* @param selection the selection to use as the insertion point for the content in the DataTransfer object
+*/
+function $insertDataTransferForPlainText(dataTransfer, selection) {
+	const text = dataTransfer.getData("text/plain") || dataTransfer.getData("text/uri-list");
+	if (text != null) selection.insertRawText(text);
+}
+/**
+* Attempts to insert content of the mime-types application/x-lexical-editor, text/html,
+* text/plain, or text/uri-list (in descending order of priority) from the provided DataTransfer
+* object into the editor at the provided selection.
+*
+* @param dataTransfer an object conforming to the [DataTransfer interface] (https://html.spec.whatwg.org/multipage/dnd.html#the-datatransfer-interface)
+* @param selection the selection to use as the insertion point for the content in the DataTransfer object
+* @param editor the LexicalEditor the content is being inserted into.
+*/
+function $insertDataTransferForRichText(dataTransfer, selection, editor) {
+	const lexicalString = dataTransfer.getData("application/x-lexical-editor");
+	if (lexicalString) try {
+		const payload = JSON.parse(lexicalString);
+		if (payload.namespace === editor._config.namespace && Array.isArray(payload.nodes)) return $insertGeneratedNodes(editor, $generateNodesFromSerializedNodes(payload.nodes), selection);
+	} catch (error) {
+		console.error(error);
+	}
+	const htmlString = dataTransfer.getData("text/html");
+	const plainString = dataTransfer.getData("text/plain");
+	if (htmlString && plainString !== htmlString) try {
+		return $insertGeneratedNodes(editor, $generateNodesFromDOM(editor, new DOMParser().parseFromString(trustHTML(htmlString), "text/html")), selection);
+	} catch (error) {
+		console.error(error);
+	}
+	const text = plainString || dataTransfer.getData("text/uri-list");
+	if (text != null) if ($isRangeSelection(selection)) {
+		const parts = text.split(/(\r?\n|\t)/);
+		if (parts[parts.length - 1] === "") parts.pop();
+		for (let i = 0; i < parts.length; i++) {
+			const currentSelection = $getSelection();
+			if ($isRangeSelection(currentSelection)) {
+				const part = parts[i];
+				if (part === "\n" || part === "\r\n") currentSelection.insertParagraph();
+				else if (part === "	") currentSelection.insertNodes([$createTabNode()]);
+				else currentSelection.insertText(part);
+			}
+		}
+	} else selection.insertRawText(text);
+}
+const LEXICAL_DRAG_MIME_TYPE = "application/x-lexical-drag";
+/**
+* Populate `dataTransfer` with a marker identifying the current editor as a
+* drag source. Pair this with {@link $handleRichTextDrop} or
+* {@link $handlePlainTextDrop} on the drop side to get cut-and-paste semantics
+* for drags that end in a different editor.
+*
+* Only the source editor's key needs to round-trip — the source's
+* RangeSelection itself is preserved on the source editor between drag start
+* and drop (Lexical suppresses selectionchange during drag), so the drop
+* handler reads it directly via `$getSelection()` on the resolved source
+* editor.
+*
+* Callers typically invoke this from a DRAGSTART_COMMAND handler alongside
+* {@link setLexicalClipboardDataTransfer} (so that the dragged content itself
+* round-trips with full node fidelity).
+*/
+function $writeDragSourceToDataTransfer(dataTransfer, editor) {
+	const marker = { editorKey: editor.getKey() };
+	dataTransfer.setData(LEXICAL_DRAG_MIME_TYPE, JSON.stringify(marker));
+}
+function isLexicalDragMarker(value) {
+	return value !== null && typeof value === "object" && "editorKey" in value && typeof value.editorKey === "string";
+}
+function readDragMarker(dataTransfer) {
+	const raw = dataTransfer.getData(LEXICAL_DRAG_MIME_TYPE);
+	if (!raw) return null;
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch (_unused) {
+		return null;
+	}
+	return isLexicalDragMarker(parsed) ? parsed : null;
+}
+function findEditorRootByKey(key, doc) {
+	const elements = doc.querySelectorAll("[data-lexical-editor=\"true\"]");
+	for (const el of Array.from(elements)) {
+		const editor = el.__lexicalEditor;
+		if (editor && editor.getKey() === key) return el;
+	}
+	return null;
+}
+function $resolveDropPointCaret(event) {
+	const hit = caretFromPoint(event.clientX, event.clientY);
+	if (hit === null) return null;
+	const node = $getNearestNodeFromDOMNode(hit.node);
+	if (node === null) return null;
+	if ($isTextNode(node)) return $getTextPointCaret(node, "next", hit.offset);
+	if ($isElementNode(node)) return $getChildCaretAtIndex(node, hit.offset, "next");
+	const parent = node.getParent();
+	if (parent === null) return null;
+	return $getChildCaretAtIndex(parent, node.getIndexWithinParent() + 1, "next");
+}
+function $isDropCaretInsideSelection(dropCaret, selection) {
+	const { anchor: start, focus: end } = $getCaretRangeInDirection($caretRangeFromSelection(selection), "next");
+	return $comparePointCaretNext(start, dropCaret) < 0 && $comparePointCaretNext(dropCaret, end) < 0;
+}
+function $doDrop(event, editor, $insertDataTransfer) {
+	const dataTransfer = event.dataTransfer;
+	if (dataTransfer === null) return false;
+	const marker = readDragMarker(dataTransfer);
+	if (marker === null) return false;
+	const dropCaret = $resolveDropPointCaret(event);
+	if (dropCaret === null) return false;
+	const stableDropCaret = $splitAtPointCaretNext(dropCaret);
+	if (stableDropCaret === null) return false;
+	const isSameEditorDrag = marker.editorKey === editor.getKey();
+	const currentSelection = $getSelection();
+	if (isSameEditorDrag) {
+		if (!$isRangeSelection(currentSelection) || currentSelection.isCollapsed()) return false;
+		if ($isDropCaretInsideSelection(dropCaret, currentSelection)) {
+			event.preventDefault();
+			return true;
+		}
+		currentSelection.removeText();
+	}
+	if (!stableDropCaret.origin.isAttached()) {
+		event.preventDefault();
+		return true;
+	}
+	$insertDataTransfer(dataTransfer, $setSelectionFromCaretRange($getCollapsedCaretRange(stableDropCaret)), editor);
+	if (!isSameEditorDrag) {
+		const rootElement = editor.getRootElement();
+		const doc = rootElement ? rootElement.ownerDocument : null;
+		const sourceRoot = doc ? findEditorRootByKey(marker.editorKey, doc) : null;
+		if (sourceRoot !== null) sourceRoot.dispatchEvent(new InputEvent("beforeinput", {
+			bubbles: true,
+			cancelable: true,
+			inputType: "deleteByDrag"
+		}));
+	}
+	event.preventDefault();
+	return true;
+}
+/**
+* Drop handler for rich-text editors. Inserts the DataTransfer payload via
+* {@link $insertDataTransferForRichText} at the drop caret and, when the drag
+* originated from a Lexical editor (marked via
+* {@link $writeDragSourceToDataTransfer} on DRAGSTART), removes the source
+* range — producing cut-and-paste semantics whether the drop is in the same
+* editor or a different one on the same page.
+*/
+function $handleRichTextDrop(event, editor) {
+	return $doDrop(event, editor, $insertDataTransferForRichText);
+}
+/**
+* Drop handler for plain-text editors. Same semantics as
+* {@link $handleRichTextDrop} but inserts via
+* {@link $insertDataTransferForPlainText}.
+*/
+function $handlePlainTextDrop(event, editor) {
+	return $doDrop(event, editor, (dataTransfer, selection) => $insertDataTransferForPlainText(dataTransfer, selection));
+}
+function trustHTML(html) {
+	if (window.trustedTypes && window.trustedTypes.createPolicy) return window.trustedTypes.createPolicy("lexical", { createHTML: (input) => input }).createHTML(html);
+	return html;
+}
+/**
+* Inserts Lexical nodes into the editor using different strategies depending on
+* some simple selection-based heuristics. If you're looking for a generic way to
+* to insert nodes into the editor at a specific selection point, you probably want
+* {@link lexical.$insertNodes}
+*
+* @param editor LexicalEditor instance to insert the nodes into.
+* @param nodes The nodes to insert.
+* @param selection The selection to insert the nodes into.
+*/
+function $insertGeneratedNodes(editor, nodes, selection) {
+	if (!editor.dispatchCommand(SELECTION_INSERT_CLIPBOARD_NODES_COMMAND, {
+		nodes,
+		selection
+	})) {
+		selection.insertNodes(nodes);
+		$updateSelectionOnInsert(selection);
+	}
+}
+function $updateSelectionOnInsert(selection) {
+	if ($isRangeSelection(selection) && selection.isCollapsed()) {
+		const anchor = selection.anchor;
+		let nodeToInspect = null;
+		const anchorCaret = $caretFromPoint(anchor, "previous");
+		if (anchorCaret) if ($isTextPointCaret(anchorCaret)) nodeToInspect = anchorCaret.origin;
+		else {
+			const range = $getCaretRange(anchorCaret, $getChildCaret($getRoot(), "next").getFlipped());
+			for (const caret of range) if ($isTextNode(caret.origin)) {
+				nodeToInspect = caret.origin;
+				break;
+			} else if ($isElementNode(caret.origin) && !caret.origin.isInline()) break;
+		}
+		if (nodeToInspect && $isTextNode(nodeToInspect)) {
+			const newFormat = nodeToInspect.getFormat();
+			const newStyle = nodeToInspect.getStyle();
+			if (selection.format !== newFormat || selection.style !== newStyle) {
+				selection.format = newFormat;
+				selection.style = newStyle;
+				selection.dirty = true;
+			}
+		}
+	}
+}
+function exportNodeToJSON(node) {
+	const serializedNode = node.exportJSON();
+	const nodeClass = node.constructor;
+	if (serializedNode.type !== nodeClass.getType()) formatDevErrorMessage(`LexicalNode: Node ${nodeClass.name} does not implement .exportJSON().`);
+	if ($isElementNode(node)) {
+		const serializedChildren = serializedNode.children;
+		if (!Array.isArray(serializedChildren)) formatDevErrorMessage(`LexicalNode: Node ${nodeClass.name} is an element but .exportJSON() does not have a children array.`);
+	}
+	return serializedNode;
+}
+function $appendNodesToJSON(editor, selection, currentNode, targetArray = []) {
+	let shouldInclude = selection !== null ? currentNode.isSelected(selection) : true;
+	const shouldExclude = $isElementNode(currentNode) && currentNode.excludeFromCopy("html");
+	let target = currentNode;
+	if (selection !== null && $isTextNode(target)) target = $sliceSelectedTextNodeContent(selection, target, "clone");
+	const children = $isElementNode(target) ? target.getChildren() : [];
+	const serializedNode = exportNodeToJSON(target);
+	if ($isTextNode(target) && target.getTextContentSize() === 0) shouldInclude = false;
+	for (let i = 0; i < children.length; i++) {
+		const childNode = children[i];
+		const shouldIncludeChild = $appendNodesToJSON(editor, selection, childNode, serializedNode.children);
+		if (!shouldInclude && $isElementNode(currentNode) && shouldIncludeChild && currentNode.extractWithChild(childNode, selection, "clone")) shouldInclude = true;
+	}
+	if (shouldInclude && !shouldExclude) targetArray.push(serializedNode);
+	else if (Array.isArray(serializedNode.children)) for (let i = 0; i < serializedNode.children.length; i++) {
+		const serializedChildNode = serializedNode.children[i];
+		targetArray.push(serializedChildNode);
+	}
+	return shouldInclude;
+}
+/**
+* Gets the Lexical JSON of the nodes inside the provided Selection.
+*
+* @param editor LexicalEditor to get the JSON content from.
+* @param selection Selection to get the JSON content from.
+* @returns an object with the editor namespace and a list of serializable nodes as JavaScript objects.
+*/
+function $generateJSONFromSelectedNodes(editor, selection) {
+	const nodes = [];
+	const topLevelChildren = $getRoot().getChildren();
+	for (let i = 0; i < topLevelChildren.length; i++) {
+		const topLevelNode = topLevelChildren[i];
+		$appendNodesToJSON(editor, selection, topLevelNode, nodes);
+	}
+	return {
+		namespace: editor._config.namespace,
+		nodes
+	};
+}
+/**
+* This method takes an array of objects conforming to the BaseSerializedNode interface and returns
+* an Array containing instances of the corresponding LexicalNode classes registered on the editor.
+* Normally, you'd get an Array of BaseSerialized nodes from {@link $generateJSONFromSelectedNodes}
+*
+* @param serializedNodes an Array of objects conforming to the BaseSerializedNode interface.
+* @returns an Array of Lexical Node objects.
+*/
+function $generateNodesFromSerializedNodes(serializedNodes) {
+	const nodes = [];
+	for (let i = 0; i < serializedNodes.length; i++) {
+		const serializedNode = serializedNodes[i];
+		const node = $parseSerializedNode(serializedNode);
+		if ($isTextNode(node)) $addNodeStyle(node);
+		nodes.push(node);
+	}
+	return nodes;
+}
+const EVENT_LATENCY = 50;
+let clipboardEventTimeout = null;
+/**
+* Copies the content of the current selection to the clipboard in
+* text/plain, text/html, and application/x-lexical-editor (Lexical JSON)
+* formats.
+*
+* @param editor the LexicalEditor instance to copy content from
+* @param event the native browser ClipboardEvent to add the content to.
+* @returns
+*/
+async function copyToClipboard(editor, event, data) {
+	if (clipboardEventTimeout !== null) return false;
+	if (event !== null) return new Promise((resolve, reject) => {
+		editor.update(() => {
+			resolve($copyToClipboardEvent(editor, event, data));
+		});
+	});
+	const rootElement = editor.getRootElement();
+	const editorWindow = editor._window || window;
+	const windowDocument = editorWindow.document;
+	const domSelection = getDOMSelection(editorWindow);
+	if (rootElement === null || domSelection === null) return false;
+	const element = windowDocument.createElement("span");
+	element.style.position = "fixed";
+	element.style.top = "-1000px";
+	element.append(windowDocument.createTextNode("#"));
+	rootElement.append(element);
+	const range = new Range();
+	range.setStart(element, 0);
+	range.setEnd(element, 1);
+	domSelection.removeAllRanges();
+	domSelection.addRange(range);
+	return new Promise((resolve, reject) => {
+		const removeListener = editor.registerCommand(COPY_COMMAND, (secondEvent) => {
+			if (objectKlassEquals(secondEvent, ClipboardEvent)) {
+				removeListener();
+				if (clipboardEventTimeout !== null) {
+					editorWindow.clearTimeout(clipboardEventTimeout);
+					clipboardEventTimeout = null;
+				}
+				resolve($copyToClipboardEvent(editor, secondEvent, data));
+			}
+			return true;
+		}, COMMAND_PRIORITY_CRITICAL);
+		clipboardEventTimeout = editorWindow.setTimeout(() => {
+			removeListener();
+			clipboardEventTimeout = null;
+			resolve(false);
+		}, EVENT_LATENCY);
+		windowDocument.execCommand("copy");
+		element.remove();
+	});
+}
+function $copyToClipboardEvent(editor, event, data) {
+	if (data === void 0) {
+		const domSelection = getDOMSelection(editor._window);
+		const selection = $getSelection();
+		if (!selection || selection.isCollapsed()) return false;
+		if (!domSelection) return false;
+		const anchorDOM = domSelection.anchorNode;
+		const focusDOM = domSelection.focusNode;
+		if (anchorDOM !== null && focusDOM !== null && !isSelectionWithinEditor(editor, anchorDOM, focusDOM)) return false;
+		data = $getClipboardDataFromSelection(selection);
+	}
+	event.preventDefault();
+	const clipboardData = event.clipboardData;
+	if (clipboardData === null) return false;
+	setLexicalClipboardDataTransfer(clipboardData, data);
+	return true;
+}
+const clipboardDataFunctions = [["text/html", $getHtmlContent], ["application/x-lexical-editor", $getLexicalContent]];
+/**
+* Serialize the content of the current selection to strings in
+* text/plain, text/html, and application/x-lexical-editor (Lexical JSON)
+* formats (as available).
+*
+* @param selection the selection to serialize (defaults to $getSelection())
+* @returns LexicalClipboardData
+*/
+function $getClipboardDataFromSelection(selection = $getSelection()) {
+	return $getClipboardDataWithConfigFromSelection($getExportConfig(), selection);
+}
+/**
+* Call setData on the given clipboardData for each MIME type present
+* in the given data (from {@link $getClipboardDataFromSelection})
+*
+* @param clipboardData the event.clipboardData to populate from data
+* @param data The lexical data
+*/
+function setLexicalClipboardDataTransfer(clipboardData, data) {
+	for (const [k] of clipboardDataFunctions) if (data[k] === void 0) clipboardData.setData(k, "");
+	for (const k in data) {
+		const v = data[k];
+		if (v !== void 0) clipboardData.setData(k, v);
+	}
+}
+function $getExportConfig() {
+	const editor = $getEditor();
+	const builder = LexicalBuilder.maybeFromEditor(editor);
+	if (builder && builder.hasExtensionByName(GetClipboardDataExtension.name)) return getExtensionDependencyFromEditor(editor, GetClipboardDataExtension).output;
+	return DEFAULT_EXPORT_MIME_TYPE;
+}
+const DEFAULT_EXPORT_MIME_TYPE = {
+	"application/x-lexical-editor": [(sel, next) => sel ? $getLexicalContent($getEditor(), sel) : next()],
+	"text/html": [(sel, next) => sel ? $getHtmlContent($getEditor(), sel) : next()],
+	"text/plain": [(sel, next) => sel ? sel.getTextContent() : next()]
+};
+function $getClipboardDataWithConfigFromSelection($exportMimeType, selection) {
+	const clipboardData = { "text/plain": "" };
+	for (const [k, fns] of Object.entries($exportMimeType)) {
+		const v = callExportMimeTypeFunctionStack(fns, selection);
+		if (v !== null) clipboardData[k] = v;
+	}
+	return clipboardData;
+}
+function callExportMimeTypeFunctionStack(fns, selection) {
+	const callAt = (i) => fns[i] ? fns[i](selection, callAt.bind(null, i - 1)) : null;
+	return callAt(fns.length - 1);
+}
+const GetClipboardDataExtension = defineExtension({
+	build(editor, config, state) {
+		return config.$exportMimeType;
+	},
+	config: safeCast({ $exportMimeType: DEFAULT_EXPORT_MIME_TYPE }),
+	mergeConfig(config, partial) {
+		const merged = shallowMergeConfig(config, partial);
+		if (partial.$exportMimeType) {
+			const $exportMimeType = { ...config.$exportMimeType };
+			for (const [k, v] of Object.entries(partial.$exportMimeType)) $exportMimeType[k] = [...$exportMimeType[k], ...v];
+			merged.$exportMimeType = $exportMimeType;
+		}
+		return merged;
+	},
+	name: "@lexical/clipboard/GetClipboardData"
+});
+//#endregion
+export { $generateJSONFromSelectedNodes, $generateNodesFromSerializedNodes, $getClipboardDataFromSelection, $getHtmlContent, $getLexicalContent, $handlePlainTextDrop, $handleRichTextDrop, $insertDataTransferForPlainText, $insertDataTransferForRichText, $insertGeneratedNodes, $writeDragSourceToDataTransfer, copyToClipboard, setLexicalClipboardDataTransfer };
+
+//# sourceMappingURL=LexicalClipboard.dev-CdeeWCIq.mjs.map

package/dist/LexicalClipboard.dev-CdeeWCIq.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"LexicalClipboard.dev-CdeeWCIq.mjs","names":[],"sources":["../../../node_modules/.pnpm/@lexical+clipboard@0.44.0/node_modules/@lexical/clipboard/LexicalClipboard.dev.mjs"],"sourcesContent":["/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport { LexicalBuilder, getExtensionDependencyFromEditor } from '@lexical/extension';\nimport { $generateHtmlFromNodes, $generateNodesFromDOM } from '@lexical/html';\nimport { $addNodeStyle, $sliceSelectedTextNodeContent } from '@lexical/selection';\nimport { objectKlassEquals } from '@lexical/utils';\nimport { $isRangeSelection, $getSelection, $createTabNode, SELECTION_INSERT_CLIPBOARD_NODES_COMMAND, $caretFromPoint, $isTextPointCaret, $getCaretRange, $getChildCaret, $getRoot, $isTextNode, $isElementNode, $parseSerializedNode, getDOMSelection, COPY_COMMAND, COMMAND_PRIORITY_CRITICAL, isSelectionWithinEditor, $getEditor, defineExtension, shallowMergeConfig, safeCast, $splitAtPointCaretNext, $setSelectionFromCaretRange, $getCollapsedCaretRange, $getNearestNodeFromDOMNode, $getTextPointCaret, $getChildCaretAtIndex, $getCaretRangeInDirection, $caretRangeFromSelection, $comparePointCaretNext } from 'lexical';\n\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n// Do not require this module directly! Use normal `invariant` calls.\n\nfunction formatDevErrorMessage(message) {\n  throw new Error(message);\n}\n\n/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nfunction caretFromPoint(x, y) {\n  if (typeof document.caretRangeFromPoint !== 'undefined') {\n    const range = document.caretRangeFromPoint(x, y);\n    if (range === null) {\n      return null;\n    }\n    return {\n      node: range.startContainer,\n      offset: range.startOffset\n    };\n    // @ts-ignore\n  } else if (document.caretPositionFromPoint !== 'undefined') {\n    // @ts-ignore FF - no types\n    const range = document.caretPositionFromPoint(x, y);\n    if (range === null) {\n      return null;\n    }\n    return {\n      node: range.offsetNode,\n      offset: range.offset\n    };\n  } else {\n    // Gracefully handle IE\n    return null;\n  }\n}\n\n/**\n * Returns the *currently selected* Lexical content as an HTML string, relying on the\n * logic defined in the exportDOM methods on the LexicalNode classes. Note that\n * this will not return the HTML content of the entire editor (unless all the content is included\n * in the current selection).\n *\n * @param editor - LexicalEditor instance to get HTML content from\n * @param selection - The selection to use (default is $getSelection())\n * @returns a string of HTML content\n */\nfunction $getHtmlContent(editor, selection = $getSelection()) {\n  if (selection == null) {\n    {\n      formatDevErrorMessage(`Expected valid LexicalSelection`);\n    }\n  }\n\n  // If we haven't selected anything\n  if ($isRangeSelection(selection) && selection.isCollapsed() || selection.getNodes().length === 0) {\n    return '';\n  }\n  return $generateHtmlFromNodes(editor, selection);\n}\n\n/**\n * Returns the *currently selected* Lexical content as a JSON string, relying on the\n * logic defined in the exportJSON methods on the LexicalNode classes. Note that\n * this will not return the JSON content of the entire editor (unless all the content is included\n * in the current selection).\n *\n * @param editor  - LexicalEditor instance to get the JSON content from\n * @param selection - The selection to use (default is $getSelection())\n * @returns\n */\nfunction $getLexicalContent(editor, selection = $getSelection()) {\n  if (selection == null) {\n    {\n      formatDevErrorMessage(`Expected valid LexicalSelection`);\n    }\n  }\n\n  // If we haven't selected anything\n  if ($isRangeSelection(selection) && selection.isCollapsed() || selection.getNodes().length === 0) {\n    return null;\n  }\n  return JSON.stringify($generateJSONFromSelectedNodes(editor, selection));\n}\n\n/**\n * Attempts to insert content of the mime-types text/plain or text/uri-list from\n * the provided DataTransfer object into the editor at the provided selection.\n * text/uri-list is only used if text/plain is not also provided.\n *\n * @param dataTransfer an object conforming to the [DataTransfer interface] (https://html.spec.whatwg.org/multipage/dnd.html#the-datatransfer-interface)\n * @param selection the selection to use as the insertion point for the content in the DataTransfer object\n */\nfunction $insertDataTransferForPlainText(dataTransfer, selection) {\n  const text = dataTransfer.getData('text/plain') || dataTransfer.getData('text/uri-list');\n  if (text != null) {\n    selection.insertRawText(text);\n  }\n}\n\n/**\n * Attempts to insert content of the mime-types application/x-lexical-editor, text/html,\n * text/plain, or text/uri-list (in descending order of priority) from the provided DataTransfer\n * object into the editor at the provided selection.\n *\n * @param dataTransfer an object conforming to the [DataTransfer interface] (https://html.spec.whatwg.org/multipage/dnd.html#the-datatransfer-interface)\n * @param selection the selection to use as the insertion point for the content in the DataTransfer object\n * @param editor the LexicalEditor the content is being inserted into.\n */\nfunction $insertDataTransferForRichText(dataTransfer, selection, editor) {\n  const lexicalString = dataTransfer.getData('application/x-lexical-editor');\n  if (lexicalString) {\n    try {\n      const payload = JSON.parse(lexicalString);\n      if (payload.namespace === editor._config.namespace && Array.isArray(payload.nodes)) {\n        const nodes = $generateNodesFromSerializedNodes(payload.nodes);\n        return $insertGeneratedNodes(editor, nodes, selection);\n      }\n    } catch (error) {\n      console.error(error);\n    }\n  }\n  const htmlString = dataTransfer.getData('text/html');\n  const plainString = dataTransfer.getData('text/plain');\n\n  // Skip HTML handling if it matches the plain text representation.\n  // This avoids unnecessary processing for plain text strings created by\n  // iOS Safari autocorrect, which incorrectly includes a `text/html` type.\n  if (htmlString && plainString !== htmlString) {\n    try {\n      const parser = new DOMParser();\n      const dom = parser.parseFromString(trustHTML(htmlString), 'text/html');\n      const nodes = $generateNodesFromDOM(editor, dom);\n      return $insertGeneratedNodes(editor, nodes, selection);\n    } catch (error) {\n      console.error(error);\n    }\n  }\n\n  // Multi-line plain text in rich text mode pasted as separate paragraphs\n  // instead of single paragraph with linebreaks.\n  // Webkit-specific: Supports read 'text/uri-list' in clipboard.\n  const text = plainString || dataTransfer.getData('text/uri-list');\n  if (text != null) {\n    if ($isRangeSelection(selection)) {\n      const parts = text.split(/(\\r?\\n|\\t)/);\n      if (parts[parts.length - 1] === '') {\n        parts.pop();\n      }\n      for (let i = 0; i < parts.length; i++) {\n        const currentSelection = $getSelection();\n        if ($isRangeSelection(currentSelection)) {\n          const part = parts[i];\n          if (part === '\\n' || part === '\\r\\n') {\n            currentSelection.insertParagraph();\n          } else if (part === '\\t') {\n            currentSelection.insertNodes([$createTabNode()]);\n          } else {\n            currentSelection.insertText(part);\n          }\n        }\n      }\n    } else {\n      selection.insertRawText(text);\n    }\n  }\n}\nconst LEXICAL_DRAG_MIME_TYPE = 'application/x-lexical-drag';\n/**\n * Populate `dataTransfer` with a marker identifying the current editor as a\n * drag source. Pair this with {@link $handleRichTextDrop} or\n * {@link $handlePlainTextDrop} on the drop side to get cut-and-paste semantics\n * for drags that end in a different editor.\n *\n * Only the source editor's key needs to round-trip — the source's\n * RangeSelection itself is preserved on the source editor between drag start\n * and drop (Lexical suppresses selectionchange during drag), so the drop\n * handler reads it directly via `$getSelection()` on the resolved source\n * editor.\n *\n * Callers typically invoke this from a DRAGSTART_COMMAND handler alongside\n * {@link setLexicalClipboardDataTransfer} (so that the dragged content itself\n * round-trips with full node fidelity).\n */\nfunction $writeDragSourceToDataTransfer(dataTransfer, editor) {\n  const marker = {\n    editorKey: editor.getKey()\n  };\n  dataTransfer.setData(LEXICAL_DRAG_MIME_TYPE, JSON.stringify(marker));\n}\nfunction isLexicalDragMarker(value) {\n  return value !== null && typeof value === 'object' && 'editorKey' in value && typeof value.editorKey === 'string';\n}\nfunction readDragMarker(dataTransfer) {\n  const raw = dataTransfer.getData(LEXICAL_DRAG_MIME_TYPE);\n  if (!raw) {\n    return null;\n  }\n  let parsed;\n  try {\n    parsed = JSON.parse(raw);\n  } catch (_unused) {\n    return null;\n  }\n  return isLexicalDragMarker(parsed) ? parsed : null;\n}\nfunction findEditorRootByKey(key, doc) {\n  const elements = doc.querySelectorAll('[data-lexical-editor=\"true\"]');\n  for (const el of Array.from(elements)) {\n    const editor = el.__lexicalEditor;\n    if (editor && editor.getKey() === key) {\n      return el;\n    }\n  }\n  return null;\n}\nfunction $resolveDropPointCaret(event) {\n  const hit = caretFromPoint(event.clientX, event.clientY);\n  if (hit === null) {\n    return null;\n  }\n  const node = $getNearestNodeFromDOMNode(hit.node);\n  if (node === null) {\n    return null;\n  }\n  if ($isTextNode(node)) {\n    return $getTextPointCaret(node, 'next', hit.offset);\n  }\n  if ($isElementNode(node)) {\n    return $getChildCaretAtIndex(node, hit.offset, 'next');\n  }\n  const parent = node.getParent();\n  if (parent === null) {\n    return null;\n  }\n  return $getChildCaretAtIndex(parent, node.getIndexWithinParent() + 1, 'next');\n}\nfunction $isDropCaretInsideSelection(dropCaret, selection) {\n  const {\n    anchor: start,\n    focus: end\n  } = $getCaretRangeInDirection($caretRangeFromSelection(selection), 'next');\n  return $comparePointCaretNext(start, dropCaret) < 0 && $comparePointCaretNext(dropCaret, end) < 0;\n}\nfunction $doDrop(event, editor, $insertDataTransfer) {\n  const dataTransfer = event.dataTransfer;\n  if (dataTransfer === null) {\n    return false;\n  }\n\n  // Drags that didn't originate in a Lexical editor (no marker) fall through\n  // to the browser's native drag-and-drop flow; its beforeinput\n  // insertFromDrop is already handled correctly by Lexical's existing\n  // beforeinput logic.\n  const marker = readDragMarker(dataTransfer);\n  if (marker === null) {\n    return false;\n  }\n  const dropCaret = $resolveDropPointCaret(event);\n  if (dropCaret === null) {\n    return false;\n  }\n\n  // Split at the drop caret so we have a stable NodeCaret boundary that\n  // survives text-content mutations in its siblings.\n  const stableDropCaret = $splitAtPointCaretNext(dropCaret);\n  if (stableDropCaret === null) {\n    return false;\n  }\n  const isSameEditorDrag = marker.editorKey === editor.getKey();\n  const currentSelection = $getSelection();\n  if (isSameEditorDrag) {\n    // Same-editor drag: the destination's $getSelection() is the still-\n    // selected dragged range, so Lexical's beforeinput handler would skip\n    // applyDOMRange and route the insert to the source's location instead\n    // of the drop point. Remove the dragged range ourselves, then insert\n    // at the stable drop caret.\n    if (!$isRangeSelection(currentSelection) || currentSelection.isCollapsed()) {\n      return false;\n    }\n    if ($isDropCaretInsideSelection(dropCaret, currentSelection)) {\n      event.preventDefault();\n      return true;\n    }\n    currentSelection.removeText();\n  }\n\n  // If the drop caret's origin was swept away by the source removal, abort —\n  // this can happen on a same-editor drag whose range covered the entire\n  // text node we tried to split at.\n  if (!stableDropCaret.origin.isAttached()) {\n    event.preventDefault();\n    return true;\n  }\n  const dropSelection = $setSelectionFromCaretRange($getCollapsedCaretRange(stableDropCaret));\n  $insertDataTransfer(dataTransfer, dropSelection, editor);\n  if (!isSameEditorDrag) {\n    // Cross-editor drag. The native drag-out deletion that the browser\n    // would normally fire (beforeinput deleteByDrag on the source) isn't\n    // reliable when the source is a nested contenteditable of the\n    // destination (e.g. an image caption inside the main editor), so we\n    // dispatch it ourselves at the source editor's root. The source\n    // editor's own beforeinput handler runs the deletion through its own\n    // REMOVE_TEXT_COMMAND and SKIP_SELECTION_FOCUS_TAG path.\n    const rootElement = editor.getRootElement();\n    const doc = rootElement ? rootElement.ownerDocument : null;\n    const sourceRoot = doc ? findEditorRootByKey(marker.editorKey, doc) : null;\n    if (sourceRoot !== null) {\n      sourceRoot.dispatchEvent(new InputEvent('beforeinput', {\n        bubbles: true,\n        cancelable: true,\n        inputType: 'deleteByDrag'\n      }));\n    }\n  }\n  event.preventDefault();\n  return true;\n}\n\n/**\n * Drop handler for rich-text editors. Inserts the DataTransfer payload via\n * {@link $insertDataTransferForRichText} at the drop caret and, when the drag\n * originated from a Lexical editor (marked via\n * {@link $writeDragSourceToDataTransfer} on DRAGSTART), removes the source\n * range — producing cut-and-paste semantics whether the drop is in the same\n * editor or a different one on the same page.\n */\nfunction $handleRichTextDrop(event, editor) {\n  return $doDrop(event, editor, $insertDataTransferForRichText);\n}\n\n/**\n * Drop handler for plain-text editors. Same semantics as\n * {@link $handleRichTextDrop} but inserts via\n * {@link $insertDataTransferForPlainText}.\n */\nfunction $handlePlainTextDrop(event, editor) {\n  return $doDrop(event, editor, (dataTransfer, selection) => $insertDataTransferForPlainText(dataTransfer, selection));\n}\nfunction trustHTML(html) {\n  if (window.trustedTypes && window.trustedTypes.createPolicy) {\n    const policy = window.trustedTypes.createPolicy('lexical', {\n      createHTML: input => input\n    });\n    return policy.createHTML(html);\n  }\n  return html;\n}\n\n/**\n * Inserts Lexical nodes into the editor using different strategies depending on\n * some simple selection-based heuristics. If you're looking for a generic way to\n * to insert nodes into the editor at a specific selection point, you probably want\n * {@link lexical.$insertNodes}\n *\n * @param editor LexicalEditor instance to insert the nodes into.\n * @param nodes The nodes to insert.\n * @param selection The selection to insert the nodes into.\n */\nfunction $insertGeneratedNodes(editor, nodes, selection) {\n  if (!editor.dispatchCommand(SELECTION_INSERT_CLIPBOARD_NODES_COMMAND, {\n    nodes,\n    selection\n  })) {\n    selection.insertNodes(nodes);\n    $updateSelectionOnInsert(selection);\n  }\n  return;\n}\nfunction $updateSelectionOnInsert(selection) {\n  if ($isRangeSelection(selection) && selection.isCollapsed()) {\n    const anchor = selection.anchor;\n    let nodeToInspect = null;\n    const anchorCaret = $caretFromPoint(anchor, 'previous');\n    if (anchorCaret) {\n      if ($isTextPointCaret(anchorCaret)) {\n        nodeToInspect = anchorCaret.origin;\n      } else {\n        const range = $getCaretRange(anchorCaret, $getChildCaret($getRoot(), 'next').getFlipped());\n        for (const caret of range) {\n          if ($isTextNode(caret.origin)) {\n            nodeToInspect = caret.origin;\n            break;\n          } else if ($isElementNode(caret.origin) && !caret.origin.isInline()) {\n            break;\n          }\n        }\n      }\n    }\n    if (nodeToInspect && $isTextNode(nodeToInspect)) {\n      const newFormat = nodeToInspect.getFormat();\n      const newStyle = nodeToInspect.getStyle();\n      if (selection.format !== newFormat || selection.style !== newStyle) {\n        selection.format = newFormat;\n        selection.style = newStyle;\n        selection.dirty = true;\n      }\n    }\n  }\n}\nfunction exportNodeToJSON(node) {\n  const serializedNode = node.exportJSON();\n  const nodeClass = node.constructor;\n  if (serializedNode.type !== nodeClass.getType()) {\n    {\n      formatDevErrorMessage(`LexicalNode: Node ${nodeClass.name} does not implement .exportJSON().`);\n    }\n  }\n  if ($isElementNode(node)) {\n    const serializedChildren = serializedNode.children;\n    if (!Array.isArray(serializedChildren)) {\n      {\n        formatDevErrorMessage(`LexicalNode: Node ${nodeClass.name} is an element but .exportJSON() does not have a children array.`);\n      }\n    }\n  }\n  return serializedNode;\n}\nfunction $appendNodesToJSON(editor, selection, currentNode, targetArray = []) {\n  let shouldInclude = selection !== null ? currentNode.isSelected(selection) : true;\n  const shouldExclude = $isElementNode(currentNode) && currentNode.excludeFromCopy('html');\n  let target = currentNode;\n  if (selection !== null && $isTextNode(target)) {\n    target = $sliceSelectedTextNodeContent(selection, target, 'clone');\n  }\n  const children = $isElementNode(target) ? target.getChildren() : [];\n  const serializedNode = exportNodeToJSON(target);\n  if ($isTextNode(target) && target.getTextContentSize() === 0) {\n    // If an uncollapsed selection ends or starts at the end of a line of specialized,\n    // TextNodes, such as code tokens, we will get a 'blank' TextNode here, i.e., one\n    // with text of length 0. We don't want this, it makes a confusing mess. Reset!\n    shouldInclude = false;\n  }\n  for (let i = 0; i < children.length; i++) {\n    const childNode = children[i];\n    const shouldIncludeChild = $appendNodesToJSON(editor, selection, childNode, serializedNode.children);\n    if (!shouldInclude && $isElementNode(currentNode) && shouldIncludeChild && currentNode.extractWithChild(childNode, selection, 'clone')) {\n      shouldInclude = true;\n    }\n  }\n  if (shouldInclude && !shouldExclude) {\n    targetArray.push(serializedNode);\n  } else if (Array.isArray(serializedNode.children)) {\n    for (let i = 0; i < serializedNode.children.length; i++) {\n      const serializedChildNode = serializedNode.children[i];\n      targetArray.push(serializedChildNode);\n    }\n  }\n  return shouldInclude;\n}\n\n// TODO why $ function with Editor instance?\n/**\n * Gets the Lexical JSON of the nodes inside the provided Selection.\n *\n * @param editor LexicalEditor to get the JSON content from.\n * @param selection Selection to get the JSON content from.\n * @returns an object with the editor namespace and a list of serializable nodes as JavaScript objects.\n */\nfunction $generateJSONFromSelectedNodes(editor, selection) {\n  const nodes = [];\n  const root = $getRoot();\n  const topLevelChildren = root.getChildren();\n  for (let i = 0; i < topLevelChildren.length; i++) {\n    const topLevelNode = topLevelChildren[i];\n    $appendNodesToJSON(editor, selection, topLevelNode, nodes);\n  }\n  return {\n    namespace: editor._config.namespace,\n    nodes\n  };\n}\n\n/**\n * This method takes an array of objects conforming to the BaseSerializedNode interface and returns\n * an Array containing instances of the corresponding LexicalNode classes registered on the editor.\n * Normally, you'd get an Array of BaseSerialized nodes from {@link $generateJSONFromSelectedNodes}\n *\n * @param serializedNodes an Array of objects conforming to the BaseSerializedNode interface.\n * @returns an Array of Lexical Node objects.\n */\nfunction $generateNodesFromSerializedNodes(serializedNodes) {\n  const nodes = [];\n  for (let i = 0; i < serializedNodes.length; i++) {\n    const serializedNode = serializedNodes[i];\n    const node = $parseSerializedNode(serializedNode);\n    if ($isTextNode(node)) {\n      $addNodeStyle(node);\n    }\n    nodes.push(node);\n  }\n  return nodes;\n}\nconst EVENT_LATENCY = 50;\nlet clipboardEventTimeout = null;\n\n// TODO custom selection\n// TODO potentially have a node customizable version for plain text\n/**\n * Copies the content of the current selection to the clipboard in\n * text/plain, text/html, and application/x-lexical-editor (Lexical JSON)\n * formats.\n *\n * @param editor the LexicalEditor instance to copy content from\n * @param event the native browser ClipboardEvent to add the content to.\n * @returns\n */\nasync function copyToClipboard(editor, event, data) {\n  if (clipboardEventTimeout !== null) {\n    // Prevent weird race conditions that can happen when this function is run multiple times\n    // synchronously. In the future, we can do better, we can cancel/override the previously running job.\n    return false;\n  }\n  if (event !== null) {\n    return new Promise((resolve, reject) => {\n      editor.update(() => {\n        resolve($copyToClipboardEvent(editor, event, data));\n      });\n    });\n  }\n  const rootElement = editor.getRootElement();\n  const editorWindow = editor._window || window;\n  const windowDocument = editorWindow.document;\n  const domSelection = getDOMSelection(editorWindow);\n  if (rootElement === null || domSelection === null) {\n    return false;\n  }\n  const element = windowDocument.createElement('span');\n  element.style.position = 'fixed';\n  element.style.top = '-1000px';\n  element.append(windowDocument.createTextNode('#'));\n  rootElement.append(element);\n  const range = new Range();\n  range.setStart(element, 0);\n  range.setEnd(element, 1);\n  domSelection.removeAllRanges();\n  domSelection.addRange(range);\n  return new Promise((resolve, reject) => {\n    const removeListener = editor.registerCommand(COPY_COMMAND, secondEvent => {\n      if (objectKlassEquals(secondEvent, ClipboardEvent)) {\n        removeListener();\n        if (clipboardEventTimeout !== null) {\n          editorWindow.clearTimeout(clipboardEventTimeout);\n          clipboardEventTimeout = null;\n        }\n        resolve($copyToClipboardEvent(editor, secondEvent, data));\n      }\n      // Block the entire copy flow while we wait for the next ClipboardEvent\n      return true;\n    }, COMMAND_PRIORITY_CRITICAL);\n    // If the above hack execCommand hack works, this timeout code should never fire. Otherwise,\n    // the listener will be quickly freed so that the user can reuse it again\n    clipboardEventTimeout = editorWindow.setTimeout(() => {\n      removeListener();\n      clipboardEventTimeout = null;\n      resolve(false);\n    }, EVENT_LATENCY);\n    windowDocument.execCommand('copy');\n    element.remove();\n  });\n}\n\n// TODO shouldn't pass editor (pass namespace directly)\nfunction $copyToClipboardEvent(editor, event, data) {\n  if (data === undefined) {\n    const domSelection = getDOMSelection(editor._window);\n    const selection = $getSelection();\n    if (!selection || selection.isCollapsed()) {\n      return false;\n    }\n    if (!domSelection) {\n      return false;\n    }\n    const anchorDOM = domSelection.anchorNode;\n    const focusDOM = domSelection.focusNode;\n    if (anchorDOM !== null && focusDOM !== null && !isSelectionWithinEditor(editor, anchorDOM, focusDOM)) {\n      return false;\n    }\n    data = $getClipboardDataFromSelection(selection);\n  }\n  event.preventDefault();\n  const clipboardData = event.clipboardData;\n  if (clipboardData === null) {\n    return false;\n  }\n  setLexicalClipboardDataTransfer(clipboardData, data);\n  return true;\n}\nconst clipboardDataFunctions = [['text/html', $getHtmlContent], ['application/x-lexical-editor', $getLexicalContent]];\n\n/**\n * Serialize the content of the current selection to strings in\n * text/plain, text/html, and application/x-lexical-editor (Lexical JSON)\n * formats (as available).\n *\n * @param selection the selection to serialize (defaults to $getSelection())\n * @returns LexicalClipboardData\n */\nfunction $getClipboardDataFromSelection(selection = $getSelection()) {\n  return $getClipboardDataWithConfigFromSelection($getExportConfig(), selection);\n}\n\n/**\n * Call setData on the given clipboardData for each MIME type present\n * in the given data (from {@link $getClipboardDataFromSelection})\n *\n * @param clipboardData the event.clipboardData to populate from data\n * @param data The lexical data\n */\nfunction setLexicalClipboardDataTransfer(clipboardData, data) {\n  for (const [k] of clipboardDataFunctions) {\n    if (data[k] === undefined) {\n      clipboardData.setData(k, '');\n    }\n  }\n  for (const k in data) {\n    const v = data[k];\n    if (v !== undefined) {\n      clipboardData.setData(k, v);\n    }\n  }\n}\nfunction $getExportConfig() {\n  const editor = $getEditor();\n  const builder = LexicalBuilder.maybeFromEditor(editor);\n  if (builder && builder.hasExtensionByName(GetClipboardDataExtension.name)) {\n    return getExtensionDependencyFromEditor(editor, GetClipboardDataExtension).output;\n  }\n  return DEFAULT_EXPORT_MIME_TYPE;\n}\nconst DEFAULT_EXPORT_MIME_TYPE = {\n  'application/x-lexical-editor': [(sel, next) => sel ? $getLexicalContent($getEditor(), sel) : next()],\n  'text/html': [(sel, next) => sel ? $getHtmlContent($getEditor(), sel) : next()],\n  'text/plain': [(sel, next) => sel ? sel.getTextContent() : next()]\n};\nfunction $getClipboardDataWithConfigFromSelection($exportMimeType, selection) {\n  const clipboardData = {\n    'text/plain': ''\n  };\n  for (const [k, fns] of Object.entries($exportMimeType)) {\n    const v = callExportMimeTypeFunctionStack(fns, selection);\n    if (v !== null) {\n      clipboardData[k] = v;\n    }\n  }\n  return clipboardData;\n}\nfunction callExportMimeTypeFunctionStack(fns, selection) {\n  const callAt = i => fns[i] ? fns[i](selection, callAt.bind(null, i - 1)) : null;\n  return callAt(fns.length - 1);\n}\nconst GetClipboardDataExtension = defineExtension({\n  build(editor, config, state) {\n    return config.$exportMimeType;\n  },\n  config: safeCast({\n    $exportMimeType: DEFAULT_EXPORT_MIME_TYPE\n  }),\n  mergeConfig(config, partial) {\n    const merged = shallowMergeConfig(config, partial);\n    if (partial.$exportMimeType) {\n      const $exportMimeType = {\n        ...config.$exportMimeType\n      };\n      for (const [k, v] of Object.entries(partial.$exportMimeType)) {\n        $exportMimeType[k] = [...$exportMimeType[k], ...v];\n      }\n      merged.$exportMimeType = $exportMimeType;\n    }\n    return merged;\n  },\n  name: '@lexical/clipboard/GetClipboardData'\n});\n\nexport { $generateJSONFromSelectedNodes, $generateNodesFromSerializedNodes, $getClipboardDataFromSelection, $getHtmlContent, $getLexicalContent, $handlePlainTextDrop, $handleRichTextDrop, $insertDataTransferForPlainText, $insertDataTransferForRichText, $insertGeneratedNodes, $writeDragSourceToDataTransfer, copyToClipboard, setLexicalClipboardDataTransfer };\n"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/LexicalClipboard.node-0e9GBL1g.mjs

@@ -0,0 +1,26 @@
+//#region ../../node_modules/.pnpm/@lexical+clipboard@0.44.0/node_modules/@lexical/clipboard/LexicalClipboard.node.mjs
+/**
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*
+*/
+const mod = await (process.env.NODE_ENV !== "production" ? import("./LexicalClipboard.dev-CdeeWCIq.mjs") : import("./LexicalClipboard.prod-CsCWYmV7.mjs"));
+mod.$generateJSONFromSelectedNodes;
+mod.$generateNodesFromSerializedNodes;
+const $getClipboardDataFromSelection = mod.$getClipboardDataFromSelection;
+mod.$getHtmlContent;
+mod.$getLexicalContent;
+mod.$handlePlainTextDrop;
+const $handleRichTextDrop = mod.$handleRichTextDrop;
+mod.$insertDataTransferForPlainText;
+const $insertDataTransferForRichText = mod.$insertDataTransferForRichText;
+mod.$insertGeneratedNodes;
+const $writeDragSourceToDataTransfer = mod.$writeDragSourceToDataTransfer;
+const copyToClipboard = mod.copyToClipboard;
+const setLexicalClipboardDataTransfer = mod.setLexicalClipboardDataTransfer;
+//#endregion
+export { copyToClipboard as a, $writeDragSourceToDataTransfer as i, $handleRichTextDrop as n, setLexicalClipboardDataTransfer as o, $insertDataTransferForRichText as r, $getClipboardDataFromSelection as t };
+
+//# sourceMappingURL=LexicalClipboard.node-0e9GBL1g.mjs.map

package/dist/LexicalClipboard.node-0e9GBL1g.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"LexicalClipboard.node-0e9GBL1g.mjs","names":[],"sources":["../../../node_modules/.pnpm/@lexical+clipboard@0.44.0/node_modules/@lexical/clipboard/LexicalClipboard.node.mjs"],"sourcesContent":["/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nconst mod = await (process.env.NODE_ENV !== 'production' ? import('./LexicalClipboard.dev.mjs') : import('./LexicalClipboard.prod.mjs'));\nexport const $generateJSONFromSelectedNodes = mod.$generateJSONFromSelectedNodes;\nexport const $generateNodesFromSerializedNodes = mod.$generateNodesFromSerializedNodes;\nexport const $getClipboardDataFromSelection = mod.$getClipboardDataFromSelection;\nexport const $getHtmlContent = mod.$getHtmlContent;\nexport const $getLexicalContent = mod.$getLexicalContent;\nexport const $handlePlainTextDrop = mod.$handlePlainTextDrop;\nexport const $handleRichTextDrop = mod.$handleRichTextDrop;\nexport const $insertDataTransferForPlainText = mod.$insertDataTransferForPlainText;\nexport const $insertDataTransferForRichText = mod.$insertDataTransferForRichText;\nexport const $insertGeneratedNodes = mod.$insertGeneratedNodes;\nexport const $writeDragSourceToDataTransfer = mod.$writeDragSourceToDataTransfer;\nexport const copyToClipboard = mod.copyToClipboard;\nexport const setLexicalClipboardDataTransfer = mod.setLexicalClipboardDataTransfer;"],"x_google_ignoreList":[0],"mappings":";;;;;;;;AAQA,MAAM,MAAM,OAAO,QAAQ,IAAI,aAAa,eAAe,OAAO,yCAAgC,OAAO;AAC3D,IAAI;AACD,IAAI;AACrD,MAAa,iCAAiC,IAAI;AACnB,IAAI;AACD,IAAI;AACF,IAAI;AACxC,MAAa,sBAAsB,IAAI;AACQ,IAAI;AACnD,MAAa,iCAAiC,IAAI;AACb,IAAI;AACzC,MAAa,iCAAiC,IAAI;AAClD,MAAa,kBAAkB,IAAI;AACnC,MAAa,kCAAkC,IAAI"}