@box/threaded-annotations 1.80.0

package/dist/chunks/dist.js

@@ -0,0 +1,1749 @@
+function e(t, n, r) {
+	for (let i = 0;; i++) {
+		if (i == t.childCount || i == n.childCount) return t.childCount == n.childCount ? null : r;
+		let a = t.child(i), o = n.child(i);
+		if (a == o) {
+			r += a.nodeSize;
+			continue;
+		}
+		if (!a.sameMarkup(o)) return r;
+		if (a.isText && a.text != o.text) {
+			for (let e = 0; a.text[e] == o.text[e]; e++) r++;
+			return r;
+		}
+		if (a.content.size || o.content.size) {
+			let t = e(a.content, o.content, r + 1);
+			if (t != null) return t;
+		}
+		r += a.nodeSize;
+	}
+}
+function t(e, n, r, i) {
+	for (let a = e.childCount, o = n.childCount;;) {
+		if (a == 0 || o == 0) return a == o ? null : {
+			a: r,
+			b: i
+		};
+		let s = e.child(--a), c = n.child(--o), l = s.nodeSize;
+		if (s == c) {
+			r -= l, i -= l;
+			continue;
+		}
+		if (!s.sameMarkup(c)) return {
+			a: r,
+			b: i
+		};
+		if (s.isText && s.text != c.text) {
+			let e = 0, t = Math.min(s.text.length, c.text.length);
+			for (; e < t && s.text[s.text.length - e - 1] == c.text[c.text.length - e - 1];) e++, r--, i--;
+			return {
+				a: r,
+				b: i
+			};
+		}
+		if (s.content.size || c.content.size) {
+			let e = t(s.content, c.content, r - 1, i - 1);
+			if (e) return e;
+		}
+		r -= l, i -= l;
+	}
+}
+var n = class n {
+	constructor(e, t) {
+		if (this.content = e, this.size = t || 0, t == null) for (let t = 0; t < e.length; t++) this.size += e[t].nodeSize;
+	}
+	nodesBetween(e, t, n, r = 0, i) {
+		for (let a = 0, o = 0; o < t; a++) {
+			let s = this.content[a], c = o + s.nodeSize;
+			if (c > e && n(s, r + o, i || null, a) !== !1 && s.content.size) {
+				let i = o + 1;
+				s.nodesBetween(Math.max(0, e - i), Math.min(s.content.size, t - i), n, r + i);
+			}
+			o = c;
+		}
+	}
+	descendants(e) {
+		this.nodesBetween(0, this.size, e);
+	}
+	textBetween(e, t, n, r) {
+		let i = "", a = !0;
+		return this.nodesBetween(e, t, (o, s) => {
+			let c = o.isText ? o.text.slice(Math.max(e, s) - s, t - s) : o.isLeaf ? r ? typeof r == "function" ? r(o) : r : o.type.spec.leafText ? o.type.spec.leafText(o) : "" : "";
+			o.isBlock && (o.isLeaf && c || o.isTextblock) && n && (a ? a = !1 : i += n), i += c;
+		}, 0), i;
+	}
+	append(e) {
+		if (!e.size) return this;
+		if (!this.size) return e;
+		let t = this.lastChild, r = e.firstChild, i = this.content.slice(), a = 0;
+		for (t.isText && t.sameMarkup(r) && (i[i.length - 1] = t.withText(t.text + r.text), a = 1); a < e.content.length; a++) i.push(e.content[a]);
+		return new n(i, this.size + e.size);
+	}
+	cut(e, t = this.size) {
+		if (e == 0 && t == this.size) return this;
+		let r = [], i = 0;
+		if (t > e) for (let n = 0, a = 0; a < t; n++) {
+			let o = this.content[n], s = a + o.nodeSize;
+			s > e && ((a < e || s > t) && (o = o.isText ? o.cut(Math.max(0, e - a), Math.min(o.text.length, t - a)) : o.cut(Math.max(0, e - a - 1), Math.min(o.content.size, t - a - 1))), r.push(o), i += o.nodeSize), a = s;
+		}
+		return new n(r, i);
+	}
+	cutByIndex(e, t) {
+		return e == t ? n.empty : e == 0 && t == this.content.length ? this : new n(this.content.slice(e, t));
+	}
+	replaceChild(e, t) {
+		let r = this.content[e];
+		if (r == t) return this;
+		let i = this.content.slice(), a = this.size + t.nodeSize - r.nodeSize;
+		return i[e] = t, new n(i, a);
+	}
+	addToStart(e) {
+		return new n([e].concat(this.content), this.size + e.nodeSize);
+	}
+	addToEnd(e) {
+		return new n(this.content.concat(e), this.size + e.nodeSize);
+	}
+	eq(e) {
+		if (this.content.length != e.content.length) return !1;
+		for (let t = 0; t < this.content.length; t++) if (!this.content[t].eq(e.content[t])) return !1;
+		return !0;
+	}
+	get firstChild() {
+		return this.content.length ? this.content[0] : null;
+	}
+	get lastChild() {
+		return this.content.length ? this.content[this.content.length - 1] : null;
+	}
+	get childCount() {
+		return this.content.length;
+	}
+	child(e) {
+		let t = this.content[e];
+		if (!t) throw RangeError("Index " + e + " out of range for " + this);
+		return t;
+	}
+	maybeChild(e) {
+		return this.content[e] || null;
+	}
+	forEach(e) {
+		for (let t = 0, n = 0; t < this.content.length; t++) {
+			let r = this.content[t];
+			e(r, n, t), n += r.nodeSize;
+		}
+	}
+	findDiffStart(t, n = 0) {
+		return e(this, t, n);
+	}
+	findDiffEnd(e, n = this.size, r = e.size) {
+		return t(this, e, n, r);
+	}
+	findIndex(e) {
+		if (e == 0) return i(0, e);
+		if (e == this.size) return i(this.content.length, e);
+		if (e > this.size || e < 0) throw RangeError(`Position ${e} outside of fragment (${this})`);
+		for (let t = 0, n = 0;; t++) {
+			let r = this.child(t), a = n + r.nodeSize;
+			if (a >= e) return a == e ? i(t + 1, a) : i(t, n);
+			n = a;
+		}
+	}
+	toString() {
+		return "<" + this.toStringInner() + ">";
+	}
+	toStringInner() {
+		return this.content.join(", ");
+	}
+	toJSON() {
+		return this.content.length ? this.content.map((e) => e.toJSON()) : null;
+	}
+	static fromJSON(e, t) {
+		if (!t) return n.empty;
+		if (!Array.isArray(t)) throw RangeError("Invalid input for Fragment.fromJSON");
+		return new n(t.map(e.nodeFromJSON));
+	}
+	static fromArray(e) {
+		if (!e.length) return n.empty;
+		let t, r = 0;
+		for (let n = 0; n < e.length; n++) {
+			let i = e[n];
+			r += i.nodeSize, n && i.isText && e[n - 1].sameMarkup(i) ? (t ||= e.slice(0, n), t[t.length - 1] = i.withText(t[t.length - 1].text + i.text)) : t && t.push(i);
+		}
+		return new n(t || e, r);
+	}
+	static from(e) {
+		if (!e) return n.empty;
+		if (e instanceof n) return e;
+		if (Array.isArray(e)) return this.fromArray(e);
+		if (e.attrs) return new n([e], e.nodeSize);
+		throw RangeError("Can not convert " + e + " to a Fragment" + (e.nodesBetween ? " (looks like multiple versions of prosemirror-model were loaded)" : ""));
+	}
+};
+n.empty = new n([], 0);
+var r = {
+	index: 0,
+	offset: 0
+};
+function i(e, t) {
+	return r.index = e, r.offset = t, r;
+}
+function a(e, t) {
+	if (e === t) return !0;
+	if (!(e && typeof e == "object") || !(t && typeof t == "object")) return !1;
+	let n = Array.isArray(e);
+	if (Array.isArray(t) != n) return !1;
+	if (n) {
+		if (e.length != t.length) return !1;
+		for (let n = 0; n < e.length; n++) if (!a(e[n], t[n])) return !1;
+	} else {
+		for (let n in e) if (!(n in t) || !a(e[n], t[n])) return !1;
+		for (let n in t) if (!(n in e)) return !1;
+	}
+	return !0;
+}
+var o = class e {
+	constructor(e, t) {
+		this.type = e, this.attrs = t;
+	}
+	addToSet(e) {
+		let t, n = !1;
+		for (let r = 0; r < e.length; r++) {
+			let i = e[r];
+			if (this.eq(i)) return e;
+			if (this.type.excludes(i.type)) t ||= e.slice(0, r);
+			else if (i.type.excludes(this.type)) return e;
+			else !n && i.type.rank > this.type.rank && (t ||= e.slice(0, r), t.push(this), n = !0), t && t.push(i);
+		}
+		return t ||= e.slice(), n || t.push(this), t;
+	}
+	removeFromSet(e) {
+		for (let t = 0; t < e.length; t++) if (this.eq(e[t])) return e.slice(0, t).concat(e.slice(t + 1));
+		return e;
+	}
+	isInSet(e) {
+		for (let t = 0; t < e.length; t++) if (this.eq(e[t])) return !0;
+		return !1;
+	}
+	eq(e) {
+		return this == e || this.type == e.type && a(this.attrs, e.attrs);
+	}
+	toJSON() {
+		let e = { type: this.type.name };
+		for (let t in this.attrs) {
+			e.attrs = this.attrs;
+			break;
+		}
+		return e;
+	}
+	static fromJSON(e, t) {
+		if (!t) throw RangeError("Invalid input for Mark.fromJSON");
+		let n = e.marks[t.type];
+		if (!n) throw RangeError(`There is no mark type ${t.type} in this schema`);
+		let r = n.create(t.attrs);
+		return n.checkAttrs(r.attrs), r;
+	}
+	static sameSet(e, t) {
+		if (e == t) return !0;
+		if (e.length != t.length) return !1;
+		for (let n = 0; n < e.length; n++) if (!e[n].eq(t[n])) return !1;
+		return !0;
+	}
+	static setFrom(t) {
+		if (!t || Array.isArray(t) && t.length == 0) return e.none;
+		if (t instanceof e) return [t];
+		let n = t.slice();
+		return n.sort((e, t) => e.type.rank - t.type.rank), n;
+	}
+};
+o.none = [];
+var s = class extends Error {}, c = class e {
+	constructor(e, t, n) {
+		this.content = e, this.openStart = t, this.openEnd = n;
+	}
+	get size() {
+		return this.content.size - this.openStart - this.openEnd;
+	}
+	insertAt(t, n) {
+		let r = u(this.content, t + this.openStart, n);
+		return r && new e(r, this.openStart, this.openEnd);
+	}
+	removeBetween(t, n) {
+		return new e(l(this.content, t + this.openStart, n + this.openStart), this.openStart, this.openEnd);
+	}
+	eq(e) {
+		return this.content.eq(e.content) && this.openStart == e.openStart && this.openEnd == e.openEnd;
+	}
+	toString() {
+		return this.content + "(" + this.openStart + "," + this.openEnd + ")";
+	}
+	toJSON() {
+		if (!this.content.size) return null;
+		let e = { content: this.content.toJSON() };
+		return this.openStart > 0 && (e.openStart = this.openStart), this.openEnd > 0 && (e.openEnd = this.openEnd), e;
+	}
+	static fromJSON(t, r) {
+		if (!r) return e.empty;
+		let i = r.openStart || 0, a = r.openEnd || 0;
+		if (typeof i != "number" || typeof a != "number") throw RangeError("Invalid input for Slice.fromJSON");
+		return new e(n.fromJSON(t, r.content), i, a);
+	}
+	static maxOpen(t, n = !0) {
+		let r = 0, i = 0;
+		for (let e = t.firstChild; e && !e.isLeaf && (n || !e.type.spec.isolating); e = e.firstChild) r++;
+		for (let e = t.lastChild; e && !e.isLeaf && (n || !e.type.spec.isolating); e = e.lastChild) i++;
+		return new e(t, r, i);
+	}
+};
+c.empty = new c(n.empty, 0, 0);
+function l(e, t, n) {
+	let { index: r, offset: i } = e.findIndex(t), a = e.maybeChild(r), { index: o, offset: s } = e.findIndex(n);
+	if (i == t || a.isText) {
+		if (s != n && !e.child(o).isText) throw RangeError("Removing non-flat range");
+		return e.cut(0, t).append(e.cut(n));
+	}
+	if (r != o) throw RangeError("Removing non-flat range");
+	return e.replaceChild(r, a.copy(l(a.content, t - i - 1, n - i - 1)));
+}
+function u(e, t, n, r) {
+	let { index: i, offset: a } = e.findIndex(t), o = e.maybeChild(i);
+	if (a == t || o.isText) return r && !r.canReplace(i, i, n) ? null : e.cut(0, t).append(n).append(e.cut(t));
+	let s = u(o.content, t - a - 1, n, o);
+	return s && e.replaceChild(i, o.copy(s));
+}
+function d(e, t, n) {
+	if (n.openStart > e.depth) throw new s("Inserted content deeper than insertion position");
+	if (e.depth - n.openStart != t.depth - n.openEnd) throw new s("Inconsistent open depths");
+	return f(e, t, n, 0);
+}
+function f(e, t, n, r) {
+	let i = e.index(r), a = e.node(r);
+	if (i == t.index(r) && r < e.depth - n.openStart) {
+		let o = f(e, t, n, r + 1);
+		return a.copy(a.content.replaceChild(i, o));
+	} else if (!n.content.size) return g(a, v(e, t, r));
+	else if (!n.openStart && !n.openEnd && e.depth == r && t.depth == r) {
+		let r = e.parent, i = r.content;
+		return g(r, i.cut(0, e.parentOffset).append(n.content).append(i.cut(t.parentOffset)));
+	} else {
+		let { start: i, end: o } = te(n, e);
+		return g(a, _(e, i, o, t, r));
+	}
+}
+function ee(e, t) {
+	if (!t.type.compatibleContent(e.type)) throw new s("Cannot join " + t.type.name + " onto " + e.type.name);
+}
+function p(e, t, n) {
+	let r = e.node(n);
+	return ee(r, t.node(n)), r;
+}
+function m(e, t) {
+	let n = t.length - 1;
+	n >= 0 && e.isText && e.sameMarkup(t[n]) ? t[n] = e.withText(t[n].text + e.text) : t.push(e);
+}
+function h(e, t, n, r) {
+	let i = (t || e).node(n), a = 0, o = t ? t.index(n) : i.childCount;
+	e && (a = e.index(n), e.depth > n ? a++ : e.textOffset && (m(e.nodeAfter, r), a++));
+	for (let e = a; e < o; e++) m(i.child(e), r);
+	t && t.depth == n && t.textOffset && m(t.nodeBefore, r);
+}
+function g(e, t) {
+	return e.type.checkContent(t), e.copy(t);
+}
+function _(e, t, r, i, a) {
+	let o = e.depth > a && p(e, t, a + 1), s = i.depth > a && p(r, i, a + 1), c = [];
+	return h(null, e, a, c), o && s && t.index(a) == r.index(a) ? (ee(o, s), m(g(o, _(e, t, r, i, a + 1)), c)) : (o && m(g(o, v(e, t, a + 1)), c), h(t, r, a, c), s && m(g(s, v(r, i, a + 1)), c)), h(i, null, a, c), new n(c);
+}
+function v(e, t, r) {
+	let i = [];
+	return h(null, e, r, i), e.depth > r && m(g(p(e, t, r + 1), v(e, t, r + 1)), i), h(t, null, r, i), new n(i);
+}
+function te(e, t) {
+	let r = t.depth - e.openStart, i = t.node(r).copy(e.content);
+	for (let e = r - 1; e >= 0; e--) i = t.node(e).copy(n.from(i));
+	return {
+		start: i.resolveNoCache(e.openStart + r),
+		end: i.resolveNoCache(i.content.size - e.openEnd - r)
+	};
+}
+var y = class e {
+	constructor(e, t, n) {
+		this.pos = e, this.path = t, this.parentOffset = n, this.depth = t.length / 3 - 1;
+	}
+	resolveDepth(e) {
+		return e == null ? this.depth : e < 0 ? this.depth + e : e;
+	}
+	get parent() {
+		return this.node(this.depth);
+	}
+	get doc() {
+		return this.node(0);
+	}
+	node(e) {
+		return this.path[this.resolveDepth(e) * 3];
+	}
+	index(e) {
+		return this.path[this.resolveDepth(e) * 3 + 1];
+	}
+	indexAfter(e) {
+		return e = this.resolveDepth(e), this.index(e) + (e == this.depth && !this.textOffset ? 0 : 1);
+	}
+	start(e) {
+		return e = this.resolveDepth(e), e == 0 ? 0 : this.path[e * 3 - 1] + 1;
+	}
+	end(e) {
+		return e = this.resolveDepth(e), this.start(e) + this.node(e).content.size;
+	}
+	before(e) {
+		if (e = this.resolveDepth(e), !e) throw RangeError("There is no position before the top-level node");
+		return e == this.depth + 1 ? this.pos : this.path[e * 3 - 1];
+	}
+	after(e) {
+		if (e = this.resolveDepth(e), !e) throw RangeError("There is no position after the top-level node");
+		return e == this.depth + 1 ? this.pos : this.path[e * 3 - 1] + this.path[e * 3].nodeSize;
+	}
+	get textOffset() {
+		return this.pos - this.path[this.path.length - 1];
+	}
+	get nodeAfter() {
+		let e = this.parent, t = this.index(this.depth);
+		if (t == e.childCount) return null;
+		let n = this.pos - this.path[this.path.length - 1], r = e.child(t);
+		return n ? e.child(t).cut(n) : r;
+	}
+	get nodeBefore() {
+		let e = this.index(this.depth), t = this.pos - this.path[this.path.length - 1];
+		return t ? this.parent.child(e).cut(0, t) : e == 0 ? null : this.parent.child(e - 1);
+	}
+	posAtIndex(e, t) {
+		t = this.resolveDepth(t);
+		let n = this.path[t * 3], r = t == 0 ? 0 : this.path[t * 3 - 1] + 1;
+		for (let t = 0; t < e; t++) r += n.child(t).nodeSize;
+		return r;
+	}
+	marks() {
+		let e = this.parent, t = this.index();
+		if (e.content.size == 0) return o.none;
+		if (this.textOffset) return e.child(t).marks;
+		let n = e.maybeChild(t - 1), r = e.maybeChild(t);
+		if (!n) {
+			let e = n;
+			n = r, r = e;
+		}
+		let i = n.marks;
+		for (var a = 0; a < i.length; a++) i[a].type.spec.inclusive === !1 && (!r || !i[a].isInSet(r.marks)) && (i = i[a--].removeFromSet(i));
+		return i;
+	}
+	marksAcross(e) {
+		let t = this.parent.maybeChild(this.index());
+		if (!t || !t.isInline) return null;
+		let n = t.marks, r = e.parent.maybeChild(e.index());
+		for (var i = 0; i < n.length; i++) n[i].type.spec.inclusive === !1 && (!r || !n[i].isInSet(r.marks)) && (n = n[i--].removeFromSet(n));
+		return n;
+	}
+	sharedDepth(e) {
+		for (let t = this.depth; t > 0; t--) if (this.start(t) <= e && this.end(t) >= e) return t;
+		return 0;
+	}
+	blockRange(e = this, t) {
+		if (e.pos < this.pos) return e.blockRange(this);
+		for (let n = this.depth - (this.parent.inlineContent || this.pos == e.pos ? 1 : 0); n >= 0; n--) if (e.pos <= this.end(n) && (!t || t(this.node(n)))) return new ie(this, e, n);
+		return null;
+	}
+	sameParent(e) {
+		return this.pos - this.parentOffset == e.pos - e.parentOffset;
+	}
+	max(e) {
+		return e.pos > this.pos ? e : this;
+	}
+	min(e) {
+		return e.pos < this.pos ? e : this;
+	}
+	toString() {
+		let e = "";
+		for (let t = 1; t <= this.depth; t++) e += (e ? "/" : "") + this.node(t).type.name + "_" + this.index(t - 1);
+		return e + ":" + this.parentOffset;
+	}
+	static resolve(t, n) {
+		if (!(n >= 0 && n <= t.content.size)) throw RangeError("Position " + n + " out of range");
+		let r = [], i = 0, a = n;
+		for (let e = t;;) {
+			let { index: t, offset: n } = e.content.findIndex(a), o = a - n;
+			if (r.push(e, t, i + n), !o || (e = e.child(t), e.isText)) break;
+			a = o - 1, i += n + 1;
+		}
+		return new e(n, r, a);
+	}
+	static resolveCached(t, n) {
+		let r = b.get(t);
+		if (r) for (let e = 0; e < r.elts.length; e++) {
+			let t = r.elts[e];
+			if (t.pos == n) return t;
+		}
+		else b.set(t, r = new ne());
+		let i = r.elts[r.i] = e.resolve(t, n);
+		return r.i = (r.i + 1) % re, i;
+	}
+}, ne = class {
+	constructor() {
+		this.elts = [], this.i = 0;
+	}
+}, re = 12, b = /* @__PURE__ */ new WeakMap(), ie = class {
+	constructor(e, t, n) {
+		this.$from = e, this.$to = t, this.depth = n;
+	}
+	get start() {
+		return this.$from.before(this.depth + 1);
+	}
+	get end() {
+		return this.$to.after(this.depth + 1);
+	}
+	get parent() {
+		return this.$from.node(this.depth);
+	}
+	get startIndex() {
+		return this.$from.index(this.depth);
+	}
+	get endIndex() {
+		return this.$to.indexAfter(this.depth);
+	}
+}, ae = Object.create(null), oe = class e {
+	constructor(e, t, r, i = o.none) {
+		this.type = e, this.attrs = t, this.marks = i, this.content = r || n.empty;
+	}
+	get children() {
+		return this.content.content;
+	}
+	get nodeSize() {
+		return this.isLeaf ? 1 : 2 + this.content.size;
+	}
+	get childCount() {
+		return this.content.childCount;
+	}
+	child(e) {
+		return this.content.child(e);
+	}
+	maybeChild(e) {
+		return this.content.maybeChild(e);
+	}
+	forEach(e) {
+		this.content.forEach(e);
+	}
+	nodesBetween(e, t, n, r = 0) {
+		this.content.nodesBetween(e, t, n, r, this);
+	}
+	descendants(e) {
+		this.nodesBetween(0, this.content.size, e);
+	}
+	get textContent() {
+		return this.isLeaf && this.type.spec.leafText ? this.type.spec.leafText(this) : this.textBetween(0, this.content.size, "");
+	}
+	textBetween(e, t, n, r) {
+		return this.content.textBetween(e, t, n, r);
+	}
+	get firstChild() {
+		return this.content.firstChild;
+	}
+	get lastChild() {
+		return this.content.lastChild;
+	}
+	eq(e) {
+		return this == e || this.sameMarkup(e) && this.content.eq(e.content);
+	}
+	sameMarkup(e) {
+		return this.hasMarkup(e.type, e.attrs, e.marks);
+	}
+	hasMarkup(e, t, n) {
+		return this.type == e && a(this.attrs, t || e.defaultAttrs || ae) && o.sameSet(this.marks, n || o.none);
+	}
+	copy(t = null) {
+		return t == this.content ? this : new e(this.type, this.attrs, t, this.marks);
+	}
+	mark(t) {
+		return t == this.marks ? this : new e(this.type, this.attrs, this.content, t);
+	}
+	cut(e, t = this.content.size) {
+		return e == 0 && t == this.content.size ? this : this.copy(this.content.cut(e, t));
+	}
+	slice(e, t = this.content.size, n = !1) {
+		if (e == t) return c.empty;
+		let r = this.resolve(e), i = this.resolve(t), a = n ? 0 : r.sharedDepth(t), o = r.start(a);
+		return new c(r.node(a).content.cut(r.pos - o, i.pos - o), r.depth - a, i.depth - a);
+	}
+	replace(e, t, n) {
+		return d(this.resolve(e), this.resolve(t), n);
+	}
+	nodeAt(e) {
+		for (let t = this;;) {
+			let { index: n, offset: r } = t.content.findIndex(e);
+			if (t = t.maybeChild(n), !t) return null;
+			if (r == e || t.isText) return t;
+			e -= r + 1;
+		}
+	}
+	childAfter(e) {
+		let { index: t, offset: n } = this.content.findIndex(e);
+		return {
+			node: this.content.maybeChild(t),
+			index: t,
+			offset: n
+		};
+	}
+	childBefore(e) {
+		if (e == 0) return {
+			node: null,
+			index: 0,
+			offset: 0
+		};
+		let { index: t, offset: n } = this.content.findIndex(e);
+		if (n < e) return {
+			node: this.content.child(t),
+			index: t,
+			offset: n
+		};
+		let r = this.content.child(t - 1);
+		return {
+			node: r,
+			index: t - 1,
+			offset: n - r.nodeSize
+		};
+	}
+	resolve(e) {
+		return y.resolveCached(this, e);
+	}
+	resolveNoCache(e) {
+		return y.resolve(this, e);
+	}
+	rangeHasMark(e, t, n) {
+		let r = !1;
+		return t > e && this.nodesBetween(e, t, (e) => (n.isInSet(e.marks) && (r = !0), !r)), r;
+	}
+	get isBlock() {
+		return this.type.isBlock;
+	}
+	get isTextblock() {
+		return this.type.isTextblock;
+	}
+	get inlineContent() {
+		return this.type.inlineContent;
+	}
+	get isInline() {
+		return this.type.isInline;
+	}
+	get isText() {
+		return this.type.isText;
+	}
+	get isLeaf() {
+		return this.type.isLeaf;
+	}
+	get isAtom() {
+		return this.type.isAtom;
+	}
+	toString() {
+		if (this.type.spec.toDebugString) return this.type.spec.toDebugString(this);
+		let e = this.type.name;
+		return this.content.size && (e += "(" + this.content.toStringInner() + ")"), se(this.marks, e);
+	}
+	contentMatchAt(e) {
+		let t = this.type.contentMatch.matchFragment(this.content, 0, e);
+		if (!t) throw Error("Called contentMatchAt on a node with invalid content");
+		return t;
+	}
+	canReplace(e, t, r = n.empty, i = 0, a = r.childCount) {
+		let o = this.contentMatchAt(e).matchFragment(r, i, a), s = o && o.matchFragment(this.content, t);
+		if (!s || !s.validEnd) return !1;
+		for (let e = i; e < a; e++) if (!this.type.allowsMarks(r.child(e).marks)) return !1;
+		return !0;
+	}
+	canReplaceWith(e, t, n, r) {
+		if (r && !this.type.allowsMarks(r)) return !1;
+		let i = this.contentMatchAt(e).matchType(n), a = i && i.matchFragment(this.content, t);
+		return a ? a.validEnd : !1;
+	}
+	canAppend(e) {
+		return e.content.size ? this.canReplace(this.childCount, this.childCount, e.content) : this.type.compatibleContent(e.type);
+	}
+	check() {
+		this.type.checkContent(this.content), this.type.checkAttrs(this.attrs);
+		let e = o.none;
+		for (let t = 0; t < this.marks.length; t++) {
+			let n = this.marks[t];
+			n.type.checkAttrs(n.attrs), e = n.addToSet(e);
+		}
+		if (!o.sameSet(e, this.marks)) throw RangeError(`Invalid collection of marks for node ${this.type.name}: ${this.marks.map((e) => e.type.name)}`);
+		this.content.forEach((e) => e.check());
+	}
+	toJSON() {
+		let e = { type: this.type.name };
+		for (let t in this.attrs) {
+			e.attrs = this.attrs;
+			break;
+		}
+		return this.content.size && (e.content = this.content.toJSON()), this.marks.length && (e.marks = this.marks.map((e) => e.toJSON())), e;
+	}
+	static fromJSON(e, t) {
+		if (!t) throw RangeError("Invalid input for Node.fromJSON");
+		let r;
+		if (t.marks) {
+			if (!Array.isArray(t.marks)) throw RangeError("Invalid mark data for Node.fromJSON");
+			r = t.marks.map(e.markFromJSON);
+		}
+		if (t.type == "text") {
+			if (typeof t.text != "string") throw RangeError("Invalid text node in JSON");
+			return e.text(t.text, r);
+		}
+		let i = n.fromJSON(e, t.content), a = e.nodeType(t.type).create(t.attrs, i, r);
+		return a.type.checkAttrs(a.attrs), a;
+	}
+};
+oe.prototype.text = void 0;
+function se(e, t) {
+	for (let n = e.length - 1; n >= 0; n--) t = e[n].type.name + "(" + t + ")";
+	return t;
+}
+var x = class e {
+	constructor(e) {
+		this.validEnd = e, this.next = [], this.wrapCache = [];
+	}
+	static parse(t, n) {
+		let r = new ce(t, n);
+		if (r.next == null) return e.empty;
+		let i = le(r);
+		r.next && r.err("Unexpected trailing text");
+		let a = ge(he(i));
+		return _e(a, r), a;
+	}
+	matchType(e) {
+		for (let t = 0; t < this.next.length; t++) if (this.next[t].type == e) return this.next[t].next;
+		return null;
+	}
+	matchFragment(e, t = 0, n = e.childCount) {
+		let r = this;
+		for (let i = t; r && i < n; i++) r = r.matchType(e.child(i).type);
+		return r;
+	}
+	get inlineContent() {
+		return this.next.length != 0 && this.next[0].type.isInline;
+	}
+	get defaultType() {
+		for (let e = 0; e < this.next.length; e++) {
+			let { type: t } = this.next[e];
+			if (!(t.isText || t.hasRequiredAttrs())) return t;
+		}
+		return null;
+	}
+	compatible(e) {
+		for (let t = 0; t < this.next.length; t++) for (let n = 0; n < e.next.length; n++) if (this.next[t].type == e.next[n].type) return !0;
+		return !1;
+	}
+	fillBefore(e, t = !1, r = 0) {
+		let i = [this];
+		function a(o, s) {
+			let c = o.matchFragment(e, r);
+			if (c && (!t || c.validEnd)) return n.from(s.map((e) => e.createAndFill()));
+			for (let e = 0; e < o.next.length; e++) {
+				let { type: t, next: n } = o.next[e];
+				if (!(t.isText || t.hasRequiredAttrs()) && i.indexOf(n) == -1) {
+					i.push(n);
+					let e = a(n, s.concat(t));
+					if (e) return e;
+				}
+			}
+			return null;
+		}
+		return a(this, []);
+	}
+	findWrapping(e) {
+		for (let t = 0; t < this.wrapCache.length; t += 2) if (this.wrapCache[t] == e) return this.wrapCache[t + 1];
+		let t = this.computeWrapping(e);
+		return this.wrapCache.push(e, t), t;
+	}
+	computeWrapping(e) {
+		let t = Object.create(null), n = [{
+			match: this,
+			type: null,
+			via: null
+		}];
+		for (; n.length;) {
+			let r = n.shift(), i = r.match;
+			if (i.matchType(e)) {
+				let e = [];
+				for (let t = r; t.type; t = t.via) e.push(t.type);
+				return e.reverse();
+			}
+			for (let e = 0; e < i.next.length; e++) {
+				let { type: a, next: o } = i.next[e];
+				!a.isLeaf && !a.hasRequiredAttrs() && !(a.name in t) && (!r.type || o.validEnd) && (n.push({
+					match: a.contentMatch,
+					type: a,
+					via: r
+				}), t[a.name] = !0);
+			}
+		}
+		return null;
+	}
+	get edgeCount() {
+		return this.next.length;
+	}
+	edge(e) {
+		if (e >= this.next.length) throw RangeError(`There's no ${e}th edge in this content match`);
+		return this.next[e];
+	}
+	toString() {
+		let e = [];
+		function t(n) {
+			e.push(n);
+			for (let r = 0; r < n.next.length; r++) e.indexOf(n.next[r].next) == -1 && t(n.next[r].next);
+		}
+		return t(this), e.map((t, n) => {
+			let r = n + (t.validEnd ? "*" : " ") + " ";
+			for (let n = 0; n < t.next.length; n++) r += (n ? ", " : "") + t.next[n].type.name + "->" + e.indexOf(t.next[n].next);
+			return r;
+		}).join("\n");
+	}
+};
+x.empty = new x(!0);
+var ce = class {
+	constructor(e, t) {
+		this.string = e, this.nodeTypes = t, this.inline = null, this.pos = 0, this.tokens = e.split(/\s*(?=\b|\W|$)/), this.tokens[this.tokens.length - 1] == "" && this.tokens.pop(), this.tokens[0] == "" && this.tokens.shift();
+	}
+	get next() {
+		return this.tokens[this.pos];
+	}
+	eat(e) {
+		return this.next == e && (this.pos++ || !0);
+	}
+	err(e) {
+		throw SyntaxError(e + " (in content expression '" + this.string + "')");
+	}
+};
+function le(e) {
+	let t = [];
+	do
+		t.push(ue(e));
+	while (e.eat("|"));
+	return t.length == 1 ? t[0] : {
+		type: "choice",
+		exprs: t
+	};
+}
+function ue(e) {
+	let t = [];
+	do
+		t.push(de(e));
+	while (e.next && e.next != ")" && e.next != "|");
+	return t.length == 1 ? t[0] : {
+		type: "seq",
+		exprs: t
+	};
+}
+function de(e) {
+	let t = me(e);
+	for (;;) if (e.eat("+")) t = {
+		type: "plus",
+		expr: t
+	};
+	else if (e.eat("*")) t = {
+		type: "star",
+		expr: t
+	};
+	else if (e.eat("?")) t = {
+		type: "opt",
+		expr: t
+	};
+	else if (e.eat("{")) t = fe(e, t);
+	else break;
+	return t;
+}
+function S(e) {
+	/\D/.test(e.next) && e.err("Expected number, got '" + e.next + "'");
+	let t = Number(e.next);
+	return e.pos++, t;
+}
+function fe(e, t) {
+	let n = S(e), r = n;
+	return e.eat(",") && (r = e.next == "}" ? -1 : S(e)), e.eat("}") || e.err("Unclosed braced range"), {
+		type: "range",
+		min: n,
+		max: r,
+		expr: t
+	};
+}
+function pe(e, t) {
+	let n = e.nodeTypes, r = n[t];
+	if (r) return [r];
+	let i = [];
+	for (let e in n) {
+		let r = n[e];
+		r.isInGroup(t) && i.push(r);
+	}
+	return i.length == 0 && e.err("No node type or group '" + t + "' found"), i;
+}
+function me(e) {
+	if (e.eat("(")) {
+		let t = le(e);
+		return e.eat(")") || e.err("Missing closing paren"), t;
+	} else if (/\W/.test(e.next)) e.err("Unexpected token '" + e.next + "'");
+	else {
+		let t = pe(e, e.next).map((t) => (e.inline == null ? e.inline = t.isInline : e.inline != t.isInline && e.err("Mixing inline and block content"), {
+			type: "name",
+			value: t
+		}));
+		return e.pos++, t.length == 1 ? t[0] : {
+			type: "choice",
+			exprs: t
+		};
+	}
+}
+function he(e) {
+	let t = [[]];
+	return i(a(e, 0), n()), t;
+	function n() {
+		return t.push([]) - 1;
+	}
+	function r(e, n, r) {
+		let i = {
+			term: r,
+			to: n
+		};
+		return t[e].push(i), i;
+	}
+	function i(e, t) {
+		e.forEach((e) => e.to = t);
+	}
+	function a(e, t) {
+		if (e.type == "choice") return e.exprs.reduce((e, n) => e.concat(a(n, t)), []);
+		if (e.type == "seq") for (let r = 0;; r++) {
+			let o = a(e.exprs[r], t);
+			if (r == e.exprs.length - 1) return o;
+			i(o, t = n());
+		}
+		else if (e.type == "star") {
+			let o = n();
+			return r(t, o), i(a(e.expr, o), o), [r(o)];
+		} else if (e.type == "plus") {
+			let o = n();
+			return i(a(e.expr, t), o), i(a(e.expr, o), o), [r(o)];
+		} else if (e.type == "opt") return [r(t)].concat(a(e.expr, t));
+		else if (e.type == "range") {
+			let o = t;
+			for (let t = 0; t < e.min; t++) {
+				let t = n();
+				i(a(e.expr, o), t), o = t;
+			}
+			if (e.max == -1) i(a(e.expr, o), o);
+			else for (let t = e.min; t < e.max; t++) {
+				let t = n();
+				r(o, t), i(a(e.expr, o), t), o = t;
+			}
+			return [r(o)];
+		} else if (e.type == "name") return [r(t, void 0, e.value)];
+		else throw Error("Unknown expr type");
+	}
+}
+function C(e, t) {
+	return t - e;
+}
+function w(e, t) {
+	let n = [];
+	return r(t), n.sort(C);
+	function r(t) {
+		let i = e[t];
+		if (i.length == 1 && !i[0].term) return r(i[0].to);
+		n.push(t);
+		for (let e = 0; e < i.length; e++) {
+			let { term: t, to: a } = i[e];
+			!t && n.indexOf(a) == -1 && r(a);
+		}
+	}
+}
+function ge(e) {
+	let t = Object.create(null);
+	return n(w(e, 0));
+	function n(r) {
+		let i = [];
+		r.forEach((t) => {
+			e[t].forEach(({ term: t, to: n }) => {
+				if (!t) return;
+				let r;
+				for (let e = 0; e < i.length; e++) i[e][0] == t && (r = i[e][1]);
+				w(e, n).forEach((e) => {
+					r || i.push([t, r = []]), r.indexOf(e) == -1 && r.push(e);
+				});
+			});
+		});
+		let a = t[r.join(",")] = new x(r.indexOf(e.length - 1) > -1);
+		for (let e = 0; e < i.length; e++) {
+			let r = i[e][1].sort(C);
+			a.next.push({
+				type: i[e][0],
+				next: t[r.join(",")] || n(r)
+			});
+		}
+		return a;
+	}
+}
+function _e(e, t) {
+	for (let n = 0, r = [e]; n < r.length; n++) {
+		let e = r[n], i = !e.validEnd, a = [];
+		for (let t = 0; t < e.next.length; t++) {
+			let { type: n, next: o } = e.next[t];
+			a.push(n.name), i && !(n.isText || n.hasRequiredAttrs()) && (i = !1), r.indexOf(o) == -1 && r.push(o);
+		}
+		i && t.err("Only non-generatable nodes (" + a.join(", ") + ") in a required position (see https://prosemirror.net/docs/guide/#generatable)");
+	}
+}
+var T = 65535, E = 2 ** 16;
+function ve(e, t) {
+	return e + t * E;
+}
+function D(e) {
+	return e & T;
+}
+function ye(e) {
+	return (e - (e & T)) / E;
+}
+var O = 1, k = 2, A = 4, j = 8, M = class {
+	constructor(e, t, n) {
+		this.pos = e, this.delInfo = t, this.recover = n;
+	}
+	get deleted() {
+		return (this.delInfo & j) > 0;
+	}
+	get deletedBefore() {
+		return (this.delInfo & (O | A)) > 0;
+	}
+	get deletedAfter() {
+		return (this.delInfo & (k | A)) > 0;
+	}
+	get deletedAcross() {
+		return (this.delInfo & A) > 0;
+	}
+}, N = class e {
+	constructor(t, n = !1) {
+		if (this.ranges = t, this.inverted = n, !t.length && e.empty) return e.empty;
+	}
+	recover(e) {
+		let t = 0, n = D(e);
+		if (!this.inverted) for (let e = 0; e < n; e++) t += this.ranges[e * 3 + 2] - this.ranges[e * 3 + 1];
+		return this.ranges[n * 3] + t + ye(e);
+	}
+	mapResult(e, t = 1) {
+		return this._map(e, t, !1);
+	}
+	map(e, t = 1) {
+		return this._map(e, t, !0);
+	}
+	_map(e, t, n) {
+		let r = 0, i = this.inverted ? 2 : 1, a = this.inverted ? 1 : 2;
+		for (let o = 0; o < this.ranges.length; o += 3) {
+			let s = this.ranges[o] - (this.inverted ? r : 0);
+			if (s > e) break;
+			let c = this.ranges[o + i], l = this.ranges[o + a], u = s + c;
+			if (e <= u) {
+				let i = c ? e == s ? -1 : e == u ? 1 : t : t, a = s + r + (i < 0 ? 0 : l);
+				if (n) return a;
+				let d = e == (t < 0 ? s : u) ? null : ve(o / 3, e - s), f = e == s ? k : e == u ? O : A;
+				return (t < 0 ? e != s : e != u) && (f |= j), new M(a, f, d);
+			}
+			r += l - c;
+		}
+		return n ? e + r : new M(e + r, 0, null);
+	}
+	touches(e, t) {
+		let n = 0, r = D(t), i = this.inverted ? 2 : 1, a = this.inverted ? 1 : 2;
+		for (let t = 0; t < this.ranges.length; t += 3) {
+			let o = this.ranges[t] - (this.inverted ? n : 0);
+			if (o > e) break;
+			let s = this.ranges[t + i];
+			if (e <= o + s && t == r * 3) return !0;
+			n += this.ranges[t + a] - s;
+		}
+		return !1;
+	}
+	forEach(e) {
+		let t = this.inverted ? 2 : 1, n = this.inverted ? 1 : 2;
+		for (let r = 0, i = 0; r < this.ranges.length; r += 3) {
+			let a = this.ranges[r], o = a - (this.inverted ? i : 0), s = a + (this.inverted ? 0 : i), c = this.ranges[r + t], l = this.ranges[r + n];
+			e(o, o + c, s, s + l), i += l - c;
+		}
+	}
+	invert() {
+		return new e(this.ranges, !this.inverted);
+	}
+	toString() {
+		return (this.inverted ? "-" : "") + JSON.stringify(this.ranges);
+	}
+	static offset(t) {
+		return t == 0 ? e.empty : new e(t < 0 ? [
+			0,
+			-t,
+			0
+		] : [
+			0,
+			0,
+			t
+		]);
+	}
+};
+N.empty = new N([]);
+var P = Object.create(null), F = class {
+	getMap() {
+		return N.empty;
+	}
+	merge(e) {
+		return null;
+	}
+	static fromJSON(e, t) {
+		if (!t || !t.stepType) throw RangeError("Invalid input for Step.fromJSON");
+		let n = P[t.stepType];
+		if (!n) throw RangeError(`No step type ${t.stepType} defined`);
+		return n.fromJSON(e, t);
+	}
+	static jsonID(e, t) {
+		if (e in P) throw RangeError("Duplicate use of step JSON ID " + e);
+		return P[e] = t, t.prototype.jsonID = e, t;
+	}
+}, I = class e {
+	constructor(e, t) {
+		this.doc = e, this.failed = t;
+	}
+	static ok(t) {
+		return new e(t, null);
+	}
+	static fail(t) {
+		return new e(null, t);
+	}
+	static fromReplace(t, n, r, i) {
+		try {
+			return e.ok(t.replace(n, r, i));
+		} catch (t) {
+			if (t instanceof s) return e.fail(t.message);
+			throw t;
+		}
+	}
+};
+function L(e, t, r) {
+	let i = [];
+	for (let n = 0; n < e.childCount; n++) {
+		let a = e.child(n);
+		a.content.size && (a = a.copy(L(a.content, t, a))), a.isInline && (a = t(a, r, n)), i.push(a);
+	}
+	return n.fromArray(i);
+}
+var R = class e extends F {
+	constructor(e, t, n) {
+		super(), this.from = e, this.to = t, this.mark = n;
+	}
+	apply(e) {
+		let t = e.slice(this.from, this.to), n = e.resolve(this.from), r = n.node(n.sharedDepth(this.to)), i = new c(L(t.content, (e, t) => !e.isAtom || !t.type.allowsMarkType(this.mark.type) ? e : e.mark(this.mark.addToSet(e.marks)), r), t.openStart, t.openEnd);
+		return I.fromReplace(e, this.from, this.to, i);
+	}
+	invert() {
+		return new be(this.from, this.to, this.mark);
+	}
+	map(t) {
+		let n = t.mapResult(this.from, 1), r = t.mapResult(this.to, -1);
+		return n.deleted && r.deleted || n.pos >= r.pos ? null : new e(n.pos, r.pos, this.mark);
+	}
+	merge(t) {
+		return t instanceof e && t.mark.eq(this.mark) && this.from <= t.to && this.to >= t.from ? new e(Math.min(this.from, t.from), Math.max(this.to, t.to), this.mark) : null;
+	}
+	toJSON() {
+		return {
+			stepType: "addMark",
+			mark: this.mark.toJSON(),
+			from: this.from,
+			to: this.to
+		};
+	}
+	static fromJSON(t, n) {
+		if (typeof n.from != "number" || typeof n.to != "number") throw RangeError("Invalid input for AddMarkStep.fromJSON");
+		return new e(n.from, n.to, t.markFromJSON(n.mark));
+	}
+};
+F.jsonID("addMark", R);
+var be = class e extends F {
+	constructor(e, t, n) {
+		super(), this.from = e, this.to = t, this.mark = n;
+	}
+	apply(e) {
+		let t = e.slice(this.from, this.to), n = new c(L(t.content, (e) => e.mark(this.mark.removeFromSet(e.marks)), e), t.openStart, t.openEnd);
+		return I.fromReplace(e, this.from, this.to, n);
+	}
+	invert() {
+		return new R(this.from, this.to, this.mark);
+	}
+	map(t) {
+		let n = t.mapResult(this.from, 1), r = t.mapResult(this.to, -1);
+		return n.deleted && r.deleted || n.pos >= r.pos ? null : new e(n.pos, r.pos, this.mark);
+	}
+	merge(t) {
+		return t instanceof e && t.mark.eq(this.mark) && this.from <= t.to && this.to >= t.from ? new e(Math.min(this.from, t.from), Math.max(this.to, t.to), this.mark) : null;
+	}
+	toJSON() {
+		return {
+			stepType: "removeMark",
+			mark: this.mark.toJSON(),
+			from: this.from,
+			to: this.to
+		};
+	}
+	static fromJSON(t, n) {
+		if (typeof n.from != "number" || typeof n.to != "number") throw RangeError("Invalid input for RemoveMarkStep.fromJSON");
+		return new e(n.from, n.to, t.markFromJSON(n.mark));
+	}
+};
+F.jsonID("removeMark", be);
+var z = class e extends F {
+	constructor(e, t) {
+		super(), this.pos = e, this.mark = t;
+	}
+	apply(e) {
+		let t = e.nodeAt(this.pos);
+		if (!t) return I.fail("No node at mark step's position");
+		let r = t.type.create(t.attrs, null, this.mark.addToSet(t.marks));
+		return I.fromReplace(e, this.pos, this.pos + 1, new c(n.from(r), 0, +!t.isLeaf));
+	}
+	invert(t) {
+		let n = t.nodeAt(this.pos);
+		if (n) {
+			let t = this.mark.addToSet(n.marks);
+			if (t.length == n.marks.length) {
+				for (let r = 0; r < n.marks.length; r++) if (!n.marks[r].isInSet(t)) return new e(this.pos, n.marks[r]);
+				return new e(this.pos, this.mark);
+			}
+		}
+		return new B(this.pos, this.mark);
+	}
+	map(t) {
+		let n = t.mapResult(this.pos, 1);
+		return n.deletedAfter ? null : new e(n.pos, this.mark);
+	}
+	toJSON() {
+		return {
+			stepType: "addNodeMark",
+			pos: this.pos,
+			mark: this.mark.toJSON()
+		};
+	}
+	static fromJSON(t, n) {
+		if (typeof n.pos != "number") throw RangeError("Invalid input for AddNodeMarkStep.fromJSON");
+		return new e(n.pos, t.markFromJSON(n.mark));
+	}
+};
+F.jsonID("addNodeMark", z);
+var B = class e extends F {
+	constructor(e, t) {
+		super(), this.pos = e, this.mark = t;
+	}
+	apply(e) {
+		let t = e.nodeAt(this.pos);
+		if (!t) return I.fail("No node at mark step's position");
+		let r = t.type.create(t.attrs, null, this.mark.removeFromSet(t.marks));
+		return I.fromReplace(e, this.pos, this.pos + 1, new c(n.from(r), 0, +!t.isLeaf));
+	}
+	invert(e) {
+		let t = e.nodeAt(this.pos);
+		return !t || !this.mark.isInSet(t.marks) ? this : new z(this.pos, this.mark);
+	}
+	map(t) {
+		let n = t.mapResult(this.pos, 1);
+		return n.deletedAfter ? null : new e(n.pos, this.mark);
+	}
+	toJSON() {
+		return {
+			stepType: "removeNodeMark",
+			pos: this.pos,
+			mark: this.mark.toJSON()
+		};
+	}
+	static fromJSON(t, n) {
+		if (typeof n.pos != "number") throw RangeError("Invalid input for RemoveNodeMarkStep.fromJSON");
+		return new e(n.pos, t.markFromJSON(n.mark));
+	}
+};
+F.jsonID("removeNodeMark", B);
+var V = class e extends F {
+	constructor(e, t, n, r = !1) {
+		super(), this.from = e, this.to = t, this.slice = n, this.structure = r;
+	}
+	apply(e) {
+		return this.structure && U(e, this.from, this.to) ? I.fail("Structure replace would overwrite content") : I.fromReplace(e, this.from, this.to, this.slice);
+	}
+	getMap() {
+		return new N([
+			this.from,
+			this.to - this.from,
+			this.slice.size
+		]);
+	}
+	invert(t) {
+		return new e(this.from, this.from + this.slice.size, t.slice(this.from, this.to));
+	}
+	map(t) {
+		let n = t.mapResult(this.from, 1), r = t.mapResult(this.to, -1);
+		return n.deletedAcross && r.deletedAcross ? null : new e(n.pos, Math.max(n.pos, r.pos), this.slice, this.structure);
+	}
+	merge(t) {
+		if (!(t instanceof e) || t.structure || this.structure) return null;
+		if (this.from + this.slice.size == t.from && !this.slice.openEnd && !t.slice.openStart) {
+			let n = this.slice.size + t.slice.size == 0 ? c.empty : new c(this.slice.content.append(t.slice.content), this.slice.openStart, t.slice.openEnd);
+			return new e(this.from, this.to + (t.to - t.from), n, this.structure);
+		} else if (t.to == this.from && !this.slice.openStart && !t.slice.openEnd) {
+			let n = this.slice.size + t.slice.size == 0 ? c.empty : new c(t.slice.content.append(this.slice.content), t.slice.openStart, this.slice.openEnd);
+			return new e(t.from, this.to, n, this.structure);
+		} else return null;
+	}
+	toJSON() {
+		let e = {
+			stepType: "replace",
+			from: this.from,
+			to: this.to
+		};
+		return this.slice.size && (e.slice = this.slice.toJSON()), this.structure && (e.structure = !0), e;
+	}
+	static fromJSON(t, n) {
+		if (typeof n.from != "number" || typeof n.to != "number") throw RangeError("Invalid input for ReplaceStep.fromJSON");
+		return new e(n.from, n.to, c.fromJSON(t, n.slice), !!n.structure);
+	}
+};
+F.jsonID("replace", V);
+var H = class e extends F {
+	constructor(e, t, n, r, i, a, o = !1) {
+		super(), this.from = e, this.to = t, this.gapFrom = n, this.gapTo = r, this.slice = i, this.insert = a, this.structure = o;
+	}
+	apply(e) {
+		if (this.structure && (U(e, this.from, this.gapFrom) || U(e, this.gapTo, this.to))) return I.fail("Structure gap-replace would overwrite content");
+		let t = e.slice(this.gapFrom, this.gapTo);
+		if (t.openStart || t.openEnd) return I.fail("Gap is not a flat range");
+		let n = this.slice.insertAt(this.insert, t.content);
+		return n ? I.fromReplace(e, this.from, this.to, n) : I.fail("Content does not fit in gap");
+	}
+	getMap() {
+		return new N([
+			this.from,
+			this.gapFrom - this.from,
+			this.insert,
+			this.gapTo,
+			this.to - this.gapTo,
+			this.slice.size - this.insert
+		]);
+	}
+	invert(t) {
+		let n = this.gapTo - this.gapFrom;
+		return new e(this.from, this.from + this.slice.size + n, this.from + this.insert, this.from + this.insert + n, t.slice(this.from, this.to).removeBetween(this.gapFrom - this.from, this.gapTo - this.from), this.gapFrom - this.from, this.structure);
+	}
+	map(t) {
+		let n = t.mapResult(this.from, 1), r = t.mapResult(this.to, -1), i = this.from == this.gapFrom ? n.pos : t.map(this.gapFrom, -1), a = this.to == this.gapTo ? r.pos : t.map(this.gapTo, 1);
+		return n.deletedAcross && r.deletedAcross || i < n.pos || a > r.pos ? null : new e(n.pos, r.pos, i, a, this.slice, this.insert, this.structure);
+	}
+	toJSON() {
+		let e = {
+			stepType: "replaceAround",
+			from: this.from,
+			to: this.to,
+			gapFrom: this.gapFrom,
+			gapTo: this.gapTo,
+			insert: this.insert
+		};
+		return this.slice.size && (e.slice = this.slice.toJSON()), this.structure && (e.structure = !0), e;
+	}
+	static fromJSON(t, n) {
+		if (typeof n.from != "number" || typeof n.to != "number" || typeof n.gapFrom != "number" || typeof n.gapTo != "number" || typeof n.insert != "number") throw RangeError("Invalid input for ReplaceAroundStep.fromJSON");
+		return new e(n.from, n.to, n.gapFrom, n.gapTo, c.fromJSON(t, n.slice), n.insert, !!n.structure);
+	}
+};
+F.jsonID("replaceAround", H);
+function U(e, t, n) {
+	let r = e.resolve(t), i = n - t, a = r.depth;
+	for (; i > 0 && a > 0 && r.indexAfter(a) == r.node(a).childCount;) a--, i--;
+	if (i > 0) {
+		let e = r.node(a).maybeChild(r.indexAfter(a));
+		for (; i > 0;) {
+			if (!e || e.isLeaf) return !0;
+			e = e.firstChild, i--;
+		}
+	}
+	return !1;
+}
+var xe = class e extends F {
+	constructor(e, t, n) {
+		super(), this.pos = e, this.attr = t, this.value = n;
+	}
+	apply(e) {
+		let t = e.nodeAt(this.pos);
+		if (!t) return I.fail("No node at attribute step's position");
+		let r = Object.create(null);
+		for (let e in t.attrs) r[e] = t.attrs[e];
+		r[this.attr] = this.value;
+		let i = t.type.create(r, null, t.marks);
+		return I.fromReplace(e, this.pos, this.pos + 1, new c(n.from(i), 0, +!t.isLeaf));
+	}
+	getMap() {
+		return N.empty;
+	}
+	invert(t) {
+		return new e(this.pos, this.attr, t.nodeAt(this.pos).attrs[this.attr]);
+	}
+	map(t) {
+		let n = t.mapResult(this.pos, 1);
+		return n.deletedAfter ? null : new e(n.pos, this.attr, this.value);
+	}
+	toJSON() {
+		return {
+			stepType: "attr",
+			pos: this.pos,
+			attr: this.attr,
+			value: this.value
+		};
+	}
+	static fromJSON(t, n) {
+		if (typeof n.pos != "number" || typeof n.attr != "string") throw RangeError("Invalid input for AttrStep.fromJSON");
+		return new e(n.pos, n.attr, n.value);
+	}
+};
+F.jsonID("attr", xe);
+var Se = class e extends F {
+	constructor(e, t) {
+		super(), this.attr = e, this.value = t;
+	}
+	apply(e) {
+		let t = Object.create(null);
+		for (let n in e.attrs) t[n] = e.attrs[n];
+		t[this.attr] = this.value;
+		let n = e.type.create(t, e.content, e.marks);
+		return I.ok(n);
+	}
+	getMap() {
+		return N.empty;
+	}
+	invert(t) {
+		return new e(this.attr, t.attrs[this.attr]);
+	}
+	map(e) {
+		return this;
+	}
+	toJSON() {
+		return {
+			stepType: "docAttr",
+			attr: this.attr,
+			value: this.value
+		};
+	}
+	static fromJSON(t, n) {
+		if (typeof n.attr != "string") throw RangeError("Invalid input for DocAttrStep.fromJSON");
+		return new e(n.attr, n.value);
+	}
+};
+F.jsonID("docAttr", Se);
+var W = class extends Error {};
+W = function e(t) {
+	let n = Error.call(this, t);
+	return n.__proto__ = e.prototype, n;
+}, W.prototype = Object.create(Error.prototype), W.prototype.constructor = W, W.prototype.name = "TransformError";
+var G = Object.create(null), K = class {
+	constructor(e, t, n) {
+		this.$anchor = e, this.$head = t, this.ranges = n || [new Ce(e.min(t), e.max(t))];
+	}
+	get anchor() {
+		return this.$anchor.pos;
+	}
+	get head() {
+		return this.$head.pos;
+	}
+	get from() {
+		return this.$from.pos;
+	}
+	get to() {
+		return this.$to.pos;
+	}
+	get $from() {
+		return this.ranges[0].$from;
+	}
+	get $to() {
+		return this.ranges[0].$to;
+	}
+	get empty() {
+		let e = this.ranges;
+		for (let t = 0; t < e.length; t++) if (e[t].$from.pos != e[t].$to.pos) return !1;
+		return !0;
+	}
+	content() {
+		return this.$from.doc.slice(this.from, this.to, !0);
+	}
+	replace(e, t = c.empty) {
+		let n = t.content.lastChild, r = null;
+		for (let e = 0; e < t.openEnd; e++) r = n, n = n.lastChild;
+		let i = e.steps.length, a = this.ranges;
+		for (let o = 0; o < a.length; o++) {
+			let { $from: s, $to: l } = a[o], u = e.mapping.slice(i);
+			e.replaceRange(u.map(s.pos), u.map(l.pos), o ? c.empty : t), o == 0 && Oe(e, i, (n ? n.isInline : r && r.isTextblock) ? -1 : 1);
+		}
+	}
+	replaceWith(e, t) {
+		let n = e.steps.length, r = this.ranges;
+		for (let i = 0; i < r.length; i++) {
+			let { $from: a, $to: o } = r[i], s = e.mapping.slice(n), c = s.map(a.pos), l = s.map(o.pos);
+			i ? e.deleteRange(c, l) : (e.replaceRangeWith(c, l, t), Oe(e, n, t.isInline ? -1 : 1));
+		}
+	}
+	static findFrom(e, t, n = !1) {
+		let r = e.parent.inlineContent ? new q(e) : Z(e.node(0), e.parent, e.pos, e.index(), t, n);
+		if (r) return r;
+		for (let r = e.depth - 1; r >= 0; r--) {
+			let i = t < 0 ? Z(e.node(0), e.node(r), e.before(r + 1), e.index(r), t, n) : Z(e.node(0), e.node(r), e.after(r + 1), e.index(r) + 1, t, n);
+			if (i) return i;
+		}
+		return null;
+	}
+	static near(e, t = 1) {
+		return this.findFrom(e, t) || this.findFrom(e, -t) || new X(e.node(0));
+	}
+	static atStart(e) {
+		return Z(e, e, 0, 0, 1) || new X(e);
+	}
+	static atEnd(e) {
+		return Z(e, e, e.content.size, e.childCount, -1) || new X(e);
+	}
+	static fromJSON(e, t) {
+		if (!t || !t.type) throw RangeError("Invalid input for Selection.fromJSON");
+		let n = G[t.type];
+		if (!n) throw RangeError(`No selection type ${t.type} defined`);
+		return n.fromJSON(e, t);
+	}
+	static jsonID(e, t) {
+		if (e in G) throw RangeError("Duplicate use of selection JSON ID " + e);
+		return G[e] = t, t.prototype.jsonID = e, t;
+	}
+	getBookmark() {
+		return q.between(this.$anchor, this.$head).getBookmark();
+	}
+};
+K.prototype.visible = !0;
+var Ce = class {
+	constructor(e, t) {
+		this.$from = e, this.$to = t;
+	}
+}, we = !1;
+function Te(e) {
+	!we && !e.parent.inlineContent && (we = !0, console.warn("TextSelection endpoint not pointing into a node with inline content (" + e.parent.type.name + ")"));
+}
+var q = class e extends K {
+	constructor(e, t = e) {
+		Te(e), Te(t), super(e, t);
+	}
+	get $cursor() {
+		return this.$anchor.pos == this.$head.pos ? this.$head : null;
+	}
+	map(t, n) {
+		let r = t.resolve(n.map(this.head));
+		if (!r.parent.inlineContent) return K.near(r);
+		let i = t.resolve(n.map(this.anchor));
+		return new e(i.parent.inlineContent ? i : r, r);
+	}
+	replace(e, t = c.empty) {
+		if (super.replace(e, t), t == c.empty) {
+			let t = this.$from.marksAcross(this.$to);
+			t && e.ensureMarks(t);
+		}
+	}
+	eq(t) {
+		return t instanceof e && t.anchor == this.anchor && t.head == this.head;
+	}
+	getBookmark() {
+		return new J(this.anchor, this.head);
+	}
+	toJSON() {
+		return {
+			type: "text",
+			anchor: this.anchor,
+			head: this.head
+		};
+	}
+	static fromJSON(t, n) {
+		if (typeof n.anchor != "number" || typeof n.head != "number") throw RangeError("Invalid input for TextSelection.fromJSON");
+		return new e(t.resolve(n.anchor), t.resolve(n.head));
+	}
+	static create(e, t, n = t) {
+		let r = e.resolve(t);
+		return new this(r, n == t ? r : e.resolve(n));
+	}
+	static between(t, n, r) {
+		let i = t.pos - n.pos;
+		if ((!r || i) && (r = i >= 0 ? 1 : -1), !n.parent.inlineContent) {
+			let e = K.findFrom(n, r, !0) || K.findFrom(n, -r, !0);
+			if (e) n = e.$head;
+			else return K.near(n, r);
+		}
+		return t.parent.inlineContent || (i == 0 ? t = n : (t = (K.findFrom(t, -r, !0) || K.findFrom(t, r, !0)).$anchor, t.pos < n.pos != i < 0 && (t = n))), new e(t, n);
+	}
+};
+K.jsonID("text", q);
+var J = class e {
+	constructor(e, t) {
+		this.anchor = e, this.head = t;
+	}
+	map(t) {
+		return new e(t.map(this.anchor), t.map(this.head));
+	}
+	resolve(e) {
+		return q.between(e.resolve(this.anchor), e.resolve(this.head));
+	}
+}, Y = class e extends K {
+	constructor(e) {
+		let t = e.nodeAfter, n = e.node(0).resolve(e.pos + t.nodeSize);
+		super(e, n), this.node = t;
+	}
+	map(t, n) {
+		let { deleted: r, pos: i } = n.mapResult(this.anchor), a = t.resolve(i);
+		return r ? K.near(a) : new e(a);
+	}
+	content() {
+		return new c(n.from(this.node), 0, 0);
+	}
+	eq(t) {
+		return t instanceof e && t.anchor == this.anchor;
+	}
+	toJSON() {
+		return {
+			type: "node",
+			anchor: this.anchor
+		};
+	}
+	getBookmark() {
+		return new Ee(this.anchor);
+	}
+	static fromJSON(t, n) {
+		if (typeof n.anchor != "number") throw RangeError("Invalid input for NodeSelection.fromJSON");
+		return new e(t.resolve(n.anchor));
+	}
+	static create(t, n) {
+		return new e(t.resolve(n));
+	}
+	static isSelectable(e) {
+		return !e.isText && e.type.spec.selectable !== !1;
+	}
+};
+Y.prototype.visible = !1, K.jsonID("node", Y);
+var Ee = class e {
+	constructor(e) {
+		this.anchor = e;
+	}
+	map(t) {
+		let { deleted: n, pos: r } = t.mapResult(this.anchor);
+		return n ? new J(r, r) : new e(r);
+	}
+	resolve(e) {
+		let t = e.resolve(this.anchor), n = t.nodeAfter;
+		return n && Y.isSelectable(n) ? new Y(t) : K.near(t);
+	}
+}, X = class e extends K {
+	constructor(e) {
+		super(e.resolve(0), e.resolve(e.content.size));
+	}
+	replace(e, t = c.empty) {
+		if (t == c.empty) {
+			e.delete(0, e.doc.content.size);
+			let t = K.atStart(e.doc);
+			t.eq(e.selection) || e.setSelection(t);
+		} else super.replace(e, t);
+	}
+	toJSON() {
+		return { type: "all" };
+	}
+	static fromJSON(t) {
+		return new e(t);
+	}
+	map(t) {
+		return new e(t);
+	}
+	eq(t) {
+		return t instanceof e;
+	}
+	getBookmark() {
+		return De;
+	}
+};
+K.jsonID("all", X);
+var De = {
+	map() {
+		return this;
+	},
+	resolve(e) {
+		return new X(e);
+	}
+};
+function Z(e, t, n, r, i, a = !1) {
+	if (t.inlineContent) return q.create(e, n);
+	for (let o = r - (i > 0 ? 0 : 1); i > 0 ? o < t.childCount : o >= 0; o += i) {
+		let r = t.child(o);
+		if (!r.isAtom) {
+			let t = Z(e, r, n + i, i < 0 ? r.childCount : 0, i, a);
+			if (t) return t;
+		} else if (!a && Y.isSelectable(r)) return Y.create(e, n - (i < 0 ? r.nodeSize : 0));
+		n += r.nodeSize * i;
+	}
+	return null;
+}
+function Oe(e, t, n) {
+	let r = e.steps.length - 1;
+	if (r < t) return;
+	let i = e.steps[r];
+	if (!(i instanceof V || i instanceof H)) return;
+	let a = e.mapping.maps[r], o;
+	a.forEach((e, t, n, r) => {
+		o ??= r;
+	}), e.setSelection(K.near(e.doc.resolve(o), n));
+}
+function ke(e, t) {
+	return !t || !e ? e : e.bind(t);
+}
+var Q = class {
+	constructor(e, t, n) {
+		this.name = e, this.init = ke(t.init, n), this.apply = ke(t.apply, n);
+	}
+};
+new Q("doc", {
+	init(e) {
+		return e.doc || e.schema.topNodeType.createAndFill();
+	},
+	apply(e) {
+		return e.doc;
+	}
+}), new Q("selection", {
+	init(e, t) {
+		return e.selection || K.atStart(t.doc);
+	},
+	apply(e) {
+		return e.selection;
+	}
+}), new Q("storedMarks", {
+	init(e) {
+		return e.storedMarks || null;
+	},
+	apply(e, t, n, r) {
+		return r.selection.$cursor ? e.storedMarks : null;
+	}
+}), new Q("scrollToSelection", {
+	init() {
+		return 0;
+	},
+	apply(e, t) {
+		return e.scrolledIntoView ? t + 1 : t;
+	}
+});
+var $ = Object.create(null);
+function Ae(e) {
+	return e in $ ? e + "$" + ++$[e] : ($[e] = 0, e + "$");
+}
+var je = class {
+	constructor(e = "key") {
+		this.key = Ae(e);
+	}
+	get(e) {
+		return e.config.pluginsByKey[this.key];
+	}
+	getState(e) {
+		return e[this.key];
+	}
+};
+export { je as t };