@guodun/antdv 1.5.3 → 1.6.0

package/dist/es/node_modules/prosemirror-model/dist/index.mjs

@@ -0,0 +1,1128 @@
+import "../../orderedmap/dist/index.mjs";
+//#region ../../node_modules/prosemirror-model/dist/index.js
+function e(t, i, a) {
+	for (let o = 0;; o++) {
+		if (o == t.childCount || o == i.childCount) return t.childCount == i.childCount ? null : a;
+		let s = t.child(o), c = i.child(o);
+		if (s == c) {
+			a += s.nodeSize;
+			continue;
+		}
+		if (!s.sameMarkup(c)) return a;
+		if (s.isText && s.text != c.text) {
+			let e = s.text, t = c.text, i = 0;
+			for (; e[i] == t[i]; i++) a++;
+			return i && i < e.length && i < t.length && r(e.charCodeAt(i - 1)) && n(e.charCodeAt(i)) && a--, a;
+		}
+		if (s.content.size || c.content.size) {
+			let t = e(s.content, c.content, a + 1);
+			if (t != null) return t;
+		}
+		a += s.nodeSize;
+	}
+}
+function t(e, i, a, o) {
+	for (let s = e.childCount, c = i.childCount;;) {
+		if (s == 0 || c == 0) return s == c ? null : {
+			a,
+			b: o
+		};
+		let l = e.child(--s), u = i.child(--c), d = l.nodeSize;
+		if (l == u) {
+			a -= d, o -= d;
+			continue;
+		}
+		if (!l.sameMarkup(u)) return {
+			a,
+			b: o
+		};
+		if (l.isText && l.text != u.text) {
+			let e = l.text, t = u.text, i = e.length, s = t.length;
+			for (; i > 0 && s > 0 && e[i - 1] == t[s - 1];) i--, s--, a--, o--;
+			return i && s && i < e.length && r(e.charCodeAt(i - 1)) && n(e.charCodeAt(i)) && (a++, o++), {
+				a,
+				b: o
+			};
+		}
+		if (l.content.size || u.content.size) {
+			let e = t(l.content, u.content, a - 1, o - 1);
+			if (e) return e;
+		}
+		a -= d, o -= d;
+	}
+}
+function n(e) {
+	return e >= 56320 && e < 57344;
+}
+function r(e) {
+	return e >= 55296 && e < 56320;
+}
+var i = 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 o(0, e);
+		if (e == this.size) return o(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), i = n + r.nodeSize;
+			if (i >= e) return i == e ? o(t + 1, i) : o(t, n);
+			n = i;
+		}
+	}
+	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 n.fromArray(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)" : ""));
+	}
+};
+i.empty = new i([], 0);
+var a = {
+	index: 0,
+	offset: 0
+};
+function o(e, t) {
+	return a.index = e, a.offset = t, a;
+}
+function s(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 (!s(e[n], t[n])) return !1;
+	} else {
+		for (let n in e) if (!(n in t) || !s(e[n], t[n])) return !1;
+		for (let n in t) if (!(n in e)) return !1;
+	}
+	return !0;
+}
+var c = 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 && s(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;
+	}
+};
+c.none = [];
+var l = class extends Error {}, u = 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 = f(this.content, t + this.openStart, n, this.openStart + 1, this.openEnd + 1);
+		return r && new e(r, this.openStart, this.openEnd);
+	}
+	removeBetween(t, n) {
+		return new e(d(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, n) {
+		if (!n) return e.empty;
+		let r = n.openStart || 0, a = n.openEnd || 0;
+		if (typeof r != "number" || typeof a != "number") throw RangeError("Invalid input for Slice.fromJSON");
+		return new e(i.fromJSON(t, n.content), r, 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);
+	}
+};
+u.empty = new u(i.empty, 0, 0);
+function d(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(d(a.content, t - i - 1, n - i - 1)));
+}
+function f(e, t, n, r, i, a) {
+	let { index: o, offset: s } = e.findIndex(t), c = e.maybeChild(o);
+	if (s == t || c.isText) return a && r <= 0 && i <= 0 && !a.canReplace(o, o, n) ? null : e.cut(0, t).append(n).append(e.cut(t));
+	let l = f(c.content, t - s - 1, n, o == 0 ? r - 1 : 0, o == e.childCount - 1 ? i - 1 : 0, c);
+	return l && e.replaceChild(o, c.copy(l));
+}
+function p(e, t, n) {
+	if (n.openStart > e.depth) throw new l("Inserted content deeper than insertion position");
+	if (e.depth - n.openStart != t.depth - n.openEnd) throw new l("Inconsistent open depths");
+	return m(e, t, n, 0);
+}
+function m(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 = m(e, t, n, r + 1);
+		return a.copy(a.content.replaceChild(i, o));
+	} else if (!n.content.size) return y(a, x(e, t, r));
+	else if (!n.openStart && !n.openEnd && e.depth == r && t.depth == r) {
+		let r = e.parent, i = r.content;
+		return y(r, i.cut(0, e.parentOffset).append(n.content).append(i.cut(t.parentOffset)));
+	} else {
+		let { start: i, end: o } = S(n, e);
+		return y(a, b(e, i, o, t, r));
+	}
+}
+function h(e, t) {
+	if (!t.type.compatibleContent(e.type)) throw new l("Cannot join " + t.type.name + " onto " + e.type.name);
+}
+function g(e, t, n) {
+	let r = e.node(n);
+	return h(r, t.node(n)), r;
+}
+function _(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 v(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 && (_(e.nodeAfter, r), a++));
+	for (let e = a; e < o; e++) _(i.child(e), r);
+	t && t.depth == n && t.textOffset && _(t.nodeBefore, r);
+}
+function y(e, t) {
+	if (!e.type.validContent(t)) throw new l("Invalid content for node " + e.type.name);
+	return e.copy(t);
+}
+function b(e, t, n, r, a) {
+	let o = e.depth > a && g(e, t, a + 1), s = r.depth > a && g(n, r, a + 1), c = [];
+	return v(null, e, a, c), o && s && t.index(a) == n.index(a) ? (h(o, s), _(y(o, b(e, t, n, r, a + 1)), c)) : (o && _(y(o, x(e, t, a + 1)), c), v(t, n, a, c), s && _(y(s, x(n, r, a + 1)), c)), v(r, null, a, c), new i(c);
+}
+function x(e, t, n) {
+	let r = [];
+	return v(null, e, n, r), e.depth > n && _(y(g(e, t, n + 1), x(e, t, n + 1)), r), v(t, null, n, r), new i(r);
+}
+function S(e, t) {
+	let n = t.depth - e.openStart, r = t.node(n).copy(e.content);
+	for (let e = n - 1; e >= 0; e--) r = t.node(e).copy(i.from(r));
+	return {
+		start: r.resolveNoCache(e.openStart + n),
+		end: r.resolveNoCache(r.content.size - e.openEnd - n)
+	};
+}
+var C = 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 c.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 D(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 = E.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 E.set(t, r = new w());
+		let i = r.elts[r.i] = e.resolve(t, n);
+		return r.i = (r.i + 1) % T, i;
+	}
+}, w = class {
+	constructor() {
+		this.elts = [], this.i = 0;
+	}
+}, T = 12, E = /* @__PURE__ */ new WeakMap(), D = 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);
+	}
+}, O = Object.create(null), k = class e {
+	constructor(e, t, n, r = c.none) {
+		this.type = e, this.attrs = t, this.marks = r, this.content = n || i.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 && s(this.attrs, t || e.defaultAttrs || O) && c.sameSet(this.marks, n || c.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 u.empty;
+		let r = this.resolve(e), i = this.resolve(t), a = n ? 0 : r.sharedDepth(t), o = r.start(a);
+		return new u(r.node(a).content.cut(r.pos - o, i.pos - o), r.depth - a, i.depth - a);
+	}
+	replace(e, t, n) {
+		return p(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 C.resolveCached(this, e);
+	}
+	resolveNoCache(e) {
+		return C.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() + ")"), A(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, n = i.empty, r = 0, a = n.childCount) {
+		let o = this.contentMatchAt(e).matchFragment(n, r, a), s = o && o.matchFragment(this.content, t);
+		if (!s || !s.validEnd) return !1;
+		for (let e = r; e < a; e++) if (!this.type.allowsMarks(n.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 = c.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 (!c.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 n;
+		if (t.marks) {
+			if (!Array.isArray(t.marks)) throw RangeError("Invalid mark data for Node.fromJSON");
+			n = 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, n);
+		}
+		let r = i.fromJSON(e, t.content), a = e.nodeType(t.type).create(t.attrs, r, n);
+		return a.type.checkAttrs(a.attrs), a;
+	}
+};
+k.prototype.text = void 0;
+function A(e, t) {
+	for (let n = e.length - 1; n >= 0; n--) t = e[n].type.name + "(" + t + ")";
+	return t;
+}
+var j = class e {
+	constructor(e) {
+		this.validEnd = e, this.next = [], this.wrapCache = [];
+	}
+	static parse(t, n) {
+		let r = new M(t, n);
+		if (r.next == null) return e.empty;
+		let i = N(r);
+		r.next && r.err("Unexpected trailing text");
+		let a = U(B(i));
+		return W(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, n = 0) {
+		let r = [this];
+		function a(o, s) {
+			let c = o.matchFragment(e, n);
+			if (c && (!t || c.validEnd)) return i.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()) && r.indexOf(n) == -1) {
+					r.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");
+	}
+};
+j.empty = new j(!0);
+var M = 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 N(e) {
+	let t = [];
+	do
+		t.push(P(e));
+	while (e.eat("|"));
+	return t.length == 1 ? t[0] : {
+		type: "choice",
+		exprs: t
+	};
+}
+function P(e) {
+	let t = [];
+	do
+		t.push(F(e));
+	while (e.next && e.next != ")" && e.next != "|");
+	return t.length == 1 ? t[0] : {
+		type: "seq",
+		exprs: t
+	};
+}
+function F(e) {
+	let t = z(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 = L(e, t);
+	else break;
+	return t;
+}
+function I(e) {
+	/\D/.test(e.next) && e.err("Expected number, got '" + e.next + "'");
+	let t = Number(e.next);
+	return e.pos++, t;
+}
+function L(e, t) {
+	let n = I(e), r = n;
+	return e.eat(",") && (r = e.next == "}" ? -1 : I(e)), e.eat("}") || e.err("Unclosed braced range"), {
+		type: "range",
+		min: n,
+		max: r,
+		expr: t
+	};
+}
+function R(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 z(e) {
+	if (e.eat("(")) {
+		let t = N(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 = R(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 B(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 V(e, t) {
+	return t - e;
+}
+function H(e, t) {
+	let n = [];
+	return r(t), n.sort(V);
+	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 U(e) {
+	let t = Object.create(null);
+	return n(H(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]);
+				H(e, n).forEach((e) => {
+					r || i.push([t, r = []]), r.indexOf(e) == -1 && r.push(e);
+				});
+			});
+		});
+		let a = t[r.join(",")] = new j(r.indexOf(e.length - 1) > -1);
+		for (let e = 0; e < i.length; e++) {
+			let r = i[e][1].sort(V);
+			a.next.push({
+				type: i[e][0],
+				next: t[r.join(",")] || n(r)
+			});
+		}
+		return a;
+	}
+}
+function W(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)");
+	}
+}
+function G(e) {
+	let t = Object.create(null);
+	for (let n in e) {
+		let r = e[n];
+		if (!r.hasDefault) return null;
+		t[n] = r.default;
+	}
+	return t;
+}
+function K(e, t) {
+	let n = Object.create(null);
+	for (let r in e) {
+		let i = t && t[r];
+		if (i === void 0) {
+			let t = e[r];
+			if (t.hasDefault) i = t.default;
+			else throw RangeError("No value supplied for attribute " + r);
+		}
+		n[r] = i;
+	}
+	return n;
+}
+function q(e, t, n, r) {
+	for (let i in t) if (!(i in e)) throw RangeError(`Unsupported attribute ${i} for ${n} of type ${r}`);
+	for (let n in e) e[n].validate && e[n].validate(t[n]);
+}
+function J(e, t) {
+	let n = Object.create(null);
+	if (t) for (let r in t) n[r] = new X(e, r, t[r]);
+	return n;
+}
+function Y(e, t, n) {
+	let r = n.split("|");
+	return (n) => {
+		let i = n === null ? "null" : typeof n;
+		if (r.indexOf(i) < 0) throw RangeError(`Expected value of type ${r} for attribute ${t} on type ${e}, got ${i}`);
+	};
+}
+var X = class {
+	constructor(e, t, n) {
+		this.hasDefault = Object.prototype.hasOwnProperty.call(n, "default"), this.default = n.default, this.validate = typeof n.validate == "string" ? Y(e, t, n.validate) : n.validate;
+	}
+	get isRequired() {
+		return !this.hasDefault;
+	}
+}, Z = class e {
+	constructor(e, t, n, r) {
+		this.name = e, this.rank = t, this.schema = n, this.spec = r, this.attrs = J(e, r.attrs), this.excluded = null;
+		let i = G(this.attrs);
+		this.instance = i ? new c(this, i) : null;
+	}
+	create(e = null) {
+		return !e && this.instance ? this.instance : new c(this, K(this.attrs, e));
+	}
+	static compile(t, n) {
+		let r = Object.create(null), i = 0;
+		return t.forEach((t, a) => r[t] = new e(t, i++, n, a)), r;
+	}
+	removeFromSet(e) {
+		for (var t = 0; t < e.length; t++) e[t].type == this && (e = e.slice(0, t).concat(e.slice(t + 1)), t--);
+		return e;
+	}
+	isInSet(e) {
+		for (let t = 0; t < e.length; t++) if (e[t].type == this) return e[t];
+	}
+	checkAttrs(e) {
+		q(this.attrs, e, "mark", this.name);
+	}
+	excludes(e) {
+		return this.excluded.indexOf(e) > -1;
+	}
+}, Q = /* @__PURE__ */ new WeakMap();
+function $(e) {
+	let t = Q.get(e);
+	return t === void 0 && Q.set(e, t = ee(e)), t;
+}
+function ee(e) {
+	let t = null;
+	function n(e) {
+		if (e && typeof e == "object") if (Array.isArray(e)) if (typeof e[0] == "string") t ||= [], t.push(e);
+		else for (let t = 0; t < e.length; t++) n(e[t]);
+		else for (let t in e) n(e[t]);
+	}
+	return n(e), t;
+}
+function te(e, t, n, r) {
+	if (t.nodeType == 1) return { dom: t };
+	if (t.dom && t.dom.nodeType == 1) return t;
+	let i = t[0], a;
+	if (typeof i != "string") throw RangeError("Invalid array passed to renderSpec");
+	if (r && (a = $(r)) && a.indexOf(t) > -1) throw RangeError("Using an array from an attribute object as a DOM spec. This may be an attempted cross site scripting attack.");
+	let o = i.indexOf(" ");
+	o > 0 && (n = i.slice(0, o), i = i.slice(o + 1));
+	let s, c = n ? e.createElementNS(n, i) : e.createElement(i), l = t[1], u = 1;
+	if (l && typeof l == "object" && l.nodeType == null && !Array.isArray(l)) {
+		u = 2;
+		for (let e in l) if (l[e] != null) {
+			let t = e.indexOf(" ");
+			t > 0 ? c.setAttributeNS(e.slice(0, t), e.slice(t + 1), l[e]) : e == "style" && c.style ? c.style.cssText = l[e] : c.setAttribute(e, l[e]);
+		}
+	}
+	for (let i = u; i < t.length; i++) {
+		let a = t[i];
+		if (a === 0) {
+			if (i < t.length - 1 || i > u) throw RangeError("Content hole must be the only child of its parent node");
+			return {
+				dom: c,
+				contentDOM: c
+			};
+		} else if (typeof a == "string") c.appendChild(e.createTextNode(a));
+		else {
+			let { dom: t, contentDOM: i } = te(e, a, n, r);
+			if (c.appendChild(t), i) {
+				if (s) throw RangeError("Multiple content holes");
+				s = i;
+			}
+		}
+	}
+	return {
+		dom: c,
+		contentDOM: s
+	};
+}
+//#endregion
+export { i as Fragment, c as Mark, Z as MarkType, k as Node, l as ReplaceError, u as Slice };