@witchcraft/editor 0.0.1

package/src/runtime/pm/features/Blocks/commands/copyOrMoveItem.ts

@@ -0,0 +1,179 @@
+/**
+ * Copies/moves an item to be before/after/child of the target item.
+ */
+
+import type { Command } from "@tiptap/core"
+import { Fragment, Slice } from "@tiptap/pm/model"
+import { TextSelection } from "@tiptap/pm/state"
+import { ReplaceAroundStep } from "@tiptap/pm/transform"
+
+import { redirectFromEmbedded } from "../../EmbeddedDocument/utils/redirectFromEmbedded.js"
+
+declare module "@tiptap/core" {
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	interface Commands<ReturnType> {
+		copyOrMoveItem: {
+			/**
+			 * @redirectable
+			 */
+			copyOrMoveItem: (
+				itemPos: number,
+				moveItemPos: number,
+				position: "before" | "after" | "child",
+				options?: {
+					move?: boolean
+				}
+			) => ReturnType
+		}
+	}
+}
+
+/** Copies or moves a single list item. This is for using while dragging an item. */
+export const copyOrMoveItem = ({
+	listNodeTypeName = "list",
+	itemNodeTypeName = "item"
+}: {
+	listNodeTypeName?: string
+	itemNodeTypeName?: string
+} = {}) =>
+	(
+		itemPos: number,
+		moveItemPos: number,
+		position: "before" | "after" | "child",
+		{
+			move = true
+		}: { move?: boolean } = {}
+	): Command =>
+		({ tr, state, view, commands, dispatch }): boolean => {
+			const redirect = redirectFromEmbedded(
+				view,
+				"copyOrMoveItem",
+				{ args: [itemPos, moveItemPos, position, { move }], view, commands }
+			)
+			if (redirect.redirected) {
+				return redirect.result as any // todo
+			}
+
+			const listNode = state.schema.nodes[listNodeTypeName]
+			const itemNode = state.schema.nodes[itemNodeTypeName]
+			const $targetItem = tr.doc.resolve(moveItemPos)
+			const $item = tr.doc.resolve(itemPos)
+			if ($item.node().type.name !== itemNodeTypeName) {
+				throw new Error(`itemPos ${itemPos} does not point to node type ${itemNodeTypeName} but to ${$item.node().type.name}`)
+			}
+			if ($targetItem.node().type.name !== itemNodeTypeName) {
+				throw new Error(`moveItemPos ${moveItemPos} does not point to node type ${itemNodeTypeName} but to ${$targetItem.node().type.name}`)
+			}
+
+			// internally we use $target pointing at the first node of the item (e.g. a paragraph or some other block content)
+			// this makes it easier to tell if it has a list child after the p or not
+			const $target = tr.doc.resolve($targetItem.start() + 1)
+			// sometimes the target is still pointing at an item
+			// this happens with blocks that have no inline content, such as embedded docs
+			// these require some special handling and shifting of positions since we cant resolve to a ResolvedPos whose .node() is the block
+			const targetIsContentless = $target.node().type.name === $targetItem.node().type.name
+			const parent = targetIsContentless ? $targetItem.node() : $target.node(-1)
+			const nodeAfterIsList = parent.childCount > 1 && parent.child(1).type.name === listNodeTypeName
+
+			const { from, to } = state.selection.map(tr.doc, tr.mapping)
+			const beforeItemPos = $item.before()
+			const afterItemPos = $item.after()
+
+			const selectionFromOffset = from > beforeItemPos && from < afterItemPos ? state.selection.from - beforeItemPos : undefined
+			const selectionToOffset = to > beforeItemPos && to < afterItemPos ? state.selection.to - beforeItemPos : undefined
+			function restoreSelection(start: number): void {
+				if (!dispatch) return
+				// attempt to restore selection to inside the item if it was inside
+				// this will also restore it to just the start if it was touching
+				if (selectionFromOffset) {
+					tr.setSelection(TextSelection.create(
+						tr.doc,
+						start + selectionFromOffset,
+						selectionToOffset && selectionToOffset + start
+					))
+				} else if (selectionToOffset) {
+					// otherwise to the end if it was touching
+					tr.setSelection(TextSelection.create(
+						tr.doc,
+						selectionToOffset && selectionToOffset + start
+					))
+				} else {
+					// otherwise to the start of the item
+					const $start = tr.doc.resolve(start)
+					const sel = TextSelection.findFrom($start, 1, true)
+					if (sel) {
+						tr.setSelection(sel)
+					}
+				}
+			}
+
+			const deleteItemIfWanted = (): void => {
+				if (!dispatch) return
+				if (move) {
+					const isLastItem = $item.index(-1) === 0
+					const offset = (isLastItem ? 2 : 1)
+					const start = $item.start() - offset
+					const end = $item.end() + offset
+					tr.delete(start, end)
+				}
+			}
+			if (position === "after") {
+				if (!nodeAfterIsList) {
+					const slice = tr.doc.slice($item.start() - 1, $item.end() + 1)
+					deleteItemIfWanted()
+					if (dispatch) tr.replace(tr.mapping.map($target.end()), undefined, slice)
+					restoreSelection(tr.mapping.map($target.end()) + 2)
+					return true
+				} else {
+					// start/end need to point at the start/end of the child list
+					// this is more foolproof than using .after due to contentless blocks
+					let start = $targetItem.start() + $targetItem.node().child(0).nodeSize
+					let end = start + $targetItem.node().child(1).nodeSize
+					const slice = new Slice(
+						Fragment.from([itemNode.create({}), $item.node()]),
+						1,
+						1
+					)
+					deleteItemIfWanted()
+					start = tr.mapping.map(start)
+					end = tr.mapping.map(end)
+					if (dispatch) {
+						tr.step(new ReplaceAroundStep(
+							start,
+							end,
+							start,
+							end,
+							slice,
+							slice.size,
+							false
+						))
+					}
+					restoreSelection(start + 1)
+					return true
+				}
+			}
+			if (position === "before") {
+				deleteItemIfWanted()
+				const start = tr.mapping.map($target.before(targetIsContentless ? undefined : -1))
+				if (dispatch) tr.insert(start, $item.node())
+				restoreSelection(start)
+				return true
+			}
+			if (position === "child") {
+				const slice = new Slice(
+					Fragment.from([listNode.create({}, $item.node())]),
+					0,
+					nodeAfterIsList ? 1 : 0
+				)
+				deleteItemIfWanted()
+				const unmappedStart = $target.start() + $target.node().child(0).nodeSize + (targetIsContentless ? 0 : 1)
+				const start = tr.mapping.map(unmappedStart)
+				const end = nodeAfterIsList
+					? start + 1
+					: undefined
+				if (dispatch) tr.replace(start, end, slice)
+				restoreSelection(start + 1)
+				return true
+			}
+			return false
+		}

