@thomasfosterau/effect-richtext 0.0.0 → 0.1.0

package/dist/transform/mark_step.js

@@ -0,0 +1,225 @@
+import { Fragment } from "../model/fragment.js";
+import { JSONError } from "../model/errors.js";
+import { Mark } from "../model/mark.js";
+import { Slice } from "../model/replace.js";
+import { markStepGroup, pushMarkStep } from "./mark_set_step.js";
+import { Step, StepResult } from "./step.js";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+// src/transform/mark_step.ts
+/**
+* Mark steps.
+*
+* @since 0.1.0
+*/
+function mapFragment(fragment, f, parent) {
+	const mapped = [];
+	for (let i = 0; i < fragment.childCount; i++) {
+		let child = fragment.content[i];
+		if (child.content.size) child = child.copy(mapFragment(child.content, f, child));
+		if (child.isInline) child = f(child, parent, i);
+		mapped.push(child);
+	}
+	return Fragment.fromArray(mapped);
+}
+function replaceMarked(doc, from, to, parent, f) {
+	const oldSlice = doc.sliceUnsafe(from, to);
+	const slice = new Slice(mapFragment(oldSlice.content, f, parent), oldSlice.openStart, oldSlice.openEnd);
+	return StepResult.fromReplace(doc, from, to, slice);
+}
+function invertSteps(doc, from, to, visit) {
+	const steps = [];
+	doc.nodesBetween(from, to, (node, pos) => {
+		if (node.isInline && node.isAtom) visit(node, Math.max(from, pos), Math.min(to, pos + node.nodeSize), steps);
+	});
+	return markStepGroup(steps);
+}
+const mapMarkRange = (mapping, from, to) => {
+	const mappedFrom = mapping.map(from, 1), mappedTo = mapping.map(to, -1);
+	return mappedFrom >= mappedTo ? Option.none() : Option.some([mappedFrom, mappedTo]);
+};
+/**
+* Add a mark to all inline content between two positions.
+*
+* @since 0.1.0
+* @category steps
+*/
+var AddMarkStep = class AddMarkStep extends Step {
+	/** Create a mark step. */
+	constructor(from, to, mark) {
+		super();
+		this.from = from;
+		this.to = to;
+		this.mark = mark;
+	}
+	apply(doc) {
+		const $from = doc.resolveUnsafe(this.from);
+		return replaceMarked(doc, this.from, this.to, $from.node($from.sharedDepth(this.to)), (node, parent) => !node.isAtom || !parent.type.allowsMarkType(this.mark.type) ? node : node.mark(this.mark.addToSet(node.marks)));
+	}
+	invert(doc) {
+		return invertSteps(doc, this.from, this.to, (node, from, to, steps) => {
+			const added = this.mark.addToSet(node.marks);
+			if (Mark.sameSet(added, node.marks)) return;
+			pushMarkStep(RemoveMarkStep, from, to, this.mark, steps);
+			node.marks.forEach((mark) => {
+				if (!mark.isInSet(added)) pushMarkStep(AddMarkStep, from, to, mark, steps);
+			});
+		});
+	}
+	map(mapping) {
+		return Option.map(mapMarkRange(mapping, this.from, this.to), ([from, to]) => new AddMarkStep(from, to, this.mark));
+	}
+	merge(other) {
+		if (other instanceof AddMarkStep && other.mark.eq(this.mark) && this.from <= other.to && this.to >= other.from) return Option.some(new AddMarkStep(Math.min(this.from, other.from), Math.max(this.to, other.to), this.mark));
+		return Option.none();
+	}
+	toJSON() {
+		return {
+			stepType: "addMark",
+			mark: this.mark.toJSON(),
+			from: this.from,
+			to: this.to
+		};
+	}
+	/** @internal */
+	static fromJSONUnsafe(schema, json) {
+		if (!Predicate.isNumber(json.from) || !Predicate.isNumber(json.to)) throw new JSONError({ message: "Invalid input for AddMarkStep.fromJSON" });
+		return new AddMarkStep(json.from, json.to, schema.markFromJSONUnsafe(json.mark));
+	}
+};
+Step.jsonID("addMark", AddMarkStep);
+/**
+* Remove a mark from all inline content between two positions.
+*
+* @since 0.1.0
+* @category steps
+*/
+var RemoveMarkStep = class RemoveMarkStep extends Step {
+	/** Create a mark-removing step. */
+	constructor(from, to, mark) {
+		super();
+		this.from = from;
+		this.to = to;
+		this.mark = mark;
+	}
+	apply(doc) {
+		return replaceMarked(doc, this.from, this.to, doc, (node) => node.mark(this.mark.removeFromSet(node.marks)));
+	}
+	invert(doc) {
+		return invertSteps(doc, this.from, this.to, (node, from, to, steps) => {
+			if (this.mark.isInSet(node.marks)) pushMarkStep(AddMarkStep, from, to, this.mark, steps);
+		});
+	}
+	map(mapping) {
+		return Option.map(mapMarkRange(mapping, this.from, this.to), ([from, to]) => new RemoveMarkStep(from, to, this.mark));
+	}
+	merge(other) {
+		if (other instanceof RemoveMarkStep && other.mark.eq(this.mark) && this.from <= other.to && this.to >= other.from) return Option.some(new RemoveMarkStep(Math.min(this.from, other.from), Math.max(this.to, other.to), this.mark));
+		return Option.none();
+	}
+	toJSON() {
+		return {
+			stepType: "removeMark",
+			mark: this.mark.toJSON(),
+			from: this.from,
+			to: this.to
+		};
+	}
+	/** @internal */
+	static fromJSONUnsafe(schema, json) {
+		if (!Predicate.isNumber(json.from) || !Predicate.isNumber(json.to)) throw new JSONError({ message: "Invalid input for RemoveMarkStep.fromJSON" });
+		return new RemoveMarkStep(json.from, json.to, schema.markFromJSONUnsafe(json.mark));
+	}
+};
+Step.jsonID("removeMark", RemoveMarkStep);
+/**
+* Add a mark to a specific node.
+*
+* @since 0.1.0
+* @category steps
+*/
+var AddNodeMarkStep = class AddNodeMarkStep extends Step {
+	/** Create a node mark step. */
+	constructor(pos, mark) {
+		super();
+		this.pos = pos;
+		this.mark = mark;
+	}
+	apply(doc) {
+		const node = doc.nodeAtOrNull(this.pos);
+		if (!node) return StepResult.fail("No node at mark step's position");
+		const updated = node.type.createUnsafe(node.attrs, null, this.mark.addToSet(node.marks));
+		return StepResult.fromReplace(doc, this.pos, this.pos + 1, new Slice(Fragment.from(updated), 0, node.isLeaf ? 0 : 1));
+	}
+	invert(doc) {
+		const node = doc.nodeAtOrNull(this.pos);
+		if (node) {
+			const newSet = this.mark.addToSet(node.marks);
+			if (newSet.length === node.marks.length) {
+				for (let i = 0; i < node.marks.length; i++) if (!node.marks[i].isInSet(newSet)) return new AddNodeMarkStep(this.pos, node.marks[i]);
+				return new AddNodeMarkStep(this.pos, this.mark);
+			}
+		}
+		return new RemoveNodeMarkStep(this.pos, this.mark);
+	}
+	map(mapping) {
+		const pos = mapping.mapResult(this.pos, 1);
+		return pos.deletedAfter ? Option.none() : Option.some(new AddNodeMarkStep(pos.pos, this.mark));
+	}
+	toJSON() {
+		return {
+			stepType: "addNodeMark",
+			pos: this.pos,
+			mark: this.mark.toJSON()
+		};
+	}
+	/** @internal */
+	static fromJSONUnsafe(schema, json) {
+		if (!Predicate.isNumber(json.pos)) throw new JSONError({ message: "Invalid input for AddNodeMarkStep.fromJSON" });
+		return new AddNodeMarkStep(json.pos, schema.markFromJSONUnsafe(json.mark));
+	}
+};
+Step.jsonID("addNodeMark", AddNodeMarkStep);
+/**
+* Remove a mark from a specific node.
+*
+* @since 0.1.0
+* @category steps
+*/
+var RemoveNodeMarkStep = class RemoveNodeMarkStep extends Step {
+	/** Create a mark-removing step. */
+	constructor(pos, mark) {
+		super();
+		this.pos = pos;
+		this.mark = mark;
+	}
+	apply(doc) {
+		const node = doc.nodeAtOrNull(this.pos);
+		if (!node) return StepResult.fail("No node at mark step's position");
+		const updated = node.type.createUnsafe(node.attrs, null, this.mark.removeFromSet(node.marks));
+		return StepResult.fromReplace(doc, this.pos, this.pos + 1, new Slice(Fragment.from(updated), 0, node.isLeaf ? 0 : 1));
+	}
+	invert(doc) {
+		const node = doc.nodeAtOrNull(this.pos);
+		if (!node || !this.mark.isInSet(node.marks)) return this;
+		return new AddNodeMarkStep(this.pos, this.mark);
+	}
+	map(mapping) {
+		const pos = mapping.mapResult(this.pos, 1);
+		return pos.deletedAfter ? Option.none() : Option.some(new RemoveNodeMarkStep(pos.pos, this.mark));
+	}
+	toJSON() {
+		return {
+			stepType: "removeNodeMark",
+			pos: this.pos,
+			mark: this.mark.toJSON()
+		};
+	}
+	/** @internal */
+	static fromJSONUnsafe(schema, json) {
+		if (!Predicate.isNumber(json.pos)) throw new JSONError({ message: "Invalid input for RemoveNodeMarkStep.fromJSON" });
+		return new RemoveNodeMarkStep(json.pos, schema.markFromJSONUnsafe(json.mark));
+	}
+};
+Step.jsonID("removeNodeMark", RemoveNodeMarkStep);
+export { AddMarkStep, AddNodeMarkStep, RemoveMarkStep, RemoveNodeMarkStep };

