@prosekit/core 0.8.7 → 0.10.0

package/dist/prosekit-core.js

@@ -1,15 +1,13 @@
-import { A as isSelection, B as assert, C as defineFacetPayload, D as isNodeSelection, E as isMark, F as rootFacet, H as EditorNotFoundError, I as defineFacet, L as Priority, M as isTextSelection, N as toReversed, O as isNotNullish, P as schemaFacet, R as isNodeActive, S as stateFacet, T as isFragment, U as ProseKitError, V as getMarkType, _ as jsonFromState, a as union, b as nodeFromJSON, c as isMarkActive, d as elementFromJSON, f as elementFromNode, g as jsonFromNode, h as jsonFromHTML, j as isSlice, k as isProseMirrorNode, l as isMarkAbsent, m as htmlFromNode, p as htmlFromJSON, r as createEditor, t as Editor, u as defineDefaultState, v as nodeFromElement, w as isAllSelection, x as stateFromJSON, y as nodeFromHTML, z as getNodeType } from "./editor-B0L9BgMi.js";
-import { AllSelection, Plugin, PluginKey, ProseMirrorPlugin, TextSelection } from "@prosekit/pm/state";
-import { ReplaceAroundStep, findWrapping, insertPoint } from "@prosekit/pm/transform";
-import { baseKeymap, chainCommands, createParagraphNear, deleteSelection, joinTextblockBackward, lift, liftEmptyBlock, newlineInCode, selectNodeBackward, setBlockType as setBlockType$1, toggleMark as toggleMark$1 } from "@prosekit/pm/commands";
-import { DOMSerializer, Fragment, ProseMirrorFragment, ProseMirrorNode, Slice } from "@prosekit/pm/model";
-import { isElementLike, once } from "@ocavue/utils";
-import OrderedMap from "orderedmap";
-import mapValues from "just-map-values";
-import clone from "just-clone";
+import { A as isFragment, B as EditorNotFoundError, C as defineFacetPayload, D as Priority, E as defineFacet, F as isSlice, I as isTextSelection, L as getNodeType, M as isNodeSelection, N as isProseMirrorNode, O as isNodeActive, P as isSelection, R as assert, S as stateFacet, T as rootFacet, V as ProseKitError, _ as jsonFromState, a as union, b as nodeFromJSON, c as isMarkActive, d as elementFromJSON, f as elementFromNode, g as jsonFromNode, h as jsonFromHTML, j as isMark, k as isAllSelection, l as isMarkAbsent, m as htmlFromNode, p as htmlFromJSON, r as createEditor, t as Editor, u as defineDefaultState, v as nodeFromElement, w as schemaFacet, x as stateFromJSON, y as nodeFromHTML, z as getMarkType } from "./editor-g-Rqn-ZE.js";
+import { Plugin, PluginKey, ProseMirrorPlugin, TextSelection } from "@prosekit/pm/state";
+import { DOMSerializer, Fragment, Slice } from "@prosekit/pm/model";
+import { ReplaceAroundStep, dropPoint, findWrapping } from "@prosekit/pm/transform";
+import { baseKeymap, chainCommands, createParagraphNear, deleteSelection, joinTextblockBackward, lift, liftEmptyBlock, newlineInCode, selectAll as selectAll$1, selectNodeBackward, setBlockType as setBlockType$1, toggleMark as toggleMark$1 } from "@prosekit/pm/commands";
+import { isElementLike, isNotNullish, mapGroupBy, once } from "@ocavue/utils";
 import { history, redo, undo } from "@prosekit/pm/history";
 import { keydownHandler } from "@prosekit/pm/keymap";
 import { splitSplittableBlock } from "prosemirror-splittable";
+import OrderedMap from "orderedmap";
 import clsxLite from "clsx/lite";
 
 //#region src/commands/add-mark.ts