package/src/runtime/pm/features/Blocks/commands/deleteItem.ts

@@ -0,0 +1,24 @@
+import type { Command } from "@tiptap/core"
+
+import { redirectFromEmbedded } from "../../EmbeddedDocument/utils/redirectFromEmbedded.js"
+
+declare module "@tiptap/core" {
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	interface Commands<ReturnType> {
+		deleteItem: {
+			/**
+			 * @redirectable
+			 */
+			deleteItem: (pos?: number | undefined) => ReturnType
+		}
+	}
+}
+
+export const deleteItem = (type: string) =>
+	(pos?: number | undefined): Command =>
+		({ view, commands }): boolean => {
+			const redirect = redirectFromEmbedded(view, "deleteItem", { args: [pos], view, commands })
+			if (redirect.redirected) { return redirect.result as any }
+
+			return commands.deleteNodes(type, pos)
+		}

package/src/runtime/pm/features/Blocks/commands/indentItem.ts

@@ -0,0 +1,105 @@
+import type { Command } from "@tiptap/core"
+import type { Node } from "@tiptap/pm/model"
+import { Fragment, Slice } from "@tiptap/pm/model"
+import { TextSelection } from "@tiptap/pm/state"
+import { ReplaceAroundStep } from "@tiptap/pm/transform"
+
+import { getTypeByName } from "../../../utils/getTypeByName.js"
+import { mapSelection } from "../../../utils/mapSelection.js"
+import { splitIntoChunks } from "../../../utils/splitIntoChunks.js"
+import { redirectFromEmbedded } from "../../EmbeddedDocument/utils/redirectFromEmbedded.js"
+
+declare module "@tiptap/core" {
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	interface Commands<ReturnType> {
+		indentItem: {
+			/**
+			 * @redirectable
+			 */
+			indentItem: (from?: number, to?: number) => ReturnType
+		}
+
+	}
+}
+
+export const indentItem = (
+	itemTypeName: string,
+	listTypeName: string
+) =>
+	(from?: number, to?: number): Command => ({ state, dispatch, tr, editor, view, commands }): boolean => {
+		const redirect = redirectFromEmbedded(view, "indentItem", { args: [from, to], view, commands })
+		if (redirect.redirected) { return redirect.result as any }
+
+		const listType = getTypeByName(editor.schema, listTypeName)
+		const itemType = getTypeByName(editor.schema, itemTypeName)
+
+		const sel = from !== undefined
+			? TextSelection.create(tr.doc, from, to)
+			: state.selection.map(tr.doc, tr.mapping)
+
+		const chunks = splitIntoChunks(tr.doc, itemType, sel)
+		const blockRangeFilter = (node: Node): boolean => node.childCount > 0 && node.firstChild!.type === itemType
+
+		let canChange = false
+		for (const chunk of chunks) {
+			const { $from, $to } = mapSelection(tr, chunk)
+			const range = $from.blockRange($to, blockRangeFilter)
+			if (!range) continue
+			canChange = true
+			const start = range.start
+			const end = range.end
+
+			// A
+			//		B <- first child of A
+			const itemIndex = $from.index(-1)
+			const isFirstChild = itemIndex === 0
+			// A <- nodebefore
+			// B <-
+			const nodeBefore = !isFirstChild
+				? $from.node(-1).child(itemIndex - 1)
+				: undefined
+			// A
+			// 	B <- nested node before
+			// C <-
+			const nodeBeforeIsNested = nodeBefore?.lastChild?.type === listType
+
+			// item [list [item?]]
+			const fragment = Fragment.from(
+				itemType.create(
+					null,
+					Fragment.from(listType.create(
+						null,
+						Fragment.from(nodeBeforeIsNested ? itemType.create() : null)
+					))
+				)
+			)
+
+			// make sibling of previous by leaving /item /list /item open
+			const startOpen = nodeBeforeIsNested
+				? 3
+			// just wrap in list
+				: isFirstChild
+					? 0
+				// nest under sibling by leaving /item open
+					: 1
+
+			const slice = new Slice(
+				fragment,
+				startOpen,
+				0
+			)
+			if (dispatch) {
+				// debugNode(slice, `${slice.openStart}-${slice.openEnd}`)
+				tr.step(new ReplaceAroundStep(
+					start - startOpen,
+					end,
+					start,
+					end,
+					slice,
+					isFirstChild ? 2 : 1,
+					true
+				))
+			}
+		}
+		return canChange
+	}