package/dist/transform/replace.d.ts

@@ -0,0 +1,18 @@
+import { Slice } from "../model/replace.js";
+import { AnySchema } from "../model/schema.js";
+import { Node } from "../model/node.js";
+import "../model.js";
+import { Step } from "./step.js";
+import "./transform.js";
+import * as Option from "effect/Option";
+/**
+ * ‘Fit’ a slice into a given position in the document, producing a step
+ * that inserts it. Will return `None` if there's no meaningful way to
+ * insert the slice here, or inserting it would be a no-op (an empty
+ * slice over an empty range). Throws a `PositionError` when `from` or
+ * `to` are outside of the document.
+ *
+ * @since 0.1.0
+ * @category queries
+ */
+export declare const replaceStep: <Sc extends AnySchema>(doc: Node<Sc>, from: number, to?: number, slice?: Slice<Sc>) => Option.Option<Step<Sc>>;

package/dist/transform/replace.js

@@ -0,0 +1,381 @@
+import { Fragment } from "../model/fragment.js";
+import { Slice } from "../model/replace.js";
+import { ReplaceAroundStep, ReplaceStep } from "./replace_step.js";
+import { insertPointOrNull } from "./structure.js";
+import * as Option from "effect/Option";
+// src/transform/replace.ts
+/**
+* Fitting slices into documents: `replaceStep` and the implementations
+* of `replaceRange`, `replaceRangeWith` and `deleteRange`.
+*
+* @since 0.1.0
+*/
+/**
+* ‘Fit’ a slice into a given position in the document, producing a step
+* that inserts it. Will return `None` if there's no meaningful way to
+* insert the slice here, or inserting it would be a no-op (an empty
+* slice over an empty range). Throws a `PositionError` when `from` or
+* `to` are outside of the document.
+*
+* @since 0.1.0
+* @category queries
+*/
+const replaceStep = (doc, from, to = from, slice = Slice.empty) => Option.fromNullishOr(replaceStepOrNull(doc, from, to, slice));
+/** @internal */
+function replaceStepOrNull(doc, from, to = from, slice = Slice.empty) {
+	if (from === to && !slice.size) return null;
+	const $from = doc.resolveUnsafe(from), $to = doc.resolveUnsafe(to);
+	if (fitsTrivially($from, $to, slice)) return new ReplaceStep(from, to, slice);
+	return new Fitter($from, $to, slice).fit();
+}
+function fitsTrivially($from, $to, slice) {
+	return !slice.openStart && !slice.openEnd && $from.start() === $to.start() && $from.parent.canReplace($from.index(), $to.index(), slice.content);
+}
+var Fitter = class {
+	constructor($from, $to, unplaced) {
+		this.$from = $from;
+		this.$to = $to;
+		this.unplaced = unplaced;
+		this.frontier = [];
+		this.placed = Fragment.empty;
+		for (let i = 0; i <= $from.depth; i++) {
+			const node = $from.node(i);
+			this.frontier.push({
+				type: node.type,
+				match: node.contentMatchAtUnsafe($from.indexAfter(i))
+			});
+		}
+		for (let i = $from.depth; i > 0; i--) this.placed = Fragment.from($from.node(i).copy(this.placed));
+	}
+	get depth() {
+		return this.frontier.length - 1;
+	}
+	fit() {
+		while (this.unplaced.size) {
+			const fit = this.findFittable();
+			if (fit) this.placeNodes(fit);
+			else if (!this.openMore()) this.dropNode();
+		}
+		const moveInline = this.mustMoveInline(), placedSize = this.placed.size - this.depth - this.$from.depth;
+		const $from = this.$from, $to = this.close(moveInline < 0 ? this.$to : $from.doc.resolveUnsafe(moveInline));
+		if (!$to) return null;
+		let content = this.placed, openStart = $from.depth, openEnd = $to.depth;
+		while (openStart && openEnd && content.childCount === 1) {
+			content = content.content[0].content;
+			openStart--;
+			openEnd--;
+		}
+		const slice = new Slice(content, openStart, openEnd);
+		if (moveInline > -1) return new ReplaceAroundStep($from.pos, moveInline, this.$to.pos, this.$to.end(), slice, placedSize);
+		if (slice.size || $from.pos !== this.$to.pos) return new ReplaceStep($from.pos, $to.pos, slice);
+		return null;
+	}
+	findFittable() {
+		let startDepth = this.unplaced.openStart;
+		for (let cur = this.unplaced.content, d = 0, openEnd = this.unplaced.openEnd; d < startDepth; d++) {
+			const node = cur.content[0];
+			if (cur.childCount > 1) openEnd = 0;
+			if (node.type.spec.isolating && openEnd <= d) {
+				startDepth = d;
+				break;
+			}
+			cur = node.content;
+		}
+		for (let pass = 1; pass <= 2; pass++) for (let sliceDepth = pass === 1 ? startDepth : this.unplaced.openStart; sliceDepth >= 0; sliceDepth--) {
+			let fragment, parent = null;
+			if (sliceDepth) {
+				parent = contentAt(this.unplaced.content, sliceDepth - 1).content[0];
+				fragment = parent.content;
+			} else fragment = this.unplaced.content;
+			const first = fragment.content[0];
+			for (let frontierDepth = this.depth; frontierDepth >= 0; frontierDepth--) {
+				const { match, type } = this.frontier[frontierDepth];
+				let wrap = null, inject = null;
+				if (pass === 1 && (first ? match.matchTypeOrNull(first.type) || (inject = match.fillBeforeOrNull(Fragment.from(first), false)) : parent && type.compatibleContent(parent.type))) return {
+					sliceDepth,
+					frontierDepth,
+					parent,
+					inject
+				};
+				else if (pass === 2 && first && (wrap = match.findWrappingOrNull(first.type))) return {
+					sliceDepth,
+					frontierDepth,
+					parent,
+					wrap
+				};
+				if (parent && match.matchTypeOrNull(parent.type)) break;
+			}
+		}
+	}
+	openMore() {
+		const { content, openStart } = this.unplaced;
+		let { openEnd } = this.unplaced;
+		if (maxOpen(content, -1) <= openStart) return false;
+		if (this.unplaced.size > 1 && maxOpen(content, 1) > openEnd) openEnd++;
+		this.unplaced = new Slice(content, openStart + 1, openEnd);
+		return true;
+	}
+	dropNode() {
+		const { content, openEnd, openStart } = this.unplaced;
+		const inner = contentAt(content, openStart);
+		if (inner.childCount <= 1 && openStart > 0) {
+			const openAtEnd = content.size - openStart <= openStart + inner.size;
+			this.unplaced = new Slice(dropFromFragment(content, openStart - 1, 1), openStart - 1, openAtEnd ? openStart - 1 : openEnd);
+		} else this.unplaced = new Slice(dropFromFragment(content, openStart, 1), openStart, openEnd);
+	}
+	placeNodes({ frontierDepth, inject, parent, sliceDepth, wrap }) {
+		while (this.depth > frontierDepth) this.closeFrontierNode();
+		if (wrap) for (let i = 0; i < wrap.length; i++) this.openFrontierNode(wrap[i]);
+		const slice = this.unplaced, fragment = parent ? parent.content : slice.content;
+		const openStart = slice.openStart - sliceDepth;
+		let taken = 0;
+		const add = [];
+		let { match } = this.frontier[frontierDepth];
+		const { type } = this.frontier[frontierDepth];
+		if (inject) {
+			for (let i = 0; i < inject.childCount; i++) add.push(inject.content[i]);
+			match = match.matchFragmentOrNull(inject);
+		}
+		let openEndCount = fragment.size + sliceDepth - (slice.content.size - slice.openEnd);
+		while (taken < fragment.childCount) {
+			const next = fragment.content[taken], matches = match.matchTypeOrNull(next.type);
+			if (!matches) break;
+			taken++;
+			if (taken > 1 || openStart === 0 || next.content.size) {
+				match = matches;
+				add.push(closeNodeStart(next.mark(type.allowedMarks(next.marks)), taken === 1 ? openStart : 0, taken === fragment.childCount ? openEndCount : -1));
+			}
+		}
+		const toEnd = taken === fragment.childCount;
+		if (!toEnd) openEndCount = -1;
+		this.placed = addToFragment(this.placed, frontierDepth, Fragment.from(add));
+		this.frontier[frontierDepth].match = match;
+		if (toEnd && openEndCount < 0 && parent && parent.type === this.frontier[this.depth].type && this.frontier.length > 1) this.closeFrontierNode();
+		for (let i = 0, cur = add.at(-1); cur && i < openEndCount; i++) {
+			this.frontier.push({
+				type: cur.type,
+				match: cur.contentMatchAtUnsafe(cur.childCount)
+			});
+			cur = cur.content.content.at(-1);
+		}
+		this.unplaced = !toEnd ? new Slice(dropFromFragment(slice.content, sliceDepth, taken), sliceDepth, slice.openEnd) : sliceDepth === 0 ? Slice.empty : new Slice(dropFromFragment(slice.content, sliceDepth - 1, 1), sliceDepth - 1, openEndCount < 0 ? slice.openEnd : sliceDepth - 1);
+	}
+	mustMoveInline() {
+		if (!this.$to.parent.isTextblock) return -1;
+		const top = this.frontier[this.depth];
+		let level;
+		if (!top.type.isTextblock || !contentAfterFits(this.$to, this.$to.depth, top.type, top.match, false) || this.$to.depth === this.depth && (level = this.findCloseLevel(this.$to)) && level.depth === this.depth) return -1;
+		let { depth } = this.$to, after = this.$to.afterUnsafe(depth);
+		while (depth > 1 && after === this.$to.end(--depth)) ++after;
+		return after;
+	}
+	findCloseLevel($to) {
+		scan: for (let i = Math.min(this.depth, $to.depth); i >= 0; i--) {
+			const { match, type } = this.frontier[i];
+			const dropInner = i < $to.depth && $to.end(i + 1) === $to.pos + ($to.depth - (i + 1));
+			const fit = contentAfterFits($to, i, type, match, dropInner);
+			if (!fit) continue;
+			for (let d = i - 1; d >= 0; d--) {
+				const { match, type } = this.frontier[d];
+				const matches = contentAfterFits($to, d, type, match, true);
+				if (!matches || matches.childCount) continue scan;
+			}
+			return {
+				depth: i,
+				fit,
+				move: dropInner ? $to.doc.resolveUnsafe($to.afterUnsafe(i + 1)) : $to
+			};
+		}
+	}
+	close($to) {
+		const close = this.findCloseLevel($to);
+		if (!close) return null;
+		while (this.depth > close.depth) this.closeFrontierNode();
+		if (close.fit.childCount) this.placed = addToFragment(this.placed, close.depth, close.fit);
+		$to = close.move;
+		for (let d = close.depth + 1; d <= $to.depth; d++) {
+			const node = $to.node(d), add = node.type.contentMatch.fillBeforeOrNull(node.content, true, $to.index(d));
+			this.openFrontierNode(node.type, node.attrs, add);
+		}
+		return $to;
+	}
+	openFrontierNode(type, attrs = null, content) {
+		const top = this.frontier[this.depth];
+		top.match = top.match.matchTypeOrNull(type);
+		this.placed = addToFragment(this.placed, this.depth, Fragment.from(type.createUnsafe(attrs, content)));
+		this.frontier.push({
+			type,
+			match: type.contentMatch
+		});
+	}
+	closeFrontierNode() {
+		const add = this.frontier.pop().match.fillBeforeOrNull(Fragment.empty, true);
+		if (add.childCount) this.placed = addToFragment(this.placed, this.frontier.length, add);
+	}
+};
+function dropFromFragment(fragment, depth, count) {
+	if (depth === 0) return fragment.cutByIndex(count, fragment.childCount);
+	const first = fragment.content[0];
+	return fragment.replaceChild(0, first.copy(dropFromFragment(first.content, depth - 1, count)));
+}
+function addToFragment(fragment, depth, content) {
+	if (depth === 0) return fragment.append(content);
+	const last = fragment.content[fragment.childCount - 1];
+	return fragment.replaceChild(fragment.childCount - 1, last.copy(addToFragment(last.content, depth - 1, content)));
+}
+function contentAt(fragment, depth) {
+	for (let i = 0; i < depth; i++) fragment = fragment.content[0].content;
+	return fragment;
+}
+function closeNodeStart(node, openStart, openEnd) {
+	if (openStart <= 0) return node;
+	let frag = node.content;
+	if (openStart > 1) frag = frag.replaceChild(0, closeNodeStart(frag.content[0], openStart - 1, frag.childCount === 1 ? openEnd - 1 : 0));
+	if (openStart > 0) {
+		frag = node.type.contentMatch.fillBeforeOrNull(frag).append(frag);
+		if (openEnd <= 0) frag = frag.append(node.type.contentMatch.matchFragmentOrNull(frag).fillBeforeOrNull(Fragment.empty, true));
+	}
+	return node.copy(frag);
+}
+function contentAfterFits($to, depth, type, match, open) {
+	const node = $to.node(depth), index = open ? $to.indexAfter(depth) : $to.index(depth);
+	if (index === node.childCount && !type.compatibleContent(node.type)) return null;
+	const fit = match.fillBeforeOrNull(node.content, true, index);
+	return fit && !invalidMarks(type, node.content, index) ? fit : null;
+}
+function invalidMarks(type, fragment, start) {
+	for (let i = start; i < fragment.childCount; i++) if (!type.allowsMarks(fragment.content[i].marks)) return true;
+	return false;
+}
+function definesContent(type) {
+	return type.spec.defining || type.spec.definingForContent;
+}
+function maxOpen(frag, side) {
+	const ch = side < 0 ? frag.content[0] : frag.content.at(-1);
+	return !ch || ch.isAtom ? 0 : 1 + maxOpen(ch.content, side);
+}
+/** @internal */
+function replaceRange(tr, from, to, slice) {
+	if (!slice.size) {
+		tr.deleteRangeUnsafe(from, to);
+		return;
+	}
+	const $from = tr.doc.resolveUnsafe(from), $to = tr.doc.resolveUnsafe(to);
+	if (fitsTrivially($from, $to, slice)) {
+		tr.stepUnsafe(new ReplaceStep(from, to, slice));
+		return;
+	}
+	const targetDepths = coveredDepths($from, $to);
+	if (targetDepths[targetDepths.length - 1] === 0) targetDepths.pop();
+	let preferredTarget = -($from.depth + 1);
+	targetDepths.unshift(preferredTarget);
+	for (let d = $from.depth, pos = $from.pos - 1; d > 0; d--, pos--) {
+		const spec = $from.node(d).type.spec;
+		if (spec.defining || spec.definingAsContext || spec.isolating) break;
+		if (targetDepths.indexOf(d) > -1) preferredTarget = d;
+		else if ($from.beforeUnsafe(d) === pos) targetDepths.splice(1, 0, -d);
+	}
+	const preferredTargetIndex = targetDepths.indexOf(preferredTarget);
+	const leftNodes = [];
+	let preferredDepth = slice.openStart;
+	for (let content = slice.content, i = 0;; i++) {
+		const node = content.content[0];
+		leftNodes.push(node);
+		if (i === slice.openStart) break;
+		content = node.content;
+	}
+	for (let d = preferredDepth - 1; d >= 0; d--) {
+		const leftNode = leftNodes[d], def = definesContent(leftNode.type);
+		if (def && !leftNode.sameMarkup($from.node(Math.abs(preferredTarget) - 1))) preferredDepth = d;
+		else if (def || !leftNode.type.isTextblock) break;
+	}
+	for (let j = slice.openStart; j >= 0; j--) {
+		const openDepth = (j + preferredDepth + 1) % (slice.openStart + 1);
+		const insert = leftNodes[openDepth];
+		if (!insert) continue;
+		for (let i = 0; i < targetDepths.length; i++) {
+			let targetDepth = targetDepths[(i + preferredTargetIndex) % targetDepths.length], expand = true;
+			if (targetDepth < 0) {
+				expand = false;
+				targetDepth = -targetDepth;
+			}
+			const parent = $from.node(targetDepth - 1), index = $from.index(targetDepth - 1);
+			if (parent.canReplaceWith(index, index, insert.type, insert.marks)) {
+				tr.replaceUnsafe($from.beforeUnsafe(targetDepth), expand ? $to.afterUnsafe(targetDepth) : to, new Slice(closeFragment(slice.content, 0, slice.openStart, openDepth), openDepth, slice.openEnd));
+				return;
+			}
+		}
+	}
+	const startSteps = tr.steps.length;
+	for (let i = targetDepths.length - 1; i >= 0; i--) {
+		tr.replaceUnsafe(from, to, slice);
+		if (tr.steps.length > startSteps) break;
+		const depth = targetDepths[i];
+		if (depth < 0) continue;
+		from = $from.beforeUnsafe(depth);
+		to = $to.afterUnsafe(depth);
+	}
+}
+function closeFragment(fragment, depth, oldOpen, newOpen, parent) {
+	if (depth < oldOpen) {
+		const first = fragment.content[0];
+		fragment = fragment.replaceChild(0, first.copy(closeFragment(first.content, depth + 1, oldOpen, newOpen, first)));
+	}
+	if (depth > newOpen) {
+		const match = parent.contentMatchAtUnsafe(0);
+		const start = match.fillBeforeOrNull(fragment).append(fragment);
+		fragment = start.append(match.matchFragmentOrNull(start).fillBeforeOrNull(Fragment.empty, true));
+	}
+	return fragment;
+}
+/** @internal */
+function replaceRangeWith(tr, from, to, node) {
+	if (!node.isInline && from === to && tr.doc.resolveUnsafe(from).parent.content.size) {
+		const point = insertPointOrNull(tr.doc, from, node.type);
+		if (point != null) from = to = point;
+	}
+	tr.replaceRangeUnsafe(from, to, new Slice(Fragment.from(node), 0, 0));
+}
+/** @internal */
+function deleteRange(tr, from, to) {
+	let $from = tr.doc.resolveUnsafe(from), $to = tr.doc.resolveUnsafe(to);
+	if ($from.parent.isTextblock && $to.parent.isTextblock && $from.start() !== $to.start() && $from.parentOffset === 0 && $to.parentOffset === 0) {
+		const shared = $from.sharedDepth(to);
+		let isolated = false;
+		for (let d = $from.depth; d > shared; d--) if ($from.node(d).type.spec.isolating) isolated = true;
+		for (let d = $to.depth; d > shared; d--) if ($to.node(d).type.spec.isolating) isolated = true;
+		if (!isolated) {
+			for (let d = $from.depth; d > 0 && from === $from.start(d); d--) from = $from.beforeUnsafe(d);
+			for (let d = $to.depth; d > 0 && to === $to.start(d); d--) to = $to.beforeUnsafe(d);
+			$from = tr.doc.resolveUnsafe(from);
+			$to = tr.doc.resolveUnsafe(to);
+		}
+	}
+	const covered = coveredDepths($from, $to);
+	for (let i = 0; i < covered.length; i++) {
+		const depth = covered[i], last = i === covered.length - 1;
+		if (last && depth === 0 || $from.node(depth).type.contentMatch.validEnd) {
+			tr.deleteUnsafe($from.start(depth), $to.end(depth));
+			return;
+		}
+		if (depth > 0 && (last || $from.node(depth - 1).canReplace($from.index(depth - 1), $to.indexAfter(depth - 1)))) {
+			tr.deleteUnsafe($from.beforeUnsafe(depth), $to.afterUnsafe(depth));
+			return;
+		}
+	}
+	for (let d = 1; d <= $from.depth && d <= $to.depth; d++) if (from - $from.start(d) === $from.depth - d && to > $from.end(d) && $to.end(d) - to !== $to.depth - d && $from.start(d - 1) === $to.start(d - 1) && $from.node(d - 1).canReplace($from.index(d - 1), $to.index(d - 1))) {
+		tr.deleteUnsafe($from.beforeUnsafe(d), to);
+		return;
+	}
+	tr.deleteUnsafe(from, to);
+}
+function coveredDepths($from, $to) {
+	const result = [], minDepth = Math.min($from.depth, $to.depth);
+	for (let d = minDepth; d >= 0; d--) {
+		const start = $from.start(d);
+		if (start < $from.pos - ($from.depth - d) || $to.end(d) > $to.pos + ($to.depth - d) || $from.node(d).type.spec.isolating || $to.node(d).type.spec.isolating) break;
+		if (start === $to.start(d) || d === $from.depth && d === $to.depth && $from.parent.inlineContent && $to.parent.inlineContent && d && $to.start(d - 1) === start - 1) result.push(d);
+	}
+	return result;
+}
+export { deleteRange, replaceRange, replaceRangeWith, replaceStep, replaceStepOrNull };