vitest-prosemirror 0.4.0 → 1.0.0

package/README.md

@@ -5,11 +5,16 @@
 [![Codecov (with branch)](https://img.shields.io/codecov/c/github/marekdedic/vitest-prosemirror/master?logo=codecov)](https://app.codecov.io/gh/marekdedic/vitest-prosemirror)
 [![NPM Downloads](https://img.shields.io/npm/dm/vitest-prosemirror?logo=npm)](https://www.npmjs.com/package/vitest-prosemirror)
 [![NPM License](https://img.shields.io/npm/l/vitest-prosemirror)](https://github.com/marekdedic/vitest-prosemirror/blob/master/LICENSE)
+[![Documentation](https://img.shields.io/badge/docs-vitepress-blue?logo=vite)](https://marekdedic.github.io/vitest-prosemirror/)
 
 ![GitHub package.json dev/peer/optional dependency version (branch)](https://img.shields.io/github/package-json/dependency-version/marekdedic/vitest-prosemirror/peer/vitest/master?logo=vitest)
 
 A plugin for Vitest that enables you to write tests using the ProseMirror editor
 
+## Documentation
+
+Full documentation — a getting-started guide and the API reference — is available at **[marekdedic.github.io/vitest-prosemirror](https://marekdedic.github.io/vitest-prosemirror/)**.
+
 ## How to install
 
 ```sh

package/dist/index.d.ts

@@ -0,0 +1,80 @@
+import { Command } from 'prosemirror-state';
+import { DirectEditorProps } from 'prosemirror-view';
+import { EditorState } from 'prosemirror-state';
+import { Node as Node_2 } from 'prosemirror-model';
+import { ParseOptions } from 'prosemirror-model';
+import { Schema } from 'prosemirror-model';
+import { Selection as Selection_2 } from 'prosemirror-state';
+
+declare interface Clipboard_2 {
+    html: string;
+    text: string;
+}
+export { Clipboard_2 as Clipboard }
+
+export declare interface Options {
+    autoCleanup: boolean;
+    editorProps: Omit<DirectEditorProps, "dispatchTransaction" | "state">;
+}
+
+export declare function parseHTML(html: string, schema: Schema, options?: ParseOptions): Node_2;
+
+export { ParseOptions }
+
+export declare interface PasteContent {
+    files?: Array<File>;
+    html?: string;
+    plainText?: boolean;
+    text?: string;
+}
+
+export declare type PasteInput = PasteContent | Node_2 | string;
+
+/**
+ * The handle returned by `renderProseMirror`: a live editor mounted in jsdom,
+ * exposing readers for its document and rendered DOM plus verbs that drive the
+ * ProseMirror input path.
+ */
+export declare interface ProseMirrorEditor {
+    /** Dispatch a click at the target selector or captured element. */
+    click(target: Element | string): boolean;
+    /** Run a ProseMirror command against the current state. */
+    command(command: Command): boolean;
+    /** Serialise the current selection the way the copy handler would. */
+    copy(): Clipboard_2;
+    /** Tear down the editor, its DOM node and the global mocks. */
+    destroy(): void;
+    /** The current document (`state.doc`). */
+    readonly doc: Node_2;
+    /** The single element matching the selector. */
+    element(selector: string): HTMLElement;
+    /** Every element matching the selector. */
+    elements(selector: string): Array<HTMLElement>;
+    /** The rendered `innerHTML` of the editor DOM. */
+    readonly html: string;
+    /** Paste content through the DOM paste path. */
+    paste(content: PasteInput): void;
+    /** Set the selection from a {@link TesterSelection}. */
+    setSelection(selection: TesterSelection): void;
+    /** The current editor state. Live getter - reads the latest dispatch. */
+    readonly state: EditorState;
+    /** The rendered `textContent` of the editor DOM. */
+    readonly text: string;
+    /** Type key strings through the DOM input path. */
+    type(text: string): void;
+}
+
+/**
+ * Mount a ProseMirror `EditorView` on a jsdom node and return a
+ * {@link ProseMirrorEditor} handle for driving it. Installs the mocks the
+ * tester relies on (`MutationObserver`, range rects) and registers the editor
+ * for automatic cleanup after each test unless `autoCleanup: false` is passed.
+ */
+export declare const renderProseMirror: (documentRoot: Node_2, options?: Partial<Options>) => ProseMirrorEditor;
+
+export declare type TesterSelection = "all" | "end" | "start" | {
+    anchor: number | string;
+    head: number | string;
+} | (string & {}) | Selection_2 | number;
+
+export { }

package/dist/index.js

@@ -0,0 +1,38 @@
+import { r as renderProseMirror } from "./renderProseMirror-CE37KmN_.js";
+import { DOMParser } from "prosemirror-model";
+//#region src/parseHTML.ts
+var wrapMap = {
+	caption: ["table"],
+	col: ["table", "colgroup"],
+	colgroup: ["table"],
+	tbody: ["table"],
+	td: [
+		"table",
+		"tbody",
+		"tr"
+	],
+	tfoot: ["table"],
+	th: [
+		"table",
+		"tbody",
+		"tr"
+	],
+	thead: ["table"],
+	tr: ["table", "tbody"]
+};
+function parseHTML(html, schema, options) {
+	return DOMParser.fromSchema(schema).parse(readHTML(html), options);
+}
+function readHTML(rawHtml) {
+	const metas = /^(\s*<meta [^>]*>)*/u.exec(rawHtml);
+	const stripped = metas ? rawHtml.slice(metas[0].length) : rawHtml;
+	const firstTag = /<([a-z][^>\s]+)/iu.exec(stripped);
+	const wrap = firstTag ? wrapMap[firstTag[1].toLowerCase()] : void 0;
+	const html = wrap === void 0 ? stripped : wrap.map((n) => `<${n}>`).join("") + stripped + wrap.map((n) => `</${n}>`).reverse().join("");
+	let elt = document.implementation.createHTMLDocument("title").body;
+	elt.innerHTML = html;
+	if (wrap) for (const n of wrap) elt = elt.querySelector(n) ?? elt;
+	return elt;
+}
+//#endregion
+export { parseHTML, renderProseMirror };

package/dist/{vitest-prosemirror.js → renderProseMirror-CE37KmN_.js}

@@ -1,175 +1,14 @@
-import { afterEach, expect } from "vitest";
+import { Fragment, Node, Slice } from "prosemirror-model";
 import { AllSelection, EditorState, Selection, TextSelection } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
-import stringifyObject from "stringify-object";
-//#region src/mockRangeRects.ts
-var mockRangeRects = () => {
-	const zeroRect = () => new DOMRect(0, 0, 0, 0);
-	const emptyRectList = () => [];
-	const rangePrototype = Range.prototype;
-	if (typeof rangePrototype.getBoundingClientRect !== "function") Range.prototype.getBoundingClientRect = zeroRect;
-	if (typeof rangePrototype.getClientRects !== "function") Range.prototype.getClientRects = emptyRectList;
-};
-//#endregion
-//#region src/MutationObserverMock.ts
-var MutationObserverMock = class MutationObserverMock {
-	static activeObservers = /* @__PURE__ */ new Map();
-	callback;
-	target;
-	constructor(callback) {
-		this.callback = callback;
-		this.target = void 0;
-	}
-	static createMutation(target, mutationRecords) {
-		const observer = MutationObserverMock.activeObservers.get(target);
-		if (observer === void 0) return;
-		observer.callback(mutationRecords.map((record) => ({
-			addedNodes: [],
-			attributeName: null,
-			attributeNamespace: null,
-			nextSibling: null,
-			oldValue: null,
-			previousSibling: null,
-			removedNodes: [],
-			...record
-		})), observer);
-	}
-	disconnect() {
-		if (this.target !== void 0) MutationObserverMock.activeObservers.delete(this.target);
-		this.target = void 0;
-	}
-	observe(target) {
-		this.target = target;
-		MutationObserverMock.activeObservers.set(target, this);
-	}
-	takeRecords() {
-		return [];
-	}
-};
-//#endregion
-//#region src/selection.ts
-var resolveSelection = (doc, selection) => {
-	if (selection === "all") return new AllSelection(doc);
-	if (typeof selection === "object" && "$anchor" in selection && "$head" in selection) return selection;
-	if (typeof selection === "object" && "anchor" in selection && "head" in selection) return TextSelection.between(doc.resolve(selection.anchor), doc.resolve(selection.head));
-	if (typeof selection === "object" && "from" in selection && "to" in selection) throw new Error("selectText no longer accepts { from, to } — use { anchor, head } instead. The values map directly: { from: a, to: b } becomes { anchor: a, head: b }.");
-	let pos = 0;
-	if (selection === "end") pos = doc.nodeSize - 2;
-	else if (selection !== "start") pos = selection;
-	return TextSelection.near(doc.resolve(pos));
-};
-//#endregion
-//#region src/typing/dom.ts
-var characterDataAt = (node, offset) => {
-	if (node instanceof CharacterData) return {
-		offset,
-		target: node
-	};
-	const after = node.childNodes[offset];
-	if (after instanceof CharacterData) return {
-		offset: 0,
-		target: after
-	};
-	return null;
-};
-function deleteText(view, direction) {
-	const { selection } = view.state;
-	const from = selection.empty && direction === -1 ? selection.from - 1 : selection.from;
-	const to = selection.empty && direction === 1 ? selection.to + 1 : selection.to;
-	const fromDOM = view.domAtPos(from, -1);
-	const target = characterDataAt(fromDOM.node, fromDOM.offset)?.target;
-	if (target === void 0) throw new Error("Cannot simulate deleting a range that is not inside a single text node");
-	const nodeStart = view.posAtDOM(target, 0);
-	const fromOffset = from - nodeStart;
-	const toOffset = to - nodeStart;
-	if (fromOffset < 0 || toOffset > target.data.length) throw new Error("Cannot simulate deleting a range that is not inside a single text node");
-	const oldValue = target.data;
-	target.data = target.data.slice(0, fromOffset) + target.data.slice(toOffset);
-	MutationObserverMock.createMutation(view.dom, [{
-		oldValue,
-		target,
-		type: "characterData"
-	}]);
-}
-function moveCaret(view, direction) {
-	const { selection } = view.state;
-	let pos = direction === -1 ? selection.from : selection.to;
-	if (selection.empty) pos += direction;
-	view.dispatch(view.state.tr.setSelection(Selection.near(view.state.doc.resolve(pos), direction)));
-}
-function typeCharacter(view, character) {
-	const { node, offset: domOffset } = view.domAtPos(view.state.selection.from, -1);
-	const point = characterDataAt(node, domOffset);
-	if (point !== null) {
-		const { offset, target } = point;
-		const oldValue = target.data;
-		target.data = target.data.slice(0, offset) + character + target.data.slice(offset);
-		MutationObserverMock.createMutation(view.dom, [{
-			oldValue,
-			target,
-			type: "characterData"
-		}]);
-		return;
-	}
-	const textNode = new Text(character);
-	const nextSibling = node.childNodes.item(domOffset);
-	node.insertBefore(textNode, nextSibling);
-	MutationObserverMock.createMutation(view.dom, [{
-		addedNodes: [textNode],
-		nextSibling,
-		previousSibling: textNode.previousSibling,
-		target: node,
-		type: "childList"
-	}]);
-}
-//#endregion
-//#region src/typing/keyboardInput.ts
-function tokenizeKeyboardInput(input) {
-	const output = [];
-	let currentGroupOpener = null;
-	let group = "";
-	for (const char of input) if (currentGroupOpener !== null) {
-		if (["]", "}"].includes(char)) {
-			if (group.endsWith("\\") && char === matchingBrace(currentGroupOpener)) group = group.slice(0, -2) + char;
-			else if (char === matchingBrace(currentGroupOpener)) {
-				if (group.length === 4 && group.startsWith("Key")) output.push(group.slice(3).toLowerCase());
-				else output.push(group);
-				currentGroupOpener = null;
-				group = "";
-			} else group += char;
-		} else if (group === "" && currentGroupOpener === char) {
-			output.push(char);
-			currentGroupOpener = null;
-			group = "";
-		} else group += char;
-	} else if (["[", "{"].includes(char)) currentGroupOpener = char;
-	else output.push(char);
-	output.forEach(assertSupported);
-	return output;
-}
-function assertSupported(character) {
-	if (/^\/.+/u.exec(character) || /.+>[\d]*\/?$/u.exec(character)) throw new Error("Unsupported keyboard input");
-}
-function matchingBrace(opener) {
-	return opener === "{" ? "}" : "]";
-}
-//#endregion
-//#region src/typing/keyChord.ts
-function parseKeyChord(token) {
-	const parts = token.split(/-(?!$)/u);
-	const key = parts[parts.length - 1] === "Space" ? " " : parts[parts.length - 1];
-	const modifiers = {};
-	for (const modifier of parts.slice(0, -1)) if (/^(cmd|meta|m)$/iu.test(modifier)) modifiers.metaKey = true;
-	else if (/^a(lt)?$/iu.test(modifier)) modifiers.altKey = true;
-	else if (/^(c|ctrl|control)$/iu.test(modifier)) modifiers.ctrlKey = true;
-	else if (/^s(hift)?$/iu.test(modifier)) modifiers.shiftKey = true;
-	else if (/^mod$/iu.test(modifier)) modifiers.ctrlKey = true;
-	else throw new Error(`Unrecognized modifier name: ${modifier}`);
+//#region src/clipboard/copy.ts
+var copy = (view) => {
+	const { dom, text } = view.serializeForClipboard(view.state.selection.content());
 	return {
-		key,
-		modifiers
+		html: dom.innerHTML,
+		text
 	};
-}
+};
 //#endregion
 //#region src/typing/keyIdentity.ts
 var namedKeys = new Map(Object.entries({
@@ -488,6 +327,351 @@ function keyIdentity(key) {
 	};
 }
 //#endregion
+//#region src/clipboard/ClipboardEventMock.ts
+var ClipboardEventMock = class extends Event {
+	clipboardData;
+	constructor(type, clipboardData) {
+		super(type, {
+			bubbles: true,
+			cancelable: true,
+			composed: true
+		});
+		this.clipboardData = clipboardData;
+	}
+};
+//#endregion
+//#region src/clipboard/DataTransferItemMock.ts
+var DataTransferItemMock = class {
+	kind = "file";
+	type;
+	file;
+	constructor(file) {
+		this.file = file;
+		this.type = file.type;
+	}
+	getAsFile() {
+		return this.file;
+	}
+	getAsString() {}
+	webkitGetAsEntry() {
+		return null;
+	}
+};
+//#endregion
+//#region src/clipboard/DataTransferMock.ts
+var normalizeType = (format) => format.toLowerCase() === "text" ? "text/plain" : format.toLowerCase();
+var DataTransferMock = class {
+	dropEffect = "none";
+	effectAllowed = "uninitialized";
+	files;
+	items;
+	get types() {
+		return this.files.length > 0 ? [...this.store.keys(), "Files"] : [...this.store.keys()];
+	}
+	store = /* @__PURE__ */ new Map();
+	constructor(files = []) {
+		this.files = Object.assign([...files], { item: (index) => files[index] ?? null });
+		this.items = Object.assign(files.map((file) => new DataTransferItemMock(file)), {
+			add: () => null,
+			clear: () => void 0,
+			remove: () => {
+				throw new DOMException("The DataTransferItemList is not in the read/write mode.", "InvalidStateError");
+			}
+		});
+	}
+	clearData(format) {
+		if (format === void 0) this.store.clear();
+		else this.store.delete(normalizeType(format));
+	}
+	getData(format) {
+		return this.store.get(normalizeType(format)) ?? "";
+	}
+	setData(format, data) {
+		this.store.set(normalizeType(format), data);
+	}
+	setDragImage() {
+		throw new Error("setDragImage is not supported: vitest-prosemirror models clipboard paste/copy, not drag-and-drop.");
+	}
+};
+//#endregion
+//#region src/clipboard/paste.ts
+var dispatchShift = (view, type) => {
+	const identity = keyIdentity("Shift");
+	view.dispatchEvent(new KeyboardEvent(type, {
+		bubbles: true,
+		cancelable: true,
+		code: identity.code,
+		composed: true,
+		key: identity.key,
+		keyCode: identity.keyCode,
+		location: identity.location,
+		shiftKey: true
+	}));
+};
+var normalize = (view, content) => {
+	if (typeof content === "string") return { text: content };
+	if (content instanceof Node) {
+		const { dom, text } = view.serializeForClipboard(new Slice(Fragment.from(content), 0, 0));
+		return {
+			html: dom.innerHTML,
+			text
+		};
+	}
+	return content;
+};
+var paste = (view, content) => {
+	const { files, html, plainText, text } = normalize(view, content);
+	const data = new DataTransferMock(files);
+	if (text !== void 0) data.setData("text/plain", text);
+	if (html !== void 0) data.setData("text/html", html);
+	if (plainText === true) dispatchShift(view, "keydown");
+	view.dom.dispatchEvent(new ClipboardEventMock("paste", data));
+	if (plainText === true) dispatchShift(view, "keyup");
+};
+//#endregion
+//#region src/domInteraction.ts
+var clickHandlerProps = [
+	"handleClick",
+	"handleClickOn",
+	"handleDoubleClick",
+	"handleDoubleClickOn",
+	"handleTripleClick",
+	"handleTripleClickOn"
+];
+var element = (view, selector) => {
+	const found = view.dom.querySelector(selector);
+	if (found === null) throw new Error(`No element matching "${selector}" was found in the editor DOM.`);
+	return found;
+};
+var elements = (view, selector) => [...view.dom.querySelectorAll(selector)];
+var click = (view, target) => {
+	if (clickHandlerProps.some((prop) => view.someProp(prop, () => true) === true)) throw new Error("click() cannot reach handleClick / handleClickOn / handleDoubleClick* / handleTripleClick* handlers: jsdom has no layout, so posAtCoords is always null and ProseMirror's mousedown handler bails before calling them. Click a node view's own DOM element instead.");
+	const target_ = typeof target === "string" ? element(view, target) : target;
+	const event = new MouseEvent("click", {
+		bubbles: true,
+		cancelable: true
+	});
+	target_.dispatchEvent(event);
+	return event.defaultPrevented;
+};
+//#endregion
+//#region src/mockRangeRects.ts
+var mockRangeRects = () => {
+	const zeroRect = () => new DOMRect(0, 0, 0, 0);
+	const emptyRectList = () => [];
+	const rangePrototype = Range.prototype;
+	if (typeof rangePrototype.getBoundingClientRect !== "function") Range.prototype.getBoundingClientRect = zeroRect;
+	if (typeof rangePrototype.getClientRects !== "function") Range.prototype.getClientRects = emptyRectList;
+};
+//#endregion
+//#region src/MutationObserverMock.ts
+var MutationObserverMock = class MutationObserverMock {
+	static activeObservers = /* @__PURE__ */ new Map();
+	callback;
+	target;
+	constructor(callback) {
+		this.callback = callback;
+		this.target = void 0;
+	}
+	static createMutation(target, mutationRecords) {
+		const observer = MutationObserverMock.activeObservers.get(target);
+		if (observer === void 0) return;
+		observer.callback(mutationRecords.map((record) => ({
+			addedNodes: [],
+			attributeName: null,
+			attributeNamespace: null,
+			nextSibling: null,
+			oldValue: null,
+			previousSibling: null,
+			removedNodes: [],
+			...record
+		})), observer);
+	}
+	disconnect() {
+		if (this.target !== void 0) MutationObserverMock.activeObservers.delete(this.target);
+		this.target = void 0;
+	}
+	observe(target) {
+		this.target = target;
+		MutationObserverMock.activeObservers.set(target, this);
+	}
+	takeRecords() {
+		return [];
+	}
+};
+//#endregion
+//#region src/selection.ts
+var tagsOf = (doc) => doc.tag ?? {};
+var resolvePos = (doc, value) => {
+	if (typeof value === "number") return value;
+	const tags = tagsOf(doc);
+	if (value in tags) return tags[value];
+	const available = Object.keys(tags);
+	throw new Error(`setSelection: no tag named "${value}" in the document. ${available.length > 0 ? `Available tags: ${available.map((tag) => `"${tag}"`).join(", ")}.` : "The document has no tags."}`);
+};
+var resolveSelection = (doc, selection) => {
+	if (typeof selection === "object" && "$anchor" in selection && "$head" in selection) return selection;
+	if (typeof selection === "object" && "anchor" in selection && "head" in selection) return TextSelection.between(doc.resolve(resolvePos(doc, selection.anchor)), doc.resolve(resolvePos(doc, selection.head)));
+	if (typeof selection === "object" && "from" in selection && "to" in selection) throw new Error("setSelection no longer accepts { from, to } — use { anchor, head } instead. The values map directly: { from: a, to: b } becomes { anchor: a, head: b }.");
+	if (typeof selection === "number") return TextSelection.near(doc.resolve(selection));
+	const tags = tagsOf(doc);
+	if ([
+		"all",
+		"end",
+		"start"
+	].includes(selection)) {
+		if (selection in tags) throw new Error(`setSelection: "${selection}" is both a reserved selection and a tag in the document. Use { anchor, head } to select the tag, or rename the tag.`);
+		if (selection === "all") return new AllSelection(doc);
+		return TextSelection.near(doc.resolve(selection === "end" ? doc.nodeSize - 2 : 0));
+	}
+	return TextSelection.near(doc.resolve(resolvePos(doc, selection)));
+};
+//#endregion
+//#region src/typing/direction.ts
+var rtl = /[\p{Script=Hebrew}\p{Script=Arabic}\p{Script=Syriac}\p{Script=Thaana}\p{Script=Nko}\p{Script=Samaritan}\p{Script=Mandaic}]/u;
+function containsRTL(text) {
+	return rtl.test(text);
+}
+//#endregion
+//#region src/typing/dom.ts
+var characterDataAt = (node, offset) => {
+	if (node instanceof CharacterData) return {
+		offset,
+		target: node
+	};
+	const after = node.childNodes[offset];
+	if (after instanceof CharacterData) return {
+		offset: 0,
+		target: after
+	};
+	return null;
+};
+//#endregion
+//#region src/typing/grapheme.ts
+var segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+var graphemeBoundary = (text, offset, direction) => {
+	const segment = segmenter.segment(text).containing(direction > 0 ? offset : offset - 1);
+	if (segment === void 0) return null;
+	return direction > 0 ? segment.index + segment.segment.length : segment.index;
+};
+function deleteText(view, direction) {
+	const { selection } = view.state;
+	const from = selection.empty && direction === -1 ? selection.from - 1 : selection.from;
+	const to = selection.empty && direction === 1 ? selection.to + 1 : selection.to;
+	const fromDOM = view.domAtPos(from, -1);
+	const target = characterDataAt(fromDOM.node, fromDOM.offset)?.target;
+	if (target === void 0) throw new Error("Cannot simulate deleting a range that is not inside a single text node");
+	const nodeStart = view.posAtDOM(target, 0);
+	const fromOffset = from - nodeStart;
+	const toOffset = to - nodeStart;
+	if (fromOffset < 0 || toOffset > target.data.length) throw new Error("Cannot simulate deleting a range that is not inside a single text node");
+	const oldValue = target.data;
+	target.data = target.data.slice(0, fromOffset) + target.data.slice(toOffset);
+	MutationObserverMock.createMutation(view.dom, [{
+		oldValue,
+		target,
+		type: "characterData"
+	}]);
+}
+function moveCaret(view, direction, extend) {
+	const { doc, selection } = view.state;
+	if (extend) {
+		const head = graphemeStep(view, selection.head, direction);
+		view.dispatch(view.state.tr.setSelection(TextSelection.between(doc.resolve(selection.anchor), doc.resolve(head), direction)));
+		return;
+	}
+	let pos = direction === -1 ? selection.from : selection.to;
+	if (selection.empty) pos = graphemeStep(view, pos, direction);
+	else if (containsRTL(doc.textBetween(selection.from, selection.to))) throwRTL(direction);
+	view.dispatch(view.state.tr.setSelection(Selection.near(doc.resolve(pos), direction)));
+}
+function typeCharacter(view, character) {
+	if (!view.state.selection.empty) deleteText(view, -1);
+	const { node, offset: domOffset } = view.domAtPos(view.state.selection.from, -1);
+	const point = characterDataAt(node, domOffset);
+	if (point !== null) {
+		const { offset, target } = point;
+		const oldValue = target.data;
+		target.data = target.data.slice(0, offset) + character + target.data.slice(offset);
+		MutationObserverMock.createMutation(view.dom, [{
+			oldValue,
+			target,
+			type: "characterData"
+		}]);
+		return;
+	}
+	const textNode = new Text(character);
+	const nextSibling = node.childNodes.item(domOffset);
+	node.insertBefore(textNode, nextSibling);
+	MutationObserverMock.createMutation(view.dom, [{
+		addedNodes: [textNode],
+		nextSibling,
+		previousSibling: textNode.previousSibling,
+		target: node,
+		type: "childList"
+	}]);
+}
+function graphemeStep(view, pos, direction) {
+	const dom = view.domAtPos(pos, direction);
+	const point = characterDataAt(dom.node, dom.offset);
+	if (point === null) return pos + direction;
+	if (containsRTL(point.target.data)) throwRTL(direction);
+	const nodeStart = view.posAtDOM(point.target, 0);
+	const boundary = graphemeBoundary(point.target.data, pos - nodeStart, direction);
+	return boundary === null ? pos + direction : nodeStart + boundary;
+}
+function throwRTL(direction) {
+	throw new Error(`Cannot simulate the "${direction === -1 ? "ArrowLeft" : "ArrowRight"}" key in right-to-left text.`);
+}
+//#endregion
+//#region src/typing/keyboardInput.ts
+function tokenizeKeyboardInput(input) {
+	const output = [];
+	let currentGroupOpener = null;
+	let group = "";
+	for (const char of input) if (currentGroupOpener !== null) {
+		if (["]", "}"].includes(char)) {
+			if (group.endsWith("\\") && char === matchingBrace(currentGroupOpener)) group = group.slice(0, -2) + char;
+			else if (char === matchingBrace(currentGroupOpener)) {
+				if (group.length === 4 && group.startsWith("Key")) output.push(group.slice(3).toLowerCase());
+				else output.push(group);
+				currentGroupOpener = null;
+				group = "";
+			} else group += char;
+		} else if (group === "" && currentGroupOpener === char) {
+			output.push(char);
+			currentGroupOpener = null;
+			group = "";
+		} else group += char;
+	} else if (["[", "{"].includes(char)) currentGroupOpener = char;
+	else output.push(char);
+	output.forEach(assertSupported);
+	return output;
+}
+function assertSupported(character) {
+	if (/^\/.+/u.exec(character) || /.+>[\d]*\/?$/u.exec(character)) throw new Error("Unsupported keyboard input");
+}
+function matchingBrace(opener) {
+	return opener === "{" ? "}" : "]";
+}
+//#endregion
+//#region src/typing/keyChord.ts
+function parseKeyChord(token) {
+	const parts = token.split(/-(?!$)/u);
+	const key = parts[parts.length - 1] === "Space" ? " " : parts[parts.length - 1];
+	const modifiers = {};
+	for (const modifier of parts.slice(0, -1)) if (/^(cmd|meta|m)$/iu.test(modifier)) modifiers.metaKey = true;
+	else if (/^a(lt)?$/iu.test(modifier)) modifiers.altKey = true;
+	else if (/^(c|ctrl|control)$/iu.test(modifier)) modifiers.ctrlKey = true;
+	else if (/^s(hift)?$/iu.test(modifier)) modifiers.shiftKey = true;
+	else if (/^mod$/iu.test(modifier)) modifiers.ctrlKey = true;
+	else throw new Error(`Unrecognized modifier name: ${modifier}`);
+	return {
+		key,
+		modifiers
+	};
+}
+//#endregion
 //#region src/typing/typing.ts
 var ignoredKeys = /* @__PURE__ */ new Set([
 	"Alt",
@@ -500,7 +684,7 @@ var ignoredKeys = /* @__PURE__ */ new Set([
 var hasModifiers = (modifiers) => modifiers !== void 0 && Object.values(modifiers).includes(true);
 var suppressesCharacter = (modifiers) => modifiers?.altKey === true || modifiers?.ctrlKey === true || modifiers?.metaKey === true;
 var isLetter = (key) => /^[a-z]$/iu.test(key);
-function insertText(view, text) {
+function type(view, text) {
 	for (const token of tokenizeKeyboardInput(text)) {
 		const { key, modifiers } = parseKeyChord(token);
 		const character = isLetter(key) && modifiers.shiftKey === true ? key.toUpperCase() : key;
@@ -523,7 +707,7 @@ function insertText(view, text) {
 		if (!keydownEvent.defaultPrevented) {
 			const action = keyAction(character, modifiers);
 			if (action.type === "delete") deleteText(view, action.direction);
-			else if (action.type === "moveCaret") moveCaret(view, action.direction);
+			else if (action.type === "moveCaret") moveCaret(view, action.direction, action.extend);
 			else if (action.type === "type") {
 				view.dispatchEvent(new KeyboardEvent("keypress", {
 					...eventInit,
@@ -546,10 +730,19 @@ function keyAction(key, modifiers) {
 		direction: 1,
 		type: "delete"
 	};
-	if ((key === "ArrowLeft" || key === "ArrowRight") && !hasModifiers(modifiers)) return {
-		direction: key === "ArrowLeft" ? -1 : 1,
-		type: "moveCaret"
-	};
+	if (key === "ArrowLeft" || key === "ArrowRight") {
+		const direction = key === "ArrowLeft" ? -1 : 1;
+		if (!hasModifiers(modifiers)) return {
+			direction,
+			extend: false,
+			type: "moveCaret"
+		};
+		if (modifiers?.shiftKey === true && !suppressesCharacter(modifiers)) return {
+			direction,
+			extend: true,
+			type: "moveCaret"
+		};
+	}
 	if (key.length === 1) {
 		if (suppressesCharacter(modifiers)) return { type: "ignore" };
 		return {
@@ -560,14 +753,14 @@ function keyAction(key, modifiers) {
 	throw new Error(`Cannot simulate the "${key}" key`);
 }
 //#endregion
-//#region src/ProseMirrorTester.ts
+//#region src/renderProseMirror.ts
 var originalMutationObserver = global.MutationObserver;
-var liveTesters = /* @__PURE__ */ new Set();
-var autoCleanupTesters = /* @__PURE__ */ new Set();
-var cleanupTesters = () => {
-	for (const tester of [...autoCleanupTesters]) tester.destroy();
+var liveEditors = /* @__PURE__ */ new Set();
+var autoCleanupEditors = /* @__PURE__ */ new Set();
+var cleanupEditors = () => {
+	for (const editor of [...autoCleanupEditors]) editor.destroy();
 };
-var ProseMirrorTester = class {
+var ProseMirrorEditorImpl = class {
 	get doc() {
 		this.assertAlive();
 		return this.view.state.doc;
@@ -585,108 +778,79 @@ var ProseMirrorTester = class {
 		return this.view.dom.textContent;
 	}
 	destroyed = false;
-	element;
+	mountPoint;
 	view;
 	constructor(documentRoot, options = {}) {
 		if (typeof document === "undefined") throw new Error("TODO");
-		this.element = document.createElement("div");
-		document.body.append(this.element);
+		this.mountPoint = document.createElement("div");
+		document.body.append(this.mountPoint);
+		const { autoCleanup = true, editorProps = {} } = options;
+		const { plugins = [], ...directEditorProps } = editorProps;
 		const state = EditorState.create({
 			doc: documentRoot,
-			plugins: options.plugins ?? []
+			plugins
 		});
 		global.MutationObserver = MutationObserverMock;
 		mockRangeRects();
-		this.view = new EditorView(this.element, { state });
-		liveTesters.add(this);
-		if (options.autoCleanup ?? true) autoCleanupTesters.add(this);
+		this.view = new EditorView(this.mountPoint, {
+			state,
+			...directEditorProps
+		});
+		liveEditors.add(this);
+		if (autoCleanup) autoCleanupEditors.add(this);
+	}
+	click(target) {
+		this.assertAlive();
+		return click(this.view, target);
+	}
+	command(command) {
+		this.assertAlive();
+		return command(this.view.state, this.view.dispatch.bind(this.view), this.view);
+	}
+	copy() {
+		this.assertAlive();
+		return copy(this.view);
 	}
 	destroy() {
 		if (this.destroyed) return;
 		this.destroyed = true;
 		this.view.destroy();
-		this.element.remove();
+		this.mountPoint.remove();
 		document.getSelection()?.removeAllRanges();
-		autoCleanupTesters.delete(this);
-		liveTesters.delete(this);
-		if (liveTesters.size === 0) global.MutationObserver = originalMutationObserver;
+		autoCleanupEditors.delete(this);
+		liveEditors.delete(this);
+		if (liveEditors.size === 0) global.MutationObserver = originalMutationObserver;
+	}
+	element(selector) {
+		this.assertAlive();
+		return element(this.view, selector);
 	}
-	insertText(text) {
+	elements(selector) {
 		this.assertAlive();
-		insertText(this.view, text);
+		return elements(this.view, selector);
 	}
-	selectText(selection) {
+	paste(content) {
+		this.assertAlive();
+		paste(this.view, content);
+	}
+	setSelection(selection) {
 		this.assertAlive();
 		this.view.dispatch(this.view.state.tr.setSelection(resolveSelection(this.doc, selection)));
 	}
+	type(text) {
+		this.assertAlive();
+		type(this.view, text);
+	}
 	assertAlive() {
-		if (this.destroyed) throw new Error("This ProseMirrorTester has been destroyed. Testers are destroyed automatically after each test; pass { autoCleanup: false } to keep one alive (e.g. across a beforeAll).");
+		if (this.destroyed) throw new Error("This ProseMirror editor has been destroyed. Editors are destroyed automatically after each test; pass { autoCleanup: false } to keep one alive (e.g. across a beforeAll).");
 	}
 };
+/**
+* Mount a ProseMirror `EditorView` on a jsdom node and return a
+* {@link ProseMirrorEditor} handle for driving it. Installs the mocks the
+* tester relies on (`MutationObserver`, range rects) and registers the editor
+* for automatic cleanup after each test unless `autoCleanup: false` is passed.
+*/
+var renderProseMirror = (documentRoot, options = {}) => new ProseMirrorEditorImpl(documentRoot, options);
 //#endregion
-//#region src/stringifyProseMirrorNode.ts
-function stringifyProseMirrorNode(node, indentation = "") {
-	if (node.type.spec.toDebugString !== void 0) return `${indentation}${wrapMarks(node.marks, node.type.spec.toDebugString(node))}`;
-	if (node.type.name === "text") return `${indentation}${wrapMarks(node.marks, escapeText(node.textContent))}`;
-	const type = node.type.name;
-	const content = [];
-	const nextIndentation = `${indentation}  `;
-	if (Object.keys(node.attrs).length > 0) content.push(`${nextIndentation}${stringifyObject(node.attrs, {
-		indent: "  ",
-		inlineCharacterLimit: 1e3
-	})},`);
-	node.content.forEach((item) => {
-		content.push(`${stringifyProseMirrorNode(item, nextIndentation)},`);
-	});
-	let body;
-	if (content.length === 0) body = `${type}()`;
-	else if (content.length === 1 && node.content.firstChild?.type.name === "text") body = `${type}(${stringifyProseMirrorNode(node.content.firstChild, "")})`;
-	else body = `${type}(\n${content.join("\n")}\n${indentation})`;
-	return `${indentation}${wrapMarks(node.marks, body)}`;
-}
-function escapeText(text) {
-	return `'${text.replace(/[\p{Cc}'\\]/gu, (char) => {
-		switch (char) {
-			case "\f": return "\\f";
-			case "\n": return "\\n";
-			case "\r": return "\\r";
-			case "	": return "\\t";
-			case "\b": return "\\b";
-			case "'": return "\\'";
-			case "\\": return "\\\\";
-			default: return `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}`;
-		}
-	})}'`;
-}
-function wrapMarks(marks, origContent) {
-	let content = origContent;
-	for (const mark of [...marks].reverse()) {
-		const hasAttrs = Object.keys(mark.attrs).length > 0;
-		const items = [content];
-		if (hasAttrs) items.unshift(stringifyObject(mark.attrs, {
-			indent: "  ",
-			inlineCharacterLimit: 1e3
-		}));
-		content = `${mark.type.name}(${items.join(", ")})`;
-	}
-	return content;
-}
-//#endregion
-//#region src/index.ts
-afterEach(cleanupTesters);
-expect.extend({ toEqualProseMirrorNode(received, expected) {
-	const receivedDoc = `\n${stringifyProseMirrorNode(received)}\n`;
-	const expectedDoc = `\n${stringifyProseMirrorNode(expected)}\n`;
-	const sameSchema = received.type.schema === expected.type.schema;
-	const pass = sameSchema && this.equals(receivedDoc, expectedDoc);
-	return {
-		message: pass ? () => `${this.utils.matcherHint(".not.toEqualProsemirrorNode")}\n\nExpected value of document to not equal:\n  ${this.utils.printExpected(expectedDoc)}\nActual:\n  ${this.utils.printReceived(receivedDoc)}` : () => {
-			if (!sameSchema && this.equals(receivedDoc, expectedDoc)) return `${this.utils.matcherHint(".toEqualProsemirrorNode")}\n\nThe documents stringify identically but come from different schemas:\n${this.utils.printReceived(receivedDoc)}`;
-			const diffString = this.utils.diff(expectedDoc, receivedDoc);
-			return `${this.utils.matcherHint(".toEqualProsemirrorNode")}\n\nExpected value of document to equal:\n${this.utils.printExpected(expectedDoc)}\nActual:\n${this.utils.printReceived(receivedDoc)}${diffString === void 0 ? "" : `\n\nDifference:\n\n${diffString}`}`;
-		},
-		pass
-	};
-} });
-//#endregion
-export { ProseMirrorTester };
+export { resolveSelection as a, containsRTL as i, cleanupEditors as n, renderProseMirror as r, ProseMirrorEditorImpl as t };

package/dist/setup.d.ts

@@ -0,0 +1,21 @@
+import type { Node } from "prosemirror-model";
+
+import type { TesterSelection } from "./index.js";
+
+import "vitest";
+
+export interface CustomMatchers<R = unknown> {
+  toEqualProseMirrorNode(expected: Node): R;
+  toHaveSelection(expected: TesterSelection): R;
+}
+
+/* eslint-disable @typescript-eslint/no-empty-object-type, @typescript-eslint/no-unused-vars -- This is an override for vitest matchers; the type parameters must match vitest's Matchers signature exactly */
+
+declare module "vitest" {
+  interface Matchers<
+    R extends Promise<void> | void = Promise<void> | void,
+    T = unknown,
+  > extends CustomMatchers<R> {}
+}
+
+/* eslint-enable */

package/dist/setup.js

@@ -0,0 +1,165 @@
+import { a as resolveSelection, i as containsRTL, n as cleanupEditors, t as ProseMirrorEditorImpl } from "./renderProseMirror-CE37KmN_.js";
+import { afterEach, expect } from "vitest";
+import stringifyObject from "stringify-object";
+//#region src/isProseMirrorNode.ts
+var isProseMirrorNode = (val) => {
+	if (typeof val !== "object" || val === null) return false;
+	const node = val;
+	const type = node["type"];
+	if (typeof type !== "object" || type === null) return false;
+	const typeRecord = type;
+	return typeof typeRecord["name"] === "string" && typeof typeRecord["schema"] === "object" && "marks" in node && "attrs" in node && "content" in node;
+};
+//#endregion
+//#region src/isEditorState.ts
+var isEditorState = (val) => {
+	if (typeof val !== "object" || val === null) return false;
+	const state = val;
+	return isProseMirrorNode(state["doc"]) && typeof state["selection"] === "object" && state["selection"] !== null && "storedMarks" in state;
+};
+//#endregion
+//#region src/stringifyMark.ts
+var stringifyObjectOptions = {
+	indent: "  ",
+	inlineCharacterLimit: 1e3
+};
+var stringifyMark = (mark) => Object.keys(mark.attrs).length > 0 ? `${mark.type.name}(${stringifyObject(mark.attrs, stringifyObjectOptions)})` : mark.type.name;
+//#endregion
+//#region src/stringifyProseMirrorNode.ts
+function stringifyProseMirrorNode(node, selection, indentation = "") {
+	const markers = /* @__PURE__ */ new Map();
+	if (selection !== void 0) {
+		if (selection.anchor === selection.head) markers.set(selection.anchor, "<cursor>");
+		else {
+			markers.set(selection.anchor, "<anchor>");
+			markers.set(selection.head, "<head>");
+		}
+	}
+	return render(node, markers, indentation, 0);
+}
+function escapeText(text) {
+	return text.replace(/[\p{Cc}\p{Cf}'\\]/gu, (char) => {
+		switch (char) {
+			case "\f": return "\\f";
+			case "\n": return "\\n";
+			case "\r": return "\\r";
+			case "	": return "\\t";
+			case "\b": return "\\b";
+			case "'": return "\\'";
+			case "\\": return "\\\\";
+			default: return `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}`;
+		}
+	});
+}
+function quoteWithMarkers(text, start, markers) {
+	const inside = [...markers.entries()].filter(([pos]) => pos >= start && pos <= start + text.length).sort(([a], [b]) => a - b);
+	const wrapMarker = containsRTL(text) ? (notation) => `\u2066${notation}\u2069` : (notation) => notation;
+	let quoted = "";
+	let last = 0;
+	for (const [pos, notation] of inside) {
+		markers.delete(pos);
+		const offset = pos - start;
+		quoted += escapeText(text.slice(last, offset)) + wrapMarker(notation);
+		last = offset;
+	}
+	quoted += escapeText(text.slice(last));
+	return `'${quoted}'`;
+}
+function render(node, markers, indentation, contentStart) {
+	if (node.type.spec.toDebugString !== void 0) return `${indentation}${wrapMarks(node.marks, node.type.spec.toDebugString(node))}`;
+	if (node.type.name === "text") return `${indentation}${wrapMarks(node.marks, quoteWithMarkers(node.textContent, contentStart, markers))}`;
+	return renderElement(node, markers, indentation, contentStart);
+}
+function renderElement(node, markers, indentation, contentStart) {
+	const type = node.type.name;
+	const hasAttrs = Object.keys(node.attrs).length > 0;
+	const nextIndentation = `${indentation}  `;
+	const args = [];
+	const pushArg = (content) => {
+		args.push(`${nextIndentation}${content},`);
+	};
+	const pushMarkerAt = (pos) => {
+		const notation = markers.get(pos);
+		if (notation !== void 0) {
+			markers.delete(pos);
+			pushArg(`'${notation}'`);
+		}
+	};
+	if (hasAttrs) pushArg(stringifyObject(node.attrs, stringifyObjectOptions));
+	if (!node.type.isLeaf) {
+		if (node.content.childCount === 0) pushMarkerAt(contentStart);
+		node.content.forEach((child, offset, index) => {
+			const childStart = contentStart + offset;
+			const isText = child.type.name === "text";
+			if (!(index > 0 && node.content.child(index - 1).type.name === "text") && !isText) pushMarkerAt(childStart);
+			if (isText) pushArg(wrapMarks(child.marks, quoteWithMarkers(child.textContent, childStart, markers)));
+			else args.push(`${render(child, markers, nextIndentation, childStart + 1)},`);
+		});
+		if (node.content.lastChild?.type.name !== "text") pushMarkerAt(contentStart + node.content.size);
+	}
+	const body = !hasAttrs && (node.content.childCount === 0 || node.content.childCount === 1 && node.content.firstChild?.type.name === "text") ? `${type}(${args.map((arg) => arg.slice(nextIndentation.length, -1)).join("")})` : `${type}(\n${args.join("\n")}\n${indentation})`;
+	return `${indentation}${wrapMarks(node.marks, body)}`;
+}
+function wrapMarks(marks, origContent) {
+	let content = origContent;
+	for (const mark of [...marks].reverse()) {
+		const hasAttrs = Object.keys(mark.attrs).length > 0;
+		const items = [content];
+		if (hasAttrs) items.unshift(stringifyObject(mark.attrs, stringifyObjectOptions));
+		content = `${mark.type.name}(${items.join(", ")})`;
+	}
+	return content;
+}
+//#endregion
+//#region src/stringifyEditorState.ts
+function stringifyEditorState(state, indentation = "") {
+	const { doc, selection, storedMarks } = state;
+	const lines = [stringifyProseMirrorNode(doc, selection, indentation), `${indentation}# selection: ${selection.constructor.name} ${String(selection.from)}..${String(selection.to)}`];
+	if (storedMarks !== null) lines.push(`${indentation}# storedMarks: [${storedMarks.map(stringifyMark).join(", ")}]`);
+	return lines.join("\n");
+}
+//#endregion
+//#region src/setup.ts
+afterEach(cleanupEditors);
+expect.extend({
+	toEqualProseMirrorNode(received, expected) {
+		const receivedDoc = `\n${stringifyProseMirrorNode(received)}\n`;
+		const expectedDoc = `\n${stringifyProseMirrorNode(expected)}\n`;
+		const sameSchema = received.type.schema === expected.type.schema;
+		const pass = sameSchema && this.equals(receivedDoc, expectedDoc);
+		return {
+			message: pass ? () => `${this.utils.matcherHint(".not.toEqualProseMirrorNode")}\n\nExpected value of document to not equal:\n  ${this.utils.printExpected(expectedDoc)}\nActual:\n  ${this.utils.printReceived(receivedDoc)}` : () => {
+				if (!sameSchema && this.equals(receivedDoc, expectedDoc)) return `${this.utils.matcherHint(".toEqualProseMirrorNode")}\n\nThe documents stringify identically but come from different schemas:\n${this.utils.printReceived(receivedDoc)}`;
+				const diffString = this.utils.diff(expectedDoc, receivedDoc);
+				return `${this.utils.matcherHint(".toEqualProseMirrorNode")}\n\nExpected value of document to equal:\n${this.utils.printExpected(expectedDoc)}\nActual:\n${this.utils.printReceived(receivedDoc)}${diffString === void 0 ? "" : `\n\nDifference:\n\n${diffString}`}`;
+			},
+			pass
+		};
+	},
+	toHaveSelection(received, expected) {
+		const state = received instanceof ProseMirrorEditorImpl ? received.state : received;
+		const receivedSelection = state.selection;
+		const expectedSelection = resolveSelection(state.doc, expected);
+		const receivedDoc = `\n${stringifyProseMirrorNode(state.doc, receivedSelection)}\n`;
+		const expectedDoc = `\n${stringifyProseMirrorNode(state.doc, expectedSelection)}\n`;
+		const pass = receivedSelection.eq(expectedSelection);
+		return {
+			message: pass ? () => `${this.utils.matcherHint(".not.toHaveSelection")}\n\nExpected selection to not equal:\n${this.utils.printExpected(expectedDoc)}\nActual:\n${this.utils.printReceived(receivedDoc)}` : () => {
+				const diffString = this.utils.diff(expectedDoc, receivedDoc);
+				return `${this.utils.matcherHint(".toHaveSelection")}\n\nExpected selection to equal (${this.utils.printExpected(expectedSelection.constructor.name)}):\n${this.utils.printExpected(expectedDoc)}\nActual (${this.utils.printReceived(receivedSelection.constructor.name)}):\n${this.utils.printReceived(receivedDoc)}${diffString === void 0 ? "" : `\n\nDifference:\n\n${diffString}`}`;
+			},
+			pass
+		};
+	}
+});
+expect.addSnapshotSerializer({
+	serialize: (val, _config, indentation) => stringifyProseMirrorNode(val, void 0, indentation).slice(indentation.length),
+	test: isProseMirrorNode
+});
+expect.addSnapshotSerializer({
+	serialize: (val, _config, indentation) => {
+		return stringifyEditorState(val instanceof ProseMirrorEditorImpl ? val.state : val, indentation).slice(indentation.length);
+	},
+	test: (val) => val instanceof ProseMirrorEditorImpl || isEditorState(val)
+});
+//#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest-prosemirror",
-  "version": "0.4.0",
+  "version": "1.0.0",
   "description": "A plugin for Vitest that enables you to write tests using the ProseMirror editor",
   "keywords": [
     "vitest",
@@ -17,16 +17,22 @@
   },
   "license": "MIT",
   "author": "Marek Dědič",
-  "sideEffects": true,
+  "sideEffects": [
+    "./dist/setup.js"
+  ],
   "type": "module",
   "exports": {
     ".": {
-      "types": "./dist/vitest-prosemirror.d.ts",
-      "import": "./dist/vitest-prosemirror.js"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./setup": {
+      "types": "./dist/setup.d.ts",
+      "import": "./dist/setup.js"
     }
   },
-  "module": "dist/vitest-prosemirror.js",
-  "types": "dist/vitest-prosemirror.d.ts",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
   "files": [
     "dist"
   ],
@@ -36,6 +42,9 @@
     "check": "FORCE_COLOR=1 run-p -c --aggregate-output check:*",
     "check:js-compat": "es-check es2023 --module --checkFeatures 'dist/**/*.js'",
     "clean": "rimraf dist/*",
+    "docs:build": "vitepress build docs",
+    "docs:dev": "vitepress dev docs",
+    "docs:preview": "vitepress preview docs",
     "lint": "FORCE_COLOR=1 run-p -c --aggregate-output lint:*",
     "lint:eslint": "eslint",
     "lint:ts": "FORCE_COLOR=1 run-p -c --aggregate-output lint:ts:*",
@@ -63,6 +72,7 @@
     "@types/stringify-object": "^4.0.5",
     "@vitest/coverage-v8": "^5.0.0",
     "@vitest/eslint-plugin": "^1.3.26",
+    "blns": "^2.0.4",
     "es-check": "^9.6.4",
     "eslint": "^10.0.2",
     "eslint-config-prettier": "^10.0.1",
@@ -70,6 +80,7 @@
     "eslint-plugin-perfectionist": "^5.0.0",
     "eslint-plugin-prefer-arrow-functions": "^3.9.1",
     "eslint-plugin-prettier": "^5.1.3",
+    "jiti": "^2.7.0",
     "jsdom": "^30.0.0",
     "npm-run-all2": "^9.0.3",
     "prettier": "^3.3.0",
@@ -77,11 +88,13 @@
     "prosemirror-inputrules": "^1.5.0",
     "prosemirror-keymap": "^1.2.3",
     "prosemirror-schema-basic": "^1.2.3",
+    "prosemirror-test-builder": "^1.1.1",
     "rimraf": "^6.0.1",
     "typescript": "^6.0.2",
     "typescript-eslint": "^8.58.0",
     "unplugin-dts": "^1.0.1",
     "vite": "^8.0.0",
+    "vitepress": "^1.6.4",
     "vitest": "^5.0.0",
     "w3c-keyname": "^2.2.8"
   },

package/dist/vitest-prosemirror.d.ts

@@ -1,42 +0,0 @@
-import 'vitest';
-import { EditorState } from 'prosemirror-state';
-import { Node as Node_2 } from 'prosemirror-model';
-import { Plugin as Plugin_2 } from 'prosemirror-state';
-import { Selection as Selection_2 } from 'prosemirror-state';
-
-export declare interface CustomMatchers<R = unknown> {
-    toEqualProseMirrorNode(expected: Node_2): R;
-}
-
-export declare interface Options {
-    autoCleanup: boolean;
-    plugins: Array<Plugin_2>;
-}
-
-export declare class ProseMirrorTester {
-    get doc(): Node_2;
-    get html(): string;
-    get state(): EditorState;
-    get text(): string;
-    private destroyed;
-    private readonly element;
-    private readonly view;
-    constructor(documentRoot: Node_2, options?: Partial<Options>);
-    destroy(): void;
-    insertText(text: string): void;
-    selectText(selection: TesterSelection): void;
-    private assertAlive;
-}
-
-export declare type TesterSelection = "all" | "end" | "start" | {
-    anchor: number;
-    head: number;
-} | Selection_2 | number;
-
-export { }
-
-
-declare module "vitest" {
-    interface Matchers<R extends Promise<void> | void = Promise<void> | void, T = unknown> extends CustomMatchers<R> {
-    }
-}