package/src/runtime/pm/features/Blocks/commands/itemMenuCommands.ts

@@ -0,0 +1,62 @@
+import { unreachable } from "@alanscodelog/utils"
+import type { Command } from "@tiptap/core"
+
+import { findUpwards } from "../../../utils/findUpwards.js"
+import { itemMenuPluginKey } from "../types.js"
+
+declare module "@tiptap/core" {
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	interface Commands<ReturnType> {
+		itemMenu: {
+			openItemMenu: (id?: string) => ReturnType
+			closeItemMenu: (id?: string) => ReturnType
+			toggleItemMenu: (id?: string) => ReturnType
+		}
+	}
+}
+
+declare module "../../../../types/index.js" {
+	interface MenuCloseCommands {
+		closeItemMenu: "closeItemMenu"
+	}
+}
+
+export const openItemMenu = (itemTypeName: string) =>
+	(id?: string): Command =>
+		({ tr, state, dispatch }) => {
+			const menu = itemMenuPluginKey.getState(state)
+			id ??= findUpwards(
+				tr.doc,
+				state.selection.map(tr.doc, tr.mapping).from,
+				$pos => {
+					if ($pos.node().type.name === itemTypeName) return true
+					return false
+				}
+			).$pos?.node().attrs.blockId
+			if (!id) { unreachable() }
+			if (menu?.opened && menu.id === id) return false
+			if (dispatch) {
+				tr.setMeta("addToHistory", false)
+
+				tr.setMeta(itemMenuPluginKey, { opened: true, id })
+			}
+			return true
+		}
+
+export const closeItemMenu = () => (): Command => ({ tr, state, dispatch }) => {
+	const menu = itemMenuPluginKey.getState(state)
+	if (menu && !menu.opened) return false
+	if (dispatch) {
+		tr.setMeta("addToHistory", false)
+		tr.setMeta(itemMenuPluginKey, { opened: false, id: undefined })
+	}
+	return true
+}
+export const toggleItemMenu = () => (id?: string): Command => ({ commands, state }) => {
+	const menu = itemMenuPluginKey.getState(state)
+	if (menu?.opened) {
+		return commands.closeItemMenu()
+	} else {
+		return commands.openItemMenu(id)
+	}
+}

