@thomasfosterau/effect-richtext 0.0.0 → 0.1.0

package/dist/view/view.js

@@ -0,0 +1,623 @@
+import { NodeSelection } from "../state/selection.js";
+import { chrome, ie, safari } from "./browser.js";
+import { parseFromClipboard, serializeForClipboard } from "./clipboard.js";
+import { Decoration, viewDecorations } from "./decoration.js";
+import { clearReusedRange, deepActiveElement } from "./dom.js";
+import { readDOMChange } from "./domchange.js";
+import { coordsAtPos, endOfTextblock, focusPreventScroll, posAtCoords, resetScrollPos, scrollRectIntoView, storeScrollPos } from "./domcoords.js";
+import { DOMObserver, safariShadowSelectionRange } from "./domobserver.js";
+import { ViewError } from "./errors.js";
+import { Dragging, InputState, clearComposition, destroyInput, dispatchEvent, doPaste, endComposition, ensureListeners, findCompositionNode, initInput } from "./input.js";
+import { anchorInRightPlace, selectionToDOM, syncNodeSelection } from "./selection.js";
+import { docViewDesc } from "./viewdesc.js";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Cause from "effect/Cause";
+import * as Exit from "effect/Exit";
+import * as Context from "effect/Context";
+import { PreventSchedulerYield } from "effect/Scheduler";
+// src/view/view.ts
+/**
+* The editor view.
+*
+* @since 0.1.0
+*/
+/** @internal */
+const __parseFromClipboard = parseFromClipboard;
+/** @internal */
+const __endComposition = endComposition;
+/**
+* @since 0.1.0
+* @category symbols
+*/
+const EditorViewTypeId = Symbol.for("effect-richtext/view/EditorView");
+/**
+* An editor view manages the DOM structure that represents an editable
+* document. Its state and behavior are determined by its props.
+*
+* `R` and `E` are the requirements and errors of the effects the view
+* runs: those of its state's plugins and of its effectful props. Create
+* a view with `EditorView.make`, inside an Effect that provides `R` and a
+* `Scope`: the view captures the current context to run handler effects
+* later, and is destroyed when the scope closes.
+*
+* @since 0.1.0
+* @category models
+*/
+var EditorView = class EditorView {
+	/** @internal */
+	constructor(place, props, context) {
+		this._root = null;
+		this.focused = false;
+		this.trackWrites = null;
+		this.mounted = false;
+		this.markCursor = null;
+		this.cursorWrapper = null;
+		this.lastSelectedViewDesc = void 0;
+		this.input = new InputState();
+		this.prevDirectPlugins = [];
+		this.pluginViews = [];
+		this.listeners = [];
+		this.dispatching = null;
+		this.requiresGeckoHackNode = false;
+		this.dragging = null;
+		this.dispatch = (tr) => Effect.catchCause(this.tryDispatch(tr), (cause) => Effect.sync(() => this.reportError(cause)));
+		this.dispatchUnsafe = (tr) => {
+			const fiber = Effect.runForkWith(this.runContext)(this.tryDispatch(tr));
+			const exit = fiber.pollUnsafe();
+			if (exit) {
+				if (Exit.isFailure(exit)) throw Cause.squash(exit.cause);
+				return;
+			}
+			fiber.addObserver((exit) => {
+				if (Exit.isFailure(exit)) this.reportError(exit.cause);
+			});
+		};
+		this.context = context;
+		this.runContext = Context.add(context, PreventSchedulerYield, true);
+		this._props = props;
+		this.state = props.state;
+		this.directPlugins = props.plugins || [];
+		this.directPlugins.forEach(checkStateComponent);
+		this.dom = place && place.mount || document.createElement("div");
+		if (place) {
+			if (place.appendChild) place.appendChild(this.dom);
+			else if (typeof place == "function") place(this.dom);
+			else if (place.mount) this.mounted = true;
+		}
+		this.editable = getEditable(this);
+		updateCursorWrapper(this);
+		this.nodeViews = buildNodeViews(this);
+		this.docView = docViewDesc(this.state.doc, computeDocDeco(this), viewDecorations(this), this.dom, this);
+		this.domObserver = new DOMObserver(this, (from, to, typeOver, added) => readDOMChange(this, from, to, typeOver, added));
+		this.domObserver.start();
+		initInput(this);
+		this.updatePluginViews();
+	}
+	/**
+	* Create a view inside a scope. `place` may be a DOM node that the
+	* editor should be appended to, a function that will place it into the
+	* document, or an object whose `mount` property holds the node to use
+	* as the document container. If it is `null`, the editor will not be
+	* added to the document.
+	*
+	* The view captures the current context (which must provide `R`) to
+	* run the effects of its plugins and props, and is destroyed when the
+	* scope closes.
+	*
+	* When props' handlers require services that the state's plugins
+	* don't, pass the type arguments explicitly
+	* (`EditorView.make<typeof schema, ServiceA | ServiceB>(...)`).
+	*/
+	static make(place, props) {
+		return Effect.acquireRelease(Effect.flatMap(Effect.context(), (context) => Effect.sync(() => new EditorView(place, props, context))), (view) => Effect.sync(() => view.destroy()));
+	}
+	static makeUnsafe(place, props, context) {
+		return new EditorView(place, props, context ?? Context.empty());
+	}
+	/** Holds `true` when a composition is active. */
+	get composing() {
+		return this.input.composing;
+	}
+	/** The view's current props. */
+	get props() {
+		if (this._props.state != this.state) {
+			const prev = this._props;
+			this._props = {};
+			for (const name in prev) this._props[name] = prev[name];
+			this._props.state = this.state;
+		}
+		return this._props;
+	}
+	/** Update the view's props. Will immediately cause an update to the DOM. */
+	update(props) {
+		if (props.handleDOMEvents != this._props.handleDOMEvents) ensureListeners(this);
+		const prevProps = this._props;
+		this._props = props;
+		if (props.plugins) {
+			props.plugins.forEach(checkStateComponent);
+			this.directPlugins = props.plugins;
+		}
+		this.updateStateInner(props.state, prevProps);
+	}
+	/**
+	* Update the view by updating existing props object with the object
+	* given as argument. Equivalent to
+	* `view.update(Object.assign({}, view.props, props))`.
+	*/
+	setProps(props) {
+		const updated = {};
+		for (const name in this._props) updated[name] = this._props[name];
+		updated.state = this.state;
+		for (const name in props) updated[name] = props[name];
+		this.update(updated);
+	}
+	/** Update the editor's `state` prop, without touching any of the other props. */
+	updateState(state) {
+		this.updateStateInner(state, this._props);
+	}
+	updateStateInner(state, prevProps) {
+		const prev = this.state;
+		const transactions = this.dispatching ?? [];
+		this.dispatching = null;
+		let redraw = false, updateSel = false;
+		if (state.storedMarksOrNull && this.composing) {
+			clearComposition(this);
+			updateSel = true;
+		}
+		this.state = state;
+		const pluginsChanged = prev.plugins != state.plugins || this._props.plugins != prevProps.plugins;
+		if (pluginsChanged || this._props.plugins != prevProps.plugins || this._props.nodeViews != prevProps.nodeViews) {
+			const nodeViews = buildNodeViews(this);
+			if (changedNodeViews(nodeViews, this.nodeViews)) {
+				this.nodeViews = nodeViews;
+				redraw = true;
+			}
+		}
+		if (pluginsChanged || prevProps.handleDOMEvents != this._props.handleDOMEvents) ensureListeners(this);
+		this.editable = getEditable(this);
+		updateCursorWrapper(this);
+		const innerDeco = viewDecorations(this), outerDeco = computeDocDeco(this);
+		const scroll = prev.plugins != state.plugins && !prev.doc.eq(state.doc) ? "reset" : state.scrollToSelection > prev.scrollToSelection ? "to selection" : "preserve";
+		const updateDoc = redraw || !this.docView.matchesNode(state.doc, outerDeco, innerDeco);
+		if (updateDoc || !state.selection.eq(prev.selection)) updateSel = true;
+		const oldScrollPos = scroll == "preserve" && updateSel && this.dom.style.overflowAnchor == null && storeScrollPos(this);
+		if (updateSel) {
+			this.domObserver.stop();
+			let forceSelUpdate = updateDoc && (ie || chrome) && !this.composing && !prev.selection.empty && !state.selection.empty && selectionContextChanged(prev.selection, state.selection);
+			if (updateDoc) {
+				const chromeKludge = chrome ? this.trackWrites = this.domSelectionRange().focusNode : null;
+				if (this.composing) this.input.compositionNode = findCompositionNode(this);
+				if (redraw || !this.docView.update(state.doc, outerDeco, innerDeco, this)) {
+					this.docView.updateOuterDeco(outerDeco);
+					this.docView.destroy();
+					this.docView = docViewDesc(state.doc, outerDeco, innerDeco, this.dom, this);
+				}
+				if (chromeKludge && (!this.trackWrites || !this.dom.contains(this.trackWrites))) forceSelUpdate = true;
+			}
+			if (forceSelUpdate || !(this.input.mouseDown && this.domObserver.currentSelection.eq(this.domSelectionRange()) && anchorInRightPlace(this) && this.input.mouseDown.delaySelUpdate())) selectionToDOM(this, forceSelUpdate);
+			else {
+				syncNodeSelection(this, state.selection);
+				this.domObserver.setCurSelection();
+			}
+			this.domObserver.start();
+		}
+		this.updatePluginViews(prev);
+		if (this.dragging?.node && !prev.doc.eq(state.doc)) this.updateDraggedNode(this.dragging, prev);
+		if (scroll == "reset") this.dom.scrollTop = 0;
+		else if (scroll == "to selection") this.scrollToSelection();
+		else if (oldScrollPos) resetScrollPos(oldScrollPos);
+		if (this.listeners.length) this.notifyListeners({
+			state,
+			prevState: prev,
+			transactions
+		});
+	}
+	notifyListeners(update) {
+		const listeners = this.listeners;
+		for (let i = 0; i < listeners.length; i++) try {
+			listeners[i](update);
+		} catch (e) {
+			this.reportError(Cause.die(e));
+		}
+	}
+	/**
+	* Register a listener called after every state update of the view
+	* (once the DOM and plugin views have been updated). Returns a
+	* function that removes the listener. Exceptions thrown by listeners
+	* are reported to `onError`.
+	*/
+	subscribe(listener) {
+		this.listeners = [...this.listeners, listener];
+		return () => {
+			this.listeners = this.listeners.filter((l) => l !== listener);
+		};
+	}
+	withDispatching(transactions, f) {
+		const prev = this.dispatching;
+		this.dispatching = transactions;
+		try {
+			return f();
+		} finally {
+			this.dispatching = prev;
+		}
+	}
+	/** @internal */
+	scrollToSelection() {
+		const startDOM = this.domSelectionRange().focusNode;
+		if (!startDOM || !this.dom.contains(startDOM.nodeType == 1 ? startDOM : startDOM.parentNode)) {} else if (this.someHandler("handleScrollToSelection", (f) => f(this))) {} else if (this.state.selection instanceof NodeSelection) {
+			const target = this.docView.domAfterPos(this.state.selection.from);
+			if (target.nodeType == 1) scrollRectIntoView(this, target.getBoundingClientRect(), startDOM);
+		} else scrollRectIntoView(this, this.coordsAtPos(this.state.selection.head, 1), startDOM);
+	}
+	destroyPluginViews() {
+		let view;
+		while (view = this.pluginViews.pop()) if (view.destroy) view.destroy();
+	}
+	updatePluginViews(prevState) {
+		if (!prevState || prevState.plugins != this.state.plugins || this.directPlugins != this.prevDirectPlugins) {
+			this.prevDirectPlugins = this.directPlugins;
+			this.destroyPluginViews();
+			for (let i = 0; i < this.directPlugins.length; i++) {
+				const plugin = this.directPlugins[i];
+				if (plugin.spec.view) this.pluginViews.push(plugin.spec.view(this));
+			}
+			for (let i = 0; i < this.state.plugins.length; i++) {
+				const plugin = this.state.plugins[i];
+				if (plugin.spec.view) this.pluginViews.push(plugin.spec.view(this));
+			}
+		} else for (let i = 0; i < this.pluginViews.length; i++) {
+			const pluginView = this.pluginViews[i];
+			if (pluginView.update) pluginView.update(this, prevState);
+		}
+	}
+	updateDraggedNode(dragging, prev) {
+		const sel = dragging.node;
+		let found = -1;
+		if (sel.from < this.state.doc.content.size && this.state.doc.nodeAtOrNull(sel.from) == sel.node) found = sel.from;
+		else {
+			const movedPos = sel.from + (this.state.doc.content.size - prev.doc.content.size);
+			if ((movedPos > 0 && movedPos < this.state.doc.content.size && this.state.doc.nodeAtOrNull(movedPos)) == sel.node) found = movedPos;
+		}
+		this.dragging = new Dragging(dragging.slice, dragging.move, found < 0 ? void 0 : NodeSelection.createUnsafe(this.state.doc, found));
+	}
+	someProp(propName, f) {
+		const prop = this._props && this._props[propName];
+		let value;
+		if (prop != null && (value = f ? f(prop) : prop)) return value;
+		for (let i = 0; i < this.directPlugins.length; i++) {
+			const prop = this.directPlugins[i].props[propName];
+			if (prop != null && (value = f ? f(prop) : prop)) return value;
+		}
+		const plugins = this.state.plugins;
+		if (plugins) for (let i = 0; i < plugins.length; i++) {
+			const prop = plugins[i].props[propName];
+			if (prop != null && (value = f ? f(prop) : prop)) return value;
+		}
+	}
+	/**
+	* Like `someProp`, but for event handler props, whose results may be
+	* Effects: those are run (see `HandlerResult`) and their results used.
+	*
+	* @internal
+	*/
+	someHandler(propName, f) {
+		return !!this.someProp(propName, (h) => this.runHandler(f(h)));
+	}
+	/**
+	* Interpret the result of an event handler prop, running it with the
+	* view's context when it is an Effect.
+	*
+	* @internal
+	*/
+	runHandler(result) {
+		if (!Effect.isEffect(result)) return !!result;
+		if (Exit.isExit(result)) {
+			if (Exit.isSuccess(result)) return !!result.value;
+			this.reportError(result.cause);
+			return false;
+		}
+		const exit = this.runEffect(result);
+		if (exit === void 0) return true;
+		return Exit.isSuccess(exit) ? !!exit.value : false;
+	}
+	/**
+	* Run an effect with the view's captured context. Returns its exit
+	* when it completed synchronously (reporting failures to `onError`),
+	* or `undefined` when it is still running in the background (in which
+	* case failures are reported when it completes).
+	*
+	* @internal
+	*/
+	runEffect(effect) {
+		const fiber = Effect.runForkWith(this.runContext)(effect);
+		const exit = fiber.pollUnsafe();
+		if (exit) {
+			if (Exit.isFailure(exit)) this.reportError(exit.cause);
+			return exit;
+		}
+		fiber.addObserver((exit) => {
+			if (Exit.isFailure(exit)) this.reportError(exit.cause);
+		});
+	}
+	/** @internal */
+	reportError(cause) {
+		const onError = this._props.onError;
+		if (onError) onError(cause);
+		else Effect.runForkWith(this.context)(Effect.logError(cause));
+	}
+	/** Query whether the view has focus. */
+	hasFocus() {
+		if (ie) {
+			let node = this.root.activeElement;
+			if (node == this.dom) return true;
+			if (!node || !this.dom.contains(node)) return false;
+			while (node && this.dom != node && this.dom.contains(node)) {
+				if (node.contentEditable == "false") return false;
+				node = node.parentElement;
+			}
+			return true;
+		}
+		return this.root.activeElement == this.dom;
+	}
+	/** Focus the editor. */
+	focus() {
+		this.domObserver.stop();
+		if (this.editable) focusPreventScroll(this.dom);
+		selectionToDOM(this);
+		this.domObserver.start();
+	}
+	/**
+	* Get the document root in which the editor exists. This will usually
+	* be the top-level `document`, but might be a shadow DOM root if the
+	* editor is inside one.
+	*/
+	get root() {
+		const cached = this._root;
+		if (cached == null) {
+			for (let search = this.dom.parentNode; search; search = search.parentNode) if (search.nodeType == 9 || search.nodeType == 11 && search.host) {
+				if (!search.getSelection) Object.getPrototypeOf(search).getSelection = () => search.ownerDocument.getSelection();
+				return this._root = search;
+			}
+		}
+		return cached || document;
+	}
+	/**
+	* When an existing editor view is moved to a new document or shadow
+	* tree, call this to make it recompute its root.
+	*/
+	updateRoot() {
+		this._root = null;
+	}
+	/**
+	* Given a pair of viewport coordinates, return the document position
+	* that corresponds to them. Returns `None` if the given coordinates
+	* aren't inside of the editor.
+	*/
+	posAtCoords(coords) {
+		return Option.fromNullishOr(posAtCoords(this, coords));
+	}
+	/**
+	* Returns the viewport rectangle at a given document position. `left`
+	* and `right` will be the same number, as this returns a flat
+	* cursor-ish rectangle. If the position is between two things that
+	* aren't directly adjacent, `side` determines which element is used.
+	* When < 0, the element before the position is used, otherwise the
+	* element after.
+	*/
+	coordsAtPos(pos, side = 1) {
+		return coordsAtPos(this, pos, side);
+	}
+	/**
+	* Find the DOM position that corresponds to the given document
+	* position. When `side` is negative, find the position as close as
+	* possible to the content before the position. When positive, prefer
+	* positions close to the content after the position. When zero,
+	* prefer as shallow a position as possible.
+	*
+	* Note that you should **not** mutate the editor's internal DOM, only
+	* inspect it (and even that is usually not necessary).
+	*/
+	domAtPos(pos, side = 0) {
+		return this.docView.domFromPos(pos, side);
+	}
+	/**
+	* Find the DOM node that represents the document node after the given
+	* position. Returns `None` when the position doesn't point in front of
+	* a node or if the node is inside an opaque node view.
+	*
+	* This is intended to be able to call things like
+	* `getBoundingClientRect` on that DOM node. Do **not** mutate the
+	* editor DOM directly, or add styling this way, since that will be
+	* immediately overriden by the editor as it redraws the node.
+	*/
+	nodeDOM(pos) {
+		const desc = this.docView.descAt(pos);
+		return Option.fromNullishOr(desc ? desc.nodeDOM : null);
+	}
+	/**
+	* Find the document position that corresponds to a given DOM position.
+	* (Whenever possible, it is preferable to inspect the document
+	* structure directly, rather than poking around in the DOM, but
+	* sometimes—for example when interpreting an event target—you don't
+	* have a choice.)
+	*
+	* The `bias` parameter can be used to influence which side of a DOM
+	* node to use when the position is inside a leaf node. Fails with a
+	* `ViewError` when the DOM position is not inside the editor.
+	*/
+	posAtDOM(node, offset, bias = -1) {
+		return Effect.suspend(() => {
+			const pos = this.docView.posFromDOM(node, offset, bias);
+			return pos == null || pos < 0 ? Effect.fail(new ViewError({ message: "DOM position not inside the editor" })) : Effect.succeed(pos);
+		});
+	}
+	/** Like `posAtDOM`, but throws a `ViewError` when the position is not inside the editor. */
+	posAtDOMUnsafe(node, offset, bias = -1) {
+		const pos = this.docView.posFromDOM(node, offset, bias);
+		if (pos == null || pos < 0) throw new ViewError({ message: "DOM position not inside the editor" });
+		return pos;
+	}
+	/**
+	* Find out whether the selection is at the end of a textblock when
+	* moving in a given direction. When, for example, given `"left"`, it
+	* will return true if moving left from the current cursor position
+	* would leave that position's parent textblock. Will apply to the
+	* view's current state by default, but it is possible to pass a
+	* different state.
+	*/
+	endOfTextblock(dir, state) {
+		return endOfTextblock(this, state || this.state, dir);
+	}
+	/**
+	* Run the editor's paste logic with the given HTML string. The
+	* `event`, if given, will be passed to the `handlePaste` hook.
+	*/
+	pasteHTML(html, event) {
+		return doPaste(this, "", html, false, event || new ClipboardEvent("paste"));
+	}
+	/** Run the editor's paste logic with the given plain-text input. */
+	pasteText(text, event) {
+		return doPaste(this, text, null, true, event || new ClipboardEvent("paste"));
+	}
+	/**
+	* Serialize the given slice as it would be if it was copied from this
+	* editor. Returns a DOM element that contains a representation of the
+	* slice as its children, a textual representation, and the
+	* transformed slice (which can be different from the given input due
+	* to hooks like `transformCopied`).
+	*/
+	serializeForClipboard(slice) {
+		return serializeForClipboard(this, slice);
+	}
+	/** Removes the editor from the DOM and destroys all node views. */
+	destroy() {
+		if (!this.docView) return;
+		destroyInput(this);
+		this.destroyPluginViews();
+		if (this.mounted) {
+			this.docView.update(this.state.doc, [], viewDecorations(this), this);
+			this.dom.textContent = "";
+		} else if (this.dom.parentNode) this.dom.parentNode.removeChild(this.dom);
+		this.docView.destroy();
+		this.docView = null;
+		clearReusedRange();
+	}
+	/**
+	* This is true when the view has been destroyed (and thus should not
+	* be used anymore).
+	*/
+	get isDestroyed() {
+		return this.docView == null;
+	}
+	/** Used for testing. */
+	dispatchEvent(event) {
+		return dispatchEvent(this, event);
+	}
+	/**
+	* Like `dispatch`, but fails with the errors of the plugin hooks and
+	* of `dispatchTransaction` instead of reporting them to `onError`.
+	* Runs with the view's captured context.
+	*/
+	tryDispatch(tr) {
+		return Effect.provideContext(Effect.suspend(() => {
+			const dispatchTransaction = this._props.dispatchTransaction;
+			if (dispatchTransaction) {
+				const result = this.withDispatching([tr], () => dispatchTransaction.call(this, tr));
+				if (!Effect.isEffect(result)) return Effect.void;
+				return Effect.suspend(() => {
+					const transactions = [tr];
+					this.dispatching = transactions;
+					return Effect.ensuring(result, Effect.sync(() => {
+						if (this.dispatching === transactions) this.dispatching = null;
+					}));
+				});
+			}
+			return Effect.map(this.state.applyTransaction(tr), (result) => this.withDispatching(result.transactions, () => this.updateState(result.state)));
+		}), this.context);
+	}
+	/**
+	* Dispatch a transaction on behalf of a DOM event: like
+	* `dispatchUnsafe`, but failures are reported to `onError` instead of
+	* thrown.
+	*
+	* @internal
+	*/
+	dispatchInternal(tr) {
+		this.runEffect(this.tryDispatch(tr));
+	}
+	/** @internal */
+	domSelectionRange() {
+		const sel = this.dom.isConnected && this.domSelection();
+		if (!sel) return {
+			focusNode: null,
+			focusOffset: 0,
+			anchorNode: null,
+			anchorOffset: 0
+		};
+		return safari && this.root.nodeType === 11 && deepActiveElement(this.dom.ownerDocument) == this.dom && safariShadowSelectionRange(this, sel) || sel;
+	}
+	/** @internal */
+	domSelection() {
+		return this.root.getSelection();
+	}
+};
+function computeDocDeco(view) {
+	const attrs = Object.create(null);
+	attrs.class = "ProseMirror";
+	attrs.contenteditable = String(view.editable);
+	view.someProp("attributes", (prop) => {
+		const value = typeof prop == "function" ? prop(view.state) : prop;
+		if (value) {
+			for (const attr in value) if (attr == "class") attrs.class += " " + value[attr];
+			else if (attr == "style") attrs.style = (attrs.style ? attrs.style + ";" : "") + value[attr];
+			else if (!attrs[attr] && attr != "contenteditable" && attr != "nodeName") attrs[attr] = String(value[attr]);
+		}
+	});
+	if (!attrs.translate) attrs.translate = "no";
+	return [Decoration.node(0, view.state.doc.content.size, attrs)];
+}
+function updateCursorWrapper(view) {
+	if (view.markCursor) {
+		const dom = document.createElement("img");
+		dom.className = "ProseMirror-separator";
+		dom.setAttribute("mark-placeholder", "true");
+		dom.setAttribute("alt", "");
+		view.cursorWrapper = {
+			dom,
+			deco: Decoration.widget(view.state.selection.from, dom, {
+				raw: true,
+				marks: view.markCursor
+			})
+		};
+	} else view.cursorWrapper = null;
+}
+function getEditable(view) {
+	return !view.someProp("editable", (value) => value(view.state) === false);
+}
+function selectionContextChanged(sel1, sel2) {
+	const depth = Math.min(sel1.$anchor.sharedDepth(sel1.head), sel2.$anchor.sharedDepth(sel2.head));
+	return sel1.$anchor.start(depth) != sel2.$anchor.start(depth);
+}
+function buildNodeViews(view) {
+	const result = Object.create(null);
+	function add(obj) {
+		for (const prop in obj) if (!Object.prototype.hasOwnProperty.call(result, prop)) result[prop] = obj[prop];
+	}
+	view.someProp("nodeViews", add);
+	view.someProp("markViews", add);
+	return result;
+}
+function changedNodeViews(a, b) {
+	let nA = 0, nB = 0;
+	for (const prop in a) {
+		if (a[prop] != b[prop]) return true;
+		nA++;
+	}
+	for (const _ in b) nB++;
+	return nA != nB;
+}
+function checkStateComponent(plugin) {
+	if (plugin.spec.state || plugin.spec.filterTransaction || plugin.spec.appendTransaction) throw new ViewError({ message: "Plugins passed directly to the view must not have a state component" });
+}
+export { EditorView, EditorViewTypeId, __endComposition, __parseFromClipboard };