@btst/stack 4.5.1 → 5.0.0

package/dist/node_modules/.pnpm/@tiptap_react@3.32.0_@floating-ui_dom@1.8.0_@tiptap_core@3.32.0_@tiptap_pm@3.32.0__@tip_8215e90eae23fe6dcd148429648d62d6/node_modules/@tiptap/react/dist/index.mjs

@@ -0,0 +1,1173 @@
+"use client";
+import React__default, { createRef, memo, createElement, createContext, version, useRef, useState, useDebugValue, useEffect, useContext, forwardRef, useLayoutEffect, useMemo } from 'react';
+import { PluginKey, Plugin } from '../../../../../prosemirror-state@1.4.4/node_modules/prosemirror-state/dist/index.mjs';
+import ReactDOM__default, { flushSync } from 'react-dom';
+import { s as shimExports } from '../../../../../../../_virtual/index3.mjs';
+import { NodeView, getRenderedAttributes, isTextSelection, Editor, isiOS, isAndroid } from '../../../../../@tiptap_core@3.32.0_@tiptap_pm@3.32.0/node_modules/@tiptap/core/dist/index.mjs';
+export { CommandManager, DECORATION_MANAGER_PLUGIN_KEY, DecorationManager, Extendable, Extension, InputRule, MappablePosition, Mark, Node, NodePos, PasteRule, ResizableNodeView, attrsEqual, callOrReturn, canInsertNode, combineTransactionSteps, commands, createChainableState, createDocument, createMappablePosition, createNodeFromContent, createStyleTag, decodeHtmlEntities, defaultBlockAt, deleteProps, elementFromString, encodeHtmlEntities, findChildren, findChildrenInRange, findDuplicates, findParentNode, findParentNodeClosestToPos, flattenExtensions, fromString, generateJSON, getAttributes, getAttributesFromExtensions, getChangedRanges, getExtensionField, getHTMLFromFragment, getMarkAttributes, getMarkRange, getMarkType, getMarksBetween, getNodeAtPosition, getNodeAttributes, getNodeType, getPreviousBlockSibling, getSchema, getSchemaByResolvedExtensions, getSchemaTypeByName, getSchemaTypeNameByName, getSplittedAttributes, getStyleProperty, getText, getTextBetween, getTextContentFromNodes, getTextSerializersFromSchema, getUpdatedPosition, injectExtensionAttributesToParseRule, inputRulesPlugin, isActive, isAtEndOfNode, isAtStartOfNode, isEmptyObject, isExtensionRulesEnabled, isFunction, isList, isMacOS, isMarkActive, isNodeActive, isNodeEmpty, isNodeSelection, isNumber, isPlainObject, isProseMirrorReplaceStep, isProseMirrorStep, isRegExp, isSafari, isValidCSSStyleValue, markInputRule, markPasteRule, marksEqual, mergeAttributes, mergeDeep, minMax, nodeInputRule, objectIncludes, parseIndentedBlocks, pasteRulesPlugin, posToDOMRect, removeDuplicates, renderNestedMarkdownContent, resolveExtensions, resolveFocusPosition, selectionToInsertionEnd, sortExtensions, splitExtensions, textInputRule, textblockTypeInputRule, updateMarkViewAttributes, wrappingInputRule } from '../../../../../@tiptap_core@3.32.0_@tiptap_pm@3.32.0/node_modules/@tiptap/core/dist/index.mjs';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { circularDeepEqual } from '../../../../../fast-equals@5.4.5/node_modules/fast-equals/dist/es/index.mjs';
+import { w as withSelectorExports } from '../../../../../../../_virtual/with-selector2.mjs';
+
+//#region src/handleMobileEnter.ts
+function handleMobileEnter(editor, event) {
+	var _root$getSelection, _root$getSelection2;
+	if (editor.isDestroyed || event.defaultPrevented || !event.cancelable || !editor.isEditable || event.inputType !== "insertParagraph" && event.inputType !== "insertLineBreak" || !isiOS() && !isAndroid()) return;
+	const view = editor.view;
+	const root = view.root;
+	const selection = (_root$getSelection = (_root$getSelection2 = root.getSelection) === null || _root$getSelection2 === void 0 ? void 0 : _root$getSelection2.call(root)) !== null && _root$getSelection !== void 0 ? _root$getSelection : view.dom.ownerDocument.getSelection();
+	const anchor = selection === null || selection === void 0 ? void 0 : selection.anchorNode;
+	const element = (anchor === null || anchor === void 0 ? void 0 : anchor.nodeType) === 1 ? anchor : anchor === null || anchor === void 0 ? void 0 : anchor.parentElement;
+	const contentDOM = element === null || element === void 0 ? void 0 : element.closest("[data-node-view-content-react]");
+	if (!contentDOM || !view.dom.contains(contentDOM)) return;
+	const lastKeyCode = view.input.lastKeyCode;
+	if (lastKeyCode === 13) view.input.lastKeyCode = null;
+	view.domObserver.forceFlush();
+	view.domObserver.flush();
+	const keyEvent = new KeyboardEvent("keydown", {
+		key: "Enter",
+		code: "Enter",
+		keyCode: 13,
+		shiftKey: event.inputType === "insertLineBreak",
+		bubbles: true,
+		cancelable: true
+	});
+	if (view.someProp("handleKeyDown", (handleKeyDown) => handleKeyDown(view, keyEvent))) {
+		event.preventDefault();
+		view.input.lastIOSEnter = 0;
+		clearTimeout(view.input.lastIOSEnterFallbackTimeout);
+	} else if (lastKeyCode === 13) view.input.lastKeyCode = lastKeyCode;
+}
+//#endregion
+//#region src/EditorContent.tsx
+const mobileEnterPluginKey = new PluginKey("reactMobileEnter");
+const mergeRefs = (...refs) => {
+	return (node) => {
+		refs.forEach((ref) => {
+			if (typeof ref === "function") ref(node);
+			else if (ref) ref.current = node;
+		});
+	};
+};
+/**
+* This component renders all of the editor's node views.
+*/
+const Portals = ({ contentComponent }) => {
+	const renderers = shimExports.useSyncExternalStore(contentComponent.subscribe, contentComponent.getSnapshot, contentComponent.getServerSnapshot);
+	return /* @__PURE__ */ jsx(Fragment, { children: Object.values(renderers) });
+};
+function createContentComponent() {
+	const subscribers = /* @__PURE__ */ new Set();
+	let renderers = {};
+	let isNotificationQueued = false;
+	const notifySubscribers = () => {
+		if (isNotificationQueued || !subscribers.size) return;
+		isNotificationQueued = true;
+		queueMicrotask(() => {
+			isNotificationQueued = false;
+			subscribers.forEach((subscriber) => subscriber());
+		});
+	};
+	return {
+		/**
+		* Subscribe to the editor instance's changes.
+		*/
+		subscribe(callback) {
+			subscribers.add(callback);
+			return () => {
+				subscribers.delete(callback);
+			};
+		},
+		getSnapshot() {
+			return renderers;
+		},
+		getServerSnapshot() {
+			return renderers;
+		},
+		/**
+		* Adds a new NodeView Renderer to the editor.
+		*/
+		setRenderer(id, renderer) {
+			renderers = {
+				...renderers,
+				[id]: ReactDOM__default.createPortal(renderer.reactElement, renderer.element, id)
+			};
+			notifySubscribers();
+		},
+		/**
+		* Removes a NodeView Renderer from the editor.
+		*/
+		removeRenderer(id) {
+			const nextRenderers = { ...renderers };
+			delete nextRenderers[id];
+			renderers = nextRenderers;
+			notifySubscribers();
+		}
+	};
+}
+var PureEditorContent = class extends React__default.Component {
+	constructor(props) {
+		super(props);
+		this.editorContentRef = React__default.createRef();
+	}
+	componentDidMount() {
+		this.init();
+	}
+	componentDidUpdate() {
+		this.init();
+	}
+	init() {
+		var _editor$view$dom;
+		const editor = this.props.editor;
+		if (editor && !editor.isDestroyed && ((_editor$view$dom = editor.view.dom) === null || _editor$view$dom === void 0 ? void 0 : _editor$view$dom.parentNode)) {
+			if (editor.contentComponent) return;
+			const element = this.editorContentRef.current;
+			element.append(...editor.view.dom.parentNode.childNodes);
+			editor.setOptions({ element });
+			editor.contentComponent = createContentComponent();
+			editor.createNodeViews();
+			editor.registerPlugin(new Plugin({
+				key: mobileEnterPluginKey,
+				props: { handleDOMEvents: { beforeinput: (_view, event) => handleMobileEnter(editor, event) } }
+			}));
+			editor.isEditorContentInitialized = true;
+			this.forceUpdate();
+		}
+	}
+	componentWillUnmount() {
+		const editor = this.props.editor;
+		if (!editor) return;
+		editor.isEditorContentInitialized = false;
+		if (!editor.isDestroyed) {
+			editor.unregisterPlugin(mobileEnterPluginKey);
+			editor.view.setProps({ nodeViews: {} });
+		}
+		editor.contentComponent = null;
+		try {
+			var _editor$view$dom2;
+			if (!((_editor$view$dom2 = editor.view.dom) === null || _editor$view$dom2 === void 0 ? void 0 : _editor$view$dom2.parentNode)) return;
+			const newElement = document.createElement("div");
+			newElement.append(...editor.view.dom.parentNode.childNodes);
+			editor.setOptions({ element: newElement });
+		} catch {}
+	}
+	render() {
+		const { editor, innerRef, ...rest } = this.props;
+		return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("div", {
+			ref: mergeRefs(innerRef, this.editorContentRef),
+			...rest
+		}), (editor === null || editor === void 0 ? void 0 : editor.contentComponent) && /* @__PURE__ */ jsx(Portals, { contentComponent: editor.contentComponent })] });
+	}
+};
+const EditorContentWithKey = forwardRef((props, ref) => {
+	const key = React__default.useMemo(() => {
+		return Math.floor(Math.random() * 4294967295).toString();
+	}, [props.editor]);
+	return React__default.createElement(PureEditorContent, {
+		key,
+		innerRef: ref,
+		...props
+	});
+});
+const EditorContent = React__default.memo(EditorContentWithKey);
+//#endregion
+//#region src/useEditorState.ts
+const useIsomorphicLayoutEffect = typeof window !== "undefined" ? useLayoutEffect : useEffect;
+/**
+* To synchronize the editor instance with the component state,
+* we need to create a separate instance that is not affected by the component re-renders.
+*/
+var EditorStateManager = class {
+	constructor(initialEditor) {
+		this.transactionNumber = 0;
+		this.lastTransactionNumber = 0;
+		this.subscribers = /* @__PURE__ */ new Set();
+		this.editor = initialEditor;
+		this.lastSnapshot = {
+			editor: initialEditor,
+			transactionNumber: 0
+		};
+		this.getSnapshot = this.getSnapshot.bind(this);
+		this.getServerSnapshot = this.getServerSnapshot.bind(this);
+		this.watch = this.watch.bind(this);
+		this.subscribe = this.subscribe.bind(this);
+	}
+	/**
+	* Get the current editor instance.
+	*/
+	getSnapshot() {
+		if (this.transactionNumber === this.lastTransactionNumber) return this.lastSnapshot;
+		this.lastTransactionNumber = this.transactionNumber;
+		this.lastSnapshot = {
+			editor: this.editor,
+			transactionNumber: this.transactionNumber
+		};
+		return this.lastSnapshot;
+	}
+	/**
+	* Always disable the editor on the server-side.
+	*/
+	getServerSnapshot() {
+		return {
+			editor: null,
+			transactionNumber: 0
+		};
+	}
+	/**
+	* Subscribe to the editor instance's changes.
+	*/
+	subscribe(callback) {
+		this.subscribers.add(callback);
+		return () => {
+			this.subscribers.delete(callback);
+		};
+	}
+	/**
+	* Watch the editor instance for changes.
+	*/
+	watch(nextEditor) {
+		this.editor = nextEditor;
+		if (this.editor) {
+			/**
+			* This will force a re-render when the editor state changes.
+			* This is to support things like `editor.can().toggleBold()` in components that `useEditor`.
+			* This could be more efficient, but it's a good trade-off for now.
+			*/
+			let lastTransaction;
+			const fn = (props) => {
+				if ((props === null || props === void 0 ? void 0 : props.transaction) !== void 0 && props.transaction === lastTransaction) return;
+				lastTransaction = props === null || props === void 0 ? void 0 : props.transaction;
+				this.transactionNumber += 1;
+				this.subscribers.forEach((callback) => callback());
+			};
+			const currentEditor = this.editor;
+			currentEditor.on("transaction", fn);
+			currentEditor.on("update", fn);
+			return () => {
+				currentEditor.off("transaction", fn);
+				currentEditor.off("update", fn);
+			};
+		}
+	}
+};
+/**
+* This hook allows you to watch for changes on the editor instance.
+* It will allow you to select a part of the editor state and re-render the component when it changes.
+* @example
+* ```tsx
+* const editor = useEditor({...options})
+* const { currentSelection } = useEditorState({
+*  editor,
+*  selector: snapshot => ({ currentSelection: snapshot.editor.state.selection }),
+* })
+*/
+function useEditorState(options) {
+	var _options$equalityFn;
+	const [editorStateManager] = useState(() => new EditorStateManager(options.editor));
+	const selectedState = withSelectorExports.useSyncExternalStoreWithSelector(editorStateManager.subscribe, editorStateManager.getSnapshot, editorStateManager.getServerSnapshot, options.selector, (_options$equalityFn = options.equalityFn) !== null && _options$equalityFn !== void 0 ? _options$equalityFn : circularDeepEqual);
+	useIsomorphicLayoutEffect(() => {
+		return editorStateManager.watch(options.editor);
+	}, [options.editor, editorStateManager]);
+	useDebugValue(selectedState);
+	return selectedState;
+}
+//#endregion
+//#region src/useEditor.ts
+const isDev = process.env.NODE_ENV !== "production";
+const isSSR = typeof window === "undefined";
+const isNext = isSSR || Boolean(typeof window !== "undefined" && window.next);
+/**
+* This class handles the creation, destruction, and re-creation of the editor instance.
+*/
+var EditorInstanceManager = class EditorInstanceManager {
+	constructor(options) {
+		this.editor = null;
+		this.subscriptions = /* @__PURE__ */ new Set();
+		this.isComponentMounted = false;
+		this.previousDeps = null;
+		this.instanceId = "";
+		this.options = options;
+		this.subscriptions = /* @__PURE__ */ new Set();
+		this.setEditor(this.getInitialEditor());
+		this.scheduleDestroy();
+		this.getEditor = this.getEditor.bind(this);
+		this.getServerSnapshot = this.getServerSnapshot.bind(this);
+		this.subscribe = this.subscribe.bind(this);
+		this.refreshEditorInstance = this.refreshEditorInstance.bind(this);
+		this.scheduleDestroy = this.scheduleDestroy.bind(this);
+		this.onRender = this.onRender.bind(this);
+		this.createEditor = this.createEditor.bind(this);
+	}
+	setEditor(editor) {
+		this.editor = editor;
+		this.instanceId = Math.random().toString(36).slice(2, 9);
+		this.subscriptions.forEach((cb) => cb());
+	}
+	getInitialEditor() {
+		const explicit = this.options.current.immediatelyRender;
+		let immediatelyRender = explicit !== null && explicit !== void 0 ? explicit : true;
+		if (isSSR) {
+			if (immediatelyRender && isDev) console.warn("SSR detected. `immediatelyRender` has been set to false to avoid hydration mismatches");
+			immediatelyRender = false;
+		} else if (isNext && explicit === void 0) {
+			immediatelyRender = false;
+			if (isDev) console.warn("Next.js detected. `immediatelyRender` defaults to false to avoid hydration mismatches. Pass `immediatelyRender: true` explicitly if you are rendering the editor only on the client.");
+		}
+		return immediatelyRender ? this.createEditor() : null;
+	}
+	/**
+	* Create a new editor instance. And attach event listeners.
+	*/
+	createEditor() {
+		const optionsToApply = {
+			...this.options.current,
+			onBeforeCreate: (...args) => {
+				var _this$options$current, _this$options$current2;
+				return (_this$options$current = (_this$options$current2 = this.options.current).onBeforeCreate) === null || _this$options$current === void 0 ? void 0 : _this$options$current.call(_this$options$current2, ...args);
+			},
+			onBlur: (...args) => {
+				var _this$options$current3, _this$options$current4;
+				return (_this$options$current3 = (_this$options$current4 = this.options.current).onBlur) === null || _this$options$current3 === void 0 ? void 0 : _this$options$current3.call(_this$options$current4, ...args);
+			},
+			onCreate: (...args) => {
+				var _this$options$current5, _this$options$current6;
+				return (_this$options$current5 = (_this$options$current6 = this.options.current).onCreate) === null || _this$options$current5 === void 0 ? void 0 : _this$options$current5.call(_this$options$current6, ...args);
+			},
+			onDestroy: (...args) => {
+				var _this$options$current7, _this$options$current8;
+				return (_this$options$current7 = (_this$options$current8 = this.options.current).onDestroy) === null || _this$options$current7 === void 0 ? void 0 : _this$options$current7.call(_this$options$current8, ...args);
+			},
+			onFocus: (...args) => {
+				var _this$options$current9, _this$options$current10;
+				return (_this$options$current9 = (_this$options$current10 = this.options.current).onFocus) === null || _this$options$current9 === void 0 ? void 0 : _this$options$current9.call(_this$options$current10, ...args);
+			},
+			onSelectionUpdate: (...args) => {
+				var _this$options$current11, _this$options$current12;
+				return (_this$options$current11 = (_this$options$current12 = this.options.current).onSelectionUpdate) === null || _this$options$current11 === void 0 ? void 0 : _this$options$current11.call(_this$options$current12, ...args);
+			},
+			onTransaction: (...args) => {
+				var _this$options$current13, _this$options$current14;
+				return (_this$options$current13 = (_this$options$current14 = this.options.current).onTransaction) === null || _this$options$current13 === void 0 ? void 0 : _this$options$current13.call(_this$options$current14, ...args);
+			},
+			onUpdate: (...args) => {
+				var _this$options$current15, _this$options$current16;
+				return (_this$options$current15 = (_this$options$current16 = this.options.current).onUpdate) === null || _this$options$current15 === void 0 ? void 0 : _this$options$current15.call(_this$options$current16, ...args);
+			},
+			onContentError: (...args) => {
+				var _this$options$current17, _this$options$current18;
+				return (_this$options$current17 = (_this$options$current18 = this.options.current).onContentError) === null || _this$options$current17 === void 0 ? void 0 : _this$options$current17.call(_this$options$current18, ...args);
+			},
+			onDrop: (...args) => {
+				var _this$options$current19, _this$options$current20;
+				return (_this$options$current19 = (_this$options$current20 = this.options.current).onDrop) === null || _this$options$current19 === void 0 ? void 0 : _this$options$current19.call(_this$options$current20, ...args);
+			},
+			onPaste: (...args) => {
+				var _this$options$current21, _this$options$current22;
+				return (_this$options$current21 = (_this$options$current22 = this.options.current).onPaste) === null || _this$options$current21 === void 0 ? void 0 : _this$options$current21.call(_this$options$current22, ...args);
+			},
+			onDelete: (...args) => {
+				var _this$options$current23, _this$options$current24;
+				return (_this$options$current23 = (_this$options$current24 = this.options.current).onDelete) === null || _this$options$current23 === void 0 ? void 0 : _this$options$current23.call(_this$options$current24, ...args);
+			},
+			onMount: (...args) => {
+				var _this$options$current25, _this$options$current26;
+				return (_this$options$current25 = (_this$options$current26 = this.options.current).onMount) === null || _this$options$current25 === void 0 ? void 0 : _this$options$current25.call(_this$options$current26, ...args);
+			},
+			onUnmount: (...args) => {
+				var _this$options$current27, _this$options$current28;
+				return (_this$options$current27 = (_this$options$current28 = this.options.current).onUnmount) === null || _this$options$current27 === void 0 ? void 0 : _this$options$current27.call(_this$options$current28, ...args);
+			}
+		};
+		return new Editor(optionsToApply);
+	}
+	/**
+	* Get the current editor instance.
+	*/
+	getEditor() {
+		return this.editor;
+	}
+	/**
+	* Always disable the editor on the server-side.
+	*/
+	getServerSnapshot() {
+		return null;
+	}
+	/**
+	* Subscribe to the editor instance's changes.
+	*/
+	subscribe(onStoreChange) {
+		this.subscriptions.add(onStoreChange);
+		return () => {
+			this.subscriptions.delete(onStoreChange);
+		};
+	}
+	static compareOptions(a, b) {
+		return Object.keys(a).every((key) => {
+			if ([
+				"onCreate",
+				"onBeforeCreate",
+				"onDestroy",
+				"onUpdate",
+				"onTransaction",
+				"onFocus",
+				"onBlur",
+				"onSelectionUpdate",
+				"onContentError",
+				"onDrop",
+				"onPaste"
+			].includes(key)) return true;
+			if (key === "extensions" && a.extensions && b.extensions) {
+				if (a.extensions.length !== b.extensions.length) return false;
+				return a.extensions.every((extension, index) => {
+					var _b$extensions;
+					if (extension !== ((_b$extensions = b.extensions) === null || _b$extensions === void 0 ? void 0 : _b$extensions[index])) return false;
+					return true;
+				});
+			}
+			if (a[key] !== b[key]) return false;
+			return true;
+		});
+	}
+	/**
+	* On each render, we will create, update, or destroy the editor instance.
+	* @param deps The dependencies to watch for changes
+	* @returns A cleanup function
+	*/
+	onRender(deps) {
+		return () => {
+			this.isComponentMounted = true;
+			clearTimeout(this.scheduledDestructionTimeout);
+			if (this.editor && !this.editor.isDestroyed && deps.length === 0) {
+				if (!EditorInstanceManager.compareOptions(this.options.current, this.editor.options)) this.editor.setOptions({
+					...this.options.current,
+					editable: this.editor.isEditable
+				});
+			} else this.refreshEditorInstance(deps);
+			return () => {
+				this.isComponentMounted = false;
+				this.scheduleDestroy();
+			};
+		};
+	}
+	/**
+	* Recreate the editor instance if the dependencies have changed.
+	*/
+	refreshEditorInstance(deps) {
+		if (this.editor && !this.editor.isDestroyed) {
+			if (this.previousDeps === null) {
+				this.previousDeps = deps;
+				return;
+			}
+			if (this.previousDeps.length === deps.length && this.previousDeps.every((dep, index) => dep === deps[index])) return;
+		}
+		if (this.editor && !this.editor.isDestroyed) this.editor.destroy();
+		this.setEditor(this.createEditor());
+		this.previousDeps = deps;
+	}
+	/**
+	* Schedule the destruction of the editor instance.
+	* This will only destroy the editor if it was not mounted on the next tick.
+	* This is to avoid destroying the editor instance when it's actually still mounted.
+	*/
+	scheduleDestroy() {
+		const currentInstanceId = this.instanceId;
+		const currentEditor = this.editor;
+		this.scheduledDestructionTimeout = setTimeout(() => {
+			if (this.isComponentMounted && this.instanceId === currentInstanceId) {
+				if (currentEditor) currentEditor.setOptions(this.options.current);
+				return;
+			}
+			if (currentEditor && !currentEditor.isDestroyed) {
+				currentEditor.destroy();
+				if (this.instanceId === currentInstanceId) this.setEditor(null);
+			}
+		}, 1);
+	}
+};
+function useEditor(options = {}, deps = []) {
+	const mostRecentOptions = useRef(options);
+	mostRecentOptions.current = options;
+	const [instanceManager] = useState(() => new EditorInstanceManager(mostRecentOptions));
+	const editor = shimExports.useSyncExternalStore(instanceManager.subscribe, instanceManager.getEditor, instanceManager.getServerSnapshot);
+	useDebugValue(editor);
+	useEffect(instanceManager.onRender(deps));
+	useEditorState({
+		editor,
+		selector: ({ transactionNumber }) => {
+			if (options.shouldRerenderOnTransaction === false || options.shouldRerenderOnTransaction === void 0) return null;
+			if (options.immediatelyRender && transactionNumber === 0) return 0;
+			return transactionNumber + 1;
+		}
+	});
+	return editor;
+}
+//#endregion
+//#region src/Context.tsx
+const EditorContext = createContext({ editor: null });
+EditorContext.Consumer;
+/**
+* A hook to get the current editor instance.
+*/
+const useCurrentEditor = () => useContext(EditorContext);
+//#endregion
+//#region src/useReactNodeView.ts
+const ReactNodeViewContext = createContext({
+	onDragStart: () => {},
+	nodeViewContentChildren: void 0,
+	nodeViewContentRef: () => {}
+});
+const useReactNodeView = () => useContext(ReactNodeViewContext);
+//#endregion
+//#region src/NodeViewWrapper.tsx
+const NodeViewWrapper = React__default.forwardRef((props, ref) => {
+	const { onDragStart } = useReactNodeView();
+	const Tag = props.as || "div";
+	return /* @__PURE__ */ jsx(Tag, {
+		...props,
+		ref,
+		"data-node-view-wrapper": "",
+		onDragStart,
+		style: {
+			whiteSpace: "normal",
+			...props.style
+		}
+	});
+});
+//#endregion
+//#region src/ReactRenderer.tsx
+/**
+* Check if a component is a class component.
+* @param Component
+* @returns {boolean}
+*/
+function isClassComponent(Component) {
+	return !!(typeof Component === "function" && Component.prototype && Component.prototype.isReactComponent);
+}
+/**
+* Check if a component is a forward ref component.
+* @param Component
+* @returns {boolean}
+*/
+function isForwardRefComponent(Component) {
+	return !!(typeof Component === "object" && Component.$$typeof && (Component.$$typeof.toString() === "Symbol(react.forward_ref)" || Component.$$typeof.description === "react.forward_ref"));
+}
+/**
+* Check if a component is a memoized component.
+* @param Component
+* @returns {boolean}
+*/
+function isMemoComponent(Component) {
+	return !!(typeof Component === "object" && Component.$$typeof && (Component.$$typeof.toString() === "Symbol(react.memo)" || Component.$$typeof.description === "react.memo"));
+}
+/**
+* Check if a component can safely receive a ref prop.
+* This includes class components, forwardRef components, and memoized components
+* that wrap forwardRef or class components.
+* @param Component
+* @returns {boolean}
+*/
+function canReceiveRef(Component) {
+	if (isClassComponent(Component)) return true;
+	if (isForwardRefComponent(Component)) return true;
+	if (isMemoComponent(Component)) {
+		const wrappedComponent = Component.type;
+		if (wrappedComponent) return isClassComponent(wrappedComponent) || isForwardRefComponent(wrappedComponent);
+	}
+	return false;
+}
+/**
+* Check if we're running React 19+ by detecting if function components support ref props
+* @returns {boolean}
+*/
+function isReact19Plus() {
+	try {
+		if (version) return parseInt(version.split(".")[0], 10) >= 19;
+	} catch {}
+	return false;
+}
+/**
+* The ReactRenderer class. It's responsible for rendering React components inside the editor.
+* @example
+* new ReactRenderer(MyComponent, {
+*   editor,
+*   props: {
+*     foo: 'bar',
+*   },
+*   as: 'span',
+* })
+*/
+var ReactRenderer = class {
+	/**
+	* Immediately creates element and renders the provided React component.
+	*/
+	constructor(component, { editor, props = {}, as = "div", className = "" }) {
+		this.ref = null;
+		this.destroyed = false;
+		this.id = Math.floor(Math.random() * 4294967295).toString();
+		this.component = component;
+		this.editor = editor;
+		this.props = props;
+		this.element = document.createElement(as);
+		this.element.classList.add("react-renderer");
+		if (className) this.element.classList.add(...className.split(" "));
+		if (this.editor.isEditorContentInitialized) flushSync(() => {
+			this.render();
+		});
+		else queueMicrotask(() => {
+			if (this.destroyed) return;
+			this.render();
+		});
+	}
+	/**
+	* Render the React component.
+	*/
+	render() {
+		var _editor$contentCompon;
+		if (this.destroyed) return;
+		const Component = this.component;
+		const props = this.props;
+		const editor = this.editor;
+		const isReact19 = isReact19Plus();
+		const componentCanReceiveRef = canReceiveRef(Component);
+		const elementProps = { ...props };
+		if (elementProps.ref && !(isReact19 || componentCanReceiveRef)) delete elementProps.ref;
+		if (!elementProps.ref && (isReact19 || componentCanReceiveRef)) elementProps.ref = (ref) => {
+			this.ref = ref;
+		};
+		this.reactElement = /* @__PURE__ */ jsx(Component, { ...elementProps });
+		editor === null || editor === void 0 || (_editor$contentCompon = editor.contentComponent) === null || _editor$contentCompon === void 0 || _editor$contentCompon.setRenderer(this.id, this);
+	}
+	/**
+	* Re-renders the React component with new props.
+	* Skips the render if none of the supplied props actually changed,
+	* to avoid unnecessary portal re-creation.
+	*/
+	updateProps(props = {}) {
+		if (this.destroyed) return;
+		let changed = false;
+		const keys = Object.keys(props);
+		for (let i = 0; i < keys.length; i += 1) {
+			const key = keys[i];
+			if (props[key] !== this.props[key]) {
+				changed = true;
+				break;
+			}
+		}
+		if (!changed) return;
+		this.props = {
+			...this.props,
+			...props
+		};
+		this.render();
+	}
+	/**
+	* Destroy the React component.
+	*/
+	destroy() {
+		var _editor$contentCompon2;
+		this.destroyed = true;
+		const editor = this.editor;
+		editor === null || editor === void 0 || (_editor$contentCompon2 = editor.contentComponent) === null || _editor$contentCompon2 === void 0 || _editor$contentCompon2.removeRenderer(this.id);
+		try {
+			if (this.element && this.element.parentNode) this.element.parentNode.removeChild(this.element);
+		} catch {}
+	}
+	/**
+	* Update the attributes of the element that holds the React component.
+	*/
+	updateAttributes(attributes) {
+		Object.keys(attributes).forEach((key) => {
+			this.element.setAttribute(key, attributes[key]);
+		});
+	}
+};
+//#endregion
+//#region src/ReactMarkViewRenderer.tsx
+React__default.createContext({ markViewContentRef: () => {} });
+//#endregion
+//#region src/captureDOMSelection.ts
+/**
+* Saves the DOM selection inside `element`, returns a function to put it back.
+* Browsers drop the selection when an element moves, so restore it after the move.
+*/
+function captureDOMSelection(element) {
+	var _element$ownerDocumen;
+	const root = element.getRootNode();
+	const selection = typeof root.getSelection === "function" ? root.getSelection() : (_element$ownerDocumen = element.ownerDocument) === null || _element$ownerDocumen === void 0 || (_element$ownerDocumen = _element$ownerDocumen.defaultView) === null || _element$ownerDocumen === void 0 ? void 0 : _element$ownerDocumen.getSelection();
+	if (!selection || selection.rangeCount === 0) return null;
+	const { anchorNode, anchorOffset, focusNode, focusOffset } = selection;
+	if (!anchorNode || !focusNode) return null;
+	if (!element.contains(anchorNode) || !element.contains(focusNode)) return null;
+	return () => {
+		try {
+			selection.setBaseAndExtent(anchorNode, anchorOffset, focusNode, focusOffset);
+		} catch {}
+	};
+}
+//#endregion
+//#region src/lib/utils/getTextSelectionAncestorPositions.ts
+function isSameAncestor($from, $to, depth) {
+	return $from.node(depth) === $to.node(depth) && $from.before(depth) === $to.before(depth);
+}
+function getTextSelectionAncestorPositions(selection) {
+	if (!isTextSelection(selection)) return [];
+	const { $from, $to } = selection;
+	const positions = [];
+	const maxDepth = Math.min($from.depth, $to.depth);
+	for (let depth = 1; depth <= maxDepth; depth += 1) {
+		if (!isSameAncestor($from, $to, depth)) break;
+		positions.push($from.before(depth));
+	}
+	return positions;
+}
+//#endregion
+//#region src/ReactNodeViewSelectionTracker.ts
+var ReactNodeViewSelectionTracker = class {
+	constructor(editor) {
+		this.views = /* @__PURE__ */ new WeakMap();
+		this.viewCount = 0;
+		this.insideViews = /* @__PURE__ */ new Set();
+		this.syncQueued = false;
+		this.scheduleSync = () => {
+			if (this.syncQueued) return;
+			this.syncQueued = true;
+			queueMicrotask(() => {
+				this.syncQueued = false;
+				this.sync();
+			});
+		};
+		this.handleTransaction = () => this.scheduleSync();
+		this.editor = editor;
+	}
+	register(view) {
+		if (this.viewCount === 0) this.editor.on("transaction", this.handleTransaction);
+		this.views.set(view.dom, view);
+		this.viewCount += 1;
+		this.scheduleSync();
+	}
+	unregister(view) {
+		this.views.delete(view.dom);
+		this.viewCount -= 1;
+		this.insideViews.delete(view);
+		if (this.viewCount === 0) this.editor.off("transaction", this.handleTransaction);
+	}
+	sync() {
+		if (this.viewCount === 0 || this.editor.isDestroyed) return;
+		const nextInsideViews = this.findInsideViews();
+		this.updateViews(this.insideViews, nextInsideViews, false);
+		this.updateViews(nextInsideViews, this.insideViews, true);
+		this.insideViews = nextInsideViews;
+	}
+	updateViews(views, unchangedViews, selectionInside) {
+		for (const view of views) if (!unchangedViews.has(view)) view.setSelectionInside(selectionInside);
+	}
+	findInsideViews() {
+		const insideViews = /* @__PURE__ */ new Set();
+		for (const position of getTextSelectionAncestorPositions(this.editor.state.selection)) {
+			const dom = this.editor.view.nodeDOM(position);
+			const view = dom ? this.views.get(dom) : void 0;
+			if (view) insideViews.add(view);
+		}
+		return insideViews;
+	}
+};
+const trackers = /* @__PURE__ */ new WeakMap();
+function getReactNodeViewSelectionTracker(editor) {
+	let tracker = trackers.get(editor);
+	if (!tracker) {
+		tracker = new ReactNodeViewSelectionTracker(editor);
+		trackers.set(editor, tracker);
+	}
+	return tracker;
+}
+//#endregion
+//#region src/ReactNodeViewRenderer.tsx
+var ReactNodeView = class extends NodeView {
+	constructor(component, props, options) {
+		super(component, props, options);
+		this.nodeSelected = false;
+		this.handlePositionUpdate = () => {
+			const newPos = this.getPos();
+			if (typeof newPos !== "number" || newPos === this.currentPos) return;
+			this.currentPos = newPos;
+			this.renderer.updateProps({ getPos: () => this.getPos() });
+			if (typeof this.options.attrs === "function") this.updateElementAttributes();
+		};
+		this.cachedExtensionWithSyncedStorage = null;
+		if (!this.node.isLeaf) {
+			if (this.options.contentDOMElementTag) this.contentDOMElement = document.createElement(this.options.contentDOMElementTag);
+			else this.contentDOMElement = document.createElement(this.node.isInline ? "span" : "div");
+			this.contentDOMElement.dataset.nodeViewContentReact = "";
+			this.contentDOMElement.dataset.nodeViewWrapper = "";
+			this.contentDOMElement.style.whiteSpace = "inherit";
+			const contentTarget = this.dom.querySelector("[data-node-view-content]");
+			if (contentTarget) contentTarget.appendChild(this.contentDOMElement);
+			else this.dom.appendChild(this.contentDOMElement);
+		}
+		if (this.options.trackNodeViewPosition) this.editor.on("update", this.handlePositionUpdate);
+	}
+	/**
+	* Returns a proxy of the extension that redirects storage access to the editor's mutable storage.
+	* This preserves the original prototype chain (instanceof checks, methods like configure/extend work).
+	* Cached to avoid proxy creation on every update.
+	*/
+	get extensionWithSyncedStorage() {
+		if (!this.cachedExtensionWithSyncedStorage) {
+			const editor = this.editor;
+			const extension = this.extension;
+			this.cachedExtensionWithSyncedStorage = new Proxy(extension, { get(target, prop, receiver) {
+				if (prop === "storage") {
+					var _editor$storage;
+					return (_editor$storage = editor.storage[extension.name]) !== null && _editor$storage !== void 0 ? _editor$storage : {};
+				}
+				return Reflect.get(target, prop, receiver);
+			} });
+		}
+		return this.cachedExtensionWithSyncedStorage;
+	}
+	/**
+	* Setup the React component.
+	* Called on initialization.
+	*/
+	mount() {
+		const mountProps = {
+			editor: this.editor,
+			node: this.node,
+			decorations: this.decorations,
+			innerDecorations: this.innerDecorations,
+			view: this.view,
+			selected: false,
+			selectionInside: false,
+			extension: this.extensionWithSyncedStorage,
+			HTMLAttributes: this.HTMLAttributes,
+			getPos: () => this.getPos(),
+			updateAttributes: (attributes = {}) => this.updateAttributes(attributes),
+			deleteNode: () => this.deleteNode(),
+			ref: createRef()
+		};
+		if (!this.component.displayName) {
+			const capitalizeFirstChar = (string) => {
+				return string.charAt(0).toUpperCase() + string.substring(1);
+			};
+			this.component.displayName = capitalizeFirstChar(this.extension.name);
+		}
+		const onDragStart = this.onDragStart.bind(this);
+		const nodeViewContentRef = (element) => {
+			if (element && this.contentDOMElement && element.firstChild !== this.contentDOMElement) {
+				if (element.hasAttribute("data-node-view-wrapper")) element.removeAttribute("data-node-view-wrapper");
+				const restoreSelection = captureDOMSelection(this.contentDOMElement);
+				element.appendChild(this.contentDOMElement);
+				restoreSelection === null || restoreSelection === void 0 || restoreSelection();
+			}
+		};
+		const context = {
+			onDragStart,
+			nodeViewContentRef
+		};
+		const Component = this.component;
+		const ReactNodeViewProvider = memo((componentProps) => {
+			return /* @__PURE__ */ jsx(ReactNodeViewContext.Provider, {
+				value: context,
+				children: createElement(Component, componentProps)
+			});
+		});
+		ReactNodeViewProvider.displayName = "ReactNodeView";
+		let as = this.node.isInline ? "span" : "div";
+		if (this.options.as) as = this.options.as;
+		const { className = "" } = this.options;
+		this.renderer = new ReactRenderer(ReactNodeViewProvider, {
+			editor: this.editor,
+			props: mountProps,
+			as,
+			className: `node-${this.node.type.name} ${className}`.trim()
+		});
+		getReactNodeViewSelectionTracker(this.editor).register(this);
+		this.updateElementAttributes();
+		this.currentPos = this.getPos();
+	}
+	/**
+	* Return the DOM element.
+	* This is the element that will be used to display the node view.
+	*/
+	get dom() {
+		var _this$renderer$elemen;
+		if (this.renderer.element.firstElementChild && !((_this$renderer$elemen = this.renderer.element.firstElementChild) === null || _this$renderer$elemen === void 0 ? void 0 : _this$renderer$elemen.hasAttribute("data-node-view-wrapper"))) throw Error("Please use the NodeViewWrapper component for your node view.");
+		return this.renderer.element;
+	}
+	/**
+	* Return the content DOM element.
+	* This is the element that will be used to display the rich-text content of the node.
+	*/
+	get contentDOM() {
+		if (this.node.isLeaf) return null;
+		return this.contentDOMElement;
+	}
+	/**
+	* On update, update the React component.
+	* To prevent unnecessary updates, the `update` option can be used.
+	*/
+	update(node, decorations, innerDecorations) {
+		const rerenderComponent = (props) => {
+			this.renderer.updateProps(props);
+			if (typeof this.options.attrs === "function") this.updateElementAttributes();
+		};
+		if (node.type !== this.node.type) return false;
+		if (typeof this.options.update === "function") {
+			const oldNode = this.node;
+			const oldDecorations = this.decorations;
+			const oldInnerDecorations = this.innerDecorations;
+			this.node = node;
+			this.decorations = decorations;
+			this.innerDecorations = innerDecorations;
+			this.currentPos = this.getPos();
+			return this.options.update({
+				oldNode,
+				oldDecorations,
+				newNode: node,
+				newDecorations: decorations,
+				oldInnerDecorations,
+				innerDecorations,
+				updateProps: () => rerenderComponent({
+					node,
+					decorations,
+					innerDecorations,
+					extension: this.extensionWithSyncedStorage
+				})
+			});
+		}
+		if (!(node !== this.node)) {
+			this.node = node;
+			this.decorations = decorations;
+			this.innerDecorations = innerDecorations;
+			return true;
+		}
+		const newPos = this.getPos();
+		this.node = node;
+		this.decorations = decorations;
+		this.innerDecorations = innerDecorations;
+		this.currentPos = newPos;
+		const extraProps = {
+			node,
+			decorations,
+			innerDecorations,
+			extension: this.extensionWithSyncedStorage
+		};
+		if (this.options.trackNodeViewPosition) extraProps.getPos = () => this.getPos();
+		rerenderComponent(extraProps);
+		return true;
+	}
+	/**
+	* Select the node.
+	* Add the `selected` prop and the `ProseMirror-selectednode` class.
+	*/
+	selectNode() {
+		this.nodeSelected = true;
+		this.updateSelectedState(true);
+	}
+	/**
+	* Deselect the node.
+	* Remove the `selected` prop and the `ProseMirror-selectednode` class.
+	*/
+	deselectNode() {
+		this.nodeSelected = false;
+		this.updateSelectedState(this.options.selectedOnTextSelection === true && this.isTextSelectionInside());
+	}
+	setSelectionInside(selectionInside) {
+		const selected = this.nodeSelected || this.options.selectedOnTextSelection === true && selectionInside;
+		this.renderer.updateProps({
+			selectionInside,
+			selected
+		});
+		this.renderer.element.classList.toggle("ProseMirror-selectednode", selected);
+	}
+	updateSelectedState(selected) {
+		this.renderer.updateProps({ selected });
+		this.renderer.element.classList.toggle("ProseMirror-selectednode", selected);
+	}
+	isTextSelectionInside() {
+		const pos = this.getPos();
+		return typeof pos === "number" && getTextSelectionAncestorPositions(this.editor.state.selection).includes(pos);
+	}
+	/**
+	* Destroy the React component instance.
+	*/
+	destroy() {
+		this.renderer.destroy();
+		getReactNodeViewSelectionTracker(this.editor).unregister(this);
+		if (this.options.trackNodeViewPosition) this.editor.off("update", this.handlePositionUpdate);
+		this.contentDOMElement = null;
+	}
+	/**
+	* Update the attributes of the top-level element that holds the React component.
+	* Applying the attributes defined in the `attrs` option.
+	*/
+	updateElementAttributes() {
+		if (this.options.attrs) {
+			let attrsObj = {};
+			if (typeof this.options.attrs === "function") {
+				const extensionAttributes = this.editor.extensionManager.attributes;
+				const HTMLAttributes = getRenderedAttributes(this.node, extensionAttributes);
+				attrsObj = this.options.attrs({
+					node: this.node,
+					HTMLAttributes
+				});
+			} else attrsObj = this.options.attrs;
+			this.renderer.updateAttributes(attrsObj);
+		}
+	}
+};
+/**
+* Create a React node view renderer.
+*/
+function ReactNodeViewRenderer(component, options) {
+	return (props) => {
+		if (!props.editor.contentComponent) return {
+			dom: document.createElement("span"),
+			contentDOM: null,
+			update: () => false,
+			destroy: () => {},
+			selectNode: () => {},
+			deselectNode: () => {},
+			stopEvent: () => false,
+			ignoreMutation: () => true
+		};
+		return new ReactNodeView(component, props, options);
+	};
+}
+//#endregion
+//#region src/Tiptap.tsx
+/**
+* React context that stores the current editor instance.
+*
+* Use `useTiptap()` to read from this context in child components.
+*/
+const TiptapContext = createContext({ get editor() {
+	throw new Error("useTiptap must be used within a <Tiptap> provider");
+} });
+TiptapContext.displayName = "TiptapContext";
+/**
+* Hook to read the Tiptap context and access the editor instance.
+*
+* This is a small convenience wrapper around `useContext(TiptapContext)`.
+* The editor is always available when used within a `<Tiptap>` provider.
+*
+* @returns The current `TiptapContextType` value from the provider.
+*
+* @example
+* ```tsx
+* import { useTiptap } from '@tiptap/react'
+*
+* function Toolbar() {
+*   const { editor } = useTiptap()
+*
+*   return (
+*     <button onClick={() => editor.chain().focus().toggleBold().run()}>
+*       Bold
+*     </button>
+*   )
+* }
+* ```
+*/
+const useTiptap = () => useContext(TiptapContext);
+/**
+* Top-level provider component that makes the editor instance available via
+* React context to all child components.
+*
+* This component also provides backwards compatibility with the legacy
+* `EditorContext`, so components using `useCurrentEditor()` will work
+* inside a `<Tiptap>` provider.
+*
+* @param props - Component props.
+* @returns A context provider element wrapping `children`.
+*
+* @example
+* ```tsx
+* import { Tiptap, useEditor } from '@tiptap/react'
+*
+* function App() {
+*   const editor = useEditor({ extensions: [...] })
+*
+*   return (
+*     <Tiptap editor={editor}>
+*       <Toolbar />
+*       <Tiptap.Content />
+*     </Tiptap>
+*   )
+* }
+* ```
+*/
+function TiptapWrapper({ children, ...props }) {
+	const resolvedEditor = "editor" in props ? props.editor : props.instance;
+	if (!resolvedEditor) throw new Error("Tiptap: An editor instance is required. Pass a non-null `editor` prop.");
+	const tiptapContextValue = useMemo(() => ({ editor: resolvedEditor }), [resolvedEditor]);
+	const legacyContextValue = useMemo(() => ({ editor: resolvedEditor }), [resolvedEditor]);
+	return /* @__PURE__ */ jsx(EditorContext.Provider, {
+		value: legacyContextValue,
+		children: /* @__PURE__ */ jsx(TiptapContext.Provider, {
+			value: tiptapContextValue,
+			children
+		})
+	});
+}
+TiptapWrapper.displayName = "Tiptap";
+/**
+* Convenience component that renders `EditorContent` using the context-provided
+* editor instance. Use this instead of manually passing the `editor` prop.
+*
+* @param props - All `EditorContent` props except `editor` and `ref`.
+* @returns An `EditorContent` element bound to the context editor.
+*
+* @example
+* ```tsx
+* // inside a Tiptap provider
+* <Tiptap.Content className="editor" />
+* ```
+*/
+function TiptapContent({ ...rest }) {
+	const { editor } = useTiptap();
+	return /* @__PURE__ */ jsx(EditorContent, {
+		editor,
+		...rest
+	});
+}
+TiptapContent.displayName = "Tiptap.Content";
+/**
+* Root `Tiptap` component. Use it as the provider for all child components.
+*
+* The exported object includes the `Content` subcomponent for rendering the
+* editor content area.
+*
+* This component provides both the new `TiptapContext` (accessed via `useTiptap()`)
+* and the legacy `EditorContext` (accessed via `useCurrentEditor()`) for
+* backwards compatibility.
+*
+* For bubble menus and floating menus, import them separately from
+* `@tiptap/react/menus` to keep floating-ui as an optional dependency.
+*
+* @example
+* ```tsx
+* import { Tiptap, useEditor } from '@tiptap/react'
+* import { BubbleMenu } from '@tiptap/react/menus'
+*
+* function App() {
+*   const editor = useEditor({ extensions: [...] })
+*
+*   return (
+*     <Tiptap editor={editor}>
+*       <Tiptap.Content />
+*       <BubbleMenu>
+*         <button onClick={() => editor.chain().focus().toggleBold().run()}>Bold</button>
+*       </BubbleMenu>
+*     </Tiptap>
+*   )
+* }
+* ```
+*/
+Object.assign(TiptapWrapper, { 
+/**
+* The Tiptap Content component that renders the EditorContent with the editor instance from the context.
+* @see TiptapContent
+*/
+Content: TiptapContent });
+
+export { Editor, EditorContent, EditorContext, NodeView, NodeViewWrapper, PureEditorContent, ReactNodeView, ReactNodeViewContext, ReactNodeViewRenderer, ReactRenderer, TiptapContent, TiptapContext, TiptapWrapper, createContentComponent, getRenderedAttributes, isAndroid, isTextSelection, isiOS, useCurrentEditor, useEditor, useEditorState, useReactNodeView, useTiptap };