@@ -131,7 +129,7 @@ function insertNode(options) {
 	return (state, dispatch) => {
 		const node = options.node ? options.node : options.type ? getNodeType(state.schema, options.type).createAndFill(options.attrs) : null;
 		assert(node, "You must provide either a node or a type");
-		const insertPos = insertPoint(state.doc, options.pos ?? state.selection.anchor, node.type);
+		const insertPos = dropPoint(state.doc, options.pos ?? state.selection.anchor, new Slice(Fragment.from([node]), 0, 0));
 		if (insertPos == null) return false;
 		if (dispatch) {
 			const tr = state.tr.insert(insertPos, node);
@@ -180,6 +178,16 @@ function findParentNode(predicate, $pos) {
 	}
 }
 
+//#endregion
+//#region src/utils/get-node-types.ts
+/**
+* @internal
+*/
+function getNodeTypes(schema, types) {
+	if (Array.isArray(types)) return types.map((type) => getNodeType(schema, type));
+	return [getNodeType(schema, types)];
+}
+
 //#endregion
 //#region src/utils/find-parent-node-of-type.ts
 /**
@@ -188,8 +196,8 @@ function findParentNode(predicate, $pos) {
 * @public
 */
 function findParentNodeOfType(type, $pos) {
-	const nodeType = getNodeType($pos.doc.type.schema, type);
-	return findParentNode((node) => node.type === nodeType, $pos);
+	const nodeTypes = getNodeTypes($pos.doc.type.schema, type);
+	return findParentNode((node) => nodeTypes.includes(node.type), $pos);
 }
 
 //#endregion
@@ -210,6 +218,56 @@ function removeNode(options) {
 	};
 }
 
+//#endregion
+//#region src/commands/select-all.ts
+/**
+* Returns a command that selects the whole document.
+*
+* @public
+*/
+function selectAll() {
+	return selectAll$1;
+}
+
+//#endregion
+//#region src/commands/select-block.ts
+function getTextblockEndpoint(selection, side) {
+	const $pos = side < 0 ? selection.$from : selection.$to;
+	let depth = $pos.depth;
+	while ($pos.node(depth).isInline) {
+		if (!depth) return;
+		depth--;
+	}
+	if (!$pos.node(depth).isTextblock) return;
+	return side < 0 ? $pos.start(depth) : $pos.end(depth);
+}
+/**
+* @internal
+*/
+const selectBlockCommand = (state, dispatch) => {
+	const { selection } = state;
+	if (!isTextSelection(selection)) return false;
+	const expectedFrom = getTextblockEndpoint(selection, -1);
+	const expectedTo = getTextblockEndpoint(selection, 1);
+	if (expectedFrom == null || expectedTo == null) return false;
+	if (selection.from <= expectedFrom && selection.to >= expectedTo) return false;
+	if (dispatch) {
+		const newSelection = TextSelection.create(state.doc, expectedFrom, expectedTo);
+		dispatch(state.tr.setSelection(newSelection));
+	}
+	return true;
+};
+/**
+* Returns a command to expand the text selection to cover the current block
+* node. If the text selection spans multiple blocks, it will select all
+* blocks in the selection.
+*
+* @public
+*/
+function selectBlock() {
+	return selectBlockCommand;
+}
+
 //#endregion
 //#region src/utils/get-custom-selection.ts
 function getCustomSelection(state, from, to) {
@@ -262,36 +320,65 @@ function setBlockType(options) {
 }
 
 //#endregion
-//#region src/utils/get-node-types.ts
+//#region src/commands/set-node-attrs.ts
 /**
-* @internal
+* Returns a command that sets the attributes of the current node.
+*
+* @param options
+*
+* @public
 */
-function getNodeTypes(schema, types) {
-	if (Array.isArray(types)) return types.map((type) => getNodeType(schema, type));
-	return [getNodeType(schema, types)];
+function setNodeAttrs({ type, attrs, pos }) {
+	return (state, dispatch) => {
+		let updatePos;
+		if (pos == null) {
+			const found = findParentNodeOfType(type, state.selection.$anchor);
+			if (!found) return false;
+			updatePos = found.pos;
+		} else {
+			const found = state.doc.nodeAt(pos);
+			if (!found) return false;
+			if (!getNodeTypes(state.schema, type).includes(found.type)) return false;
+			updatePos = pos;
+		}
+		if (dispatch) {
+			const { tr } = state;
+			for (const [key, value] of Object.entries(attrs)) tr.setNodeAttribute(updatePos, key, value);
+			dispatch(tr);
+		}
+		return true;
+	};
 }
 
 //#endregion
-//#region src/commands/set-node-attrs.ts
+//#region src/commands/set-node-attrs-between.ts
 /**
-* Returns a command that set the attributes of the current node.
+* Returns a command that sets the attributes of all matching nodes between the
+* `from` and `to` positions.
+*
+* @param options
 *
 * @public
 */
-function setNodeAttrs(options) {
+function setNodeAttrsBetween(options) {
 	return (state, dispatch) => {
+		const from = options.from ?? state.selection.from;
+		const to = options.to ?? state.selection.to;
+		if (from > to) return false;
 		const nodeTypes = getNodeTypes(state.schema, options.type);
-		const from = options.pos ?? state.selection.from;
-		const to = options.pos ?? state.selection.to;
 		const positions = [];
+		let found = false;
 		state.doc.nodesBetween(from, to, (node, pos) => {
-			if (nodeTypes.includes(node.type)) positions.push(pos);
-			if (!dispatch && positions.length > 0) return false;
+			if (nodeTypes.includes(node.type)) {
+				positions.push(pos);
+				found = true;
+			}
+			if (!dispatch && found) return false;
 		});
-		if (positions.length === 0) return false;
+		if (!found) return false;
 		if (dispatch) {
 			const { tr } = state;
-			for (const pos of positions) for (const [key, value] of Object.entries(options.attrs)) tr.setNodeAttribute(pos, key, value);
+			for (const [key, value] of Object.entries(options.attrs)) for (const pos of positions) tr.setNodeAttribute(pos, key, value);
 			dispatch(tr);
 		}
 		return true;
@@ -319,7 +406,7 @@ function toggleMark({ type, attrs, removeWhenPresent = false, enterInlineAtoms =
 //#endregion
 //#region src/commands/toggle-node.ts
 /**
-* Returns a command that set the selected textblocks to the given node type
+* Returns a command that sets the selected textblocks to the given node type
 * with the given attributes.
 *
 * @param options
@@ -350,7 +437,7 @@ function wrap(options) {
 		const { $from, $to } = state.selection;
 		const range = $from.blockRange($to);
 		if (!range) return false;
-		const wrapping = findWrapping(range, getNodeType(state.schema, options.nodeType || options.type), options.attrs);
+		const wrapping = findWrapping(range, getNodeType(state.schema, options.type), options.attrs);
 		if (!wrapping) return false;
 		dispatch?.(state.tr.wrap(range, wrapping));
 		return true;
@@ -480,7 +567,7 @@ const pluginFacet = defineFacet({
 			else if (Array.isArray(payload) && payload.every((p) => p instanceof Plugin)) plugins.push(...payload);
 			else if (typeof payload === "function") plugins.push(...[payload({ schema })].flat());
 			else throw new ProseKitError("Invalid plugin");
-			return { plugins: toReversed(plugins) };
+			return { plugins: [...plugins].reverse() };
 		};
 	},
 	parent: stateFacet
@@ -489,7 +576,7 @@ const pluginFacet = defineFacet({
 //#endregion
 //#region src/extensions/clipboard-serializer.ts
 function mergeWrappers(wrappers) {
-	return (fn) => wrappers.filter(isNotNullish).reduce((fn$1, wrapper) => wrapper(fn$1), fn);
+	return (fn) => wrappers.filter(isNotNullish).reduce((fn, wrapper) => wrapper(fn), fn);
 }
 function wrapFunction(fn, wrapper) {
 	return wrapper ? wrapper(fn) : fn;
@@ -501,11 +588,11 @@ var CustomDOMSerializer = class extends DOMSerializer {
 		this.serializeNodeWrapper = serializeNodeWrapper;
 	}
 	serializeFragment(...args) {
-		const fn = (...args$1) => super.serializeFragment(...args$1);
+		const fn = (...args) => super.serializeFragment(...args);
 		return wrapFunction(fn, this.serializeFragmentWrapper)(...args);
 	}
 	serializeNode(...args) {
-		const fn = (...args$1) => super.serializeNode(...args$1);
+		const fn = (...args) => super.serializeNode(...args);
 		return wrapFunction(fn, this.serializeNodeWrapper)(...args);
 	}
 };
@@ -554,25 +641,15 @@ function insertText({ text, from, to }) {
 	};
 }
 
-//#endregion
-//#region src/commands/select-all.ts
-/**
-* Returns a command that selects the whole document.
-*
-* @public
-*/
-function selectAll() {
-	return (state, dispatch) => {
-		dispatch?.(state.tr.setSelection(new AllSelection(state.doc)));
-		return true;
-	};
-}
-
 //#endregion
 //#region src/facets/command.ts
 const commandFacet = defineFacet({
 	reducer: (inputs) => {
-		return { commands: Object.assign({}, ...inputs) };
+		switch (inputs.length) {
+			case 0: return { commands: {} };
+			case 1: return { commands: inputs[0] };
+			default: return { commands: Object.assign({}, ...inputs) };
+		}
 	},
 	parent: rootFacet,
 	singleton: true
@@ -580,8 +657,8 @@ const commandFacet = defineFacet({
 
 //#endregion
 //#region src/extensions/command.ts
-function defineCommands(commands$1) {
-	return defineFacetPayload(commandFacet, [commands$1]);
+function defineCommands(commands) {
+	return defineFacetPayload(commandFacet, [commands]);
 }
 /**
 * Add some base commands
@@ -597,8 +674,10 @@ function defineBaseCommands() {
 		toggleWrap,
 		setBlockType,
 		setNodeAttrs,
+		setNodeAttrsBetween,
 		insertDefaultBlock,
 		selectAll,
+		selectBlock,
 		addMark,
 		removeMark,
 		unsetBlockType,
@@ -607,37 +686,94 @@ function defineBaseCommands() {
 }
 
 //#endregion
-//#region src/facets/schema-spec.ts
-const schemaSpecFacet = defineFacet({
-	reducer: (specs) => {
-		let nodes = OrderedMap.from({});
-		let marks = OrderedMap.from({});
-		let topNode = void 0;
-		for (const spec of specs) {
-			nodes = nodes.append(spec.nodes);
-			marks = marks.append(spec.marks ?? {});
-			topNode = topNode ?? spec.topNode;
-		}
-		return {
-			nodes,
-			marks,
-			topNode
+//#region src/extensions/events/plugin-view.ts
+/**
+* Registers a event handler that is called when the editor view is mounted.
+*
+* @public
+*/
+function defineMountHandler(handler) {
+	return definePluginViewFacetPayload(["mount", handler]);
+}
+/**
+* Registers a event handler that is called when the editor state is updated.
+*
+* @public
+*/
+function defineUpdateHandler(handler) {
+	return definePluginViewFacetPayload(["update", handler]);
+}
+/**
+* Registers a event handler that is called when the editor view is unmounted.
+*
+* @public
+*/
+function defineUnmountHandler(handler) {
+	return definePluginViewFacetPayload(["unmount", handler]);
+}
+function definePluginViewFacetPayload(input) {
+	return defineFacetPayload(pluginViewFacet, [input]);
+}
+const pluginViewFacet = defineFacet({
+	reduce: () => {
+		let mountHandlers = [];
+		let updateHandlers = [];
+		let unmountHandlers = [];
+		const plugin = new ProseMirrorPlugin({
+			key: pluginKey,
+			view: (view) => {
+				mountHandlers.forEach((fn) => fn(view));
+				return {
+					update: (view, prevState) => {
+						updateHandlers.forEach((fn) => fn(view, prevState));
+					},
+					destroy: () => {
+						unmountHandlers.forEach((fn) => fn());
+					}
+				};
+			}
+		});
+		const register = (input) => {
+			mountHandlers = [];
+			updateHandlers = [];
+			unmountHandlers = [];
+			for (const args of input) switch (args[0]) {
+				case "mount":
+					mountHandlers.push(args[1]);
+					break;
+				case "update":
+					updateHandlers.push(args[1]);
+					break;
+				case "unmount":
+					unmountHandlers.push(args[1]);
+					break;
+			}
+		};
+		return function reducer(input) {
+			register(input);
+			return plugin;
 		};
 	},
-	parent: schemaFacet,
+	parent: pluginFacet,
 	singleton: true
 });
+const pluginKey = new PluginKey("prosekit-plugin-view-handler");
 
 //#endregion
-//#region src/utils/array-grouping.ts
-function groupBy(items, keySelector) {
-	const result = {};
-	for (const item of items) {
-		const key = keySelector(item);
-		(result[key] ||= []).push(item);
-	}
-	return result;
+//#region src/extensions/events/doc-change.ts
+/**
+* Registers a event handler that is called when the editor document is changed.
+*
+* @public
+*/
+function defineDocChangeHandler(handler) {
+	return defineUpdateHandler((view, prevState) => {
+		if (!view.state.doc.eq(prevState.doc)) handler(view, prevState);
+	});
 }
+
+//#endregion
+//#region src/utils/array-grouping.ts
 function groupEntries(entries) {
 	const result = {};
 	for (const [key, value] of entries) (result[key] ||= []).push(value);
@@ -645,329 +781,66 @@ function groupEntries(entries) {
 }
 
 //#endregion
-//#region src/utils/remove-undefined-values.ts
-function removeUndefinedValues(obj) {
-	const result = {};
-	for (const [key, value] of Object.entries(obj)) if (value !== void 0) result[key] = value;
-	return result;
+//#region src/utils/combine-event-handlers.ts
+function combineEventHandlers() {
+	let handlers = [];
+	function setHandlers(eventHandlers) {
+		handlers = eventHandlers;
+	}
+	function combinedEventHandler(...args) {
+		for (let i = handlers.length - 1; i >= 0; i--) if (handlers[i](...args)) return true;
+		return false;
+	}
+	return [setHandlers, combinedEventHandler];
 }
 
 //#endregion
-//#region src/utils/merge-objects.ts
-function mergeObjects(...objects) {
-	const filteredObjects = objects.filter(isNotNullish).map(removeUndefinedValues);
-	return Object.assign({}, ...filteredObjects);
+//#region src/extensions/events/dom-event.ts
+/**
+* @internal
+*/
+function defineDomEventFacetPayload(...payloads) {
+	return defineFacetPayload(domEventFacet, payloads);
 }
-
-//#endregion
-//#region src/utils/merge-specs.ts
-function mergeSpecs(a, b) {
-	const attrs = {};
-	const attrNames = new Set([...Object.keys(a.attrs ?? {}), ...Object.keys(b.attrs ?? {})]);
-	for (const name of attrNames) {
-		const attrSpecA = a.attrs?.[name];
-		const attrSpecB = b.attrs?.[name];
-		const attrSpecMerged = mergeObjects(attrSpecA, attrSpecB);
-		if (attrSpecMerged) attrs[name] = attrSpecMerged;
-	}
-	return mergeObjects(a, b, {
-		attrs,
-		parseDOM: [...a.parseDOM ?? [], ...b.parseDOM ?? []]
-	});
+/**
+* Register a new event handler for the given event type.
+*
+* @public
+*/
+function defineDOMEventHandler(event, handler) {
+	return defineDomEventFacetPayload([event, handler]);
 }
-
-//#endregion
-//#region src/utils/output-spec.ts
-function wrapOutputSpecAttrs(toDOM, options) {
-	return (node, ...args) => {
-		return insertOutputSpecAttrs(toDOM(node, ...args), options.map((option) => option.toDOM?.(node.attrs[option.attr])).filter(isNotNullish));
-	};
-}
-function wrapTagParseRuleAttrs(rule, options) {
-	const existingGetAttrs = rule.getAttrs;
-	const existingAttrs = rule.attrs;
-	return {
-		...rule,
-		getAttrs: (dom) => {
-			const baseAttrs = existingGetAttrs?.(dom) ?? existingAttrs ?? {};
-			if (baseAttrs === false || !dom || !isElementLike(dom)) return baseAttrs ?? null;
-			const insertedAttrs = {};
-			for (const option of options) if (option.parseDOM) insertedAttrs[option.attr] = option.parseDOM(dom);
-			return {
-				...baseAttrs,
-				...insertedAttrs
-			};
-		}
-	};
-}
-function insertOutputSpecAttrs(dom, attrs) {
-	if (!dom) return dom;
-	if (Array.isArray(dom)) {
-		const rest = dom.slice(1);
-		let oldAttrs;
-		if (rest.length > 0 && (rest[0] == null || typeof rest[0] === "object")) oldAttrs = rest.shift();
-		else oldAttrs = {};
-		const newAttrs = setObjectAttributes(oldAttrs, attrs);
-		return [
-			dom[0],
-			newAttrs,
-			...rest
-		];
-	}
-	if (isElementLike(dom)) return setElementAttributes(dom, attrs);
-	if (typeof dom === "object" && "dom" in dom && isElementLike(dom.dom)) return {
-		...dom,
-		dom: setElementAttributes(dom.dom, attrs)
-	};
-	return dom;
-}
-function setObjectAttributes(obj, attrs) {
-	obj = { ...obj };
-	for (const [key, value] of attrs) {
-		const oldValue = obj[key];
-		obj[key] = key === "style" ? joinStyles(value, typeof oldValue === "string" ? oldValue : "") : value;
-	}
-	return obj;
-}
-function setElementAttributes(element, attrs) {
-	element = element.cloneNode(true);
-	for (const [key, value] of attrs) {
-		const oldValue = element.getAttribute(key);
-		const newValue = key === "style" ? joinStyles(value, typeof oldValue === "string" ? oldValue : "") : value;
-		element.setAttribute(key, newValue);
-	}
-	return element;
-}
-function joinStyles(...styles) {
-	return styles.map((style) => style.trim().replace(/;$/, "")).filter(Boolean).join("; ");
-}
-
-//#endregion
-//#region src/extensions/node-spec.ts
-/**
-* Defines a node type.
-*
-* @public
-*/
-function defineNodeSpec(options) {
-	return defineFacetPayload(nodeSpecFacet, [[options, void 0]]);
-}
-/**
-* Defines an attribute for a node type.
-*
-* @public
-*/
-function defineNodeAttr(options) {
-	return defineFacetPayload(nodeSpecFacet, [[void 0, options]]);
-}
-const nodeSpecFacet = defineFacet({
-	reducer: (payloads) => {
-		let specs = OrderedMap.from({});
-		let topNodeName = void 0;
-		const specPayloads = payloads.map((input) => input[0]).filter(isNotNullish);
-		const attrPayloads = payloads.map((input) => input[1]).filter(isNotNullish);
-		for (const { name, topNode, ...spec } of specPayloads) {
-			if (topNode) topNodeName = name;
-			const prevSpec = specs.get(name);
-			if (prevSpec) specs = specs.update(name, mergeSpecs(prevSpec, spec));
-			else specs = specs.addToStart(name, spec);
-		}
-		const groupedAttrs = groupBy(attrPayloads, (payload) => payload.type);
-		for (const [type, attrs] of Object.entries(groupedAttrs)) {
-			if (!attrs) continue;
-			const maybeSpec = specs.get(type);
-			assert(maybeSpec, `Node type ${type} must be defined`);
-			const spec = clone(maybeSpec);
-			if (!spec.attrs) spec.attrs = {};
-			for (const attr of attrs) spec.attrs[attr.attr] = {
-				default: attr.default,
-				validate: attr.validate,
-				splittable: attr.splittable
-			};
-			if (spec.toDOM) spec.toDOM = wrapOutputSpecAttrs(spec.toDOM, attrs);
-			if (spec.parseDOM) spec.parseDOM = spec.parseDOM.map((rule) => wrapTagParseRuleAttrs(rule, attrs));
-			specs = specs.update(type, spec);
-		}
-		return {
-			nodes: specs,
-			topNode: topNodeName
-		};
-	},
-	parent: schemaSpecFacet,
-	singleton: true
-});
-
-//#endregion
-//#region src/extensions/doc.ts
-/**
-* @public
-*
-* @deprecated Use the following import instead:
-*
-* ```ts
-* import { defineDoc } from 'prosekit/extensions/doc'
-* ```
-*/
-function defineDoc() {
-	console.warn("[prosekit] The `defineDoc` function from `prosekit/core` is deprecated. Use the following import instead: `import { defineDoc } from \"prosekit/extensions/doc\"`.");
-	return defineNodeSpec({
-		name: "doc",
-		content: "block+",
-		topNode: true
-	});
-}
-
-//#endregion
-//#region src/extensions/events/plugin-view.ts
-/**
-* Registers a event handler that is called when the editor view is mounted.
-*
-* @public
-*/
-function defineMountHandler(handler) {
-	return definePluginViewFacetPayload(["mount", handler]);
-}
-/**
-* Registers a event handler that is called when the editor state is updated.
-*
-* @public
-*/
-function defineUpdateHandler(handler) {
-	return definePluginViewFacetPayload(["update", handler]);
-}
-/**
-* Registers a event handler that is called when the editor view is unmounted.
-*
-* @public
-*/
-function defineUnmountHandler(handler) {
-	return definePluginViewFacetPayload(["unmount", handler]);
-}
-function definePluginViewFacetPayload(input) {
-	return defineFacetPayload(pluginViewFacet, [input]);
-}
-const pluginViewFacet = defineFacet({
-	reduce: () => {
-		let mountHandlers = [];
-		let updateHandlers = [];
-		let unmountHandlers = [];
-		const plugin = new ProseMirrorPlugin({
-			key: pluginKey,
-			view: (view) => {
-				mountHandlers.forEach((fn) => fn(view));
-				return {
-					update: (view$1, prevState) => {
-						updateHandlers.forEach((fn) => fn(view$1, prevState));
-					},
-					destroy: () => {
-						unmountHandlers.forEach((fn) => fn());
-					}
-				};
-			}
-		});
-		const register = (input) => {
-			mountHandlers = [];
-			updateHandlers = [];
-			unmountHandlers = [];
-			for (const args of input) switch (args[0]) {
-				case "mount":
-					mountHandlers.push(args[1]);
-					break;
-				case "update":
-					updateHandlers.push(args[1]);
-					break;
-				case "unmount":
-					unmountHandlers.push(args[1]);
-					break;
-			}
-		};
-		return function reducer(input) {
-			register(input);
-			return plugin;
-		};
-	},
-	parent: pluginFacet,
-	singleton: true
-});
-const pluginKey = new PluginKey("prosekit-plugin-view-handler");
-
-//#endregion
-//#region src/extensions/events/doc-change.ts
-/**
-* Registers a event handler that is called when the editor document is changed.
-*
-* @public
-*/
-function defineDocChangeHandler(handler) {
-	return defineUpdateHandler((view, prevState) => {
-		if (!view.state.doc.eq(prevState.doc)) handler(view, prevState);
-	});
-}
-
-//#endregion
-//#region src/utils/combine-event-handlers.ts
-function combineEventHandlers() {
-	let handlers = [];
-	function setHandlers(eventHandlers) {
-		handlers = toReversed(eventHandlers);
-	}
-	function combinedEventHandler(...args) {
-		for (const handler of handlers) if (handler(...args)) return true;
-		return false;
-	}
-	return [setHandlers, combinedEventHandler];
-}
-
-//#endregion
-//#region src/extensions/events/dom-event.ts
-/**
-* @internal
-*/
-function defineDomEventFacetPayload(...payloads) {
-	return defineFacetPayload(domEventFacet, payloads);
-}
-/**
-* Register a new event handler for the given event type.
-*
-* @public
-*/
-function defineDOMEventHandler(event, handler) {
-	return defineDomEventFacetPayload([event, handler]);
-}
-/**
-* @internal
-*/
-const domEventFacet = defineFacet({
-	reduce: () => {
-		const setHandlersMap = {};
-		const combinedHandlerMap = {};
-		let plugin;
-		const update = (payloads) => {
-			let hasNewEvent = false;
-			for (const [event] of payloads) if (!setHandlersMap[event]) {
-				hasNewEvent = true;
-				const [setHandlers, combinedHandler] = combineEventHandlers();
-				setHandlersMap[event] = setHandlers;
-				const e = (view, eventObject) => {
-					return combinedHandler(view, eventObject);
-				};
-				combinedHandlerMap[event] = e;
-			}
-			const map = groupEntries(payloads);
-			for (const [event, setHandlers] of Object.entries(setHandlersMap)) setHandlers(map[event] ?? []);
-			if (hasNewEvent) plugin = new ProseMirrorPlugin({
-				key: new PluginKey("prosekit-dom-event-handler"),
-				props: { handleDOMEvents: combinedHandlerMap }
-			});
-		};
-		return function reducer(inputs) {
-			update(inputs);
-			return plugin ?? [];
-		};
-	},
-	parent: pluginFacet,
-	singleton: true
-});
+/**
+* @internal
+*/
+const domEventFacet = defineFacet({
+	reduce: () => {
+		const setHandlersMap = {};
+		const combinedHandlerMap = {};
+		let plugin;
+		const update = (payloads) => {
+			let hasNewEvent = false;
+			for (const [event] of payloads) if (!setHandlersMap[event]) {
+				hasNewEvent = true;
+				const [setHandlers, combinedHandler] = combineEventHandlers();
+				setHandlersMap[event] = setHandlers;
+				combinedHandlerMap[event] = combinedHandler;
+			}
+			const map = groupEntries(payloads);
+			for (const [event, setHandlers] of Object.entries(setHandlersMap)) setHandlers(map[event] ?? []);
+			if (hasNewEvent) plugin = new ProseMirrorPlugin({
+				key: new PluginKey("prosekit-dom-event-handler"),
+				props: { handleDOMEvents: combinedHandlerMap }
+			});
+		};
+		return function reducer(inputs) {
+			update(inputs);
+			return plugin ?? [];
+		};
+	},
+	parent: pluginFacet,
+	singleton: true
+});
 
 //#endregion
 //#region src/extensions/events/editor-event.ts
@@ -1161,69 +1034,38 @@ const isApple = typeof navigator !== "undefined" ? /Mac|iP(hone|[ao]d)/.test(nav
 *
 * @public
 */
-function defineKeymap(keymap$1) {
-	return defineFacetPayload(keymapFacet, [keymap$1]);
+function defineKeymap(keymap) {
+	return defineFacetPayload(keymapFacet, [keymap]);
 }
 /**
 * @internal
 */
 const keymapFacet = defineFacet({
 	reduce: () => {
-		let handler;
-		const handlerWrapper = (view, event) => {
-			if (handler) return handler(view, event);
+		let subHandlers = [];
+		const rootHandler = (view, event) => {
+			for (const handler of subHandlers) if (handler(view, event)) return true;
 			return false;
 		};
 		const plugin = new Plugin({
 			key: keymapPluginKey,
-			props: { handleKeyDown: handlerWrapper }
+			props: { handleKeyDown: rootHandler }
 		});
 		return (keymaps) => {
-			handler = keydownHandler(mergeKeymaps(toReversed(keymaps)));
+			subHandlers = keymaps.map(keydownHandler).reverse();
 			return plugin;
 		};
 	},
 	parent: pluginFacet,
 	singleton: true
 });
-function mergeKeymaps(keymaps) {
-	const bindings = {};
-	for (const keymap$1 of keymaps) for (const [key, command] of Object.entries(keymap$1)) {
-		const normalizedKey = normalizeKeyName(key);
-		(bindings[normalizedKey] ||= []).push(command);
-	}
-	return mapValues(bindings, mergeCommands);
-}
-function mergeCommands(commands$1) {
-	return chainCommands(...commands$1);
-}
-function normalizeKeyName(name) {
-	let parts = name.split(/-(?!$)/), result = parts[parts.length - 1];
-	if (result == "Space") result = " ";
-	let alt, ctrl, shift, meta;
-	for (let i = 0; i < parts.length - 1; i++) {
-		let mod = parts[i];
-		if (/^(cmd|meta|m)$/i.test(mod)) meta = true;
-		else if (/^a(lt)?$/i.test(mod)) alt = true;
-		else if (/^(c|ctrl|control)$/i.test(mod)) ctrl = true;
-		else if (/^s(hift)?$/i.test(mod)) shift = true;
-		else if (/^mod$/i.test(mod)) if (isApple) meta = true;
-		else ctrl = true;
-		else throw new Error("Unrecognized modifier name: " + mod);
-	}
-	if (alt) result = "Alt-" + result;
-	if (ctrl) result = "Ctrl-" + result;
-	if (meta) result = "Meta-" + result;
-	if (shift) result = "Shift-" + result;
-	return result;
-}
 const keymapPluginKey = new PluginKey("prosekit-keymap");
 
 //#endregion
 //#region src/extensions/history.ts
 const keymap = {
 	"Mod-z": undo,
-	"Shift-Mod-z": redo
+	"Mod-Z": redo
 };
 if (!isApple) keymap["Mod-y"] = redo;
 const commands = {
@@ -1248,25 +1090,168 @@ function defineHistory({ depth = 200, newGroupDelay = 250 } = {}) {
 //#region src/extensions/keymap-base.ts
 const customEnter = chainCommands(newlineInCode, createParagraphNear, liftEmptyBlock, splitSplittableBlock);
 const customBackspace = chainCommands(deleteSelection, joinTextblockBackward, selectNodeBackward);
-const customBaseKeymap = {
-	...baseKeymap,
-	Enter: customEnter,
-	Backspace: customBackspace
-};
 /**
 * Defines some basic key bindings.
 *
+* @param options
+*
 * @public
 */
-function defineBaseKeymap(options) {
-	const priority = options?.priority ?? Priority.low;
-	return withPriority(defineKeymap(customBaseKeymap), priority);
+function defineBaseKeymap({ priority = Priority.low, preferBlockSelection = true } = {}) {
+	return withPriority(defineKeymap({
+		...baseKeymap,
+		"Mod-a": preferBlockSelection ? chainCommands(selectBlockCommand, selectAll$1) : selectAll$1,
+		"Enter": customEnter,
+		"Backspace": customBackspace
+	}), priority);
+}
+
+//#endregion
+//#region src/facets/schema-spec.ts
+const schemaSpecFacet = defineFacet({
+	reducer: (specs) => {
+		let nodes = OrderedMap.from({});
+		let marks = OrderedMap.from({});
+		let topNode = void 0;
+		for (const spec of specs) {
+			nodes = nodes.append(spec.nodes);
+			marks = marks.append(spec.marks ?? {});
+			topNode = topNode ?? spec.topNode;
+		}
+		return {
+			nodes,
+			marks,
+			topNode
+		};
+	},
+	parent: schemaFacet,
+	singleton: true
+});
+
+//#endregion
+//#region src/utils/remove-undefined-values.ts
+function removeUndefinedValues(obj) {
+	const result = {};
+	for (const [key, value] of Object.entries(obj)) if (value !== void 0) result[key] = value;
+	return result;
+}
+
+//#endregion
+//#region src/utils/merge-objects.ts
+function mergeObjects(...objects) {
+	const filteredObjects = objects.filter(isNotNullish).map(removeUndefinedValues);
+	return Object.assign({}, ...filteredObjects);
+}
+
+//#endregion
+//#region src/utils/merge-specs.ts
+function mergeSpecs(a, b) {
+	const attrs = {};
+	const attrNames = new Set([...Object.keys(a.attrs ?? {}), ...Object.keys(b.attrs ?? {})]);
+	for (const name of attrNames) {
+		const attrSpecA = a.attrs?.[name];
+		const attrSpecB = b.attrs?.[name];
+		const attrSpecMerged = mergeObjects(attrSpecA, attrSpecB);
+		if (attrSpecMerged) attrs[name] = attrSpecMerged;
+	}
+	return mergeObjects(a, b, {
+		attrs,
+		parseDOM: [...a.parseDOM ?? [], ...b.parseDOM ?? []]
+	});
+}
+
+//#endregion
+//#region src/utils/output-spec.ts
+function wrapOutputSpecAttrs(toDOM, options) {
+	return (node, ...args) => {
+		return insertOutputSpecAttrs(toDOM(node, ...args), options.map((option) => option.toDOM?.(node.attrs[option.attr])).filter(isNotNullish));
+	};
+}
+function wrapTagParseRuleAttrs(rule, options) {
+	const existingGetAttrs = rule.getAttrs;
+	const existingAttrs = rule.attrs;
+	return {
+		...rule,
+		getAttrs: (dom) => {
+			const baseAttrs = existingGetAttrs?.(dom) ?? existingAttrs ?? {};
+			if (baseAttrs === false || !dom || !isElementLike(dom)) return baseAttrs ?? null;
+			const insertedAttrs = {};
+			for (const option of options) if (option.parseDOM) insertedAttrs[option.attr] = option.parseDOM(dom);
+			return {
+				...baseAttrs,
+				...insertedAttrs
+			};
+		}
+	};
+}
+function wrapParseRuleAttrs(rule, attrs) {
+	if (rule.tag) return wrapTagParseRuleAttrs(rule, attrs);
+	return rule;
+}
+function insertOutputSpecAttrs(dom, attrs) {
+	if (!dom) return dom;
+	if (Array.isArray(dom)) {
+		const rest = dom.slice(1);
+		let oldAttrs;
+		if (rest.length > 0 && (rest[0] == null || typeof rest[0] === "object")) oldAttrs = rest.shift();
+		else oldAttrs = {};
+		const newAttrs = setObjectAttributes(oldAttrs, attrs);
+		return [
+			dom[0],
+			newAttrs,
+			...rest
+		];
+	}
+	if (isElementLike(dom)) return setElementAttributes(dom, attrs);
+	if (typeof dom === "object" && "dom" in dom && isElementLike(dom.dom)) return {
+		...dom,
+		dom: setElementAttributes(dom.dom, attrs)
+	};
+	return dom;
+}
+function setObjectAttributes(obj, attrs) {
+	obj = { ...obj };
+	for (const [key, value] of attrs) {
+		const oldValue = obj[key];
+		const newValue = key === "style" ? joinStyles(value, typeof oldValue === "string" ? oldValue : "") : value;
+		obj[key] = newValue;
+	}
+	return obj;
+}
+function setElementAttributes(element, attrs) {
+	element = element.cloneNode(true);
+	for (const [key, value] of attrs) {
+		const oldValue = element.getAttribute(key);
+		const newValue = key === "style" ? joinStyles(value, typeof oldValue === "string" ? oldValue : "") : value;
+		element.setAttribute(key, newValue);
+	}
+	return element;
+}
+function joinStyles(...styles) {
+	return styles.map((style) => style.trim().replace(/;$/, "")).filter(Boolean).join("; ");
 }
 
 //#endregion
 //#region src/extensions/mark-spec.ts
 /**
+* Defines a mark type into the editor schema.
+*
 * @public
+*
+* @example
+*
+* ```ts
+* const extension = defineMarkSpec({
+*   name: 'bold',
+*   parseDOM: [
+*     { tag: 'strong' },
+*     { tag: 'b' },
+*   ],
+*   toDOM() {
+*     return ['strong', 0]
+*   },
+* })
+* ```
 */
 function defineMarkSpec(options) {
 	return defineFacetPayload(markSpecFacet, [[options, void 0]]);
@@ -1287,20 +1272,22 @@ const markSpecFacet = defineFacet({
 			if (prevSpec) specs = specs.update(name, mergeSpecs(prevSpec, spec));
 			else specs = specs.addToStart(name, spec);
 		}
-		const groupedAttrs = groupBy(attrPayloads, (payload) => payload.type);
-		for (const [type, attrs] of Object.entries(groupedAttrs)) {
+		const groupedAttrs = mapGroupBy(attrPayloads, (payload) => payload.type);
+		for (const [type, attrs] of groupedAttrs.entries()) {
 			if (!attrs) continue;
-			const maybeSpec = specs.get(type);
-			assert(maybeSpec, `Mark type ${type} must be defined`);
-			const spec = clone(maybeSpec);
-			if (!spec.attrs) spec.attrs = {};
-			for (const attr of attrs) spec.attrs[attr.attr] = {
+			const oldSpec = specs.get(type);
+			assert(oldSpec, `Mark type ${type} must be defined`);
+			const newSpec = {
+				...oldSpec,
+				attrs: { ...oldSpec.attrs }
+			};
+			for (const attr of attrs) newSpec.attrs[attr.attr] = {
 				default: attr.default,
 				validate: attr.validate
 			};
-			if (spec.toDOM) spec.toDOM = wrapOutputSpecAttrs(spec.toDOM, attrs);
-			if (spec.parseDOM) spec.parseDOM = spec.parseDOM.map((rule) => wrapParseRuleAttrs(rule, attrs));
-			specs = specs.update(type, spec);
+			if (oldSpec.toDOM) newSpec.toDOM = wrapOutputSpecAttrs(oldSpec.toDOM, attrs);
+			if (oldSpec.parseDOM) newSpec.parseDOM = oldSpec.parseDOM.map((rule) => wrapParseRuleAttrs(rule, attrs));
+			specs = specs.update(type, newSpec);
 		}
 		return {
 			marks: specs,
@@ -1310,10 +1297,6 @@ const markSpecFacet = defineFacet({
 	parent: schemaSpecFacet,
 	singleton: true
 });
-function wrapParseRuleAttrs(rule, attrs) {
-	if (rule.tag) return wrapTagParseRuleAttrs(rule, attrs);
-	return rule;
-}
 
 //#endregion
 //#region src/extensions/mark-view.ts
@@ -1354,7 +1337,7 @@ const markViewFactoryFacet = defineFacet({
 		const factories = inputs.map((x) => x[0]).filter(isNotNullish);
 		const options = inputs.map((x) => x[1]).filter(isNotNullish);
 		for (const { group, name, args } of options) {
-			const factory = factories.find((factory$1) => factory$1.group === group);
+			const factory = factories.find((factory) => factory.group === group);
 			if (!factory) continue;
 			markViews[name] = factory.factory(args);
 		}
@@ -1366,6 +1349,77 @@ const markViewFactoryFacet = defineFacet({
 	parent: pluginFacet
 });
 
+//#endregion
+//#region src/extensions/node-spec.ts
+/**
+* Defines a node type into the editor schema.
+*
+* @public
+*
+* @example
+*
+* ```ts
+* const extension = defineNodeSpec({
+*   name: 'fancyParagraph',
+*   content: 'inline*',
+*   group: 'block',
+*   parseDOM: [{ tag: 'p.fancy' }],
+*   toDOM() {
+*     return ['p', { 'class': 'fancy' }, 0]
+*   },
+* })
+* ```
+*/
+function defineNodeSpec(options) {
+	return defineFacetPayload(nodeSpecFacet, [[options, void 0]]);
+}
+/**
+* Defines an attribute for a node type.
+*
+* @public
+*/
+function defineNodeAttr(options) {
+	return defineFacetPayload(nodeSpecFacet, [[void 0, options]]);
+}
+const nodeSpecFacet = defineFacet({
+	reducer: (payloads) => {
+		let specs = OrderedMap.from({});
+		let topNodeName = void 0;
+		const specPayloads = payloads.map((input) => input[0]).filter(isNotNullish);
+		const attrPayloads = payloads.map((input) => input[1]).filter(isNotNullish);
+		for (const { name, topNode, ...spec } of specPayloads) {
+			if (topNode) topNodeName = name;
+			const prevSpec = specs.get(name);
+			if (prevSpec) specs = specs.update(name, mergeSpecs(prevSpec, spec));
+			else specs = specs.addToStart(name, spec);
+		}
+		const groupedAttrs = mapGroupBy(attrPayloads, (payload) => payload.type);
+		for (const [type, attrs] of groupedAttrs.entries()) {
+			if (!attrs) continue;
+			const oldSpec = specs.get(type);
+			assert(oldSpec, `Node type ${type} must be defined`);
+			const newSpec = {
+				...oldSpec,
+				attrs: { ...oldSpec.attrs }
+			};
+			for (const attr of attrs) newSpec.attrs[attr.attr] = {
+				default: attr.default,
+				validate: attr.validate,
+				splittable: attr.splittable
+			};
+			if (oldSpec.toDOM) newSpec.toDOM = wrapOutputSpecAttrs(oldSpec.toDOM, attrs);
+			if (oldSpec.parseDOM) newSpec.parseDOM = oldSpec.parseDOM.map((rule) => wrapTagParseRuleAttrs(rule, attrs));
+			specs = specs.update(type, newSpec);
+		}
+		return {
+			nodes: specs,
+			topNode: topNodeName
+		};
+	},
+	parent: schemaSpecFacet,
+	singleton: true
+});
+
 //#endregion
 //#region src/extensions/node-view.ts
 function defineNodeView(options) {
@@ -1405,7 +1459,7 @@ const nodeViewFactoryFacet = defineFacet({
 		const factories = inputs.map((x) => x[0]).filter(isNotNullish);
 		const options = inputs.map((x) => x[1]).filter(isNotNullish);
 		for (const { group, name, args } of options) {
-			const factory = factories.find((factory$1) => factory$1.group === group);
+			const factory = factories.find((factory) => factory.group === group);
 			if (!factory) continue;
 			nodeViews[name] = factory.factory(args);
 		}
@@ -1417,57 +1471,6 @@ const nodeViewFactoryFacet = defineFacet({
 	parent: pluginFacet
 });
 
-//#endregion
-//#region src/extensions/paragraph.ts
-/**
-* Defines a paragraph node spec.
-*/
-function defineParagraphSpec() {
-	return defineNodeSpec({
-		name: "paragraph",
-		content: "inline*",
-		group: "block",
-		parseDOM: [{ tag: "p" }],
-		toDOM() {
-			return ["p", 0];
-		}
-	});
-}
-/**
-* @public
-*
-* Defines a paragraph node spec as the highest priority, because it should be the default block node for most cases.
-*
-* @deprecated Use the following import instead:
-*
-* ```ts
-* import { defineParagraph } from 'prosekit/extensions/paragraph'
-* ```
-*/
-function defineParagraph() {
-	console.warn("[prosekit] The `defineParagraph` function from `prosekit/core` is deprecated. Use the following import instead: `import { defineParagraph } from \"prosekit/extensions/paragraph\"`.");
-	return withPriority(defineParagraphSpec(), Priority.highest);
-}
-
-//#endregion
-//#region src/extensions/text.ts
-/**
-* @public
-*
-* @deprecated Use the following import instead:
-*
-* ```ts
-* import { defineText } from 'prosekit/extensions/text'
-* ```
-*/
-function defineText() {
-	console.warn("[prosekit] The `defineText` function from `prosekit/core` is deprecated. Use the following import instead: `import { defineText } from \"prosekit/extensions/text\"`.");
-	return defineNodeSpec({
-		name: "text",
-		group: "inline"
-	});
-}
-
 //#endregion
 //#region src/utils/can-use-regex-lookbehind.ts
 /**
@@ -1475,7 +1478,7 @@ function defineText() {
 */
 const canUseRegexLookbehind = once(() => {
 	try {
-		return "ab".replace(new RegExp("(?<=a)b", "g"), "c") === "ac";
+		return "ab".replace(/* @__PURE__ */ new RegExp("(?<=a)b", "g"), "c") === "ac";
 	} catch {
 		return false;
 	}
@@ -1492,41 +1495,6 @@ const canUseRegexLookbehind = once(() => {
 */
 const clsx = clsxLite;
 
-//#endregion
-//#region src/utils/collect-children.ts
-/**
-* Collects all children of a node or a fragment, and returns them as an array.
-*
-* @deprecated Use `node.children` or `fragment.content` instead.
-*
-* @hidden
-*/
-function collectChildren(parent) {
-	const children = [];
-	for (let i = 0; i < parent.childCount; i++) children.push(parent.child(i));
-	return children;
-}
-
-//#endregion
-//#region src/utils/collect-nodes.ts
-/**
-* Collects all nodes from a given content.
-*
-* @deprecated Use `collectChildren` instead.
-*
-* @hidden
-*/
-function collectNodes(content) {
-	if (Array.isArray(content)) return content.flatMap(collectNodes);
-	if (content instanceof ProseMirrorNode) return [content];
-	if (content instanceof ProseMirrorFragment) {
-		const nodes = [];
-		for (let i = 0; i < content.childCount; i++) nodes.push(content.child(i));
-		return nodes;
-	}
-	throw new ProseKitError(`Invalid node content: ${typeof content}`);
-}
-
 //#endregion
 //#region src/utils/contains-inline-node.ts
 /**
@@ -1542,18 +1510,44 @@ function containsInlineNode(doc, from, to) {
 }
 
 //#endregion
-//#region src/utils/get-id.ts
-let id = 0;
+//#region src/utils/find-node.ts
 /**
-* Returns a unique id in the current process that can be used in various places.
+* Finds the first node that satisfies the predicate from the given document.
 *
 * @internal
+*/
+function findNode(doc, predicate) {
+	let found;
+	doc.descendants((node, pos, parent, index) => {
+		if (found) return false;
+		if (predicate(node)) {
+			found = {
+				node,
+				pos,
+				parent,
+				index
+			};
+			return false;
+		}
+	});
+	return found;
+}
+/**
+* Finds all nodes that satisfy the predicate from the given document.
 *
-* @deprecated Import `getId` from `@ocavue/utils` package instead. Remove it in a future version.
+* @internal
 */
-function getId() {
-	id = (id + 1) % Number.MAX_SAFE_INTEGER;
-	return `id:${id}`;
+function findNodes(doc, predicate) {
+	const results = [];
+	doc.descendants((node, pos, parent, index) => {
+		if (predicate(node)) results.push({
+			node,
+			pos,
+			parent,
+			index
+		});
+	});
+	return results;
 }
 
 //#endregion
@@ -1612,5 +1606,5 @@ function withSkipCodeBlock(command) {
 }
 
 //#endregion
-export { Editor, EditorNotFoundError, OBJECT_REPLACEMENT_CHARACTER, Priority, ProseKitError, getId as _getId, addMark, assert, canUseRegexLookbehind, clsx, collectChildren, collectNodes, containsInlineNode, createEditor, defaultBlockAt, defineBaseCommands, defineBaseKeymap, defineClickHandler, defineClickOnHandler, defineClipboardSerializer, defineCommands, defineDOMEventHandler, defineDefaultState, defineDoc, defineDocChangeHandler, defineDoubleClickHandler, defineDoubleClickOnHandler, defineDropHandler, defineFacet, defineFacetPayload, defineFocusChangeHandler, defineHistory, defineKeyDownHandler, defineKeyPressHandler, defineKeymap, defineMarkAttr, defineMarkSpec, defineMarkView, defineMarkViewComponent, defineMarkViewFactory, defineMountHandler, defineNodeAttr, defineNodeSpec, defineNodeView, defineNodeViewComponent, defineNodeViewFactory, defineParagraph, definePasteHandler, definePlugin, defineScrollToSelectionHandler, defineText, defineTextInputHandler, defineTripleClickHandler, defineTripleClickOnHandler, defineUnmountHandler, defineUpdateHandler, editorEventFacet, elementFromJSON, elementFromNode, expandMark, findParentNode, findParentNodeOfType, getMarkType, getNodeType, htmlFromJSON, htmlFromNode, insertDefaultBlock, insertNode, isAllSelection, isApple, isAtBlockStart, isFragment, isInCodeBlock, isMark, isMarkAbsent, isMarkActive, isNodeSelection, isProseMirrorNode, isSelection, isSlice, isTextSelection, jsonFromHTML, jsonFromNode, jsonFromState, keymapFacet, maybeRun, nodeFromElement, nodeFromHTML, nodeFromJSON, pluginFacet, removeMark, removeNode, setBlockType, setNodeAttrs, setSelectionAround, stateFromJSON, toggleMark, toggleNode, toggleWrap, union, unsetBlockType, unsetMark, withPriority, withSkipCodeBlock, wrap };
+export { Editor, EditorNotFoundError, OBJECT_REPLACEMENT_CHARACTER, Priority, ProseKitError, addMark, assert, canUseRegexLookbehind, clsx, containsInlineNode, createEditor, defaultBlockAt, defineBaseCommands, defineBaseKeymap, defineClickHandler, defineClickOnHandler, defineClipboardSerializer, defineCommands, defineDOMEventHandler, defineDefaultState, defineDocChangeHandler, defineDoubleClickHandler, defineDoubleClickOnHandler, defineDropHandler, defineFacet, defineFacetPayload, defineFocusChangeHandler, defineHistory, defineKeyDownHandler, defineKeyPressHandler, defineKeymap, defineMarkAttr, defineMarkSpec, defineMarkView, defineMarkViewComponent, defineMarkViewFactory, defineMountHandler, defineNodeAttr, defineNodeSpec, defineNodeView, defineNodeViewComponent, defineNodeViewFactory, definePasteHandler, definePlugin, defineScrollToSelectionHandler, defineTextInputHandler, defineTripleClickHandler, defineTripleClickOnHandler, defineUnmountHandler, defineUpdateHandler, editorEventFacet, elementFromJSON, elementFromNode, expandMark, findNode, findNodes, findParentNode, findParentNodeOfType, getMarkType, getNodeType, htmlFromJSON, htmlFromNode, insertDefaultBlock, insertNode, isAllSelection, isApple, isAtBlockStart, isFragment, isInCodeBlock, isMark, isMarkAbsent, isMarkActive, isNodeSelection, isProseMirrorNode, isSelection, isSlice, isTextSelection, jsonFromHTML, jsonFromNode, jsonFromState, keymapFacet, maybeRun, nodeFromElement, nodeFromHTML, nodeFromJSON, pluginFacet, removeMark, removeNode, selectAll, selectBlock, setBlockType, setNodeAttrs, setNodeAttrsBetween, setSelectionAround, stateFromJSON, toggleMark, toggleNode, toggleWrap, union, unsetBlockType, unsetMark, withPriority, withSkipCodeBlock, wrap };
 //# sourceMappingURL=prosekit-core.js.map