vitest-prosemirror 0.3.2 → 0.5.0

package/dist/vitest-prosemirror.d.ts

@@ -1,44 +1,70 @@
 import 'vitest';
+import { Command } from 'prosemirror-state';
+import { DirectEditorProps } from 'prosemirror-view';
+import { EditorState } from 'prosemirror-state';
 import { Node as Node_2 } from 'prosemirror-model';
-import { Plugin as Plugin_2 } from 'prosemirror-state';
+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 CustomMatchers<R = unknown> {
     toEqualProseMirrorNode(expected: Node_2): R;
+    toHaveSelection(expected: TesterSelection): R;
 }
 
-export declare interface KeyboardModifiers {
-    altKey?: boolean;
-    ctrlKey?: boolean;
-    metaKey?: boolean;
-    shiftKey?: boolean;
+export declare interface Options extends Omit<DirectEditorProps, "dispatchTransaction" | "state"> {
+    autoCleanup: boolean;
 }
 
-export declare interface Options {
-    plugins: Array<Plugin_2>;
+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;
+
 export declare class ProseMirrorTester {
     get doc(): Node_2;
-    get schema(): Schema;
+    get html(): string;
+    get state(): EditorState;
+    get text(): string;
+    private destroyed;
+    private readonly mountPoint;
     private readonly view;
     constructor(documentRoot: Node_2, options?: Partial<Options>);
-    insertText(text: string, modifiers?: KeyboardModifiers): void;
+    click(target: Element | string): boolean;
+    command(command: Command): boolean;
+    copy(): Clipboard_2;
+    destroy(): void;
+    element(selector: string): HTMLElement;
+    elements(selector: string): Array<HTMLElement>;
+    insertText(text: string): void;
+    paste(content: PasteInput): void;
     selectText(selection: TesterSelection): void;
+    private assertAlive;
 }
 
 export declare type TesterSelection = "all" | "end" | "start" | {
-    from: number;
-    to: number;
-} | Selection_2 | number;
+    anchor: number | string;
+    head: number | string;
+} | (string & {}) | Selection_2 | number;
 
 export { }
 
 
 declare module "vitest" {
-    interface Assertion<T = any> extends CustomMatchers<T> {
-    }
-    interface AsymmetricMatchersContaining extends CustomMatchers {
+    interface Matchers<R extends Promise<void> | void = Promise<void> | void, T = unknown> extends CustomMatchers<R> {
     }
 }

package/dist/vitest-prosemirror.js

@@ -1,146 +1,35 @@
-import { expect } from "vitest";
-import stringifyObject from "stringify-object";
+import { afterEach, expect } from "vitest";
 import { AllSelection, EditorState, Selection, TextSelection } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
-//#region src/stringifyProseMirrorNode.ts
-function getMarks(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;
-}
-var renamedTypes = {
-	hardBreak: "br",
-	heading: "h",
-	horizontalRule: "hr",
-	paragraph: "p"
-};
-function stringifyProseMirrorNode(node, indentation = "") {
-	if (node.type.name === "text") return `${indentation}${getMarks(node.marks, node.text ?? "")}`;
-	const type = renamedTypes[node.type.name] ?? 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)},`);
-	});
-	if (content.length === 0) return `${indentation}${type}()`;
-	if (content.length === 1 && node.content.firstChild?.type.name === "text") return `${indentation}${type}(${stringifyProseMirrorNode(node.content.firstChild, "")})`;
-	return `${indentation}${type}(\n${content.join("\n")}\n${indentation})`;
-}
-//#endregion
-//#region src/utils/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/utils/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 [];
-	}
+import { DOMParser, Fragment, Node, Slice } from "prosemirror-model";
+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/utils/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" && "from" in selection && "to" in selection) return TextSelection.between(doc.resolve(selection.from), doc.resolve(selection.to));
-	let pos = 0;
-	if (selection === "end") pos = doc.nodeSize - 2;
-	else if (selection !== "start") pos = selection;
-	return TextSelection.near(doc.resolve(pos));
+//#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/utils/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
+//#region src/clipboard/copy.ts
+var copy = (view) => {
+	const { dom, text } = view.serializeForClipboard(view.state.selection.content());
+	return {
+		html: dom.innerHTML,
+		text
 	};
-	return null;
 };
 //#endregion
-//#region src/utils/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/utils/keyIdentity.ts
+//#region src/typing/keyIdentity.ts
 var namedKeys = new Map(Object.entries({
 	Alt: 18,
 	ArrowDown: 40,
@@ -457,7 +346,352 @@ function keyIdentity(key) {
 	};
 }
 //#endregion
-//#region src/utils/typing.ts
+//#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: ProseMirrorTester 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(`selectText: 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("selectText 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(`selectText: "${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",
 	"CapsLock",
@@ -466,15 +700,14 @@ var ignoredKeys = /* @__PURE__ */ new Set([
 	"Shift",
 	"Tab"
 ]);
-var backward = -1;
-var forward = 1;
 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, modifiers) {
-	for (const key of tokenizeKeyboardInput(text)) {
-		const character = isLetter(key) && modifiers?.shiftKey === true ? key.toUpperCase() : key;
-		const shiftKey = isLetter(character) ? character === character.toUpperCase() : modifiers?.shiftKey ?? false;
+function insertText(view, text) {
+	for (const token of tokenizeKeyboardInput(text)) {
+		const { key, modifiers } = parseKeyChord(token);
+		const character = isLetter(key) && modifiers.shiftKey === true ? key.toUpperCase() : key;
+		const shiftKey = isLetter(character) ? character === character.toUpperCase() : modifiers.shiftKey ?? false;
 		const identity = keyIdentity(character);
 		const eventInit = {
 			bubbles: true,
@@ -493,7 +726,7 @@ function insertText(view, text, modifiers) {
 		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,
@@ -506,39 +739,29 @@ function insertText(view, text, modifiers) {
 		view.dispatchEvent(new KeyboardEvent("keyup", eventInit));
 	}
 }
-function deleteText(view, direction) {
-	const { selection } = view.state;
-	const from = selection.empty && direction === backward ? selection.from - 1 : selection.from;
-	const to = selection.empty && direction === forward ? selection.to + 1 : selection.to;
-	const fromDOM = view.domAtPos(from, backward);
-	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 keyAction(key, modifiers) {
 	if (ignoredKeys.has(key)) return { type: "ignore" };
 	if (key === "Backspace") return {
-		direction: backward,
+		direction: -1,
 		type: "delete"
 	};
 	if (key === "Delete") return {
-		direction: forward,
+		direction: 1,
 		type: "delete"
 	};
-	if ((key === "ArrowLeft" || key === "ArrowRight") && !hasModifiers(modifiers)) return {
-		direction: key === "ArrowLeft" ? backward : forward,
-		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 {
@@ -548,79 +771,277 @@ function keyAction(key, modifiers) {
 	}
 	throw new Error(`Cannot simulate the "${key}" key`);
 }
-function moveCaret(view, direction) {
-	const { selection } = view.state;
-	let pos = direction === backward ? 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, backward);
-	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/ProseMirrorTester.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 ProseMirrorTester = class {
 	get doc() {
+		this.assertAlive();
 		return this.view.state.doc;
 	}
-	get schema() {
-		return this.view.state.schema;
+	get html() {
+		this.assertAlive();
+		return this.view.dom.innerHTML;
+	}
+	get state() {
+		this.assertAlive();
+		return this.view.state;
 	}
+	get text() {
+		this.assertAlive();
+		return this.view.dom.textContent;
+	}
+	destroyed = false;
+	mountPoint;
 	view;
 	constructor(documentRoot, options = {}) {
 		if (typeof document === "undefined") throw new Error("TODO");
-		const element = document.createElement("div");
-		document.body.append(element);
+		this.mountPoint = document.createElement("div");
+		document.body.append(this.mountPoint);
+		const { autoCleanup = true, plugins = [], ...editorProps } = options;
 		const state = EditorState.create({
 			doc: documentRoot,
-			plugins: options.plugins ?? []
+			plugins
 		});
 		global.MutationObserver = MutationObserverMock;
 		mockRangeRects();
-		this.view = new EditorView(element, { state });
+		this.view = new EditorView(this.mountPoint, {
+			state,
+			...editorProps
+		});
+		liveTesters.add(this);
+		if (autoCleanup) autoCleanupTesters.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);
 	}
-	insertText(text, modifiers) {
-		insertText(this.view, text, modifiers);
+	destroy() {
+		if (this.destroyed) return;
+		this.destroyed = true;
+		this.view.destroy();
+		this.mountPoint.remove();
+		document.getSelection()?.removeAllRanges();
+		autoCleanupTesters.delete(this);
+		liveTesters.delete(this);
+		if (liveTesters.size === 0) global.MutationObserver = originalMutationObserver;
+	}
+	element(selector) {
+		this.assertAlive();
+		return element(this.view, selector);
+	}
+	elements(selector) {
+		this.assertAlive();
+		return elements(this.view, selector);
+	}
+	insertText(text) {
+		this.assertAlive();
+		insertText(this.view, text);
+	}
+	paste(content) {
+		this.assertAlive();
+		paste(this.view, content);
 	}
 	selectText(selection) {
+		this.assertAlive();
 		this.view.dispatch(this.view.state.tr.setSelection(resolveSelection(this.doc, selection)));
 	}
+	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).");
+	}
 };
 //#endregion
-//#region src/index.ts
-expect.extend({ toEqualProseMirrorNode(received, expected) {
-	const receivedDoc = `\n${stringifyProseMirrorNode(received)}\n`;
-	const expectedDoc = `\n${stringifyProseMirrorNode(expected)}\n`;
-	const pass = 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)}` : () => {
-			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
+//#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/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
+//#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
+		};
+	},
+	toHaveSelection(received, expected) {
+		const state = received instanceof ProseMirrorTester ? 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 ProseMirrorTester ? val.state : val, indentation).slice(indentation.length);
+	},
+	test: (val) => val instanceof ProseMirrorTester || isEditorState(val)
+});
 //#endregion
-export { ProseMirrorTester };
+export { ProseMirrorTester, parseHTML };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest-prosemirror",
-  "version": "0.3.2",
+  "version": "0.5.0",
   "description": "A plugin for Vitest that enables you to write tests using the ProseMirror editor",
   "keywords": [
     "vitest",
@@ -61,8 +61,9 @@
     "@microsoft/api-extractor": "^7.58.7",
     "@types/node": "^26.0.0",
     "@types/stringify-object": "^4.0.5",
-    "@vitest/coverage-v8": "^4.0.4",
+    "@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 +71,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,16 +79,17 @@
     "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",
-    "vitest": "^4.0.4",
+    "vitest": "^5.0.0",
     "w3c-keyname": "^2.2.8"
   },
   "peerDependencies": {
-    "vitest": "^2.1.9 || ^3.0.7 || ^4.0.4"
+    "vitest": "^2.1.9 || ^3.0.7 || ^4.0.4 || ^5.0.0"
   },
   "peerDependenciesMeta": {
     "vitest": {