@vonage/vivid 5.16.0 → 5.18.0

package/unbundled/slottable-request.cjs

@@ -1,3096 +1,5 @@
-//#region ../../node_modules/.pnpm/orderedmap@2.1.1/node_modules/orderedmap/dist/index.js
-function OrderedMap(content) {
-	this.content = content;
-}
-OrderedMap.prototype = {
-	constructor: OrderedMap,
-	find: function(key) {
-		for (var i = 0; i < this.content.length; i += 2) if (this.content[i] === key) return i;
-		return -1;
-	},
-	get: function(key) {
-		var found = this.find(key);
-		return found == -1 ? void 0 : this.content[found + 1];
-	},
-	update: function(key, value, newKey) {
-		var self = newKey && newKey != key ? this.remove(newKey) : this;
-		var found = self.find(key), content = self.content.slice();
-		if (found == -1) content.push(newKey || key, value);
-		else {
-			content[found + 1] = value;
-			if (newKey) content[found] = newKey;
-		}
-		return new OrderedMap(content);
-	},
-	remove: function(key) {
-		var found = this.find(key);
-		if (found == -1) return this;
-		var content = this.content.slice();
-		content.splice(found, 2);
-		return new OrderedMap(content);
-	},
-	addToStart: function(key, value) {
-		return new OrderedMap([key, value].concat(this.remove(key).content));
-	},
-	addToEnd: function(key, value) {
-		var content = this.remove(key).content.slice();
-		content.push(key, value);
-		return new OrderedMap(content);
-	},
-	addBefore: function(place, key, value) {
-		var without = this.remove(key), content = without.content.slice();
-		var found = without.find(place);
-		content.splice(found == -1 ? content.length : found, 0, key, value);
-		return new OrderedMap(content);
-	},
-	forEach: function(f) {
-		for (var i = 0; i < this.content.length; i += 2) f(this.content[i], this.content[i + 1]);
-	},
-	prepend: function(map) {
-		map = OrderedMap.from(map);
-		if (!map.size) return this;
-		return new OrderedMap(map.content.concat(this.subtract(map).content));
-	},
-	append: function(map) {
-		map = OrderedMap.from(map);
-		if (!map.size) return this;
-		return new OrderedMap(this.subtract(map).content.concat(map.content));
-	},
-	subtract: function(map) {
-		var result = this;
-		map = OrderedMap.from(map);
-		for (var i = 0; i < map.content.length; i += 2) result = result.remove(map.content[i]);
-		return result;
-	},
-	toObject: function() {
-		var result = {};
-		this.forEach(function(key, value) {
-			result[key] = value;
-		});
-		return result;
-	},
-	get size() {
-		return this.content.length >> 1;
-	}
-};
-OrderedMap.from = function(value) {
-	if (value instanceof OrderedMap) return value;
-	var content = [];
-	if (value) for (var prop in value) content.push(prop, value[prop]);
-	return new OrderedMap(content);
-};
-//#endregion
-//#region ../../node_modules/.pnpm/prosemirror-model@1.25.4/node_modules/prosemirror-model/dist/index.js
-function findDiffStart(a, b, pos) {
-	for (let i = 0;; i++) {
-		if (i == a.childCount || i == b.childCount) return a.childCount == b.childCount ? null : pos;
-		let childA = a.child(i), childB = b.child(i);
-		if (childA == childB) {
-			pos += childA.nodeSize;
-			continue;
-		}
-		if (!childA.sameMarkup(childB)) return pos;
-		if (childA.isText && childA.text != childB.text) {
-			for (let j = 0; childA.text[j] == childB.text[j]; j++) pos++;
-			return pos;
-		}
-		if (childA.content.size || childB.content.size) {
-			let inner = findDiffStart(childA.content, childB.content, pos + 1);
-			if (inner != null) return inner;
-		}
-		pos += childA.nodeSize;
-	}
-}
-function findDiffEnd(a, b, posA, posB) {
-	for (let iA = a.childCount, iB = b.childCount;;) {
-		if (iA == 0 || iB == 0) return iA == iB ? null : {
-			a: posA,
-			b: posB
-		};
-		let childA = a.child(--iA), childB = b.child(--iB), size = childA.nodeSize;
-		if (childA == childB) {
-			posA -= size;
-			posB -= size;
-			continue;
-		}
-		if (!childA.sameMarkup(childB)) return {
-			a: posA,
-			b: posB
-		};
-		if (childA.isText && childA.text != childB.text) {
-			let same = 0, minSize = Math.min(childA.text.length, childB.text.length);
-			while (same < minSize && childA.text[childA.text.length - same - 1] == childB.text[childB.text.length - same - 1]) {
-				same++;
-				posA--;
-				posB--;
-			}
-			return {
-				a: posA,
-				b: posB
-			};
-		}
-		if (childA.content.size || childB.content.size) {
-			let inner = findDiffEnd(childA.content, childB.content, posA - 1, posB - 1);
-			if (inner) return inner;
-		}
-		posA -= size;
-		posB -= size;
-	}
-}
-/**
-A fragment represents a node's collection of child nodes.
-
-Like nodes, fragments are persistent data structures, and you
-should not mutate them or their content. Rather, you create new
-instances whenever needed. The API tries to make this easy.
-*/
-var Fragment = class Fragment {
-	/**
-	@internal
-	*/
-	constructor(content, size) {
-		this.content = content;
-		this.size = size || 0;
-		if (size == null) for (let i = 0; i < content.length; i++) this.size += content[i].nodeSize;
-	}
-	/**
-	Invoke a callback for all descendant nodes between the given two
-	positions (relative to start of this fragment). Doesn't descend
-	into a node when the callback returns `false`.
-	*/
-	nodesBetween(from, to, f, nodeStart = 0, parent) {
-		for (let i = 0, pos = 0; pos < to; i++) {
-			let child = this.content[i], end = pos + child.nodeSize;
-			if (end > from && f(child, nodeStart + pos, parent || null, i) !== false && child.content.size) {
-				let start = pos + 1;
-				child.nodesBetween(Math.max(0, from - start), Math.min(child.content.size, to - start), f, nodeStart + start);
-			}
-			pos = end;
-		}
-	}
-	/**
-	Call the given callback for every descendant node. `pos` will be
-	relative to the start of the fragment. The callback may return
-	`false` to prevent traversal of a given node's children.
-	*/
-	descendants(f) {
-		this.nodesBetween(0, this.size, f);
-	}
-	/**
-	Extract the text between `from` and `to`. See the same method on
-	[`Node`](https://prosemirror.net/docs/ref/#model.Node.textBetween).
-	*/
-	textBetween(from, to, blockSeparator, leafText) {
-		let text = "", first = true;
-		this.nodesBetween(from, to, (node, pos) => {
-			let nodeText = node.isText ? node.text.slice(Math.max(from, pos) - pos, to - pos) : !node.isLeaf ? "" : leafText ? typeof leafText === "function" ? leafText(node) : leafText : node.type.spec.leafText ? node.type.spec.leafText(node) : "";
-			if (node.isBlock && (node.isLeaf && nodeText || node.isTextblock) && blockSeparator) if (first) first = false;
-			else text += blockSeparator;
-			text += nodeText;
-		}, 0);
-		return text;
-	}
-	/**
-	Create a new fragment containing the combined content of this
-	fragment and the other.
-	*/
-	append(other) {
-		if (!other.size) return this;
-		if (!this.size) return other;
-		let last = this.lastChild, first = other.firstChild, content = this.content.slice(), i = 0;
-		if (last.isText && last.sameMarkup(first)) {
-			content[content.length - 1] = last.withText(last.text + first.text);
-			i = 1;
-		}
-		for (; i < other.content.length; i++) content.push(other.content[i]);
-		return new Fragment(content, this.size + other.size);
-	}
-	/**
-	Cut out the sub-fragment between the two given positions.
-	*/
-	cut(from, to = this.size) {
-		if (from == 0 && to == this.size) return this;
-		let result = [], size = 0;
-		if (to > from) for (let i = 0, pos = 0; pos < to; i++) {
-			let child = this.content[i], end = pos + child.nodeSize;
-			if (end > from) {
-				if (pos < from || end > to) if (child.isText) child = child.cut(Math.max(0, from - pos), Math.min(child.text.length, to - pos));
-				else child = child.cut(Math.max(0, from - pos - 1), Math.min(child.content.size, to - pos - 1));
-				result.push(child);
-				size += child.nodeSize;
-			}
-			pos = end;
-		}
-		return new Fragment(result, size);
-	}
-	/**
-	@internal
-	*/
-	cutByIndex(from, to) {
-		if (from == to) return Fragment.empty;
-		if (from == 0 && to == this.content.length) return this;
-		return new Fragment(this.content.slice(from, to));
-	}
-	/**
-	Create a new fragment in which the node at the given index is
-	replaced by the given node.
-	*/
-	replaceChild(index, node) {
-		let current = this.content[index];
-		if (current == node) return this;
-		let copy = this.content.slice();
-		let size = this.size + node.nodeSize - current.nodeSize;
-		copy[index] = node;
-		return new Fragment(copy, size);
-	}
-	/**
-	Create a new fragment by prepending the given node to this
-	fragment.
-	*/
-	addToStart(node) {
-		return new Fragment([node].concat(this.content), this.size + node.nodeSize);
-	}
-	/**
-	Create a new fragment by appending the given node to this
-	fragment.
-	*/
-	addToEnd(node) {
-		return new Fragment(this.content.concat(node), this.size + node.nodeSize);
-	}
-	/**
-	Compare this fragment to another one.
-	*/
-	eq(other) {
-		if (this.content.length != other.content.length) return false;
-		for (let i = 0; i < this.content.length; i++) if (!this.content[i].eq(other.content[i])) return false;
-		return true;
-	}
-	/**
-	The first child of the fragment, or `null` if it is empty.
-	*/
-	get firstChild() {
-		return this.content.length ? this.content[0] : null;
-	}
-	/**
-	The last child of the fragment, or `null` if it is empty.
-	*/
-	get lastChild() {
-		return this.content.length ? this.content[this.content.length - 1] : null;
-	}
-	/**
-	The number of child nodes in this fragment.
-	*/
-	get childCount() {
-		return this.content.length;
-	}
-	/**
-	Get the child node at the given index. Raise an error when the
-	index is out of range.
-	*/
-	child(index) {
-		let found = this.content[index];
-		if (!found) throw new RangeError("Index " + index + " out of range for " + this);
-		return found;
-	}
-	/**
-	Get the child node at the given index, if it exists.
-	*/
-	maybeChild(index) {
-		return this.content[index] || null;
-	}
-	/**
-	Call `f` for every child node, passing the node, its offset
-	into this parent node, and its index.
-	*/
-	forEach(f) {
-		for (let i = 0, p = 0; i < this.content.length; i++) {
-			let child = this.content[i];
-			f(child, p, i);
-			p += child.nodeSize;
-		}
-	}
-	/**
-	Find the first position at which this fragment and another
-	fragment differ, or `null` if they are the same.
-	*/
-	findDiffStart(other, pos = 0) {
-		return findDiffStart(this, other, pos);
-	}
-	/**
-	Find the first position, searching from the end, at which this
-	fragment and the given fragment differ, or `null` if they are
-	the same. Since this position will not be the same in both
-	nodes, an object with two separate positions is returned.
-	*/
-	findDiffEnd(other, pos = this.size, otherPos = other.size) {
-		return findDiffEnd(this, other, pos, otherPos);
-	}
-	/**
-	Find the index and inner offset corresponding to a given relative
-	position in this fragment. The result object will be reused
-	(overwritten) the next time the function is called. @internal
-	*/
-	findIndex(pos) {
-		if (pos == 0) return retIndex(0, pos);
-		if (pos == this.size) return retIndex(this.content.length, pos);
-		if (pos > this.size || pos < 0) throw new RangeError(`Position ${pos} outside of fragment (${this})`);
-		for (let i = 0, curPos = 0;; i++) {
-			let cur = this.child(i), end = curPos + cur.nodeSize;
-			if (end >= pos) {
-				if (end == pos) return retIndex(i + 1, end);
-				return retIndex(i, curPos);
-			}
-			curPos = end;
-		}
-	}
-	/**
-	Return a debugging string that describes this fragment.
-	*/
-	toString() {
-		return "<" + this.toStringInner() + ">";
-	}
-	/**
-	@internal
-	*/
-	toStringInner() {
-		return this.content.join(", ");
-	}
-	/**
-	Create a JSON-serializeable representation of this fragment.
-	*/
-	toJSON() {
-		return this.content.length ? this.content.map((n) => n.toJSON()) : null;
-	}
-	/**
-	Deserialize a fragment from its JSON representation.
-	*/
-	static fromJSON(schema, value) {
-		if (!value) return Fragment.empty;
-		if (!Array.isArray(value)) throw new RangeError("Invalid input for Fragment.fromJSON");
-		return new Fragment(value.map(schema.nodeFromJSON));
-	}
-	/**
-	Build a fragment from an array of nodes. Ensures that adjacent
-	text nodes with the same marks are joined together.
-	*/
-	static fromArray(array) {
-		if (!array.length) return Fragment.empty;
-		let joined, size = 0;
-		for (let i = 0; i < array.length; i++) {
-			let node = array[i];
-			size += node.nodeSize;
-			if (i && node.isText && array[i - 1].sameMarkup(node)) {
-				if (!joined) joined = array.slice(0, i);
-				joined[joined.length - 1] = node.withText(joined[joined.length - 1].text + node.text);
-			} else if (joined) joined.push(node);
-		}
-		return new Fragment(joined || array, size);
-	}
-	/**
-	Create a fragment from something that can be interpreted as a
-	set of nodes. For `null`, it returns the empty fragment. For a
-	fragment, the fragment itself. For a node or array of nodes, a
-	fragment containing those nodes.
-	*/
-	static from(nodes) {
-		if (!nodes) return Fragment.empty;
-		if (nodes instanceof Fragment) return nodes;
-		if (Array.isArray(nodes)) return this.fromArray(nodes);
-		if (nodes.attrs) return new Fragment([nodes], nodes.nodeSize);
-		throw new RangeError("Can not convert " + nodes + " to a Fragment" + (nodes.nodesBetween ? " (looks like multiple versions of prosemirror-model were loaded)" : ""));
-	}
-};
-/**
-An empty fragment. Intended to be reused whenever a node doesn't
-contain anything (rather than allocating a new empty fragment for
-each leaf node).
-*/
-Fragment.empty = new Fragment([], 0);
-var found = {
-	index: 0,
-	offset: 0
-};
-function retIndex(index, offset) {
-	found.index = index;
-	found.offset = offset;
-	return found;
-}
-function compareDeep(a, b) {
-	if (a === b) return true;
-	if (!(a && typeof a == "object") || !(b && typeof b == "object")) return false;
-	let array = Array.isArray(a);
-	if (Array.isArray(b) != array) return false;
-	if (array) {
-		if (a.length != b.length) return false;
-		for (let i = 0; i < a.length; i++) if (!compareDeep(a[i], b[i])) return false;
-	} else {
-		for (let p in a) if (!(p in b) || !compareDeep(a[p], b[p])) return false;
-		for (let p in b) if (!(p in a)) return false;
-	}
-	return true;
-}
-/**
-A mark is a piece of information that can be attached to a node,
-such as it being emphasized, in code font, or a link. It has a
-type and optionally a set of attributes that provide further
-information (such as the target of the link). Marks are created
-through a `Schema`, which controls which types exist and which
-attributes they have.
-*/
-var Mark = class Mark {
-	/**
-	@internal
-	*/
-	constructor(type, attrs) {
-		this.type = type;
-		this.attrs = attrs;
-	}
-	/**
-	Given a set of marks, create a new set which contains this one as
-	well, in the right position. If this mark is already in the set,
-	the set itself is returned. If any marks that are set to be
-	[exclusive](https://prosemirror.net/docs/ref/#model.MarkSpec.excludes) with this mark are present,
-	those are replaced by this one.
-	*/
-	addToSet(set) {
-		let copy, placed = false;
-		for (let i = 0; i < set.length; i++) {
-			let other = set[i];
-			if (this.eq(other)) return set;
-			if (this.type.excludes(other.type)) {
-				if (!copy) copy = set.slice(0, i);
-			} else if (other.type.excludes(this.type)) return set;
-			else {
-				if (!placed && other.type.rank > this.type.rank) {
-					if (!copy) copy = set.slice(0, i);
-					copy.push(this);
-					placed = true;
-				}
-				if (copy) copy.push(other);
-			}
-		}
-		if (!copy) copy = set.slice();
-		if (!placed) copy.push(this);
-		return copy;
-	}
-	/**
-	Remove this mark from the given set, returning a new set. If this
-	mark is not in the set, the set itself is returned.
-	*/
-	removeFromSet(set) {
-		for (let i = 0; i < set.length; i++) if (this.eq(set[i])) return set.slice(0, i).concat(set.slice(i + 1));
-		return set;
-	}
-	/**
-	Test whether this mark is in the given set of marks.
-	*/
-	isInSet(set) {
-		for (let i = 0; i < set.length; i++) if (this.eq(set[i])) return true;
-		return false;
-	}
-	/**
-	Test whether this mark has the same type and attributes as
-	another mark.
-	*/
-	eq(other) {
-		return this == other || this.type == other.type && compareDeep(this.attrs, other.attrs);
-	}
-	/**
-	Convert this mark to a JSON-serializeable representation.
-	*/
-	toJSON() {
-		let obj = { type: this.type.name };
-		for (let _ in this.attrs) {
-			obj.attrs = this.attrs;
-			break;
-		}
-		return obj;
-	}
-	/**
-	Deserialize a mark from JSON.
-	*/
-	static fromJSON(schema, json) {
-		if (!json) throw new RangeError("Invalid input for Mark.fromJSON");
-		let type = schema.marks[json.type];
-		if (!type) throw new RangeError(`There is no mark type ${json.type} in this schema`);
-		let mark = type.create(json.attrs);
-		type.checkAttrs(mark.attrs);
-		return mark;
-	}
-	/**
-	Test whether two sets of marks are identical.
-	*/
-	static sameSet(a, b) {
-		if (a == b) return true;
-		if (a.length != b.length) return false;
-		for (let i = 0; i < a.length; i++) if (!a[i].eq(b[i])) return false;
-		return true;
-	}
-	/**
-	Create a properly sorted mark set from null, a single mark, or an
-	unsorted array of marks.
-	*/
-	static setFrom(marks) {
-		if (!marks || Array.isArray(marks) && marks.length == 0) return Mark.none;
-		if (marks instanceof Mark) return [marks];
-		let copy = marks.slice();
-		copy.sort((a, b) => a.type.rank - b.type.rank);
-		return copy;
-	}
-};
-/**
-The empty set of marks.
-*/
-Mark.none = [];
-/**
-Error type raised by [`Node.replace`](https://prosemirror.net/docs/ref/#model.Node.replace) when
-given an invalid replacement.
-*/
-var ReplaceError = class extends Error {};
-/**
-A slice represents a piece cut out of a larger document. It
-stores not only a fragment, but also the depth up to which nodes on
-both side are ‘open’ (cut through).
-*/
-var Slice = class Slice {
-	/**
-	Create a slice. When specifying a non-zero open depth, you must
-	make sure that there are nodes of at least that depth at the
-	appropriate side of the fragment—i.e. if the fragment is an
-	empty paragraph node, `openStart` and `openEnd` can't be greater
-	than 1.
-	
-	It is not necessary for the content of open nodes to conform to
-	the schema's content constraints, though it should be a valid
-	start/end/middle for such a node, depending on which sides are
-	open.
-	*/
-	constructor(content, openStart, openEnd) {
-		this.content = content;
-		this.openStart = openStart;
-		this.openEnd = openEnd;
-	}
-	/**
-	The size this slice would add when inserted into a document.
-	*/
-	get size() {
-		return this.content.size - this.openStart - this.openEnd;
-	}
-	/**
-	@internal
-	*/
-	insertAt(pos, fragment) {
-		let content = insertInto(this.content, pos + this.openStart, fragment);
-		return content && new Slice(content, this.openStart, this.openEnd);
-	}
-	/**
-	@internal
-	*/
-	removeBetween(from, to) {
-		return new Slice(removeRange(this.content, from + this.openStart, to + this.openStart), this.openStart, this.openEnd);
-	}
-	/**
-	Tests whether this slice is equal to another slice.
-	*/
-	eq(other) {
-		return this.content.eq(other.content) && this.openStart == other.openStart && this.openEnd == other.openEnd;
-	}
-	/**
-	@internal
-	*/
-	toString() {
-		return this.content + "(" + this.openStart + "," + this.openEnd + ")";
-	}
-	/**
-	Convert a slice to a JSON-serializable representation.
-	*/
-	toJSON() {
-		if (!this.content.size) return null;
-		let json = { content: this.content.toJSON() };
-		if (this.openStart > 0) json.openStart = this.openStart;
-		if (this.openEnd > 0) json.openEnd = this.openEnd;
-		return json;
-	}
-	/**
-	Deserialize a slice from its JSON representation.
-	*/
-	static fromJSON(schema, json) {
-		if (!json) return Slice.empty;
-		let openStart = json.openStart || 0, openEnd = json.openEnd || 0;
-		if (typeof openStart != "number" || typeof openEnd != "number") throw new RangeError("Invalid input for Slice.fromJSON");
-		return new Slice(Fragment.fromJSON(schema, json.content), openStart, openEnd);
-	}
-	/**
-	Create a slice from a fragment by taking the maximum possible
-	open value on both side of the fragment.
-	*/
-	static maxOpen(fragment, openIsolating = true) {
-		let openStart = 0, openEnd = 0;
-		for (let n = fragment.firstChild; n && !n.isLeaf && (openIsolating || !n.type.spec.isolating); n = n.firstChild) openStart++;
-		for (let n = fragment.lastChild; n && !n.isLeaf && (openIsolating || !n.type.spec.isolating); n = n.lastChild) openEnd++;
-		return new Slice(fragment, openStart, openEnd);
-	}
-};
-/**
-The empty slice.
-*/
-Slice.empty = new Slice(Fragment.empty, 0, 0);
-function removeRange(content, from, to) {
-	let { index, offset } = content.findIndex(from), child = content.maybeChild(index);
-	let { index: indexTo, offset: offsetTo } = content.findIndex(to);
-	if (offset == from || child.isText) {
-		if (offsetTo != to && !content.child(indexTo).isText) throw new RangeError("Removing non-flat range");
-		return content.cut(0, from).append(content.cut(to));
-	}
-	if (index != indexTo) throw new RangeError("Removing non-flat range");
-	return content.replaceChild(index, child.copy(removeRange(child.content, from - offset - 1, to - offset - 1)));
-}
-function insertInto(content, dist, insert, parent) {
-	let { index, offset } = content.findIndex(dist), child = content.maybeChild(index);
-	if (offset == dist || child.isText) {
-		if (parent && !parent.canReplace(index, index, insert)) return null;
-		return content.cut(0, dist).append(insert).append(content.cut(dist));
-	}
-	let inner = insertInto(child.content, dist - offset - 1, insert, child);
-	return inner && content.replaceChild(index, child.copy(inner));
-}
-function replace($from, $to, slice) {
-	if (slice.openStart > $from.depth) throw new ReplaceError("Inserted content deeper than insertion position");
-	if ($from.depth - slice.openStart != $to.depth - slice.openEnd) throw new ReplaceError("Inconsistent open depths");
-	return replaceOuter($from, $to, slice, 0);
-}
-function replaceOuter($from, $to, slice, depth) {
-	let index = $from.index(depth), node = $from.node(depth);
-	if (index == $to.index(depth) && depth < $from.depth - slice.openStart) {
-		let inner = replaceOuter($from, $to, slice, depth + 1);
-		return node.copy(node.content.replaceChild(index, inner));
-	} else if (!slice.content.size) return close(node, replaceTwoWay($from, $to, depth));
-	else if (!slice.openStart && !slice.openEnd && $from.depth == depth && $to.depth == depth) {
-		let parent = $from.parent, content = parent.content;
-		return close(parent, content.cut(0, $from.parentOffset).append(slice.content).append(content.cut($to.parentOffset)));
-	} else {
-		let { start, end } = prepareSliceForReplace(slice, $from);
-		return close(node, replaceThreeWay($from, start, end, $to, depth));
-	}
-}
-function checkJoin(main, sub) {
-	if (!sub.type.compatibleContent(main.type)) throw new ReplaceError("Cannot join " + sub.type.name + " onto " + main.type.name);
-}
-function joinable($before, $after, depth) {
-	let node = $before.node(depth);
-	checkJoin(node, $after.node(depth));
-	return node;
-}
-function addNode(child, target) {
-	let last = target.length - 1;
-	if (last >= 0 && child.isText && child.sameMarkup(target[last])) target[last] = child.withText(target[last].text + child.text);
-	else target.push(child);
-}
-function addRange($start, $end, depth, target) {
-	let node = ($end || $start).node(depth);
-	let startIndex = 0, endIndex = $end ? $end.index(depth) : node.childCount;
-	if ($start) {
-		startIndex = $start.index(depth);
-		if ($start.depth > depth) startIndex++;
-		else if ($start.textOffset) {
-			addNode($start.nodeAfter, target);
-			startIndex++;
-		}
-	}
-	for (let i = startIndex; i < endIndex; i++) addNode(node.child(i), target);
-	if ($end && $end.depth == depth && $end.textOffset) addNode($end.nodeBefore, target);
-}
-function close(node, content) {
-	node.type.checkContent(content);
-	return node.copy(content);
-}
-function replaceThreeWay($from, $start, $end, $to, depth) {
-	let openStart = $from.depth > depth && joinable($from, $start, depth + 1);
-	let openEnd = $to.depth > depth && joinable($end, $to, depth + 1);
-	let content = [];
-	addRange(null, $from, depth, content);
-	if (openStart && openEnd && $start.index(depth) == $end.index(depth)) {
-		checkJoin(openStart, openEnd);
-		addNode(close(openStart, replaceThreeWay($from, $start, $end, $to, depth + 1)), content);
-	} else {
-		if (openStart) addNode(close(openStart, replaceTwoWay($from, $start, depth + 1)), content);
-		addRange($start, $end, depth, content);
-		if (openEnd) addNode(close(openEnd, replaceTwoWay($end, $to, depth + 1)), content);
-	}
-	addRange($to, null, depth, content);
-	return new Fragment(content);
-}
-function replaceTwoWay($from, $to, depth) {
-	let content = [];
-	addRange(null, $from, depth, content);
-	if ($from.depth > depth) addNode(close(joinable($from, $to, depth + 1), replaceTwoWay($from, $to, depth + 1)), content);
-	addRange($to, null, depth, content);
-	return new Fragment(content);
-}
-function prepareSliceForReplace(slice, $along) {
-	let extra = $along.depth - slice.openStart;
-	let node = $along.node(extra).copy(slice.content);
-	for (let i = extra - 1; i >= 0; i--) node = $along.node(i).copy(Fragment.from(node));
-	return {
-		start: node.resolveNoCache(slice.openStart + extra),
-		end: node.resolveNoCache(node.content.size - slice.openEnd - extra)
-	};
-}
-/**
-You can [_resolve_](https://prosemirror.net/docs/ref/#model.Node.resolve) a position to get more
-information about it. Objects of this class represent such a
-resolved position, providing various pieces of context
-information, and some helper methods.
-
-Throughout this interface, methods that take an optional `depth`
-parameter will interpret undefined as `this.depth` and negative
-numbers as `this.depth + value`.
-*/
-var ResolvedPos = class ResolvedPos {
-	/**
-	@internal
-	*/
-	constructor(pos, path, parentOffset) {
-		this.pos = pos;
-		this.path = path;
-		this.parentOffset = parentOffset;
-		this.depth = path.length / 3 - 1;
-	}
-	/**
-	@internal
-	*/
-	resolveDepth(val) {
-		if (val == null) return this.depth;
-		if (val < 0) return this.depth + val;
-		return val;
-	}
-	/**
-	The parent node that the position points into. Note that even if
-	a position points into a text node, that node is not considered
-	the parent—text nodes are ‘flat’ in this model, and have no content.
-	*/
-	get parent() {
-		return this.node(this.depth);
-	}
-	/**
-	The root node in which the position was resolved.
-	*/
-	get doc() {
-		return this.node(0);
-	}
-	/**
-	The ancestor node at the given level. `p.node(p.depth)` is the
-	same as `p.parent`.
-	*/
-	node(depth) {
-		return this.path[this.resolveDepth(depth) * 3];
-	}
-	/**
-	The index into the ancestor at the given level. If this points
-	at the 3rd node in the 2nd paragraph on the top level, for
-	example, `p.index(0)` is 1 and `p.index(1)` is 2.
-	*/
-	index(depth) {
-		return this.path[this.resolveDepth(depth) * 3 + 1];
-	}
-	/**
-	The index pointing after this position into the ancestor at the
-	given level.
-	*/
-	indexAfter(depth) {
-		depth = this.resolveDepth(depth);
-		return this.index(depth) + (depth == this.depth && !this.textOffset ? 0 : 1);
-	}
-	/**
-	The (absolute) position at the start of the node at the given
-	level.
-	*/
-	start(depth) {
-		depth = this.resolveDepth(depth);
-		return depth == 0 ? 0 : this.path[depth * 3 - 1] + 1;
-	}
-	/**
-	The (absolute) position at the end of the node at the given
-	level.
-	*/
-	end(depth) {
-		depth = this.resolveDepth(depth);
-		return this.start(depth) + this.node(depth).content.size;
-	}
-	/**
-	The (absolute) position directly before the wrapping node at the
-	given level, or, when `depth` is `this.depth + 1`, the original
-	position.
-	*/
-	before(depth) {
-		depth = this.resolveDepth(depth);
-		if (!depth) throw new RangeError("There is no position before the top-level node");
-		return depth == this.depth + 1 ? this.pos : this.path[depth * 3 - 1];
-	}
-	/**
-	The (absolute) position directly after the wrapping node at the
-	given level, or the original position when `depth` is `this.depth + 1`.
-	*/
-	after(depth) {
-		depth = this.resolveDepth(depth);
-		if (!depth) throw new RangeError("There is no position after the top-level node");
-		return depth == this.depth + 1 ? this.pos : this.path[depth * 3 - 1] + this.path[depth * 3].nodeSize;
-	}
-	/**
-	When this position points into a text node, this returns the
-	distance between the position and the start of the text node.
-	Will be zero for positions that point between nodes.
-	*/
-	get textOffset() {
-		return this.pos - this.path[this.path.length - 1];
-	}
-	/**
-	Get the node directly after the position, if any. If the position
-	points into a text node, only the part of that node after the
-	position is returned.
-	*/
-	get nodeAfter() {
-		let parent = this.parent, index = this.index(this.depth);
-		if (index == parent.childCount) return null;
-		let dOff = this.pos - this.path[this.path.length - 1], child = parent.child(index);
-		return dOff ? parent.child(index).cut(dOff) : child;
-	}
-	/**
-	Get the node directly before the position, if any. If the
-	position points into a text node, only the part of that node
-	before the position is returned.
-	*/
-	get nodeBefore() {
-		let index = this.index(this.depth);
-		let dOff = this.pos - this.path[this.path.length - 1];
-		if (dOff) return this.parent.child(index).cut(0, dOff);
-		return index == 0 ? null : this.parent.child(index - 1);
-	}
-	/**
-	Get the position at the given index in the parent node at the
-	given depth (which defaults to `this.depth`).
-	*/
-	posAtIndex(index, depth) {
-		depth = this.resolveDepth(depth);
-		let node = this.path[depth * 3], pos = depth == 0 ? 0 : this.path[depth * 3 - 1] + 1;
-		for (let i = 0; i < index; i++) pos += node.child(i).nodeSize;
-		return pos;
-	}
-	/**
-	Get the marks at this position, factoring in the surrounding
-	marks' [`inclusive`](https://prosemirror.net/docs/ref/#model.MarkSpec.inclusive) property. If the
-	position is at the start of a non-empty node, the marks of the
-	node after it (if any) are returned.
-	*/
-	marks() {
-		let parent = this.parent, index = this.index();
-		if (parent.content.size == 0) return Mark.none;
-		if (this.textOffset) return parent.child(index).marks;
-		let main = parent.maybeChild(index - 1), other = parent.maybeChild(index);
-		if (!main) {
-			let tmp = main;
-			main = other;
-			other = tmp;
-		}
-		let marks = main.marks;
-		for (var i = 0; i < marks.length; i++) if (marks[i].type.spec.inclusive === false && (!other || !marks[i].isInSet(other.marks))) marks = marks[i--].removeFromSet(marks);
-		return marks;
-	}
-	/**
-	Get the marks after the current position, if any, except those
-	that are non-inclusive and not present at position `$end`. This
-	is mostly useful for getting the set of marks to preserve after a
-	deletion. Will return `null` if this position is at the end of
-	its parent node or its parent node isn't a textblock (in which
-	case no marks should be preserved).
-	*/
-	marksAcross($end) {
-		let after = this.parent.maybeChild(this.index());
-		if (!after || !after.isInline) return null;
-		let marks = after.marks, next = $end.parent.maybeChild($end.index());
-		for (var i = 0; i < marks.length; i++) if (marks[i].type.spec.inclusive === false && (!next || !marks[i].isInSet(next.marks))) marks = marks[i--].removeFromSet(marks);
-		return marks;
-	}
-	/**
-	The depth up to which this position and the given (non-resolved)
-	position share the same parent nodes.
-	*/
-	sharedDepth(pos) {
-		for (let depth = this.depth; depth > 0; depth--) if (this.start(depth) <= pos && this.end(depth) >= pos) return depth;
-		return 0;
-	}
-	/**
-	Returns a range based on the place where this position and the
-	given position diverge around block content. If both point into
-	the same textblock, for example, a range around that textblock
-	will be returned. If they point into different blocks, the range
-	around those blocks in their shared ancestor is returned. You can
-	pass in an optional predicate that will be called with a parent
-	node to see if a range into that parent is acceptable.
-	*/
-	blockRange(other = this, pred) {
-		if (other.pos < this.pos) return other.blockRange(this);
-		for (let d = this.depth - (this.parent.inlineContent || this.pos == other.pos ? 1 : 0); d >= 0; d--) if (other.pos <= this.end(d) && (!pred || pred(this.node(d)))) return new NodeRange(this, other, d);
-		return null;
-	}
-	/**
-	Query whether the given position shares the same parent node.
-	*/
-	sameParent(other) {
-		return this.pos - this.parentOffset == other.pos - other.parentOffset;
-	}
-	/**
-	Return the greater of this and the given position.
-	*/
-	max(other) {
-		return other.pos > this.pos ? other : this;
-	}
-	/**
-	Return the smaller of this and the given position.
-	*/
-	min(other) {
-		return other.pos < this.pos ? other : this;
-	}
-	/**
-	@internal
-	*/
-	toString() {
-		let str = "";
-		for (let i = 1; i <= this.depth; i++) str += (str ? "/" : "") + this.node(i).type.name + "_" + this.index(i - 1);
-		return str + ":" + this.parentOffset;
-	}
-	/**
-	@internal
-	*/
-	static resolve(doc, pos) {
-		if (!(pos >= 0 && pos <= doc.content.size)) throw new RangeError("Position " + pos + " out of range");
-		let path = [];
-		let start = 0, parentOffset = pos;
-		for (let node = doc;;) {
-			let { index, offset } = node.content.findIndex(parentOffset);
-			let rem = parentOffset - offset;
-			path.push(node, index, start + offset);
-			if (!rem) break;
-			node = node.child(index);
-			if (node.isText) break;
-			parentOffset = rem - 1;
-			start += offset + 1;
-		}
-		return new ResolvedPos(pos, path, parentOffset);
-	}
-	/**
-	@internal
-	*/
-	static resolveCached(doc, pos) {
-		let cache = resolveCache.get(doc);
-		if (cache) for (let i = 0; i < cache.elts.length; i++) {
-			let elt = cache.elts[i];
-			if (elt.pos == pos) return elt;
-		}
-		else resolveCache.set(doc, cache = new ResolveCache());
-		let result = cache.elts[cache.i] = ResolvedPos.resolve(doc, pos);
-		cache.i = (cache.i + 1) % resolveCacheSize;
-		return result;
-	}
-};
-var ResolveCache = class {
-	constructor() {
-		this.elts = [];
-		this.i = 0;
-	}
-};
-var resolveCacheSize = 12, resolveCache = /* @__PURE__ */ new WeakMap();
-/**
-Represents a flat range of content, i.e. one that starts and
-ends in the same node.
-*/
-var NodeRange = class {
-	/**
-	Construct a node range. `$from` and `$to` should point into the
-	same node until at least the given `depth`, since a node range
-	denotes an adjacent set of nodes in a single parent node.
-	*/
-	constructor($from, $to, depth) {
-		this.$from = $from;
-		this.$to = $to;
-		this.depth = depth;
-	}
-	/**
-	The position at the start of the range.
-	*/
-	get start() {
-		return this.$from.before(this.depth + 1);
-	}
-	/**
-	The position at the end of the range.
-	*/
-	get end() {
-		return this.$to.after(this.depth + 1);
-	}
-	/**
-	The parent node that the range points into.
-	*/
-	get parent() {
-		return this.$from.node(this.depth);
-	}
-	/**
-	The start index of the range in the parent node.
-	*/
-	get startIndex() {
-		return this.$from.index(this.depth);
-	}
-	/**
-	The end index of the range in the parent node.
-	*/
-	get endIndex() {
-		return this.$to.indexAfter(this.depth);
-	}
-};
-var emptyAttrs = Object.create(null);
-/**
-This class represents a node in the tree that makes up a
-ProseMirror document. So a document is an instance of `Node`, with
-children that are also instances of `Node`.
-
-Nodes are persistent data structures. Instead of changing them, you
-create new ones with the content you want. Old ones keep pointing
-at the old document shape. This is made cheaper by sharing
-structure between the old and new data as much as possible, which a
-tree shape like this (without back pointers) makes easy.
-
-**Do not** directly mutate the properties of a `Node` object. See
-[the guide](https://prosemirror.net/docs/guide/#doc) for more information.
-*/
-var Node = class Node {
-	/**
-	@internal
-	*/
-	constructor(type, attrs, content, marks = Mark.none) {
-		this.type = type;
-		this.attrs = attrs;
-		this.marks = marks;
-		this.content = content || Fragment.empty;
-	}
-	/**
-	The array of this node's child nodes.
-	*/
-	get children() {
-		return this.content.content;
-	}
-	/**
-	The size of this node, as defined by the integer-based [indexing
-	scheme](https://prosemirror.net/docs/guide/#doc.indexing). For text nodes, this is the
-	amount of characters. For other leaf nodes, it is one. For
-	non-leaf nodes, it is the size of the content plus two (the
-	start and end token).
-	*/
-	get nodeSize() {
-		return this.isLeaf ? 1 : 2 + this.content.size;
-	}
-	/**
-	The number of children that the node has.
-	*/
-	get childCount() {
-		return this.content.childCount;
-	}
-	/**
-	Get the child node at the given index. Raises an error when the
-	index is out of range.
-	*/
-	child(index) {
-		return this.content.child(index);
-	}
-	/**
-	Get the child node at the given index, if it exists.
-	*/
-	maybeChild(index) {
-		return this.content.maybeChild(index);
-	}
-	/**
-	Call `f` for every child node, passing the node, its offset
-	into this parent node, and its index.
-	*/
-	forEach(f) {
-		this.content.forEach(f);
-	}
-	/**
-	Invoke a callback for all descendant nodes recursively between
-	the given two positions that are relative to start of this
-	node's content. The callback is invoked with the node, its
-	position relative to the original node (method receiver),
-	its parent node, and its child index. When the callback returns
-	false for a given node, that node's children will not be
-	recursed over. The last parameter can be used to specify a
-	starting position to count from.
-	*/
-	nodesBetween(from, to, f, startPos = 0) {
-		this.content.nodesBetween(from, to, f, startPos, this);
-	}
-	/**
-	Call the given callback for every descendant node. Doesn't
-	descend into a node when the callback returns `false`.
-	*/
-	descendants(f) {
-		this.nodesBetween(0, this.content.size, f);
-	}
-	/**
-	Concatenates all the text nodes found in this fragment and its
-	children.
-	*/
-	get textContent() {
-		return this.isLeaf && this.type.spec.leafText ? this.type.spec.leafText(this) : this.textBetween(0, this.content.size, "");
-	}
-	/**
-	Get all text between positions `from` and `to`. When
-	`blockSeparator` is given, it will be inserted to separate text
-	from different block nodes. If `leafText` is given, it'll be
-	inserted for every non-text leaf node encountered, otherwise
-	[`leafText`](https://prosemirror.net/docs/ref/#model.NodeSpec.leafText) will be used.
-	*/
-	textBetween(from, to, blockSeparator, leafText) {
-		return this.content.textBetween(from, to, blockSeparator, leafText);
-	}
-	/**
-	Returns this node's first child, or `null` if there are no
-	children.
-	*/
-	get firstChild() {
-		return this.content.firstChild;
-	}
-	/**
-	Returns this node's last child, or `null` if there are no
-	children.
-	*/
-	get lastChild() {
-		return this.content.lastChild;
-	}
-	/**
-	Test whether two nodes represent the same piece of document.
-	*/
-	eq(other) {
-		return this == other || this.sameMarkup(other) && this.content.eq(other.content);
-	}
-	/**
-	Compare the markup (type, attributes, and marks) of this node to
-	those of another. Returns `true` if both have the same markup.
-	*/
-	sameMarkup(other) {
-		return this.hasMarkup(other.type, other.attrs, other.marks);
-	}
-	/**
-	Check whether this node's markup correspond to the given type,
-	attributes, and marks.
-	*/
-	hasMarkup(type, attrs, marks) {
-		return this.type == type && compareDeep(this.attrs, attrs || type.defaultAttrs || emptyAttrs) && Mark.sameSet(this.marks, marks || Mark.none);
-	}
-	/**
-	Create a new node with the same markup as this node, containing
-	the given content (or empty, if no content is given).
-	*/
-	copy(content = null) {
-		if (content == this.content) return this;
-		return new Node(this.type, this.attrs, content, this.marks);
-	}
-	/**
-	Create a copy of this node, with the given set of marks instead
-	of the node's own marks.
-	*/
-	mark(marks) {
-		return marks == this.marks ? this : new Node(this.type, this.attrs, this.content, marks);
-	}
-	/**
-	Create a copy of this node with only the content between the
-	given positions. If `to` is not given, it defaults to the end of
-	the node.
-	*/
-	cut(from, to = this.content.size) {
-		if (from == 0 && to == this.content.size) return this;
-		return this.copy(this.content.cut(from, to));
-	}
-	/**
-	Cut out the part of the document between the given positions, and
-	return it as a `Slice` object.
-	*/
-	slice(from, to = this.content.size, includeParents = false) {
-		if (from == to) return Slice.empty;
-		let $from = this.resolve(from), $to = this.resolve(to);
-		let depth = includeParents ? 0 : $from.sharedDepth(to);
-		let start = $from.start(depth);
-		return new Slice($from.node(depth).content.cut($from.pos - start, $to.pos - start), $from.depth - depth, $to.depth - depth);
-	}
-	/**
-	Replace the part of the document between the given positions with
-	the given slice. The slice must 'fit', meaning its open sides
-	must be able to connect to the surrounding content, and its
-	content nodes must be valid children for the node they are placed
-	into. If any of this is violated, an error of type
-	[`ReplaceError`](https://prosemirror.net/docs/ref/#model.ReplaceError) is thrown.
-	*/
-	replace(from, to, slice) {
-		return replace(this.resolve(from), this.resolve(to), slice);
-	}
-	/**
-	Find the node directly after the given position.
-	*/
-	nodeAt(pos) {
-		for (let node = this;;) {
-			let { index, offset } = node.content.findIndex(pos);
-			node = node.maybeChild(index);
-			if (!node) return null;
-			if (offset == pos || node.isText) return node;
-			pos -= offset + 1;
-		}
-	}
-	/**
-	Find the (direct) child node after the given offset, if any,
-	and return it along with its index and offset relative to this
-	node.
-	*/
-	childAfter(pos) {
-		let { index, offset } = this.content.findIndex(pos);
-		return {
-			node: this.content.maybeChild(index),
-			index,
-			offset
-		};
-	}
-	/**
-	Find the (direct) child node before the given offset, if any,
-	and return it along with its index and offset relative to this
-	node.
-	*/
-	childBefore(pos) {
-		if (pos == 0) return {
-			node: null,
-			index: 0,
-			offset: 0
-		};
-		let { index, offset } = this.content.findIndex(pos);
-		if (offset < pos) return {
-			node: this.content.child(index),
-			index,
-			offset
-		};
-		let node = this.content.child(index - 1);
-		return {
-			node,
-			index: index - 1,
-			offset: offset - node.nodeSize
-		};
-	}
-	/**
-	Resolve the given position in the document, returning an
-	[object](https://prosemirror.net/docs/ref/#model.ResolvedPos) with information about its context.
-	*/
-	resolve(pos) {
-		return ResolvedPos.resolveCached(this, pos);
-	}
-	/**
-	@internal
-	*/
-	resolveNoCache(pos) {
-		return ResolvedPos.resolve(this, pos);
-	}
-	/**
-	Test whether a given mark or mark type occurs in this document
-	between the two given positions.
-	*/
-	rangeHasMark(from, to, type) {
-		let found = false;
-		if (to > from) this.nodesBetween(from, to, (node) => {
-			if (type.isInSet(node.marks)) found = true;
-			return !found;
-		});
-		return found;
-	}
-	/**
-	True when this is a block (non-inline node)
-	*/
-	get isBlock() {
-		return this.type.isBlock;
-	}
-	/**
-	True when this is a textblock node, a block node with inline
-	content.
-	*/
-	get isTextblock() {
-		return this.type.isTextblock;
-	}
-	/**
-	True when this node allows inline content.
-	*/
-	get inlineContent() {
-		return this.type.inlineContent;
-	}
-	/**
-	True when this is an inline node (a text node or a node that can
-	appear among text).
-	*/
-	get isInline() {
-		return this.type.isInline;
-	}
-	/**
-	True when this is a text node.
-	*/
-	get isText() {
-		return this.type.isText;
-	}
-	/**
-	True when this is a leaf node.
-	*/
-	get isLeaf() {
-		return this.type.isLeaf;
-	}
-	/**
-	True when this is an atom, i.e. when it does not have directly
-	editable content. This is usually the same as `isLeaf`, but can
-	be configured with the [`atom` property](https://prosemirror.net/docs/ref/#model.NodeSpec.atom)
-	on a node's spec (typically used when the node is displayed as
-	an uneditable [node view](https://prosemirror.net/docs/ref/#view.NodeView)).
-	*/
-	get isAtom() {
-		return this.type.isAtom;
-	}
-	/**
-	Return a string representation of this node for debugging
-	purposes.
-	*/
-	toString() {
-		if (this.type.spec.toDebugString) return this.type.spec.toDebugString(this);
-		let name = this.type.name;
-		if (this.content.size) name += "(" + this.content.toStringInner() + ")";
-		return wrapMarks(this.marks, name);
-	}
-	/**
-	Get the content match in this node at the given index.
-	*/
-	contentMatchAt(index) {
-		let match = this.type.contentMatch.matchFragment(this.content, 0, index);
-		if (!match) throw new Error("Called contentMatchAt on a node with invalid content");
-		return match;
-	}
-	/**
-	Test whether replacing the range between `from` and `to` (by
-	child index) with the given replacement fragment (which defaults
-	to the empty fragment) would leave the node's content valid. You
-	can optionally pass `start` and `end` indices into the
-	replacement fragment.
-	*/
-	canReplace(from, to, replacement = Fragment.empty, start = 0, end = replacement.childCount) {
-		let one = this.contentMatchAt(from).matchFragment(replacement, start, end);
-		let two = one && one.matchFragment(this.content, to);
-		if (!two || !two.validEnd) return false;
-		for (let i = start; i < end; i++) if (!this.type.allowsMarks(replacement.child(i).marks)) return false;
-		return true;
-	}
-	/**
-	Test whether replacing the range `from` to `to` (by index) with
-	a node of the given type would leave the node's content valid.
-	*/
-	canReplaceWith(from, to, type, marks) {
-		if (marks && !this.type.allowsMarks(marks)) return false;
-		let start = this.contentMatchAt(from).matchType(type);
-		let end = start && start.matchFragment(this.content, to);
-		return end ? end.validEnd : false;
-	}
-	/**
-	Test whether the given node's content could be appended to this
-	node. If that node is empty, this will only return true if there
-	is at least one node type that can appear in both nodes (to avoid
-	merging completely incompatible nodes).
-	*/
-	canAppend(other) {
-		if (other.content.size) return this.canReplace(this.childCount, this.childCount, other.content);
-		else return this.type.compatibleContent(other.type);
-	}
-	/**
-	Check whether this node and its descendants conform to the
-	schema, and raise an exception when they do not.
-	*/
-	check() {
-		this.type.checkContent(this.content);
-		this.type.checkAttrs(this.attrs);
-		let copy = Mark.none;
-		for (let i = 0; i < this.marks.length; i++) {
-			let mark = this.marks[i];
-			mark.type.checkAttrs(mark.attrs);
-			copy = mark.addToSet(copy);
-		}
-		if (!Mark.sameSet(copy, this.marks)) throw new RangeError(`Invalid collection of marks for node ${this.type.name}: ${this.marks.map((m) => m.type.name)}`);
-		this.content.forEach((node) => node.check());
-	}
-	/**
-	Return a JSON-serializeable representation of this node.
-	*/
-	toJSON() {
-		let obj = { type: this.type.name };
-		for (let _ in this.attrs) {
-			obj.attrs = this.attrs;
-			break;
-		}
-		if (this.content.size) obj.content = this.content.toJSON();
-		if (this.marks.length) obj.marks = this.marks.map((n) => n.toJSON());
-		return obj;
-	}
-	/**
-	Deserialize a node from its JSON representation.
-	*/
-	static fromJSON(schema, json) {
-		if (!json) throw new RangeError("Invalid input for Node.fromJSON");
-		let marks = void 0;
-		if (json.marks) {
-			if (!Array.isArray(json.marks)) throw new RangeError("Invalid mark data for Node.fromJSON");
-			marks = json.marks.map(schema.markFromJSON);
-		}
-		if (json.type == "text") {
-			if (typeof json.text != "string") throw new RangeError("Invalid text node in JSON");
-			return schema.text(json.text, marks);
-		}
-		let content = Fragment.fromJSON(schema, json.content);
-		let node = schema.nodeType(json.type).create(json.attrs, content, marks);
-		node.type.checkAttrs(node.attrs);
-		return node;
-	}
-};
-Node.prototype.text = void 0;
-var TextNode = class TextNode extends Node {
-	/**
-	@internal
-	*/
-	constructor(type, attrs, content, marks) {
-		super(type, attrs, null, marks);
-		if (!content) throw new RangeError("Empty text nodes are not allowed");
-		this.text = content;
-	}
-	toString() {
-		if (this.type.spec.toDebugString) return this.type.spec.toDebugString(this);
-		return wrapMarks(this.marks, JSON.stringify(this.text));
-	}
-	get textContent() {
-		return this.text;
-	}
-	textBetween(from, to) {
-		return this.text.slice(from, to);
-	}
-	get nodeSize() {
-		return this.text.length;
-	}
-	mark(marks) {
-		return marks == this.marks ? this : new TextNode(this.type, this.attrs, this.text, marks);
-	}
-	withText(text) {
-		if (text == this.text) return this;
-		return new TextNode(this.type, this.attrs, text, this.marks);
-	}
-	cut(from = 0, to = this.text.length) {
-		if (from == 0 && to == this.text.length) return this;
-		return this.withText(this.text.slice(from, to));
-	}
-	eq(other) {
-		return this.sameMarkup(other) && this.text == other.text;
-	}
-	toJSON() {
-		let base = super.toJSON();
-		base.text = this.text;
-		return base;
-	}
-};
-function wrapMarks(marks, str) {
-	for (let i = marks.length - 1; i >= 0; i--) str = marks[i].type.name + "(" + str + ")";
-	return str;
-}
-/**
-Instances of this class represent a match state of a node type's
-[content expression](https://prosemirror.net/docs/ref/#model.NodeSpec.content), and can be used to
-find out whether further content matches here, and whether a given
-position is a valid end of the node.
-*/
-var ContentMatch = class ContentMatch {
-	/**
-	@internal
-	*/
-	constructor(validEnd) {
-		this.validEnd = validEnd;
-		/**
-		@internal
-		*/
-		this.next = [];
-		/**
-		@internal
-		*/
-		this.wrapCache = [];
-	}
-	/**
-	@internal
-	*/
-	static parse(string, nodeTypes) {
-		let stream = new TokenStream(string, nodeTypes);
-		if (stream.next == null) return ContentMatch.empty;
-		let expr = parseExpr(stream);
-		if (stream.next) stream.err("Unexpected trailing text");
-		let match = dfa(nfa(expr));
-		checkForDeadEnds(match, stream);
-		return match;
-	}
-	/**
-	Match a node type, returning a match after that node if
-	successful.
-	*/
-	matchType(type) {
-		for (let i = 0; i < this.next.length; i++) if (this.next[i].type == type) return this.next[i].next;
-		return null;
-	}
-	/**
-	Try to match a fragment. Returns the resulting match when
-	successful.
-	*/
-	matchFragment(frag, start = 0, end = frag.childCount) {
-		let cur = this;
-		for (let i = start; cur && i < end; i++) cur = cur.matchType(frag.child(i).type);
-		return cur;
-	}
-	/**
-	@internal
-	*/
-	get inlineContent() {
-		return this.next.length != 0 && this.next[0].type.isInline;
-	}
-	/**
-	Get the first matching node type at this match position that can
-	be generated.
-	*/
-	get defaultType() {
-		for (let i = 0; i < this.next.length; i++) {
-			let { type } = this.next[i];
-			if (!(type.isText || type.hasRequiredAttrs())) return type;
-		}
-		return null;
-	}
-	/**
-	@internal
-	*/
-	compatible(other) {
-		for (let i = 0; i < this.next.length; i++) for (let j = 0; j < other.next.length; j++) if (this.next[i].type == other.next[j].type) return true;
-		return false;
-	}
-	/**
-	Try to match the given fragment, and if that fails, see if it can
-	be made to match by inserting nodes in front of it. When
-	successful, return a fragment of inserted nodes (which may be
-	empty if nothing had to be inserted). When `toEnd` is true, only
-	return a fragment if the resulting match goes to the end of the
-	content expression.
-	*/
-	fillBefore(after, toEnd = false, startIndex = 0) {
-		let seen = [this];
-		function search(match, types) {
-			let finished = match.matchFragment(after, startIndex);
-			if (finished && (!toEnd || finished.validEnd)) return Fragment.from(types.map((tp) => tp.createAndFill()));
-			for (let i = 0; i < match.next.length; i++) {
-				let { type, next } = match.next[i];
-				if (!(type.isText || type.hasRequiredAttrs()) && seen.indexOf(next) == -1) {
-					seen.push(next);
-					let found = search(next, types.concat(type));
-					if (found) return found;
-				}
-			}
-			return null;
-		}
-		return search(this, []);
-	}
-	/**
-	Find a set of wrapping node types that would allow a node of the
-	given type to appear at this position. The result may be empty
-	(when it fits directly) and will be null when no such wrapping
-	exists.
-	*/
-	findWrapping(target) {
-		for (let i = 0; i < this.wrapCache.length; i += 2) if (this.wrapCache[i] == target) return this.wrapCache[i + 1];
-		let computed = this.computeWrapping(target);
-		this.wrapCache.push(target, computed);
-		return computed;
-	}
-	/**
-	@internal
-	*/
-	computeWrapping(target) {
-		let seen = Object.create(null), active = [{
-			match: this,
-			type: null,
-			via: null
-		}];
-		while (active.length) {
-			let current = active.shift(), match = current.match;
-			if (match.matchType(target)) {
-				let result = [];
-				for (let obj = current; obj.type; obj = obj.via) result.push(obj.type);
-				return result.reverse();
-			}
-			for (let i = 0; i < match.next.length; i++) {
-				let { type, next } = match.next[i];
-				if (!type.isLeaf && !type.hasRequiredAttrs() && !(type.name in seen) && (!current.type || next.validEnd)) {
-					active.push({
-						match: type.contentMatch,
-						type,
-						via: current
-					});
-					seen[type.name] = true;
-				}
-			}
-		}
-		return null;
-	}
-	/**
-	The number of outgoing edges this node has in the finite
-	automaton that describes the content expression.
-	*/
-	get edgeCount() {
-		return this.next.length;
-	}
-	/**
-	Get the _n_​th outgoing edge from this node in the finite
-	automaton that describes the content expression.
-	*/
-	edge(n) {
-		if (n >= this.next.length) throw new RangeError(`There's no ${n}th edge in this content match`);
-		return this.next[n];
-	}
-	/**
-	@internal
-	*/
-	toString() {
-		let seen = [];
-		function scan(m) {
-			seen.push(m);
-			for (let i = 0; i < m.next.length; i++) if (seen.indexOf(m.next[i].next) == -1) scan(m.next[i].next);
-		}
-		scan(this);
-		return seen.map((m, i) => {
-			let out = i + (m.validEnd ? "*" : " ") + " ";
-			for (let i = 0; i < m.next.length; i++) out += (i ? ", " : "") + m.next[i].type.name + "->" + seen.indexOf(m.next[i].next);
-			return out;
-		}).join("\n");
-	}
-};
-/**
-@internal
-*/
-ContentMatch.empty = new ContentMatch(true);
-var TokenStream = class {
-	constructor(string, nodeTypes) {
-		this.string = string;
-		this.nodeTypes = nodeTypes;
-		this.inline = null;
-		this.pos = 0;
-		this.tokens = string.split(/\s*(?=\b|\W|$)/);
-		if (this.tokens[this.tokens.length - 1] == "") this.tokens.pop();
-		if (this.tokens[0] == "") this.tokens.shift();
-	}
-	get next() {
-		return this.tokens[this.pos];
-	}
-	eat(tok) {
-		return this.next == tok && (this.pos++ || true);
-	}
-	err(str) {
-		throw new SyntaxError(str + " (in content expression '" + this.string + "')");
-	}
-};
-function parseExpr(stream) {
-	let exprs = [];
-	do
-		exprs.push(parseExprSeq(stream));
-	while (stream.eat("|"));
-	return exprs.length == 1 ? exprs[0] : {
-		type: "choice",
-		exprs
-	};
-}
-function parseExprSeq(stream) {
-	let exprs = [];
-	do
-		exprs.push(parseExprSubscript(stream));
-	while (stream.next && stream.next != ")" && stream.next != "|");
-	return exprs.length == 1 ? exprs[0] : {
-		type: "seq",
-		exprs
-	};
-}
-function parseExprSubscript(stream) {
-	let expr = parseExprAtom(stream);
-	for (;;) if (stream.eat("+")) expr = {
-		type: "plus",
-		expr
-	};
-	else if (stream.eat("*")) expr = {
-		type: "star",
-		expr
-	};
-	else if (stream.eat("?")) expr = {
-		type: "opt",
-		expr
-	};
-	else if (stream.eat("{")) expr = parseExprRange(stream, expr);
-	else break;
-	return expr;
-}
-function parseNum(stream) {
-	if (/\D/.test(stream.next)) stream.err("Expected number, got '" + stream.next + "'");
-	let result = Number(stream.next);
-	stream.pos++;
-	return result;
-}
-function parseExprRange(stream, expr) {
-	let min = parseNum(stream), max = min;
-	if (stream.eat(",")) if (stream.next != "}") max = parseNum(stream);
-	else max = -1;
-	if (!stream.eat("}")) stream.err("Unclosed braced range");
-	return {
-		type: "range",
-		min,
-		max,
-		expr
-	};
-}
-function resolveName(stream, name) {
-	let types = stream.nodeTypes, type = types[name];
-	if (type) return [type];
-	let result = [];
-	for (let typeName in types) {
-		let type = types[typeName];
-		if (type.isInGroup(name)) result.push(type);
-	}
-	if (result.length == 0) stream.err("No node type or group '" + name + "' found");
-	return result;
-}
-function parseExprAtom(stream) {
-	if (stream.eat("(")) {
-		let expr = parseExpr(stream);
-		if (!stream.eat(")")) stream.err("Missing closing paren");
-		return expr;
-	} else if (!/\W/.test(stream.next)) {
-		let exprs = resolveName(stream, stream.next).map((type) => {
-			if (stream.inline == null) stream.inline = type.isInline;
-			else if (stream.inline != type.isInline) stream.err("Mixing inline and block content");
-			return {
-				type: "name",
-				value: type
-			};
-		});
-		stream.pos++;
-		return exprs.length == 1 ? exprs[0] : {
-			type: "choice",
-			exprs
-		};
-	} else stream.err("Unexpected token '" + stream.next + "'");
-}
-function nfa(expr) {
-	let nfa = [[]];
-	connect(compile(expr, 0), node());
-	return nfa;
-	function node() {
-		return nfa.push([]) - 1;
-	}
-	function edge(from, to, term) {
-		let edge = {
-			term,
-			to
-		};
-		nfa[from].push(edge);
-		return edge;
-	}
-	function connect(edges, to) {
-		edges.forEach((edge) => edge.to = to);
-	}
-	function compile(expr, from) {
-		if (expr.type == "choice") return expr.exprs.reduce((out, expr) => out.concat(compile(expr, from)), []);
-		else if (expr.type == "seq") for (let i = 0;; i++) {
-			let next = compile(expr.exprs[i], from);
-			if (i == expr.exprs.length - 1) return next;
-			connect(next, from = node());
-		}
-		else if (expr.type == "star") {
-			let loop = node();
-			edge(from, loop);
-			connect(compile(expr.expr, loop), loop);
-			return [edge(loop)];
-		} else if (expr.type == "plus") {
-			let loop = node();
-			connect(compile(expr.expr, from), loop);
-			connect(compile(expr.expr, loop), loop);
-			return [edge(loop)];
-		} else if (expr.type == "opt") return [edge(from)].concat(compile(expr.expr, from));
-		else if (expr.type == "range") {
-			let cur = from;
-			for (let i = 0; i < expr.min; i++) {
-				let next = node();
-				connect(compile(expr.expr, cur), next);
-				cur = next;
-			}
-			if (expr.max == -1) connect(compile(expr.expr, cur), cur);
-			else for (let i = expr.min; i < expr.max; i++) {
-				let next = node();
-				edge(cur, next);
-				connect(compile(expr.expr, cur), next);
-				cur = next;
-			}
-			return [edge(cur)];
-		} else if (expr.type == "name") return [edge(from, void 0, expr.value)];
-		else throw new Error("Unknown expr type");
-	}
-}
-function cmp(a, b) {
-	return b - a;
-}
-function nullFrom(nfa, node) {
-	let result = [];
-	scan(node);
-	return result.sort(cmp);
-	function scan(node) {
-		let edges = nfa[node];
-		if (edges.length == 1 && !edges[0].term) return scan(edges[0].to);
-		result.push(node);
-		for (let i = 0; i < edges.length; i++) {
-			let { term, to } = edges[i];
-			if (!term && result.indexOf(to) == -1) scan(to);
-		}
-	}
-}
-function dfa(nfa) {
-	let labeled = Object.create(null);
-	return explore(nullFrom(nfa, 0));
-	function explore(states) {
-		let out = [];
-		states.forEach((node) => {
-			nfa[node].forEach(({ term, to }) => {
-				if (!term) return;
-				let set;
-				for (let i = 0; i < out.length; i++) if (out[i][0] == term) set = out[i][1];
-				nullFrom(nfa, to).forEach((node) => {
-					if (!set) out.push([term, set = []]);
-					if (set.indexOf(node) == -1) set.push(node);
-				});
-			});
-		});
-		let state = labeled[states.join(",")] = new ContentMatch(states.indexOf(nfa.length - 1) > -1);
-		for (let i = 0; i < out.length; i++) {
-			let states = out[i][1].sort(cmp);
-			state.next.push({
-				type: out[i][0],
-				next: labeled[states.join(",")] || explore(states)
-			});
-		}
-		return state;
-	}
-}
-function checkForDeadEnds(match, stream) {
-	for (let i = 0, work = [match]; i < work.length; i++) {
-		let state = work[i], dead = !state.validEnd, nodes = [];
-		for (let j = 0; j < state.next.length; j++) {
-			let { type, next } = state.next[j];
-			nodes.push(type.name);
-			if (dead && !(type.isText || type.hasRequiredAttrs())) dead = false;
-			if (work.indexOf(next) == -1) work.push(next);
-		}
-		if (dead) stream.err("Only non-generatable nodes (" + nodes.join(", ") + ") in a required position (see https://prosemirror.net/docs/guide/#generatable)");
-	}
-}
-function defaultAttrs(attrs) {
-	let defaults = Object.create(null);
-	for (let attrName in attrs) {
-		let attr = attrs[attrName];
-		if (!attr.hasDefault) return null;
-		defaults[attrName] = attr.default;
-	}
-	return defaults;
-}
-function computeAttrs(attrs, value) {
-	let built = Object.create(null);
-	for (let name in attrs) {
-		let given = value && value[name];
-		if (given === void 0) {
-			let attr = attrs[name];
-			if (attr.hasDefault) given = attr.default;
-			else throw new RangeError("No value supplied for attribute " + name);
-		}
-		built[name] = given;
-	}
-	return built;
-}
-function checkAttrs(attrs, values, type, name) {
-	for (let name in values) if (!(name in attrs)) throw new RangeError(`Unsupported attribute ${name} for ${type} of type ${name}`);
-	for (let name in attrs) {
-		let attr = attrs[name];
-		if (attr.validate) attr.validate(values[name]);
-	}
-}
-function initAttrs(typeName, attrs) {
-	let result = Object.create(null);
-	if (attrs) for (let name in attrs) result[name] = new Attribute(typeName, name, attrs[name]);
-	return result;
-}
-/**
-Node types are objects allocated once per `Schema` and used to
-[tag](https://prosemirror.net/docs/ref/#model.Node.type) `Node` instances. They contain information
-about the node type, such as its name and what kind of node it
-represents.
-*/
-var NodeType = class NodeType {
-	/**
-	@internal
-	*/
-	constructor(name, schema, spec) {
-		this.name = name;
-		this.schema = schema;
-		this.spec = spec;
-		/**
-		The set of marks allowed in this node. `null` means all marks
-		are allowed.
-		*/
-		this.markSet = null;
-		this.groups = spec.group ? spec.group.split(" ") : [];
-		this.attrs = initAttrs(name, spec.attrs);
-		this.defaultAttrs = defaultAttrs(this.attrs);
-		this.contentMatch = null;
-		this.inlineContent = null;
-		this.isBlock = !(spec.inline || name == "text");
-		this.isText = name == "text";
-	}
-	/**
-	True if this is an inline type.
-	*/
-	get isInline() {
-		return !this.isBlock;
-	}
-	/**
-	True if this is a textblock type, a block that contains inline
-	content.
-	*/
-	get isTextblock() {
-		return this.isBlock && this.inlineContent;
-	}
-	/**
-	True for node types that allow no content.
-	*/
-	get isLeaf() {
-		return this.contentMatch == ContentMatch.empty;
-	}
-	/**
-	True when this node is an atom, i.e. when it does not have
-	directly editable content.
-	*/
-	get isAtom() {
-		return this.isLeaf || !!this.spec.atom;
-	}
-	/**
-	Return true when this node type is part of the given
-	[group](https://prosemirror.net/docs/ref/#model.NodeSpec.group).
-	*/
-	isInGroup(group) {
-		return this.groups.indexOf(group) > -1;
-	}
-	/**
-	The node type's [whitespace](https://prosemirror.net/docs/ref/#model.NodeSpec.whitespace) option.
-	*/
-	get whitespace() {
-		return this.spec.whitespace || (this.spec.code ? "pre" : "normal");
-	}
-	/**
-	Tells you whether this node type has any required attributes.
-	*/
-	hasRequiredAttrs() {
-		for (let n in this.attrs) if (this.attrs[n].isRequired) return true;
-		return false;
-	}
-	/**
-	Indicates whether this node allows some of the same content as
-	the given node type.
-	*/
-	compatibleContent(other) {
-		return this == other || this.contentMatch.compatible(other.contentMatch);
-	}
-	/**
-	@internal
-	*/
-	computeAttrs(attrs) {
-		if (!attrs && this.defaultAttrs) return this.defaultAttrs;
-		else return computeAttrs(this.attrs, attrs);
-	}
-	/**
-	Create a `Node` of this type. The given attributes are
-	checked and defaulted (you can pass `null` to use the type's
-	defaults entirely, if no required attributes exist). `content`
-	may be a `Fragment`, a node, an array of nodes, or
-	`null`. Similarly `marks` may be `null` to default to the empty
-	set of marks.
-	*/
-	create(attrs = null, content, marks) {
-		if (this.isText) throw new Error("NodeType.create can't construct text nodes");
-		return new Node(this, this.computeAttrs(attrs), Fragment.from(content), Mark.setFrom(marks));
-	}
-	/**
-	Like [`create`](https://prosemirror.net/docs/ref/#model.NodeType.create), but check the given content
-	against the node type's content restrictions, and throw an error
-	if it doesn't match.
-	*/
-	createChecked(attrs = null, content, marks) {
-		content = Fragment.from(content);
-		this.checkContent(content);
-		return new Node(this, this.computeAttrs(attrs), content, Mark.setFrom(marks));
-	}
-	/**
-	Like [`create`](https://prosemirror.net/docs/ref/#model.NodeType.create), but see if it is
-	necessary to add nodes to the start or end of the given fragment
-	to make it fit the node. If no fitting wrapping can be found,
-	return null. Note that, due to the fact that required nodes can
-	always be created, this will always succeed if you pass null or
-	`Fragment.empty` as content.
-	*/
-	createAndFill(attrs = null, content, marks) {
-		attrs = this.computeAttrs(attrs);
-		content = Fragment.from(content);
-		if (content.size) {
-			let before = this.contentMatch.fillBefore(content);
-			if (!before) return null;
-			content = before.append(content);
-		}
-		let matched = this.contentMatch.matchFragment(content);
-		let after = matched && matched.fillBefore(Fragment.empty, true);
-		if (!after) return null;
-		return new Node(this, attrs, content.append(after), Mark.setFrom(marks));
-	}
-	/**
-	Returns true if the given fragment is valid content for this node
-	type.
-	*/
-	validContent(content) {
-		let result = this.contentMatch.matchFragment(content);
-		if (!result || !result.validEnd) return false;
-		for (let i = 0; i < content.childCount; i++) if (!this.allowsMarks(content.child(i).marks)) return false;
-		return true;
-	}
-	/**
-	Throws a RangeError if the given fragment is not valid content for this
-	node type.
-	@internal
-	*/
-	checkContent(content) {
-		if (!this.validContent(content)) throw new RangeError(`Invalid content for node ${this.name}: ${content.toString().slice(0, 50)}`);
-	}
-	/**
-	@internal
-	*/
-	checkAttrs(attrs) {
-		checkAttrs(this.attrs, attrs, "node", this.name);
-	}
-	/**
-	Check whether the given mark type is allowed in this node.
-	*/
-	allowsMarkType(markType) {
-		return this.markSet == null || this.markSet.indexOf(markType) > -1;
-	}
-	/**
-	Test whether the given set of marks are allowed in this node.
-	*/
-	allowsMarks(marks) {
-		if (this.markSet == null) return true;
-		for (let i = 0; i < marks.length; i++) if (!this.allowsMarkType(marks[i].type)) return false;
-		return true;
-	}
-	/**
-	Removes the marks that are not allowed in this node from the given set.
-	*/
-	allowedMarks(marks) {
-		if (this.markSet == null) return marks;
-		let copy;
-		for (let i = 0; i < marks.length; i++) if (!this.allowsMarkType(marks[i].type)) {
-			if (!copy) copy = marks.slice(0, i);
-		} else if (copy) copy.push(marks[i]);
-		return !copy ? marks : copy.length ? copy : Mark.none;
-	}
-	/**
-	@internal
-	*/
-	static compile(nodes, schema) {
-		let result = Object.create(null);
-		nodes.forEach((name, spec) => result[name] = new NodeType(name, schema, spec));
-		let topType = schema.spec.topNode || "doc";
-		if (!result[topType]) throw new RangeError("Schema is missing its top node type ('" + topType + "')");
-		if (!result.text) throw new RangeError("Every schema needs a 'text' type");
-		for (let _ in result.text.attrs) throw new RangeError("The text node type should not have attributes");
-		return result;
-	}
-};
-function validateType(typeName, attrName, type) {
-	let types = type.split("|");
-	return (value) => {
-		let name = value === null ? "null" : typeof value;
-		if (types.indexOf(name) < 0) throw new RangeError(`Expected value of type ${types} for attribute ${attrName} on type ${typeName}, got ${name}`);
-	};
-}
-var Attribute = class {
-	constructor(typeName, attrName, options) {
-		this.hasDefault = Object.prototype.hasOwnProperty.call(options, "default");
-		this.default = options.default;
-		this.validate = typeof options.validate == "string" ? validateType(typeName, attrName, options.validate) : options.validate;
-	}
-	get isRequired() {
-		return !this.hasDefault;
-	}
-};
-/**
-Like nodes, marks (which are associated with nodes to signify
-things like emphasis or being part of a link) are
-[tagged](https://prosemirror.net/docs/ref/#model.Mark.type) with type objects, which are
-instantiated once per `Schema`.
-*/
-var MarkType = class MarkType {
-	/**
-	@internal
-	*/
-	constructor(name, rank, schema, spec) {
-		this.name = name;
-		this.rank = rank;
-		this.schema = schema;
-		this.spec = spec;
-		this.attrs = initAttrs(name, spec.attrs);
-		this.excluded = null;
-		let defaults = defaultAttrs(this.attrs);
-		this.instance = defaults ? new Mark(this, defaults) : null;
-	}
-	/**
-	Create a mark of this type. `attrs` may be `null` or an object
-	containing only some of the mark's attributes. The others, if
-	they have defaults, will be added.
-	*/
-	create(attrs = null) {
-		if (!attrs && this.instance) return this.instance;
-		return new Mark(this, computeAttrs(this.attrs, attrs));
-	}
-	/**
-	@internal
-	*/
-	static compile(marks, schema) {
-		let result = Object.create(null), rank = 0;
-		marks.forEach((name, spec) => result[name] = new MarkType(name, rank++, schema, spec));
-		return result;
-	}
-	/**
-	When there is a mark of this type in the given set, a new set
-	without it is returned. Otherwise, the input set is returned.
-	*/
-	removeFromSet(set) {
-		for (var i = 0; i < set.length; i++) if (set[i].type == this) {
-			set = set.slice(0, i).concat(set.slice(i + 1));
-			i--;
-		}
-		return set;
-	}
-	/**
-	Tests whether there is a mark of this type in the given set.
-	*/
-	isInSet(set) {
-		for (let i = 0; i < set.length; i++) if (set[i].type == this) return set[i];
-	}
-	/**
-	@internal
-	*/
-	checkAttrs(attrs) {
-		checkAttrs(this.attrs, attrs, "mark", this.name);
-	}
-	/**
-	Queries whether a given mark type is
-	[excluded](https://prosemirror.net/docs/ref/#model.MarkSpec.excludes) by this one.
-	*/
-	excludes(other) {
-		return this.excluded.indexOf(other) > -1;
-	}
-};
-/**
-A document schema. Holds [node](https://prosemirror.net/docs/ref/#model.NodeType) and [mark
-type](https://prosemirror.net/docs/ref/#model.MarkType) objects for the nodes and marks that may
-occur in conforming documents, and provides functionality for
-creating and deserializing such documents.
-
-When given, the type parameters provide the names of the nodes and
-marks in this schema.
-*/
-var Schema = class {
-	/**
-	Construct a schema from a schema [specification](https://prosemirror.net/docs/ref/#model.SchemaSpec).
-	*/
-	constructor(spec) {
-		/**
-		The [linebreak
-		replacement](https://prosemirror.net/docs/ref/#model.NodeSpec.linebreakReplacement) node defined
-		in this schema, if any.
-		*/
-		this.linebreakReplacement = null;
-		/**
-		An object for storing whatever values modules may want to
-		compute and cache per schema. (If you want to store something
-		in it, try to use property names unlikely to clash.)
-		*/
-		this.cached = Object.create(null);
-		let instanceSpec = this.spec = {};
-		for (let prop in spec) instanceSpec[prop] = spec[prop];
-		instanceSpec.nodes = OrderedMap.from(spec.nodes), instanceSpec.marks = OrderedMap.from(spec.marks || {}), this.nodes = NodeType.compile(this.spec.nodes, this);
-		this.marks = MarkType.compile(this.spec.marks, this);
-		let contentExprCache = Object.create(null);
-		for (let prop in this.nodes) {
-			if (prop in this.marks) throw new RangeError(prop + " can not be both a node and a mark");
-			let type = this.nodes[prop], contentExpr = type.spec.content || "", markExpr = type.spec.marks;
-			type.contentMatch = contentExprCache[contentExpr] || (contentExprCache[contentExpr] = ContentMatch.parse(contentExpr, this.nodes));
-			type.inlineContent = type.contentMatch.inlineContent;
-			if (type.spec.linebreakReplacement) {
-				if (this.linebreakReplacement) throw new RangeError("Multiple linebreak nodes defined");
-				if (!type.isInline || !type.isLeaf) throw new RangeError("Linebreak replacement nodes must be inline leaf nodes");
-				this.linebreakReplacement = type;
-			}
-			type.markSet = markExpr == "_" ? null : markExpr ? gatherMarks(this, markExpr.split(" ")) : markExpr == "" || !type.inlineContent ? [] : null;
-		}
-		for (let prop in this.marks) {
-			let type = this.marks[prop], excl = type.spec.excludes;
-			type.excluded = excl == null ? [type] : excl == "" ? [] : gatherMarks(this, excl.split(" "));
-		}
-		this.nodeFromJSON = (json) => Node.fromJSON(this, json);
-		this.markFromJSON = (json) => Mark.fromJSON(this, json);
-		this.topNodeType = this.nodes[this.spec.topNode || "doc"];
-		this.cached.wrappings = Object.create(null);
-	}
-	/**
-	Create a node in this schema. The `type` may be a string or a
-	`NodeType` instance. Attributes will be extended with defaults,
-	`content` may be a `Fragment`, `null`, a `Node`, or an array of
-	nodes.
-	*/
-	node(type, attrs = null, content, marks) {
-		if (typeof type == "string") type = this.nodeType(type);
-		else if (!(type instanceof NodeType)) throw new RangeError("Invalid node type: " + type);
-		else if (type.schema != this) throw new RangeError("Node type from different schema used (" + type.name + ")");
-		return type.createChecked(attrs, content, marks);
-	}
-	/**
-	Create a text node in the schema. Empty text nodes are not
-	allowed.
-	*/
-	text(text, marks) {
-		let type = this.nodes.text;
-		return new TextNode(type, type.defaultAttrs, text, Mark.setFrom(marks));
-	}
-	/**
-	Create a mark with the given type and attributes.
-	*/
-	mark(type, attrs) {
-		if (typeof type == "string") type = this.marks[type];
-		return type.create(attrs);
-	}
-	/**
-	@internal
-	*/
-	nodeType(name) {
-		let found = this.nodes[name];
-		if (!found) throw new RangeError("Unknown node type: " + name);
-		return found;
-	}
-};
-function gatherMarks(schema, marks) {
-	let found = [];
-	for (let i = 0; i < marks.length; i++) {
-		let name = marks[i], mark = schema.marks[name], ok = mark;
-		if (mark) found.push(mark);
-		else for (let prop in schema.marks) {
-			let mark = schema.marks[prop];
-			if (name == "_" || mark.spec.group && mark.spec.group.split(" ").indexOf(name) > -1) found.push(ok = mark);
-		}
-		if (!ok) throw new SyntaxError("Unknown mark type: '" + marks[i] + "'");
-	}
-	return found;
-}
-function isTagRule(rule) {
-	return rule.tag != null;
-}
-function isStyleRule(rule) {
-	return rule.style != null;
-}
-/**
-A DOM parser represents a strategy for parsing DOM content into a
-ProseMirror document conforming to a given schema. Its behavior is
-defined by an array of [rules](https://prosemirror.net/docs/ref/#model.ParseRule).
-*/
-var DOMParser = class DOMParser {
-	/**
-	Create a parser that targets the given schema, using the given
-	parsing rules.
-	*/
-	constructor(schema, rules) {
-		this.schema = schema;
-		this.rules = rules;
-		/**
-		@internal
-		*/
-		this.tags = [];
-		/**
-		@internal
-		*/
-		this.styles = [];
-		let matchedStyles = this.matchedStyles = [];
-		rules.forEach((rule) => {
-			if (isTagRule(rule)) this.tags.push(rule);
-			else if (isStyleRule(rule)) {
-				let prop = /[^=]*/.exec(rule.style)[0];
-				if (matchedStyles.indexOf(prop) < 0) matchedStyles.push(prop);
-				this.styles.push(rule);
-			}
-		});
-		this.normalizeLists = !this.tags.some((r) => {
-			if (!/^(ul|ol)\b/.test(r.tag) || !r.node) return false;
-			let node = schema.nodes[r.node];
-			return node.contentMatch.matchType(node);
-		});
-	}
-	/**
-	Parse a document from the content of a DOM node.
-	*/
-	parse(dom, options = {}) {
-		let context = new ParseContext(this, options, false);
-		context.addAll(dom, Mark.none, options.from, options.to);
-		return context.finish();
-	}
-	/**
-	Parses the content of the given DOM node, like
-	[`parse`](https://prosemirror.net/docs/ref/#model.DOMParser.parse), and takes the same set of
-	options. But unlike that method, which produces a whole node,
-	this one returns a slice that is open at the sides, meaning that
-	the schema constraints aren't applied to the start of nodes to
-	the left of the input and the end of nodes at the end.
-	*/
-	parseSlice(dom, options = {}) {
-		let context = new ParseContext(this, options, true);
-		context.addAll(dom, Mark.none, options.from, options.to);
-		return Slice.maxOpen(context.finish());
-	}
-	/**
-	@internal
-	*/
-	matchTag(dom, context, after) {
-		for (let i = after ? this.tags.indexOf(after) + 1 : 0; i < this.tags.length; i++) {
-			let rule = this.tags[i];
-			if (matches(dom, rule.tag) && (rule.namespace === void 0 || dom.namespaceURI == rule.namespace) && (!rule.context || context.matchesContext(rule.context))) {
-				if (rule.getAttrs) {
-					let result = rule.getAttrs(dom);
-					if (result === false) continue;
-					rule.attrs = result || void 0;
-				}
-				return rule;
-			}
-		}
-	}
-	/**
-	@internal
-	*/
-	matchStyle(prop, value, context, after) {
-		for (let i = after ? this.styles.indexOf(after) + 1 : 0; i < this.styles.length; i++) {
-			let rule = this.styles[i], style = rule.style;
-			if (style.indexOf(prop) != 0 || rule.context && !context.matchesContext(rule.context) || style.length > prop.length && (style.charCodeAt(prop.length) != 61 || style.slice(prop.length + 1) != value)) continue;
-			if (rule.getAttrs) {
-				let result = rule.getAttrs(value);
-				if (result === false) continue;
-				rule.attrs = result || void 0;
-			}
-			return rule;
-		}
-	}
-	/**
-	@internal
-	*/
-	static schemaRules(schema) {
-		let result = [];
-		function insert(rule) {
-			let priority = rule.priority == null ? 50 : rule.priority, i = 0;
-			for (; i < result.length; i++) {
-				let next = result[i];
-				if ((next.priority == null ? 50 : next.priority) < priority) break;
-			}
-			result.splice(i, 0, rule);
-		}
-		for (let name in schema.marks) {
-			let rules = schema.marks[name].spec.parseDOM;
-			if (rules) rules.forEach((rule) => {
-				insert(rule = copy(rule));
-				if (!(rule.mark || rule.ignore || rule.clearMark)) rule.mark = name;
-			});
-		}
-		for (let name in schema.nodes) {
-			let rules = schema.nodes[name].spec.parseDOM;
-			if (rules) rules.forEach((rule) => {
-				insert(rule = copy(rule));
-				if (!(rule.node || rule.ignore || rule.mark)) rule.node = name;
-			});
-		}
-		return result;
-	}
-	/**
-	Construct a DOM parser using the parsing rules listed in a
-	schema's [node specs](https://prosemirror.net/docs/ref/#model.NodeSpec.parseDOM), reordered by
-	[priority](https://prosemirror.net/docs/ref/#model.GenericParseRule.priority).
-	*/
-	static fromSchema(schema) {
-		return schema.cached.domParser || (schema.cached.domParser = new DOMParser(schema, DOMParser.schemaRules(schema)));
-	}
-};
-var blockTags = {
-	address: true,
-	article: true,
-	aside: true,
-	blockquote: true,
-	canvas: true,
-	dd: true,
-	div: true,
-	dl: true,
-	fieldset: true,
-	figcaption: true,
-	figure: true,
-	footer: true,
-	form: true,
-	h1: true,
-	h2: true,
-	h3: true,
-	h4: true,
-	h5: true,
-	h6: true,
-	header: true,
-	hgroup: true,
-	hr: true,
-	li: true,
-	noscript: true,
-	ol: true,
-	output: true,
-	p: true,
-	pre: true,
-	section: true,
-	table: true,
-	tfoot: true,
-	ul: true
-};
-var ignoreTags = {
-	head: true,
-	noscript: true,
-	object: true,
-	script: true,
-	style: true,
-	title: true
-};
-var listTags = {
-	ol: true,
-	ul: true
-};
-var OPT_PRESERVE_WS = 1, OPT_PRESERVE_WS_FULL = 2, OPT_OPEN_LEFT = 4;
-function wsOptionsFor(type, preserveWhitespace, base) {
-	if (preserveWhitespace != null) return (preserveWhitespace ? OPT_PRESERVE_WS : 0) | (preserveWhitespace === "full" ? OPT_PRESERVE_WS_FULL : 0);
-	return type && type.whitespace == "pre" ? OPT_PRESERVE_WS | OPT_PRESERVE_WS_FULL : base & ~OPT_OPEN_LEFT;
-}
-var NodeContext = class {
-	constructor(type, attrs, marks, solid, match, options) {
-		this.type = type;
-		this.attrs = attrs;
-		this.marks = marks;
-		this.solid = solid;
-		this.options = options;
-		this.content = [];
-		this.activeMarks = Mark.none;
-		this.match = match || (options & OPT_OPEN_LEFT ? null : type.contentMatch);
-	}
-	findWrapping(node) {
-		if (!this.match) {
-			if (!this.type) return [];
-			let fill = this.type.contentMatch.fillBefore(Fragment.from(node));
-			if (fill) this.match = this.type.contentMatch.matchFragment(fill);
-			else {
-				let start = this.type.contentMatch, wrap;
-				if (wrap = start.findWrapping(node.type)) {
-					this.match = start;
-					return wrap;
-				} else return null;
-			}
-		}
-		return this.match.findWrapping(node.type);
-	}
-	finish(openEnd) {
-		if (!(this.options & OPT_PRESERVE_WS)) {
-			let last = this.content[this.content.length - 1], m;
-			if (last && last.isText && (m = /[ \t\r\n\u000c]+$/.exec(last.text))) {
-				let text = last;
-				if (last.text.length == m[0].length) this.content.pop();
-				else this.content[this.content.length - 1] = text.withText(text.text.slice(0, text.text.length - m[0].length));
-			}
-		}
-		let content = Fragment.from(this.content);
-		if (!openEnd && this.match) content = content.append(this.match.fillBefore(Fragment.empty, true));
-		return this.type ? this.type.create(this.attrs, content, this.marks) : content;
-	}
-	inlineContext(node) {
-		if (this.type) return this.type.inlineContent;
-		if (this.content.length) return this.content[0].isInline;
-		return node.parentNode && !blockTags.hasOwnProperty(node.parentNode.nodeName.toLowerCase());
-	}
-};
-var ParseContext = class {
-	constructor(parser, options, isOpen) {
-		this.parser = parser;
-		this.options = options;
-		this.isOpen = isOpen;
-		this.open = 0;
-		this.localPreserveWS = false;
-		let topNode = options.topNode, topContext;
-		let topOptions = wsOptionsFor(null, options.preserveWhitespace, 0) | (isOpen ? OPT_OPEN_LEFT : 0);
-		if (topNode) topContext = new NodeContext(topNode.type, topNode.attrs, Mark.none, true, options.topMatch || topNode.type.contentMatch, topOptions);
-		else if (isOpen) topContext = new NodeContext(null, null, Mark.none, true, null, topOptions);
-		else topContext = new NodeContext(parser.schema.topNodeType, null, Mark.none, true, null, topOptions);
-		this.nodes = [topContext];
-		this.find = options.findPositions;
-		this.needsBlock = false;
-	}
-	get top() {
-		return this.nodes[this.open];
-	}
-	addDOM(dom, marks) {
-		if (dom.nodeType == 3) this.addTextNode(dom, marks);
-		else if (dom.nodeType == 1) this.addElement(dom, marks);
-	}
-	addTextNode(dom, marks) {
-		let value = dom.nodeValue;
-		let top = this.top, preserveWS = top.options & OPT_PRESERVE_WS_FULL ? "full" : this.localPreserveWS || (top.options & OPT_PRESERVE_WS) > 0;
-		let { schema } = this.parser;
-		if (preserveWS === "full" || top.inlineContext(dom) || /[^ \t\r\n\u000c]/.test(value)) {
-			if (!preserveWS) {
-				value = value.replace(/[ \t\r\n\u000c]+/g, " ");
-				if (/^[ \t\r\n\u000c]/.test(value) && this.open == this.nodes.length - 1) {
-					let nodeBefore = top.content[top.content.length - 1];
-					let domNodeBefore = dom.previousSibling;
-					if (!nodeBefore || domNodeBefore && domNodeBefore.nodeName == "BR" || nodeBefore.isText && /[ \t\r\n\u000c]$/.test(nodeBefore.text)) value = value.slice(1);
-				}
-			} else if (preserveWS === "full") value = value.replace(/\r\n?/g, "\n");
-			else if (schema.linebreakReplacement && /[\r\n]/.test(value) && this.top.findWrapping(schema.linebreakReplacement.create())) {
-				let lines = value.split(/\r?\n|\r/);
-				for (let i = 0; i < lines.length; i++) {
-					if (i) this.insertNode(schema.linebreakReplacement.create(), marks, true);
-					if (lines[i]) this.insertNode(schema.text(lines[i]), marks, !/\S/.test(lines[i]));
-				}
-				value = "";
-			} else value = value.replace(/\r?\n|\r/g, " ");
-			if (value) this.insertNode(schema.text(value), marks, !/\S/.test(value));
-			this.findInText(dom);
-		} else this.findInside(dom);
-	}
-	addElement(dom, marks, matchAfter) {
-		let outerWS = this.localPreserveWS, top = this.top;
-		if (dom.tagName == "PRE" || /pre/.test(dom.style && dom.style.whiteSpace)) this.localPreserveWS = true;
-		let name = dom.nodeName.toLowerCase(), ruleID;
-		if (listTags.hasOwnProperty(name) && this.parser.normalizeLists) normalizeList(dom);
-		let rule = this.options.ruleFromNode && this.options.ruleFromNode(dom) || (ruleID = this.parser.matchTag(dom, this, matchAfter));
-		out: if (rule ? rule.ignore : ignoreTags.hasOwnProperty(name)) {
-			this.findInside(dom);
-			this.ignoreFallback(dom, marks);
-		} else if (!rule || rule.skip || rule.closeParent) {
-			if (rule && rule.closeParent) this.open = Math.max(0, this.open - 1);
-			else if (rule && rule.skip.nodeType) dom = rule.skip;
-			let sync, oldNeedsBlock = this.needsBlock;
-			if (blockTags.hasOwnProperty(name)) {
-				if (top.content.length && top.content[0].isInline && this.open) {
-					this.open--;
-					top = this.top;
-				}
-				sync = true;
-				if (!top.type) this.needsBlock = true;
-			} else if (!dom.firstChild) {
-				this.leafFallback(dom, marks);
-				break out;
-			}
-			let innerMarks = rule && rule.skip ? marks : this.readStyles(dom, marks);
-			if (innerMarks) this.addAll(dom, innerMarks);
-			if (sync) this.sync(top);
-			this.needsBlock = oldNeedsBlock;
-		} else {
-			let innerMarks = this.readStyles(dom, marks);
-			if (innerMarks) this.addElementByRule(dom, rule, innerMarks, rule.consuming === false ? ruleID : void 0);
-		}
-		this.localPreserveWS = outerWS;
-	}
-	leafFallback(dom, marks) {
-		if (dom.nodeName == "BR" && this.top.type && this.top.type.inlineContent) this.addTextNode(dom.ownerDocument.createTextNode("\n"), marks);
-	}
-	ignoreFallback(dom, marks) {
-		if (dom.nodeName == "BR" && (!this.top.type || !this.top.type.inlineContent)) this.findPlace(this.parser.schema.text("-"), marks, true);
-	}
-	readStyles(dom, marks) {
-		let styles = dom.style;
-		if (styles && styles.length) for (let i = 0; i < this.parser.matchedStyles.length; i++) {
-			let name = this.parser.matchedStyles[i], value = styles.getPropertyValue(name);
-			if (value) for (let after = void 0;;) {
-				let rule = this.parser.matchStyle(name, value, this, after);
-				if (!rule) break;
-				if (rule.ignore) return null;
-				if (rule.clearMark) marks = marks.filter((m) => !rule.clearMark(m));
-				else marks = marks.concat(this.parser.schema.marks[rule.mark].create(rule.attrs));
-				if (rule.consuming === false) after = rule;
-				else break;
-			}
-		}
-		return marks;
-	}
-	addElementByRule(dom, rule, marks, continueAfter) {
-		let sync, nodeType;
-		if (rule.node) {
-			nodeType = this.parser.schema.nodes[rule.node];
-			if (!nodeType.isLeaf) {
-				let inner = this.enter(nodeType, rule.attrs || null, marks, rule.preserveWhitespace);
-				if (inner) {
-					sync = true;
-					marks = inner;
-				}
-			} else if (!this.insertNode(nodeType.create(rule.attrs), marks, dom.nodeName == "BR")) this.leafFallback(dom, marks);
-		} else {
-			let markType = this.parser.schema.marks[rule.mark];
-			marks = marks.concat(markType.create(rule.attrs));
-		}
-		let startIn = this.top;
-		if (nodeType && nodeType.isLeaf) this.findInside(dom);
-		else if (continueAfter) this.addElement(dom, marks, continueAfter);
-		else if (rule.getContent) {
-			this.findInside(dom);
-			rule.getContent(dom, this.parser.schema).forEach((node) => this.insertNode(node, marks, false));
-		} else {
-			let contentDOM = dom;
-			if (typeof rule.contentElement == "string") contentDOM = dom.querySelector(rule.contentElement);
-			else if (typeof rule.contentElement == "function") contentDOM = rule.contentElement(dom);
-			else if (rule.contentElement) contentDOM = rule.contentElement;
-			this.findAround(dom, contentDOM, true);
-			this.addAll(contentDOM, marks);
-			this.findAround(dom, contentDOM, false);
-		}
-		if (sync && this.sync(startIn)) this.open--;
-	}
-	addAll(parent, marks, startIndex, endIndex) {
-		let index = startIndex || 0;
-		for (let dom = startIndex ? parent.childNodes[startIndex] : parent.firstChild, end = endIndex == null ? null : parent.childNodes[endIndex]; dom != end; dom = dom.nextSibling, ++index) {
-			this.findAtPoint(parent, index);
-			this.addDOM(dom, marks);
-		}
-		this.findAtPoint(parent, index);
-	}
-	findPlace(node, marks, cautious) {
-		let route, sync;
-		for (let depth = this.open, penalty = 0; depth >= 0; depth--) {
-			let cx = this.nodes[depth];
-			let found = cx.findWrapping(node);
-			if (found && (!route || route.length > found.length + penalty)) {
-				route = found;
-				sync = cx;
-				if (!found.length) break;
-			}
-			if (cx.solid) {
-				if (cautious) break;
-				penalty += 2;
-			}
-		}
-		if (!route) return null;
-		this.sync(sync);
-		for (let i = 0; i < route.length; i++) marks = this.enterInner(route[i], null, marks, false);
-		return marks;
-	}
-	insertNode(node, marks, cautious) {
-		if (node.isInline && this.needsBlock && !this.top.type) {
-			let block = this.textblockFromContext();
-			if (block) marks = this.enterInner(block, null, marks);
-		}
-		let innerMarks = this.findPlace(node, marks, cautious);
-		if (innerMarks) {
-			this.closeExtra();
-			let top = this.top;
-			if (top.match) top.match = top.match.matchType(node.type);
-			let nodeMarks = Mark.none;
-			for (let m of innerMarks.concat(node.marks)) if (top.type ? top.type.allowsMarkType(m.type) : markMayApply(m.type, node.type)) nodeMarks = m.addToSet(nodeMarks);
-			top.content.push(node.mark(nodeMarks));
-			return true;
-		}
-		return false;
-	}
-	enter(type, attrs, marks, preserveWS) {
-		let innerMarks = this.findPlace(type.create(attrs), marks, false);
-		if (innerMarks) innerMarks = this.enterInner(type, attrs, marks, true, preserveWS);
-		return innerMarks;
-	}
-	enterInner(type, attrs, marks, solid = false, preserveWS) {
-		this.closeExtra();
-		let top = this.top;
-		top.match = top.match && top.match.matchType(type);
-		let options = wsOptionsFor(type, preserveWS, top.options);
-		if (top.options & OPT_OPEN_LEFT && top.content.length == 0) options |= OPT_OPEN_LEFT;
-		let applyMarks = Mark.none;
-		marks = marks.filter((m) => {
-			if (top.type ? top.type.allowsMarkType(m.type) : markMayApply(m.type, type)) {
-				applyMarks = m.addToSet(applyMarks);
-				return false;
-			}
-			return true;
-		});
-		this.nodes.push(new NodeContext(type, attrs, applyMarks, solid, null, options));
-		this.open++;
-		return marks;
-	}
-	closeExtra(openEnd = false) {
-		let i = this.nodes.length - 1;
-		if (i > this.open) {
-			for (; i > this.open; i--) this.nodes[i - 1].content.push(this.nodes[i].finish(openEnd));
-			this.nodes.length = this.open + 1;
-		}
-	}
-	finish() {
-		this.open = 0;
-		this.closeExtra(this.isOpen);
-		return this.nodes[0].finish(!!(this.isOpen || this.options.topOpen));
-	}
-	sync(to) {
-		for (let i = this.open; i >= 0; i--) if (this.nodes[i] == to) {
-			this.open = i;
-			return true;
-		} else if (this.localPreserveWS) this.nodes[i].options |= OPT_PRESERVE_WS;
-		return false;
-	}
-	get currentPos() {
-		this.closeExtra();
-		let pos = 0;
-		for (let i = this.open; i >= 0; i--) {
-			let content = this.nodes[i].content;
-			for (let j = content.length - 1; j >= 0; j--) pos += content[j].nodeSize;
-			if (i) pos++;
-		}
-		return pos;
-	}
-	findAtPoint(parent, offset) {
-		if (this.find) {
-			for (let i = 0; i < this.find.length; i++) if (this.find[i].node == parent && this.find[i].offset == offset) this.find[i].pos = this.currentPos;
-		}
-	}
-	findInside(parent) {
-		if (this.find) {
-			for (let i = 0; i < this.find.length; i++) if (this.find[i].pos == null && parent.nodeType == 1 && parent.contains(this.find[i].node)) this.find[i].pos = this.currentPos;
-		}
-	}
-	findAround(parent, content, before) {
-		if (parent != content && this.find) {
-			for (let i = 0; i < this.find.length; i++) if (this.find[i].pos == null && parent.nodeType == 1 && parent.contains(this.find[i].node)) {
-				if (content.compareDocumentPosition(this.find[i].node) & (before ? 2 : 4)) this.find[i].pos = this.currentPos;
-			}
-		}
-	}
-	findInText(textNode) {
-		if (this.find) {
-			for (let i = 0; i < this.find.length; i++) if (this.find[i].node == textNode) this.find[i].pos = this.currentPos - (textNode.nodeValue.length - this.find[i].offset);
-		}
-	}
-	matchesContext(context) {
-		if (context.indexOf("|") > -1) return context.split(/\s*\|\s*/).some(this.matchesContext, this);
-		let parts = context.split("/");
-		let option = this.options.context;
-		let useRoot = !this.isOpen && (!option || option.parent.type == this.nodes[0].type);
-		let minDepth = -(option ? option.depth + 1 : 0) + (useRoot ? 0 : 1);
-		let match = (i, depth) => {
-			for (; i >= 0; i--) {
-				let part = parts[i];
-				if (part == "") {
-					if (i == parts.length - 1 || i == 0) continue;
-					for (; depth >= minDepth; depth--) if (match(i - 1, depth)) return true;
-					return false;
-				} else {
-					let next = depth > 0 || depth == 0 && useRoot ? this.nodes[depth].type : option && depth >= minDepth ? option.node(depth - minDepth).type : null;
-					if (!next || next.name != part && !next.isInGroup(part)) return false;
-					depth--;
-				}
-			}
-			return true;
-		};
-		return match(parts.length - 1, this.open);
-	}
-	textblockFromContext() {
-		let $context = this.options.context;
-		if ($context) for (let d = $context.depth; d >= 0; d--) {
-			let deflt = $context.node(d).contentMatchAt($context.indexAfter(d)).defaultType;
-			if (deflt && deflt.isTextblock && deflt.defaultAttrs) return deflt;
-		}
-		for (let name in this.parser.schema.nodes) {
-			let type = this.parser.schema.nodes[name];
-			if (type.isTextblock && type.defaultAttrs) return type;
-		}
-	}
-};
-function normalizeList(dom) {
-	for (let child = dom.firstChild, prevItem = null; child; child = child.nextSibling) {
-		let name = child.nodeType == 1 ? child.nodeName.toLowerCase() : null;
-		if (name && listTags.hasOwnProperty(name) && prevItem) {
-			prevItem.appendChild(child);
-			child = prevItem;
-		} else if (name == "li") prevItem = child;
-		else if (name) prevItem = null;
-	}
-}
-function matches(dom, selector) {
-	return (dom.matches || dom.msMatchesSelector || dom.webkitMatchesSelector || dom.mozMatchesSelector).call(dom, selector);
-}
-function copy(obj) {
-	let copy = {};
-	for (let prop in obj) copy[prop] = obj[prop];
-	return copy;
-}
-function markMayApply(markType, nodeType) {
-	let nodes = nodeType.schema.nodes;
-	for (let name in nodes) {
-		let parent = nodes[name];
-		if (!parent.allowsMarkType(markType)) continue;
-		let seen = [], scan = (match) => {
-			seen.push(match);
-			for (let i = 0; i < match.edgeCount; i++) {
-				let { type, next } = match.edge(i);
-				if (type == nodeType) return true;
-				if (seen.indexOf(next) < 0 && scan(next)) return true;
-			}
-		};
-		if (scan(parent.contentMatch)) return true;
-	}
-}
-/**
-A DOM serializer knows how to convert ProseMirror nodes and
-marks of various types to DOM nodes.
-*/
-var DOMSerializer = class DOMSerializer {
-	/**
-	Create a serializer. `nodes` should map node names to functions
-	that take a node and return a description of the corresponding
-	DOM. `marks` does the same for mark names, but also gets an
-	argument that tells it whether the mark's content is block or
-	inline content (for typical use, it'll always be inline). A mark
-	serializer may be `null` to indicate that marks of that type
-	should not be serialized.
-	*/
-	constructor(nodes, marks) {
-		this.nodes = nodes;
-		this.marks = marks;
-	}
-	/**
-	Serialize the content of this fragment to a DOM fragment. When
-	not in the browser, the `document` option, containing a DOM
-	document, should be passed so that the serializer can create
-	nodes.
-	*/
-	serializeFragment(fragment, options = {}, target) {
-		if (!target) target = doc(options).createDocumentFragment();
-		let top = target, active = [];
-		fragment.forEach((node) => {
-			if (active.length || node.marks.length) {
-				let keep = 0, rendered = 0;
-				while (keep < active.length && rendered < node.marks.length) {
-					let next = node.marks[rendered];
-					if (!this.marks[next.type.name]) {
-						rendered++;
-						continue;
-					}
-					if (!next.eq(active[keep][0]) || next.type.spec.spanning === false) break;
-					keep++;
-					rendered++;
-				}
-				while (keep < active.length) top = active.pop()[1];
-				while (rendered < node.marks.length) {
-					let add = node.marks[rendered++];
-					let markDOM = this.serializeMark(add, node.isInline, options);
-					if (markDOM) {
-						active.push([add, top]);
-						top.appendChild(markDOM.dom);
-						top = markDOM.contentDOM || markDOM.dom;
-					}
-				}
-			}
-			top.appendChild(this.serializeNodeInner(node, options));
-		});
-		return target;
-	}
-	/**
-	@internal
-	*/
-	serializeNodeInner(node, options) {
-		let { dom, contentDOM } = renderSpec(doc(options), this.nodes[node.type.name](node), null, node.attrs);
-		if (contentDOM) {
-			if (node.isLeaf) throw new RangeError("Content hole not allowed in a leaf node spec");
-			this.serializeFragment(node.content, options, contentDOM);
-		}
-		return dom;
-	}
-	/**
-	Serialize this node to a DOM node. This can be useful when you
-	need to serialize a part of a document, as opposed to the whole
-	document. To serialize a whole document, use
-	[`serializeFragment`](https://prosemirror.net/docs/ref/#model.DOMSerializer.serializeFragment) on
-	its [content](https://prosemirror.net/docs/ref/#model.Node.content).
-	*/
-	serializeNode(node, options = {}) {
-		let dom = this.serializeNodeInner(node, options);
-		for (let i = node.marks.length - 1; i >= 0; i--) {
-			let wrap = this.serializeMark(node.marks[i], node.isInline, options);
-			if (wrap) {
-				(wrap.contentDOM || wrap.dom).appendChild(dom);
-				dom = wrap.dom;
-			}
-		}
-		return dom;
-	}
-	/**
-	@internal
-	*/
-	serializeMark(mark, inline, options = {}) {
-		let toDOM = this.marks[mark.type.name];
-		return toDOM && renderSpec(doc(options), toDOM(mark, inline), null, mark.attrs);
-	}
-	static renderSpec(doc, structure, xmlNS = null, blockArraysIn) {
-		return renderSpec(doc, structure, xmlNS, blockArraysIn);
-	}
-	/**
-	Build a serializer using the [`toDOM`](https://prosemirror.net/docs/ref/#model.NodeSpec.toDOM)
-	properties in a schema's node and mark specs.
-	*/
-	static fromSchema(schema) {
-		return schema.cached.domSerializer || (schema.cached.domSerializer = new DOMSerializer(this.nodesFromSchema(schema), this.marksFromSchema(schema)));
-	}
-	/**
-	Gather the serializers in a schema's node specs into an object.
-	This can be useful as a base to build a custom serializer from.
-	*/
-	static nodesFromSchema(schema) {
-		let result = gatherToDOM(schema.nodes);
-		if (!result.text) result.text = (node) => node.text;
-		return result;
-	}
-	/**
-	Gather the serializers in a schema's mark specs into an object.
-	*/
-	static marksFromSchema(schema) {
-		return gatherToDOM(schema.marks);
-	}
-};
-function gatherToDOM(obj) {
-	let result = {};
-	for (let name in obj) {
-		let toDOM = obj[name].spec.toDOM;
-		if (toDOM) result[name] = toDOM;
-	}
-	return result;
-}
-function doc(options) {
-	return options.document || window.document;
-}
-var suspiciousAttributeCache = /* @__PURE__ */ new WeakMap();
-function suspiciousAttributes(attrs) {
-	let value = suspiciousAttributeCache.get(attrs);
-	if (value === void 0) suspiciousAttributeCache.set(attrs, value = suspiciousAttributesInner(attrs));
-	return value;
-}
-function suspiciousAttributesInner(attrs) {
-	let result = null;
-	function scan(value) {
-		if (value && typeof value == "object") if (Array.isArray(value)) if (typeof value[0] == "string") {
-			if (!result) result = [];
-			result.push(value);
-		} else for (let i = 0; i < value.length; i++) scan(value[i]);
-		else for (let prop in value) scan(value[prop]);
-	}
-	scan(attrs);
-	return result;
-}
-function renderSpec(doc, structure, xmlNS, blockArraysIn) {
-	if (typeof structure == "string") return { dom: doc.createTextNode(structure) };
-	if (structure.nodeType != null) return { dom: structure };
-	if (structure.dom && structure.dom.nodeType != null) return structure;
-	let tagName = structure[0], suspicious;
-	if (typeof tagName != "string") throw new RangeError("Invalid array passed to renderSpec");
-	if (blockArraysIn && (suspicious = suspiciousAttributes(blockArraysIn)) && suspicious.indexOf(structure) > -1) throw new RangeError("Using an array from an attribute object as a DOM spec. This may be an attempted cross site scripting attack.");
-	let space = tagName.indexOf(" ");
-	if (space > 0) {
-		xmlNS = tagName.slice(0, space);
-		tagName = tagName.slice(space + 1);
-	}
-	let contentDOM;
-	let dom = xmlNS ? doc.createElementNS(xmlNS, tagName) : doc.createElement(tagName);
-	let attrs = structure[1], start = 1;
-	if (attrs && typeof attrs == "object" && attrs.nodeType == null && !Array.isArray(attrs)) {
-		start = 2;
-		for (let name in attrs) if (attrs[name] != null) {
-			let space = name.indexOf(" ");
-			if (space > 0) dom.setAttributeNS(name.slice(0, space), name.slice(space + 1), attrs[name]);
-			else if (name == "style" && dom.style) dom.style.cssText = attrs[name];
-			else dom.setAttribute(name, attrs[name]);
-		}
-	}
-	for (let i = start; i < structure.length; i++) {
-		let child = structure[i];
-		if (child === 0) {
-			if (i < structure.length - 1 || i > start) throw new RangeError("Content hole must be the only child of its parent node");
-			return {
-				dom,
-				contentDOM: dom
-			};
-		} else {
-			let { dom: inner, contentDOM: innerContent } = renderSpec(doc, child, xmlNS, blockArraysIn);
-			dom.appendChild(inner);
-			if (innerContent) {
-				if (contentDOM) throw new RangeError("Multiple content holes");
-				contentDOM = innerContent;
-			}
-		}
-	}
-	return {
-		dom,
-		contentDOM
-	};
-}
-//#endregion
-//#region src/lib/rich-text-editor/rte/utils/textblock-attrs.ts
-var TextblockAttrs = class {
-	constructor(specs) {
-		this.specs = specs;
-		this.attrs = {};
-		for (const spec of specs) this.attrs[spec.name] = { default: spec.default };
-	}
-	fromDOM(dom) {
-		return Object.assign({}, ...this.specs.map((s) => ({ [s.name]: s.fromDOM(dom) })));
-	}
-	getStyle(node) {
-		return this.specs.flatMap((s) => s.toStyles(node)).join("; ");
-	}
-	getDOMAttrsProperties(node) {
-		if (!this.specs.length) return {};
-		return { style: this.getStyle(node) };
-	}
-	getDOMAttrs(node) {
-		if (!this.specs.length) return [];
-		return [this.getDOMAttrsProperties(node)];
-	}
-	extractFromNode(node) {
-		return Object.assign({}, ...Object.keys(this.attrs).map((attr) => ({ [attr]: node.attrs[attr] })));
-	}
-};
-//#endregion
-//#region src/lib/rich-text-editor/rte/utils/textblock-marks.ts
-var TextblockMarks = class {
-	constructor(specs) {
-		this.specs = specs;
-	}
-	getAllowedMarksForNode(nodeName) {
-		return this.specs.filter((spec) => !spec.onNodeName || spec.onNodeName === nodeName).map((spec) => spec.markName);
-	}
-	getReferencedNodeNames() {
-		return new Set(this.specs.map((spec) => spec.onNodeName).filter(Boolean));
-	}
-};
+//#region src/lib/rich-text-editor/rte/utils/impl.ts
+var impl = Symbol("rte-internal-impl");
 //#endregion
 //#region src/lib/rich-text-editor/rte/feature.ts
 var sortedContributions = (contributions) => {
@@ -3162,9 +71,6 @@ var featureFacade = (FeatureImpl) => {
 	return Facade;
 };
 //#endregion
-//#region src/lib/rich-text-editor/rte/utils/impl.ts
-var impl = Symbol("rte-internal-impl");
-//#endregion
 //#region src/shared/utils/slottable-request.ts
 var removeSymbol = Symbol.for("slottable-request-remove");
 function dispatchSlottableRequest(target, name, slotName, data) {
@@ -3194,84 +100,12 @@ function dispatchSlottableRequest(target, name, slotName, data) {
 	target.dispatchEvent(event);
 }
 //#endregion
-Object.defineProperty(exports, "DOMParser", {
-	enumerable: true,
-	get: function() {
-		return DOMParser;
-	}
-});
-Object.defineProperty(exports, "DOMSerializer", {
-	enumerable: true,
-	get: function() {
-		return DOMSerializer;
-	}
-});
-Object.defineProperty(exports, "Fragment", {
-	enumerable: true,
-	get: function() {
-		return Fragment;
-	}
-});
-Object.defineProperty(exports, "Mark", {
-	enumerable: true,
-	get: function() {
-		return Mark;
-	}
-});
-Object.defineProperty(exports, "MarkType", {
-	enumerable: true,
-	get: function() {
-		return MarkType;
-	}
-});
-Object.defineProperty(exports, "Node", {
-	enumerable: true,
-	get: function() {
-		return Node;
-	}
-});
-Object.defineProperty(exports, "NodeRange", {
-	enumerable: true,
-	get: function() {
-		return NodeRange;
-	}
-});
-Object.defineProperty(exports, "ReplaceError", {
-	enumerable: true,
-	get: function() {
-		return ReplaceError;
-	}
-});
 Object.defineProperty(exports, "RteFeatureImpl", {
 	enumerable: true,
 	get: function() {
 		return RteFeatureImpl;
 	}
 });
-Object.defineProperty(exports, "Schema", {
-	enumerable: true,
-	get: function() {
-		return Schema;
-	}
-});
-Object.defineProperty(exports, "Slice", {
-	enumerable: true,
-	get: function() {
-		return Slice;
-	}
-});
-Object.defineProperty(exports, "TextblockAttrs", {
-	enumerable: true,
-	get: function() {
-		return TextblockAttrs;
-	}
-});
-Object.defineProperty(exports, "TextblockMarks", {
-	enumerable: true,
-	get: function() {
-		return TextblockMarks;
-	}
-});
 Object.defineProperty(exports, "contributionPriority", {
 	enumerable: true,
 	get: function() {