package/src/runtime/pm/features/Blocks/commands/moveItem.ts

@@ -0,0 +1,128 @@
+import type { Command } from "@tiptap/core"
+import type { ResolvedPos } from "@tiptap/pm/model"
+import { TextSelection } from "@tiptap/pm/state"
+
+import { getTypeByName } from "../../../utils/getTypeByName.js"
+import { debugNode } from "../../../utils/internal/debugNode.js"
+import { nodesBetween } from "../../../utils/nodesBetween.js"
+import { redirectFromEmbedded } from "../../EmbeddedDocument/utils/redirectFromEmbedded.js"
+
+declare module "@tiptap/core" {
+
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	interface Commands<ReturnType> {
+		moveItem: {
+			/**
+			 * @redirectable
+			 */
+			moveItem: (
+				dir: "down" | "up",
+				pos?: number,
+			) => ReturnType
+		}
+	}
+}
+export const moveItem = (
+	itemTypeName: string
+) =>
+	(
+		dir: "down" | "up" = "down",
+		pos?: number
+	): Command =>
+		({ state, dispatch, tr, editor, commands, view }): boolean => {
+			const redirect = redirectFromEmbedded(view, "moveItem", { args: [pos], view, commands })
+			if (redirect.redirected) { return redirect.result as any }
+
+			const itemType = getTypeByName(editor.schema, itemTypeName)
+			const { $from, $to, from, to } = pos
+				? TextSelection.create(tr.doc, pos, pos)
+				: state.selection.map(tr.doc, tr.mapping)
+			const sharedDepth = Math.min($from.depth, $to.depth)
+
+			// get a slice of equal depths
+			// - A1
+			// 	- B|1
+			// - A|2
+			// would move A1 to A2
+			const $targetFrom = tr.doc.resolve($from.before($from.depth - sharedDepth - 1) + 1)
+			const $targetTo = tr.doc.resolve($to.before(sharedDepth - $to.depth - 1) + 1)
+			debugNode($targetFrom, `$targetFrom`)
+			debugNode($targetTo, `$targetTo`)
+			const range = $targetFrom.blockRange($targetTo)
+			if (!range) return false
+			const start = range.$from.start()
+			const end = range.$to.end()
+			const slice = tr.doc.slice(start, end)
+
+			const itemBefore = $targetFrom.before()
+			const itemAfter = $targetTo.after()
+			const selectionFromOffset = from > itemBefore && from < itemAfter ? state.selection.from - itemBefore : undefined
+			const selectionToOffset = to > itemBefore && to < itemAfter ? state.selection.to - itemBefore : undefined
+
+			function restoreSelection(start: number): void {
+				if (dispatch && selectionFromOffset) {
+					tr.setSelection(TextSelection.create(
+						tr.doc,
+						start + selectionFromOffset,
+						selectionToOffset && selectionToOffset + start
+					))
+				}
+			}
+
+			if (dir === "up") {
+				const index = $targetFrom.index(-1)
+				const isFirstTopLevelItem = sharedDepth <= 2 && index === 0
+				if (isFirstTopLevelItem) return false
+				const $itemBefore
+					= $targetFrom.index(-1) === 0
+					// get parent
+						? tr.doc.resolve($targetFrom.before(-2) + 1)
+					// get previous sibling
+						: tr.doc.resolve($targetFrom.start() - 2)
+				if (!$itemBefore || $itemBefore.node().type.name !== itemType.name) return false
+				if (dispatch) {
+					tr.delete(start - 2, end + 2)
+					const selStart = tr.mapping.map($itemBefore.start()) - 1
+					tr.insert(tr.mapping.map($itemBefore.start()), slice.content)
+					restoreSelection(selStart)
+				}
+			}
+			if (dir === "down") {
+				// search forward until we find the next item
+				// we don't do something like above, because the next item might be
+				// way further up (less deep), but we can't know how many levels up
+				let $afterItem: ResolvedPos | undefined
+				nodesBetween(tr.doc, {
+					$from: tr.doc.resolve($to.pos),
+					$to: tr.doc.resolve(tr.doc.resolve(0).end())
+
+				}, (node, pos) => {
+					if (!$afterItem && node?.type.name === itemType.name) {
+						$afterItem = tr.doc.resolve(pos + 1)
+					}
+					return false
+				})
+				if (!$afterItem) return false
+				// sibling
+				if ($afterItem.depth === sharedDepth - 1) {
+					if (dispatch) {
+						tr.delete(start - 2, end + 2)
+						const selStart = tr.mapping.map($afterItem.end() + 1)
+						tr.insert(tr.mapping.map($afterItem.end() + 1), slice.content)
+						restoreSelection(selStart)
+					}
+				} else {
+					if (dispatch) {
+						// the next item is at a much higher depth
+						// we make it the child instead
+						const $child = tr.doc.resolve($afterItem.start() + 1)
+						const insertPos = $child.end() + 1
+						tr.delete(start - 2, end + 2)
+						const selStart = tr.mapping.map(insertPos)
+						tr.insert(tr.mapping.map(insertPos), slice.content)
+						restoreSelection(selStart)
+					}
+				}
+			}
+			return true
+		}

