@thomasfosterau/effect-richtext 0.0.0 → 0.1.0

package/dist/view/input.js

@@ -0,0 +1,704 @@
+import { Slice } from "../model/replace.js";
+import { NodeSelection, Selection, TextSelection } from "../state/selection.js";
+import { dropPoint } from "../transform/structure.js";
+import { android, chrome, chrome_version, gecko, ie, ie_version, ios, mac, safari, webkit_version, windows } from "./browser.js";
+import { captureKeyDown } from "./capturekeys.js";
+import { parseFromClipboard, serializeForClipboard } from "./clipboard.js";
+import { keyEvent, textNodeAfter, textNodeBefore } from "./dom.js";
+import { selectionBetween, selectionFromDOM, selectionToDOM } from "./selection.js";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Result from "effect/Result";
+// src/view/input.ts
+/**
+* DOM event handling.
+*
+* @internal
+*/
+const handlers = {};
+const editHandlers = {};
+const isPassiveEvent = (event) => event === "touchstart" || event === "touchmove";
+/** @internal */
+var InputState = class {
+	constructor() {
+		this.shiftKey = false;
+		this.mouseDown = null;
+		this.lastKeyCode = null;
+		this.lastKeyCodeTime = 0;
+		this.lastKeyDispatched = false;
+		this.lastClick = {
+			time: 0,
+			x: 0,
+			y: 0,
+			type: "",
+			button: 0
+		};
+		this.lastSelectionOrigin = null;
+		this.lastSelectionTime = 0;
+		this.lastIOSEnter = 0;
+		this.lastIOSEnterFallbackTimeout = -1;
+		this.lastFocus = 0;
+		this.lastTouch = 0;
+		this.lastChromeDelete = 0;
+		this.composing = false;
+		this.compositionNode = null;
+		this.composingTimeout = -1;
+		this.compositionNodes = [];
+		this.compositionEndedAt = -2e8;
+		this.compositionID = 1;
+		this.badSafariComposition = false;
+		this.compositionPendingChanges = 0;
+		this.domChangeCount = 0;
+		this.eventHandlers = Object.create(null);
+		this.hideSelectionGuard = null;
+	}
+};
+/** @internal */
+function initInput(view) {
+	for (const event in handlers) {
+		const handler = handlers[event];
+		view.dom.addEventListener(event, view.input.eventHandlers[event] = (event) => {
+			if (eventBelongsToView(view, event) && !runCustomHandler(view, event) && (view.editable || !(event.type in editHandlers))) handler(view, event);
+		}, isPassiveEvent(event) ? { passive: true } : void 0);
+	}
+	if (safari) view.dom.addEventListener("input", () => null);
+	ensureListeners(view);
+}
+function setSelectionOrigin(view, origin) {
+	view.input.lastSelectionOrigin = origin;
+	view.input.lastSelectionTime = Date.now();
+}
+/** @internal */
+function destroyInput(view) {
+	if (view.input.mouseDown) view.input.mouseDown.done();
+	view.domObserver.stop();
+	for (const type in view.input.eventHandlers) view.dom.removeEventListener(type, view.input.eventHandlers[type]);
+	clearTimeout(view.input.composingTimeout);
+	clearTimeout(view.input.lastIOSEnterFallbackTimeout);
+}
+/** @internal */
+function ensureListeners(view) {
+	view.someProp("handleDOMEvents", (currentHandlers) => {
+		for (const type in currentHandlers) if (!view.input.eventHandlers[type]) view.dom.addEventListener(type, view.input.eventHandlers[type] = (event) => runCustomHandler(view, event));
+	});
+}
+function runCustomHandler(view, event) {
+	return view.someProp("handleDOMEvents", (handlers) => {
+		const handler = handlers[event.type];
+		return handler ? view.runHandler(handler(view, event)) || event.defaultPrevented : false;
+	});
+}
+function eventBelongsToView(view, event) {
+	if (!event.bubbles) return true;
+	if (event.defaultPrevented) return false;
+	for (let node = event.target; node != view.dom; node = node.parentNode) if (!node || node.nodeType == 11 || node.pmViewDesc && node.pmViewDesc.stopEvent(event)) return false;
+	return true;
+}
+/** @internal */
+function dispatchEvent(view, event) {
+	if (!runCustomHandler(view, event) && handlers[event.type] && (view.editable || !(event.type in editHandlers))) handlers[event.type](view, event);
+}
+/**
+* Run `handleKeyDown` for `event` (or a synthesized Backspace / Enter key
+* event), at most once per physical key press and never during
+* composition (prosemirror-view 1.42.9).
+*
+* @internal
+*/
+function dispatchKey(view, event) {
+	if (view.input.lastKeyDispatched || view.composing) return false;
+	view.input.lastKeyDispatched = true;
+	const key = Predicate.isString(event) ? keyEvent(event == "Backspace" ? 8 : 13, event) : event;
+	return view.someHandler("handleKeyDown", (f) => f(view, key));
+}
+editHandlers.keydown = (view, _event) => {
+	const event = _event;
+	view.input.shiftKey = event.keyCode == 16 || event.shiftKey;
+	if (inOrNearComposition(view, event)) return;
+	view.input.lastKeyCode = event.keyCode;
+	view.input.lastKeyCodeTime = Date.now();
+	view.input.lastKeyDispatched = false;
+	if (android && chrome && event.keyCode == 13) return;
+	if (event.keyCode != 229) view.domObserver.forceFlush();
+	if (ios && event.keyCode == 13 && !event.ctrlKey && !event.altKey && !event.metaKey) {
+		const now = Date.now();
+		view.input.lastIOSEnter = now;
+		view.input.lastIOSEnterFallbackTimeout = setTimeout(() => {
+			if (view.input.lastIOSEnter == now) {
+				dispatchKey(view, "Enter");
+				view.input.lastIOSEnter = 0;
+			}
+		}, 200);
+	} else if (dispatchKey(view, event) || captureKeyDown(view, event)) event.preventDefault();
+	else setSelectionOrigin(view, "key");
+};
+editHandlers.keyup = (view, event) => {
+	if (event.keyCode == 16) view.input.shiftKey = false;
+};
+editHandlers.keypress = (view, _event) => {
+	const event = _event;
+	if (inOrNearComposition(view, event) || !event.charCode || event.ctrlKey && !event.altKey || mac && event.metaKey) return;
+	if (view.someHandler("handleKeyPress", (f) => f(view, event))) {
+		event.preventDefault();
+		return;
+	}
+	const sel = view.state.selection;
+	if (!(sel instanceof TextSelection) || !sel.$from.sameParent(sel.$to)) {
+		const text = String.fromCharCode(event.charCode);
+		const deflt = () => view.state.tr.insertTextUnsafe(text).scrollIntoView();
+		if (!/[\r\n]/.test(text) && !view.someHandler("handleTextInput", (f) => f(view, sel.$from.pos, sel.$to.pos, text, deflt))) view.dispatchInternal(deflt());
+		event.preventDefault();
+	}
+};
+function eventCoords(event) {
+	return {
+		left: event.clientX,
+		top: event.clientY
+	};
+}
+function isNear(event, click) {
+	const dx = click.x - event.clientX, dy = click.y - event.clientY;
+	return dx * dx + dy * dy < 100;
+}
+function runHandlerOnContext(view, propName, pos, inside, event) {
+	if (inside == -1) return false;
+	const $pos = view.state.doc.resolveUnsafe(inside);
+	for (let i = $pos.depth + 1; i > 0; i--) if (view.someHandler(propName, (f) => i > $pos.depth ? f(view, pos, $pos.nodeAfterOrNull, $pos.beforeUnsafe(i), event, true) : f(view, pos, $pos.node(i), $pos.beforeUnsafe(i), event, false))) return true;
+	return false;
+}
+function updateSelection(view, selection, origin) {
+	if (!view.focused) view.focus();
+	if (view.state.selection.eq(selection)) return;
+	const tr = view.state.tr.setSelectionUnsafe(selection);
+	if (origin == "pointer") tr.setMeta("pointer", true);
+	view.dispatchInternal(tr);
+}
+function selectClickedLeaf(view, inside) {
+	if (inside == -1) return false;
+	const $pos = view.state.doc.resolveUnsafe(inside), node = $pos.nodeAfterOrNull;
+	if (node && node.isAtom && NodeSelection.isSelectable(node)) {
+		updateSelection(view, new NodeSelection($pos), "pointer");
+		return true;
+	}
+	return false;
+}
+function selectClickedNode(view, inside) {
+	if (inside == -1) return false;
+	const sel = view.state.selection;
+	let selectedNode, selectAt;
+	if (sel instanceof NodeSelection) selectedNode = sel.node;
+	const $pos = view.state.doc.resolveUnsafe(inside);
+	for (let i = $pos.depth + 1; i > 0; i--) {
+		const node = i > $pos.depth ? $pos.nodeAfterOrNull : $pos.node(i);
+		if (NodeSelection.isSelectable(node)) {
+			if (selectedNode && sel.$from.depth > 0 && i >= sel.$from.depth && $pos.beforeUnsafe(sel.$from.depth + 1) == sel.$from.pos) selectAt = $pos.beforeUnsafe(sel.$from.depth);
+			else selectAt = $pos.beforeUnsafe(i);
+			break;
+		}
+	}
+	if (selectAt != null) {
+		updateSelection(view, NodeSelection.createUnsafe(view.state.doc, selectAt), "pointer");
+		return true;
+	} else return false;
+}
+function handleSingleClick(view, pos, inside, event, selectNode) {
+	return runHandlerOnContext(view, "handleClickOn", pos, inside, event) || view.someHandler("handleClick", (f) => f(view, pos, event)) || (selectNode ? selectClickedNode(view, inside) : selectClickedLeaf(view, inside));
+}
+function handleDoubleClick(view, pos, inside, event) {
+	return runHandlerOnContext(view, "handleDoubleClickOn", pos, inside, event) || view.someHandler("handleDoubleClick", (f) => f(view, pos, event));
+}
+function handleTripleClick(view, pos, inside, event) {
+	return runHandlerOnContext(view, "handleTripleClickOn", pos, inside, event) || view.someHandler("handleTripleClick", (f) => f(view, pos, event)) || defaultTripleClick(view, inside, event);
+}
+function defaultTripleClick(view, inside, event) {
+	if (event.button != 0) return false;
+	const found = selectionForTripleClick(view, inside, true), doc = view.state.doc;
+	if (Option.isNone(found)) return false;
+	const selection = found.value;
+	updateSelection(view, selection, "pointer");
+	if (selection instanceof TextSelection && doc.eq(view.state.doc)) view.input.mouseDown = new TripleClickDrag(view, selection);
+	return true;
+}
+function selectionForTripleClick(view, inside, selectNodes) {
+	const doc = view.state.doc;
+	if (inside == -1) return doc.inlineContent ? Option.some(TextSelection.createUnsafe(doc, 0, doc.content.size)) : Option.none();
+	const $pos = doc.resolveUnsafe(inside);
+	for (let i = $pos.depth + 1; i > 0; i--) {
+		const node = i > $pos.depth ? $pos.nodeAfterOrNull : $pos.node(i);
+		const nodePos = $pos.beforeUnsafe(i);
+		if (node.inlineContent) return Option.some(TextSelection.createUnsafe(doc, nodePos + 1, nodePos + 1 + node.content.size));
+		else if (selectNodes && NodeSelection.isSelectable(node)) return Option.some(NodeSelection.createUnsafe(doc, nodePos));
+	}
+	return Option.none();
+}
+function forceDOMFlush(view) {
+	return endComposition(view);
+}
+const selectNodeModifier = mac ? "metaKey" : "ctrlKey";
+handlers.mousedown = (view, _event) => {
+	const event = _event;
+	view.input.shiftKey = event.shiftKey;
+	const flushed = forceDOMFlush(view);
+	const now = Date.now();
+	let type = "singleClick";
+	if (now - view.input.lastClick.time < 500 && isNear(event, view.input.lastClick) && !event[selectNodeModifier] && view.input.lastClick.button == event.button) {
+		if (view.input.lastClick.type == "singleClick") type = "doubleClick";
+		else if (view.input.lastClick.type == "doubleClick") type = "tripleClick";
+	}
+	view.input.lastClick = {
+		time: now,
+		x: event.clientX,
+		y: event.clientY,
+		type,
+		button: event.button
+	};
+	if (view.input.mouseDown) view.input.mouseDown.done();
+	const pos = Option.getOrNull(view.posAtCoords(eventCoords(event)));
+	if (!pos) return;
+	if (type == "singleClick") view.input.mouseDown = new LeftMouseDown(view, pos, event, flushed);
+	else if ((type == "doubleClick" ? handleDoubleClick : handleTripleClick)(view, pos.pos, pos.inside, event)) event.preventDefault();
+	else setSelectionOrigin(view, "pointer");
+};
+var MouseDown = class {
+	constructor(view) {
+		this.view = view;
+		this.mightDrag = null;
+		view.root.addEventListener("mouseup", this.up = this.up.bind(this));
+		view.root.addEventListener("mousemove", this.move = this.move.bind(this));
+	}
+	up(_event) {
+		this.done();
+	}
+	move(event) {
+		if (event.buttons == 0) this.done();
+	}
+	done() {
+		this.view.root.removeEventListener("mouseup", this.up);
+		this.view.root.removeEventListener("mousemove", this.move);
+		if (this.view.input.mouseDown == this) this.view.input.mouseDown = null;
+	}
+	delaySelUpdate() {
+		return false;
+	}
+};
+var LeftMouseDown = class extends MouseDown {
+	constructor(view, pos, event, flushed) {
+		super(view);
+		this.pos = pos;
+		this.event = event;
+		this.flushed = flushed;
+		this.delayedSelectionSync = false;
+		this.startDoc = view.state.doc;
+		this.selectNode = event[selectNodeModifier];
+		this.allowDefault = event.shiftKey;
+		let targetNode, targetPos;
+		if (pos.inside > -1) {
+			targetNode = view.state.doc.nodeAtOrNull(pos.inside);
+			targetPos = pos.inside;
+		} else {
+			const $pos = view.state.doc.resolveUnsafe(pos.pos);
+			targetNode = $pos.parent;
+			targetPos = $pos.depth ? $pos.beforeUnsafe() : 0;
+		}
+		const target = flushed ? null : event.target;
+		const targetDesc = target ? view.docView.nearestDesc(target, true) : null;
+		this.target = targetDesc && targetDesc.nodeDOM.nodeType == 1 ? targetDesc.nodeDOM : null;
+		const { selection } = view.state;
+		if (event.button == 0 && (targetNode.type.spec.draggable && targetNode.type.spec.selectable !== false || selection instanceof NodeSelection && selection.from <= targetPos && selection.to > targetPos)) this.mightDrag = {
+			node: targetNode,
+			pos: targetPos,
+			addAttr: !!(this.target && !this.target.draggable),
+			setUneditable: !!(this.target && gecko && !this.target.hasAttribute("contentEditable"))
+		};
+		if (this.target && this.mightDrag && (this.mightDrag.addAttr || this.mightDrag.setUneditable)) {
+			this.view.domObserver.stop();
+			if (this.mightDrag.addAttr) this.target.draggable = true;
+			if (this.mightDrag.setUneditable) setTimeout(() => {
+				if (this.view.input.mouseDown == this) this.target.setAttribute("contentEditable", "false");
+			}, 20);
+			this.view.domObserver.start();
+		}
+		setSelectionOrigin(view, "pointer");
+	}
+	done() {
+		super.done();
+		if (this.mightDrag && this.target) {
+			this.view.domObserver.stop();
+			if (this.mightDrag.addAttr) this.target.removeAttribute("draggable");
+			if (this.mightDrag.setUneditable) this.target.removeAttribute("contentEditable");
+			this.view.domObserver.start();
+		}
+		if (this.delayedSelectionSync) setTimeout(() => {
+			if (!this.view.isDestroyed) selectionToDOM(this.view);
+		});
+	}
+	up(event) {
+		this.done();
+		if (!this.view.dom.contains(event.target)) return;
+		let pos = this.pos;
+		if (this.view.state.doc != this.startDoc) pos = Option.getOrNull(this.view.posAtCoords(eventCoords(event)));
+		this.updateAllowDefault(event);
+		if (this.allowDefault || !pos) setSelectionOrigin(this.view, "pointer");
+		else if (handleSingleClick(this.view, pos.pos, pos.inside, event, this.selectNode)) event.preventDefault();
+		else if (event.button == 0 && (this.flushed || safari && this.mightDrag && !this.mightDrag.node.isAtom || chrome && !this.view.state.selection.visible && Math.min(Math.abs(pos.pos - this.view.state.selection.from), Math.abs(pos.pos - this.view.state.selection.to)) <= 2)) {
+			updateSelection(this.view, Selection.near(this.view.state.doc.resolveUnsafe(pos.pos)), "pointer");
+			event.preventDefault();
+		} else setSelectionOrigin(this.view, "pointer");
+	}
+	move(event) {
+		this.updateAllowDefault(event);
+		setSelectionOrigin(this.view, "pointer");
+		super.move(event);
+	}
+	updateAllowDefault(event) {
+		if (!this.allowDefault && (Math.abs(this.event.x - event.clientX) > 4 || Math.abs(this.event.y - event.clientY) > 4)) this.allowDefault = true;
+	}
+	delaySelUpdate() {
+		if (!this.allowDefault) return false;
+		this.delayedSelectionSync = true;
+		return true;
+	}
+};
+var TripleClickDrag = class extends MouseDown {
+	constructor(view, startSelection) {
+		super(view);
+		this.startSelection = startSelection;
+		this.startDoc = view.state.doc;
+	}
+	move(event) {
+		if (event.buttons == 0 || this.view.isDestroyed || !this.view.state.doc.eq(this.startDoc)) {
+			this.done();
+			return;
+		}
+		event.preventDefault();
+		setSelectionOrigin(this.view, "pointer");
+		const found = Option.flatMap(this.view.posAtCoords(eventCoords(event)), (pos) => selectionForTripleClick(this.view, pos.inside, false));
+		if (Option.isNone(found)) return;
+		const target = found.value;
+		const { doc } = this.view.state, start = this.startSelection;
+		const [anchor, head] = target.from < start.from ? [start.to, target.from] : [start.from, target.to];
+		updateSelection(this.view, TextSelection.createUnsafe(doc, anchor, head), "pointer");
+	}
+};
+handlers.touchstart = (view) => {
+	view.input.lastTouch = Date.now();
+	forceDOMFlush(view);
+	setSelectionOrigin(view, "pointer");
+};
+handlers.touchmove = (view) => {
+	view.input.lastTouch = Date.now();
+	setSelectionOrigin(view, "pointer");
+};
+handlers.contextmenu = (view) => forceDOMFlush(view);
+function inOrNearComposition(view, _event) {
+	if (view.composing) return true;
+	if (safari && Math.abs(Date.now() - view.input.compositionEndedAt) < 500) {
+		view.input.compositionEndedAt = -2e8;
+		return true;
+	}
+	return false;
+}
+const timeoutComposition = android ? 5e3 : -1;
+function needsMarkCursor(view) {
+	const { state } = view, $pos = state.selection.$to;
+	if (!(state.selection instanceof TextSelection) || !state.selection.empty) return false;
+	return !!(state.storedMarksOrNull || !$pos.textOffset && $pos.parentOffset && $pos.nodeBeforeOrNull.marks.some((m) => m.type.spec.inclusive === false) || chrome && windows && selectionBeforeUneditable(view));
+}
+editHandlers.compositionstart = editHandlers.compositionupdate = (view) => {
+	if (!view.composing) {
+		view.domObserver.flush();
+		const { state } = view, $pos = state.selection.$to;
+		if (needsMarkCursor(view)) {
+			view.markCursor = view.state.storedMarksOrNull || $pos.marks();
+			endComposition(view, true);
+			view.markCursor = null;
+		} else {
+			endComposition(view, !state.selection.empty);
+			if (gecko && state.selection.empty && $pos.parentOffset && !$pos.textOffset && $pos.nodeBeforeOrNull.marks.length) {
+				const sel = view.domSelectionRange();
+				for (let node = sel.focusNode, offset = sel.focusOffset; node && node.nodeType == 1 && offset != 0;) {
+					const before = offset < 0 ? node.lastChild : node.childNodes[offset - 1];
+					if (!before) break;
+					if (before.nodeType == 3) {
+						const sel = view.domSelection();
+						if (sel) sel.collapse(before, before.nodeValue.length);
+						break;
+					} else {
+						node = before;
+						offset = -1;
+					}
+				}
+			}
+		}
+		view.input.composing = true;
+	}
+	scheduleComposeEnd(view, timeoutComposition);
+};
+function selectionBeforeUneditable(view) {
+	const { focusNode, focusOffset } = view.domSelectionRange();
+	if (!focusNode || focusNode.nodeType != 1 || focusOffset >= focusNode.childNodes.length) return false;
+	const next = focusNode.childNodes[focusOffset];
+	return next.nodeType == 1 && next.contentEditable == "false";
+}
+editHandlers.compositionend = (view, _event) => {
+	if (view.composing) {
+		view.input.composing = false;
+		view.input.compositionEndedAt = Date.now();
+		view.input.compositionPendingChanges = view.domObserver.pendingRecords().length ? view.input.compositionID : 0;
+		view.input.compositionNode = null;
+		if (view.input.badSafariComposition) view.domObserver.forceFlush();
+		else if (view.input.compositionPendingChanges) Promise.resolve().then(() => view.domObserver.flush());
+		view.input.compositionID++;
+		scheduleComposeEnd(view, 20);
+	}
+};
+function scheduleComposeEnd(view, delay) {
+	clearTimeout(view.input.composingTimeout);
+	if (delay > -1) view.input.composingTimeout = setTimeout(() => endComposition(view), delay);
+}
+/** @internal */
+function clearComposition(view) {
+	if (view.composing) {
+		view.input.composing = false;
+		view.input.compositionEndedAt = Date.now();
+	}
+	while (Arr.isArrayNonEmpty(view.input.compositionNodes)) view.input.compositionNodes.pop().markParentsDirty();
+}
+/** @internal */
+function findCompositionNode(view) {
+	const sel = view.domSelectionRange();
+	if (!sel.focusNode) return null;
+	const textBefore = textNodeBefore(sel.focusNode, sel.focusOffset);
+	const textAfter = textNodeAfter(sel.focusNode, sel.focusOffset);
+	if (textBefore && textAfter && textBefore != textAfter) {
+		const descAfter = textAfter.pmViewDesc, lastChanged = view.domObserver.lastChangedTextNode;
+		if (textBefore == lastChanged || textAfter == lastChanged) return lastChanged;
+		if (!descAfter || !descAfter.isText(textAfter.nodeValue)) return textAfter;
+		else if (view.input.compositionNode == textAfter) {
+			const descBefore = textBefore.pmViewDesc;
+			if (!(!descBefore || !descBefore.isText(textBefore.nodeValue))) return textAfter;
+		}
+	}
+	return textBefore || textAfter;
+}
+/** @internal */
+function endComposition(view, restarting = false) {
+	if (android && view.domObserver.flushingSoon >= 0) return false;
+	view.domObserver.forceFlush();
+	clearComposition(view);
+	if (restarting || view.docView && view.docView.dirty) {
+		const sel = selectionFromDOM(view), cur = view.state.selection;
+		if (sel && !sel.eq(cur)) view.dispatchInternal(view.state.tr.setSelectionUnsafe(sel));
+		else if ((view.markCursor || restarting) && !cur.$from.node(cur.$from.sharedDepth(cur.to)).inlineContent) view.dispatchInternal(view.state.tr.deleteSelection());
+		else view.updateState(view.state);
+		return true;
+	}
+	return false;
+}
+function captureCopy(view, dom) {
+	if (!view.dom.parentNode) return;
+	const wrap = view.dom.parentNode.appendChild(document.createElement("div"));
+	wrap.appendChild(dom);
+	wrap.style.cssText = "position: fixed; left: -10000px; top: 10px";
+	const sel = getSelection(), range = document.createRange();
+	range.selectNodeContents(dom);
+	view.dom.blur();
+	sel.removeAllRanges();
+	sel.addRange(range);
+	setTimeout(() => {
+		if (wrap.parentNode) wrap.parentNode.removeChild(wrap);
+		view.focus();
+	}, 50);
+}
+const brokenClipboardAPI = ie && ie_version < 15 || ios && webkit_version < 604;
+handlers.copy = editHandlers.cut = (view, _event) => {
+	const event = _event;
+	const sel = view.state.selection, cut = event.type == "cut";
+	if (sel.empty) return;
+	const data = brokenClipboardAPI ? null : event.clipboardData;
+	const slice = sel.content(), { dom, text } = serializeForClipboard(view, slice);
+	if (data) {
+		event.preventDefault();
+		data.clearData();
+		data.setData("text/html", dom.innerHTML);
+		data.setData("text/plain", text);
+	} else captureCopy(view, dom);
+	if (cut) view.dispatchInternal(view.state.tr.deleteSelection().scrollIntoView().setMeta("uiEvent", "cut"));
+};
+function sliceSingleNode(slice) {
+	return slice.openStart == 0 && slice.openEnd == 0 && slice.content.childCount == 1 ? slice.content.content[0] : null;
+}
+function capturePaste(view, event) {
+	if (!view.dom.parentNode) return;
+	const plainText = view.input.shiftKey || view.state.selection.$from.parent.type.spec.code;
+	const target = view.dom.parentNode.appendChild(document.createElement(plainText ? "textarea" : "div"));
+	if (!plainText) target.contentEditable = "true";
+	target.style.cssText = "position: fixed; left: -10000px; top: 10px";
+	target.focus();
+	const plain = view.input.shiftKey && view.input.lastKeyCode != 45;
+	setTimeout(() => {
+		view.focus();
+		if (target.parentNode) target.parentNode.removeChild(target);
+		if (plainText) doPaste(view, target.value, null, plain, event);
+		else doPaste(view, target.textContent, target.innerHTML, plain, event);
+	}, 50);
+}
+/** @internal */
+function doPaste(view, text, html, preferPlain, event) {
+	const slice = parseFromClipboard(view, text, html, preferPlain, view.state.selection.$from);
+	if (view.someHandler("handlePaste", (f) => f(view, event, slice || Slice.empty))) return true;
+	if (!slice) return false;
+	const singleNode = sliceSingleNode(slice);
+	const tr = singleNode ? view.state.tr.replaceSelectionWith(singleNode, preferPlain) : view.state.tr.replaceSelection(slice);
+	view.dispatchInternal(tr.scrollIntoView().setMeta("paste", true).setMeta("uiEvent", "paste"));
+	return true;
+}
+function getText(clipboardData) {
+	const text = clipboardData.getData("text/plain") || clipboardData.getData("Text");
+	if (text) return text;
+	const uris = clipboardData.getData("text/uri-list");
+	return uris ? uris.replace(/\r?\n/g, " ") : "";
+}
+editHandlers.paste = (view, _event) => {
+	const event = _event;
+	if (view.composing && !android) return;
+	const data = brokenClipboardAPI ? null : event.clipboardData;
+	const plain = view.input.shiftKey && view.input.lastKeyCode != 45;
+	if (data && doPaste(view, getText(data), data.getData("text/html"), plain, event)) event.preventDefault();
+	else capturePaste(view, event);
+};
+/** @internal */
+var Dragging = class {
+	constructor(slice, move, node) {
+		this.slice = slice;
+		this.move = move;
+		this.node = node;
+	}
+};
+const dragCopyModifier = mac ? "altKey" : "ctrlKey";
+function dragMoves(view, event) {
+	let asked = false, copy = false;
+	view.someProp("dragCopies", (test) => {
+		asked = true;
+		copy = copy || test(event);
+	});
+	return asked ? !copy : !event[dragCopyModifier];
+}
+handlers.dragstart = (view, _event) => {
+	const event = _event;
+	const mouseDown = view.input.mouseDown;
+	if (mouseDown) mouseDown.done();
+	if (!event.dataTransfer) return;
+	const sel = view.state.selection;
+	const pos = sel.empty ? null : Option.getOrNull(view.posAtCoords(eventCoords(event)));
+	let node;
+	if (pos && pos.pos >= sel.from && pos.pos <= (sel instanceof NodeSelection ? sel.to - 1 : sel.to)) {} else if (mouseDown && mouseDown.mightDrag) node = NodeSelection.createUnsafe(view.state.doc, mouseDown.mightDrag.pos);
+	else if (event.target && event.target.nodeType == 1) {
+		const desc = view.docView.nearestDesc(event.target, true);
+		if (desc && desc.node.type.spec.draggable && desc != view.docView) node = NodeSelection.createUnsafe(view.state.doc, desc.posBefore);
+	}
+	const draggedSlice = (node || view.state.selection).content();
+	const { dom, slice, text } = serializeForClipboard(view, draggedSlice);
+	if (!event.dataTransfer.files.length || !chrome || chrome_version > 120) event.dataTransfer.clearData();
+	event.dataTransfer.setData(brokenClipboardAPI ? "Text" : "text/html", dom.innerHTML);
+	event.dataTransfer.effectAllowed = "copyMove";
+	if (!brokenClipboardAPI) event.dataTransfer.setData("text/plain", text);
+	view.dragging = new Dragging(slice, dragMoves(view, event), node);
+};
+handlers.dragend = (view) => {
+	const dragging = view.dragging;
+	window.setTimeout(() => {
+		if (view.dragging == dragging) view.dragging = null;
+	}, 50);
+};
+editHandlers.dragover = editHandlers.dragenter = (_, e) => e.preventDefault();
+editHandlers.drop = (view, event) => {
+	const result = Result.try(() => handleDrop(view, event, view.dragging));
+	view.dragging = null;
+	if (Result.isFailure(result)) throw result.failure;
+};
+function handleDrop(view, event, dragging) {
+	if (!event.dataTransfer) return;
+	const eventPos = Option.getOrNull(view.posAtCoords(eventCoords(event)));
+	if (!eventPos) return;
+	const $mouse = view.state.doc.resolveUnsafe(eventPos.pos);
+	let slice = dragging && dragging.slice;
+	if (slice) view.someProp("transformPasted", (f) => {
+		slice = f(slice, view, false);
+	});
+	else slice = parseFromClipboard(view, getText(event.dataTransfer), brokenClipboardAPI ? null : event.dataTransfer.getData("text/html"), false, $mouse);
+	const move = !!(dragging && dragMoves(view, event));
+	if (view.someHandler("handleDrop", (f) => f(view, event, slice || Slice.empty, move))) {
+		event.preventDefault();
+		return;
+	}
+	if (!slice) return;
+	event.preventDefault();
+	let insertPos = slice ? Option.getOrNull(dropPoint(view.state.doc, $mouse.pos, slice)) : $mouse.pos;
+	if (insertPos == null) insertPos = $mouse.pos;
+	const tr = view.state.tr;
+	if (move) {
+		const { node } = dragging;
+		if (node) node.replace(tr);
+		else tr.deleteSelection();
+	}
+	const pos = tr.mapping.map(insertPos);
+	const isNode = slice.openStart == 0 && slice.openEnd == 0 && slice.content.childCount == 1;
+	const beforeInsert = tr.doc;
+	if (isNode) tr.replaceRangeWithUnsafe(pos, pos, slice.content.content[0]);
+	else tr.replaceRangeUnsafe(pos, pos, slice);
+	if (tr.doc.eq(beforeInsert)) return;
+	const $pos = tr.doc.resolveUnsafe(pos);
+	if (isNode && NodeSelection.isSelectable(slice.content.content[0]) && $pos.nodeAfterOrNull && $pos.nodeAfterOrNull.sameMarkup(slice.content.content[0])) tr.setSelectionUnsafe(new NodeSelection($pos));
+	else {
+		let end = tr.mapping.map(insertPos);
+		tr.mapping.maps[tr.mapping.maps.length - 1].forEach((_from, _to, _newFrom, newTo) => end = newTo);
+		tr.setSelectionUnsafe(selectionBetween(view, $pos, tr.doc.resolveUnsafe(end)));
+	}
+	view.focus();
+	view.dispatchInternal(tr.setMeta("uiEvent", "drop"));
+}
+handlers.focus = (view) => {
+	view.input.lastFocus = Date.now();
+	if (!view.focused) {
+		view.domObserver.stop();
+		view.dom.classList.add("ProseMirror-focused");
+		view.domObserver.start();
+		view.focused = true;
+		const startSel = view.domSelectionRange();
+		if (!view.domObserver.currentSelection.eq(startSel)) {
+			const { focusNode, focusOffset } = startSel;
+			setTimeout(() => {
+				const newSel = view.domSelectionRange();
+				if (newSel.focusNode == focusNode && newSel.focusOffset == focusOffset && view.docView && view.hasFocus()) selectionToDOM(view);
+			}, 20);
+		}
+	}
+};
+handlers.blur = (view, _event) => {
+	const event = _event;
+	if (view.focused) {
+		view.domObserver.stop();
+		view.dom.classList.remove("ProseMirror-focused");
+		view.domObserver.start();
+		if (event.relatedTarget && view.dom.contains(event.relatedTarget)) view.domObserver.currentSelection.clear();
+		view.focused = false;
+	}
+};
+handlers.beforeinput = (view, _event) => {
+	if (android && _event.inputType == "deleteContentBackward") {
+		view.domObserver.flushSoon();
+		const { domChangeCount } = view.input;
+		setTimeout(() => {
+			if (view.input.domChangeCount != domChangeCount || view.domObserver.pendingRecords().length) return;
+			view.dom.blur();
+			view.focus();
+			if (dispatchKey(view, "Backspace")) return;
+			const $cursor = view.state.selection.$cursorOrNull;
+			if ($cursor && $cursor.pos > 0) view.dispatchInternal(view.state.tr.deleteUnsafe($cursor.pos - 1, $cursor.pos).scrollIntoView());
+		}, 50);
+	}
+};
+for (const prop in editHandlers) handlers[prop] = editHandlers[prop];
+export { Dragging, InputState, clearComposition, destroyInput, dispatchEvent, dispatchKey, doPaste, endComposition, ensureListeners, findCompositionNode, initInput };