package/src/runtime/pm/features/Blocks/commands/setNode.ts

@@ -0,0 +1,186 @@
+import { type Command, getNodeType } from "@tiptap/core"
+import { Fragment, type Node, type NodeType, Slice } from "@tiptap/pm/model"
+import { Selection, TextSelection } from "@tiptap/pm/state"
+
+declare module "@tiptap/core" {
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	interface Commands<ReturnType> {
+		customSetNode: {
+			/**
+			 * Override's tiptaps' setNode with one that:
+			 *
+			 * - Handles non-text node conversions.
+			 * - Can passed a position.
+			 * - Correctly preserves marks (only if allowed by the wanted node type).
+			 * - Attempts to preserve the selection, including inside the node.
+			 *
+			 * Note that if a node does not set it's marks property and it's schema's markSet is null, this function takes it as all marks being allowed.
+			 */
+			setNode: (
+				typeOrName: string | NodeType,
+				attributes?: Record<string, any>,
+				pos?: number
+			) => ReturnType
+		}
+	}
+}
+
+export const setNode = () =>
+	(
+		typeOrName: string | NodeType,
+		attributes = {},
+		pos?: number
+	): Command => ({ state, tr, dispatch }) => {
+		const type = getNodeType(typeOrName, state.schema)
+
+		const $target = tr.doc.resolve(pos ?? tr.selection.from)
+		const targetStart = $target.start()
+		const targetEnd = $target.end()
+		const targetNode = $target.node()
+
+		const selection = tr.selection
+		const offsets: { pos: number, offset: number }[] = []
+		let newNodeStartOffset = 0
+		let oldNodeStartOffset = 0
+		/**
+		 * When a node is not a text block, we grab all the inline text content,
+		 * and stick it into the new node type.
+		 */
+		if (!type.isTextblock || !targetNode.type.isTextblock) {
+			/**
+			 * This requires some custom mapping shenanigans.
+			 *
+			 * TODO: See if we can do this with StepMap instead.
+			 * TODO: Extract to a function.
+			 *
+			 * Basically every time we find a text node, we keep track of the total offset created by the wrapping nodes. So given a target like this:
+			 *
+			 * ```
+			 * target [pos: 0]
+			 *  	child [1]
+			 *  		text [2]
+			 *  	child [3]
+			 *  		text [4]
+			 * 		[ ...or any various combinations]
+			 *
+			 * We can think of the positions like this:
+			 * ```
+			 * 0               1      2             3      4             5
+			 * | [ wrappers* ] | Text | [wrappers*] | Text | [wrappers*] |
+			 * ```
+			 * And using the offset at each position, we can map postions from text nodes like this:
+			 * ```
+			 * 0 [prev: 1-2] 1 [prev: 3-4] 2
+			 * | Text        | Text      |
+			 * ````
+			 */
+			// first we create the node, letting it create any children it needs
+			const newNode = type.createAndFill(attributes)
+			if (!newNode) return false
+			let depth = 1
+			let childNode = newNode
+			// find the deepest parent that can contain text
+			while (childNode.childCount > 0) {
+				childNode = childNode.firstChild!
+				depth++
+				if (childNode.isTextblock) break
+			}
+			// get the start offset of the text for selection mapping
+			newNodeStartOffset = depth
+			// we need to know which marks this child accepts, NOT it's parent or root convert type
+			const insertNodeType = childNode.type
+
+			// for selection mapping
+			let oldNode = targetNode
+			depth = 0
+			while (oldNode.childCount > 0) {
+				oldNode = oldNode.firstChild!
+				depth++
+				if (oldNode.isTextblock) break
+			}
+			oldNodeStartOffset = depth
+
+			// map the offsets and capture the nodes
+			const nodes: Node[] = []
+			let offset = 0
+			let lastPos = 0
+
+			targetNode.nodesBetween(0, targetNode.content.size, (node, pos) => {
+				if (node.isText) {
+					offset += pos - lastPos
+					lastPos = pos - node.content.size + 1
+					offsets.push({ pos: targetStart + pos, offset: offset - oldNodeStartOffset })
+					// create doesn't validate marks
+					// so we manually filter out those that aren't allowed
+					nodes.push(state.schema.text(
+						node.text ?? "",
+						insertNodeType.allowedMarks(node.marks)
+					))
+				}
+				return true
+			})
+
+			if (newNodeStartOffset === undefined) return false
+			const contentNodes = nodes.length > 0 && insertNodeType.isTextblock ? nodes : undefined
+			// note that attempting to build the node, even with createAndFill, tends to fail when we pass the contentNodes
+			// so they are inserted after instead
+			if (dispatch) {
+				tr.replace(
+					targetStart,
+					targetEnd,
+					new Slice(Fragment.from(newNode), 0, 0)
+				)
+				if (contentNodes) {
+					tr.insert(targetStart + newNodeStartOffset, contentNodes)
+				}
+			}
+		} else {
+			if (dispatch) {
+				tr.setBlockType(targetStart, undefined, type, attributes)
+			}
+		}
+		// prevent clearing the document when we change the type of a node
+		// without inline content
+		// see https://github.com/ueberdosis/tiptap/issues/5490
+		if (dispatch) {
+			tr.setMeta("preventClearDocument", true)
+		}
+
+		// while only changing from a non-text node requires we use offsets
+		// this is all done from here for both cases since they might both need to use Selection.findFrom
+		// in some rare instances (such as cross cell table selections) we fallback
+		// to the mapped positions
+		// it's not that we can't map them correctly only that the editor does not have a correct state because they are psuedo selections
+		// would have to investigate how to get them properly
+
+		// also findFrom seems to be needed to get a nice selection
+		// otherwise the mapped position is often one step after the node which is not what we want
+
+		if (dispatch) {
+			const mappedFrom = tr.mapping.map(selection.from)
+			const mappedTo = tr.mapping.map(selection.to)
+
+			const wantedFromOffset = offsets.findLast(_ => selection.from >= _.pos)?.offset ?? 0
+
+			const from = selection.from >= targetStart && selection.from <= targetEnd
+				? (selection.from - wantedFromOffset + newNodeStartOffset - oldNodeStartOffset)
+				: Selection.findFrom(tr.doc.resolve(mappedFrom), -1, true)?.from
+
+			const wantedToOffset = offsets.findLast(_ => selection.to >= _.pos)?.offset ?? 0
+			const to = selection.to >= targetStart && selection.to <= targetEnd
+				? (selection.to - wantedToOffset + newNodeStartOffset - oldNodeStartOffset)
+				: Selection.findFrom(tr.doc.resolve(mappedTo), -1, true)?.to
+
+			tr.setSelection(
+				TextSelection.create(
+					tr.doc,
+					// avoid errors from out of range positions just in case
+					// all this position mapping is quite finicky
+					from && from > 0 && from < tr.doc.content.size ? from : mappedFrom,
+					to && to > 0 && to < tr.doc.content.size ? to : mappedTo
+				)
+			)
+		}
+
+		return true
+	}