4190 lines
130 KiB
JavaScript
4190 lines
130 KiB
JavaScript
/*
|
|
* Extracted from browser-delivered Turbopack chunk: 2a4e4dccbc3fdacb.bc4b655d5c.js
|
|
* Module id: 47091
|
|
* For reading/searching only; this factory depends on the original Turbopack runtime.
|
|
*/
|
|
|
|
const moduleFactory = (e) => {
|
|
"use strict";
|
|
function t(e) {
|
|
this.content = e;
|
|
}
|
|
(t.prototype = {
|
|
constructor: t,
|
|
find: function (e) {
|
|
for (var t = 0; t < this.content.length; t += 2)
|
|
if (this.content[t] === e) return t;
|
|
return -1;
|
|
},
|
|
get: function (e) {
|
|
var t = this.find(e);
|
|
return -1 == t ? void 0 : this.content[t + 1];
|
|
},
|
|
update: function (e, n, r) {
|
|
var i = r && r != e ? this.remove(r) : this,
|
|
o = i.find(e),
|
|
s = i.content.slice();
|
|
return (
|
|
-1 == o ? s.push(r || e, n) : ((s[o + 1] = n), r && (s[o] = r)),
|
|
new t(s)
|
|
);
|
|
},
|
|
remove: function (e) {
|
|
var n = this.find(e);
|
|
if (-1 == n) return this;
|
|
var r = this.content.slice();
|
|
return r.splice(n, 2), new t(r);
|
|
},
|
|
addToStart: function (e, n) {
|
|
return new t([e, n].concat(this.remove(e).content));
|
|
},
|
|
addToEnd: function (e, n) {
|
|
var r = this.remove(e).content.slice();
|
|
return r.push(e, n), new t(r);
|
|
},
|
|
addBefore: function (e, n, r) {
|
|
var i = this.remove(n),
|
|
o = i.content.slice(),
|
|
s = i.find(e);
|
|
return o.splice(-1 == s ? o.length : s, 0, n, r), new t(o);
|
|
},
|
|
forEach: function (e) {
|
|
for (var t = 0; t < this.content.length; t += 2)
|
|
e(this.content[t], this.content[t + 1]);
|
|
},
|
|
prepend: function (e) {
|
|
return (e = t.from(e)).size
|
|
? new t(e.content.concat(this.subtract(e).content))
|
|
: this;
|
|
},
|
|
append: function (e) {
|
|
return (e = t.from(e)).size
|
|
? new t(this.subtract(e).content.concat(e.content))
|
|
: this;
|
|
},
|
|
subtract: function (e) {
|
|
var n = this;
|
|
e = t.from(e);
|
|
for (var r = 0; r < e.content.length; r += 2)
|
|
n = n.remove(e.content[r]);
|
|
return n;
|
|
},
|
|
toObject: function () {
|
|
var e = {};
|
|
return (
|
|
this.forEach(function (t, n) {
|
|
e[t] = n;
|
|
}),
|
|
e
|
|
);
|
|
},
|
|
get size() {
|
|
return this.content.length >> 1;
|
|
},
|
|
}),
|
|
(t.from = function (e) {
|
|
if (e instanceof t) return e;
|
|
var n = [];
|
|
if (e) for (var r in e) n.push(r, e[r]);
|
|
return new t(n);
|
|
});
|
|
class n {
|
|
constructor(e, t) {
|
|
if (((this.content = e), (this.size = t || 0), null == t))
|
|
for (let t = 0; t < e.length; t++) this.size += e[t].nodeSize;
|
|
}
|
|
nodesBetween(e, t, n, r = 0, i) {
|
|
for (let o = 0, s = 0; s < t; o++) {
|
|
let l = this.content[o],
|
|
a = s + l.nodeSize;
|
|
if (a > e && !1 !== n(l, r + s, i || null, o) && l.content.size) {
|
|
let i = s + 1;
|
|
l.nodesBetween(
|
|
Math.max(0, e - i),
|
|
Math.min(l.content.size, t - i),
|
|
n,
|
|
r + i,
|
|
);
|
|
}
|
|
s = a;
|
|
}
|
|
}
|
|
descendants(e) {
|
|
this.nodesBetween(0, this.size, e);
|
|
}
|
|
textBetween(e, t, n, r) {
|
|
let i = "",
|
|
o = !0;
|
|
return (
|
|
this.nodesBetween(
|
|
e,
|
|
t,
|
|
(s, l) => {
|
|
let a = s.isText
|
|
? s.text.slice(Math.max(e, l) - l, t - l)
|
|
: s.isLeaf
|
|
? r
|
|
? "function" == typeof r
|
|
? r(s)
|
|
: r
|
|
: s.type.spec.leafText
|
|
? s.type.spec.leafText(s)
|
|
: ""
|
|
: "";
|
|
s.isBlock &&
|
|
((s.isLeaf && a) || s.isTextblock) &&
|
|
n &&
|
|
(o ? (o = !1) : (i += n)),
|
|
(i += a);
|
|
},
|
|
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(),
|
|
o = 0;
|
|
for (
|
|
t.isText &&
|
|
t.sameMarkup(r) &&
|
|
((i[i.length - 1] = t.withText(t.text + r.text)), (o = 1));
|
|
o < e.content.length;
|
|
o++
|
|
)
|
|
i.push(e.content[o]);
|
|
return new n(i, this.size + e.size);
|
|
}
|
|
cut(e, t = this.size) {
|
|
if (0 == e && t == this.size) return this;
|
|
let r = [],
|
|
i = 0;
|
|
if (t > e)
|
|
for (let n = 0, o = 0; o < t; n++) {
|
|
let s = this.content[n],
|
|
l = o + s.nodeSize;
|
|
l > e &&
|
|
((o < e || l > t) &&
|
|
(s = s.isText
|
|
? s.cut(Math.max(0, e - o), Math.min(s.text.length, t - o))
|
|
: s.cut(
|
|
Math.max(0, e - o - 1),
|
|
Math.min(s.content.size, t - o - 1),
|
|
)),
|
|
r.push(s),
|
|
(i += s.nodeSize)),
|
|
(o = l);
|
|
}
|
|
return new n(r, i);
|
|
}
|
|
cutByIndex(e, t) {
|
|
return e == t
|
|
? n.empty
|
|
: 0 == e && 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(),
|
|
o = this.size + t.nodeSize - r.nodeSize;
|
|
return (i[e] = t), new n(i, o);
|
|
}
|
|
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(e, t = 0) {
|
|
return (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 o = t.child(i),
|
|
s = n.child(i);
|
|
if (o == s) {
|
|
r += o.nodeSize;
|
|
continue;
|
|
}
|
|
if (!o.sameMarkup(s)) return r;
|
|
if (o.isText && o.text != s.text) {
|
|
for (let e = 0; o.text[e] == s.text[e]; e++) r++;
|
|
return r;
|
|
}
|
|
if (o.content.size || s.content.size) {
|
|
let t = e(o.content, s.content, r + 1);
|
|
if (null != t) return t;
|
|
}
|
|
r += o.nodeSize;
|
|
}
|
|
})(this, e, t);
|
|
}
|
|
findDiffEnd(e, t = this.size, n = e.size) {
|
|
return (function e(t, n, r, i) {
|
|
for (let o = t.childCount, s = n.childCount; ; ) {
|
|
if (0 == o || 0 == s) return o == s ? null : { a: r, b: i };
|
|
let l = t.child(--o),
|
|
a = n.child(--s),
|
|
d = l.nodeSize;
|
|
if (l == a) {
|
|
(r -= d), (i -= d);
|
|
continue;
|
|
}
|
|
if (!l.sameMarkup(a)) return { a: r, b: i };
|
|
if (l.isText && l.text != a.text) {
|
|
let e = 0,
|
|
t = Math.min(l.text.length, a.text.length);
|
|
for (
|
|
;
|
|
e < t &&
|
|
l.text[l.text.length - e - 1] == a.text[a.text.length - e - 1];
|
|
|
|
)
|
|
e++, r--, i--;
|
|
return { a: r, b: i };
|
|
}
|
|
if (l.content.size || a.content.size) {
|
|
let t = e(l.content, a.content, r - 1, i - 1);
|
|
if (t) return t;
|
|
}
|
|
(r -= d), (i -= d);
|
|
}
|
|
})(this, e, t, n);
|
|
}
|
|
findIndex(e) {
|
|
if (0 == e) 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 = n + this.child(t).nodeSize;
|
|
if (r >= e) {
|
|
if (r == e) return i(t + 1, r);
|
|
return i(t, n);
|
|
}
|
|
n = r;
|
|
}
|
|
}
|
|
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 || (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);
|
|
let r = { index: 0, offset: 0 };
|
|
function i(e, t) {
|
|
return (r.index = e), (r.offset = t), r;
|
|
}
|
|
function o(e, t) {
|
|
if (e === t) return !0;
|
|
if (!(e && "object" == typeof e) || !(t && "object" == typeof t))
|
|
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 (!o(e[n], t[n])) return !1;
|
|
} else {
|
|
for (let n in e) if (!(n in t) || !o(e[n], t[n])) return !1;
|
|
for (let n in t) if (!(n in e)) return !1;
|
|
}
|
|
return !0;
|
|
}
|
|
class s {
|
|
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 || (t = e.slice(0, r));
|
|
else {
|
|
if (i.type.excludes(this.type)) return e;
|
|
!n &&
|
|
i.type.rank > this.type.rank &&
|
|
(t || (t = e.slice(0, r)), t.push(this), (n = !0)),
|
|
t && t.push(i);
|
|
}
|
|
}
|
|
return t || (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 && o(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(e) {
|
|
if (!e || (Array.isArray(e) && 0 == e.length)) return s.none;
|
|
if (e instanceof s) return [e];
|
|
let t = e.slice();
|
|
return t.sort((e, t) => e.type.rank - t.type.rank), t;
|
|
}
|
|
}
|
|
s.none = [];
|
|
class l extends Error {}
|
|
class a {
|
|
constructor(e, t, n) {
|
|
(this.content = e), (this.openStart = t), (this.openEnd = n);
|
|
}
|
|
get size() {
|
|
return this.content.size - this.openStart - this.openEnd;
|
|
}
|
|
insertAt(e, t) {
|
|
let n = (function e(t, n, r, i) {
|
|
let { index: o, offset: s } = t.findIndex(n),
|
|
l = t.maybeChild(o);
|
|
if (s == n || l.isText)
|
|
return i && !i.canReplace(o, o, r)
|
|
? null
|
|
: t.cut(0, n).append(r).append(t.cut(n));
|
|
let a = e(l.content, n - s - 1, r, l);
|
|
return a && t.replaceChild(o, l.copy(a));
|
|
})(this.content, e + this.openStart, t);
|
|
return n && new a(n, this.openStart, this.openEnd);
|
|
}
|
|
removeBetween(e, t) {
|
|
return new a(
|
|
(function e(t, n, r) {
|
|
let { index: i, offset: o } = t.findIndex(n),
|
|
s = t.maybeChild(i),
|
|
{ index: l, offset: a } = t.findIndex(r);
|
|
if (o == n || s.isText) {
|
|
if (a != r && !t.child(l).isText)
|
|
throw RangeError("Removing non-flat range");
|
|
return t.cut(0, n).append(t.cut(r));
|
|
}
|
|
if (i != l) throw RangeError("Removing non-flat range");
|
|
return t.replaceChild(
|
|
i,
|
|
s.copy(e(s.content, n - o - 1, r - o - 1)),
|
|
);
|
|
})(this.content, e + this.openStart, t + 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(e, t) {
|
|
if (!t) return a.empty;
|
|
let r = t.openStart || 0,
|
|
i = t.openEnd || 0;
|
|
if ("number" != typeof r || "number" != typeof i)
|
|
throw RangeError("Invalid input for Slice.fromJSON");
|
|
return new a(n.fromJSON(e, t.content), r, i);
|
|
}
|
|
static maxOpen(e, t = !0) {
|
|
let n = 0,
|
|
r = 0;
|
|
for (
|
|
let r = e.firstChild;
|
|
r && !r.isLeaf && (t || !r.type.spec.isolating);
|
|
r = r.firstChild
|
|
)
|
|
n++;
|
|
for (
|
|
let n = e.lastChild;
|
|
n && !n.isLeaf && (t || !n.type.spec.isolating);
|
|
n = n.lastChild
|
|
)
|
|
r++;
|
|
return new a(e, n, r);
|
|
}
|
|
}
|
|
function d(e, t) {
|
|
if (!t.type.compatibleContent(e.type))
|
|
throw new l("Cannot join " + t.type.name + " onto " + e.type.name);
|
|
}
|
|
function c(e, t, n) {
|
|
let r = e.node(n);
|
|
return d(r, t.node(n)), r;
|
|
}
|
|
function h(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 p(e, t, n, r) {
|
|
let i = (t || e).node(n),
|
|
o = 0,
|
|
s = t ? t.index(n) : i.childCount;
|
|
e &&
|
|
((o = e.index(n)),
|
|
e.depth > n ? o++ : e.textOffset && (h(e.nodeAfter, r), o++));
|
|
for (let e = o; e < s; e++) h(i.child(e), r);
|
|
t && t.depth == n && t.textOffset && h(t.nodeBefore, r);
|
|
}
|
|
function u(e, t) {
|
|
return e.type.checkContent(t), e.copy(t);
|
|
}
|
|
function f(e, t, r) {
|
|
let i = [];
|
|
return (
|
|
p(null, e, r, i),
|
|
e.depth > r && h(u(c(e, t, r + 1), f(e, t, r + 1)), i),
|
|
p(t, null, r, i),
|
|
new n(i)
|
|
);
|
|
}
|
|
a.empty = new a(n.empty, 0, 0);
|
|
class m {
|
|
constructor(e, t, n) {
|
|
(this.pos = e),
|
|
(this.path = t),
|
|
(this.parentOffset = n),
|
|
(this.depth = t.length / 3 - 1);
|
|
}
|
|
resolveDepth(e) {
|
|
return null == e ? 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[3 * this.resolveDepth(e)];
|
|
}
|
|
index(e) {
|
|
return this.path[3 * this.resolveDepth(e) + 1];
|
|
}
|
|
indexAfter(e) {
|
|
return (
|
|
(e = this.resolveDepth(e)),
|
|
this.index(e) + (e != this.depth || this.textOffset ? 1 : 0)
|
|
);
|
|
}
|
|
start(e) {
|
|
return 0 == (e = this.resolveDepth(e)) ? 0 : this.path[3 * e - 1] + 1;
|
|
}
|
|
end(e) {
|
|
return (
|
|
(e = this.resolveDepth(e)), this.start(e) + this.node(e).content.size
|
|
);
|
|
}
|
|
before(e) {
|
|
if (!(e = this.resolveDepth(e)))
|
|
throw RangeError("There is no position before the top-level node");
|
|
return e == this.depth + 1 ? this.pos : this.path[3 * e - 1];
|
|
}
|
|
after(e) {
|
|
if (!(e = this.resolveDepth(e)))
|
|
throw RangeError("There is no position after the top-level node");
|
|
return e == this.depth + 1
|
|
? this.pos
|
|
: this.path[3 * e - 1] + this.path[3 * e].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)
|
|
: 0 == e
|
|
? null
|
|
: this.parent.child(e - 1);
|
|
}
|
|
posAtIndex(e, t) {
|
|
t = this.resolveDepth(t);
|
|
let n = this.path[3 * t],
|
|
r = 0 == t ? 0 : this.path[3 * t - 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 (0 == e.content.size) return s.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 o = 0; o < i.length; o++)
|
|
!1 !== i[o].type.spec.inclusive ||
|
|
(r && i[o].isInSet(r.marks)) ||
|
|
(i = i[o--].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++)
|
|
!1 !== n[i].type.spec.inclusive ||
|
|
(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 k(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(e, t) {
|
|
if (!(t >= 0 && t <= e.content.size))
|
|
throw RangeError("Position " + t + " out of range");
|
|
let n = [],
|
|
r = 0,
|
|
i = t;
|
|
for (let t = e; ; ) {
|
|
let { index: e, offset: o } = t.content.findIndex(i),
|
|
s = i - o;
|
|
if ((n.push(t, e, r + o), !s || (t = t.child(e)).isText)) break;
|
|
(i = s - 1), (r += o + 1);
|
|
}
|
|
return new m(t, n, i);
|
|
}
|
|
static resolveCached(e, t) {
|
|
let n = b.get(e);
|
|
if (n)
|
|
for (let e = 0; e < n.elts.length; e++) {
|
|
let r = n.elts[e];
|
|
if (r.pos == t) return r;
|
|
}
|
|
else b.set(e, (n = new g()));
|
|
let r = (n.elts[n.i] = m.resolve(e, t));
|
|
return (n.i = (n.i + 1) % y), r;
|
|
}
|
|
}
|
|
class g {
|
|
constructor() {
|
|
(this.elts = []), (this.i = 0);
|
|
}
|
|
}
|
|
let y = 12,
|
|
b = new WeakMap();
|
|
class k {
|
|
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);
|
|
}
|
|
}
|
|
let v = Object.create(null);
|
|
class w {
|
|
constructor(e, t, r, i = s.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 &&
|
|
o(this.attrs, t || e.defaultAttrs || v) &&
|
|
s.sameSet(this.marks, n || s.none)
|
|
);
|
|
}
|
|
copy(e = null) {
|
|
return e == this.content
|
|
? this
|
|
: new w(this.type, this.attrs, e, this.marks);
|
|
}
|
|
mark(e) {
|
|
return e == this.marks
|
|
? this
|
|
: new w(this.type, this.attrs, this.content, e);
|
|
}
|
|
cut(e, t = this.content.size) {
|
|
return 0 == e && t == this.content.size
|
|
? this
|
|
: this.copy(this.content.cut(e, t));
|
|
}
|
|
slice(e, t = this.content.size, n = !1) {
|
|
if (e == t) return a.empty;
|
|
let r = this.resolve(e),
|
|
i = this.resolve(t),
|
|
o = n ? 0 : r.sharedDepth(t),
|
|
s = r.start(o);
|
|
return new a(
|
|
r.node(o).content.cut(r.pos - s, i.pos - s),
|
|
r.depth - o,
|
|
i.depth - o,
|
|
);
|
|
}
|
|
replace(e, t, r) {
|
|
var i = this.resolve(e),
|
|
o = this.resolve(t);
|
|
if (r.openStart > i.depth)
|
|
throw new l("Inserted content deeper than insertion position");
|
|
if (i.depth - r.openStart != o.depth - r.openEnd)
|
|
throw new l("Inconsistent open depths");
|
|
return (function e(t, r, i, o) {
|
|
let s = t.index(o),
|
|
l = t.node(o);
|
|
if (s == r.index(o) && o < t.depth - i.openStart) {
|
|
let n = e(t, r, i, o + 1);
|
|
return l.copy(l.content.replaceChild(s, n));
|
|
}
|
|
if (!i.content.size) return u(l, f(t, r, o));
|
|
if (i.openStart || i.openEnd || t.depth != o || r.depth != o) {
|
|
let { start: e, end: s } = (function (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),
|
|
};
|
|
})(i, t);
|
|
return u(
|
|
l,
|
|
(function e(t, r, i, o, s) {
|
|
let l = t.depth > s && c(t, r, s + 1),
|
|
a = o.depth > s && c(i, o, s + 1),
|
|
m = [];
|
|
return (
|
|
p(null, t, s, m),
|
|
l && a && r.index(s) == i.index(s)
|
|
? (d(l, a), h(u(l, e(t, r, i, o, s + 1)), m))
|
|
: (l && h(u(l, f(t, r, s + 1)), m),
|
|
p(r, i, s, m),
|
|
a && h(u(a, f(i, o, s + 1)), m)),
|
|
p(o, null, s, m),
|
|
new n(m)
|
|
);
|
|
})(t, e, s, r, o),
|
|
);
|
|
}
|
|
{
|
|
let e = t.parent,
|
|
n = e.content;
|
|
return u(
|
|
e,
|
|
n
|
|
.cut(0, t.parentOffset)
|
|
.append(i.content)
|
|
.append(n.cut(r.parentOffset)),
|
|
);
|
|
}
|
|
})(i, o, r, 0);
|
|
}
|
|
nodeAt(e) {
|
|
for (let t = this; ; ) {
|
|
let { index: n, offset: r } = t.content.findIndex(e);
|
|
if (!(t = t.maybeChild(n))) 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 (0 == e) 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 m.resolveCached(this, e);
|
|
}
|
|
resolveNoCache(e) {
|
|
return m.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() + ")"),
|
|
x(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, o = r.childCount) {
|
|
let s = this.contentMatchAt(e).matchFragment(r, i, o),
|
|
l = s && s.matchFragment(this.content, t);
|
|
if (!l || !l.validEnd) return !1;
|
|
for (let e = i; e < o; 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),
|
|
o = i && i.matchFragment(this.content, t);
|
|
return !!o && o.validEnd;
|
|
}
|
|
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 = s.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 (!s.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) {
|
|
let r;
|
|
if (!t) throw RangeError("Invalid input for Node.fromJSON");
|
|
if (t.marks) {
|
|
if (!Array.isArray(t.marks))
|
|
throw RangeError("Invalid mark data for Node.fromJSON");
|
|
r = t.marks.map(e.markFromJSON);
|
|
}
|
|
if ("text" == t.type) {
|
|
if ("string" != typeof t.text)
|
|
throw RangeError("Invalid text node in JSON");
|
|
return e.text(t.text, r);
|
|
}
|
|
let i = n.fromJSON(e, t.content),
|
|
o = e.nodeType(t.type).create(t.attrs, i, r);
|
|
return o.type.checkAttrs(o.attrs), o;
|
|
}
|
|
}
|
|
w.prototype.text = void 0;
|
|
class S extends w {
|
|
constructor(e, t, n, r) {
|
|
if ((super(e, t, null, r), !n))
|
|
throw RangeError("Empty text nodes are not allowed");
|
|
this.text = n;
|
|
}
|
|
toString() {
|
|
return this.type.spec.toDebugString
|
|
? this.type.spec.toDebugString(this)
|
|
: x(this.marks, JSON.stringify(this.text));
|
|
}
|
|
get textContent() {
|
|
return this.text;
|
|
}
|
|
textBetween(e, t) {
|
|
return this.text.slice(e, t);
|
|
}
|
|
get nodeSize() {
|
|
return this.text.length;
|
|
}
|
|
mark(e) {
|
|
return e == this.marks
|
|
? this
|
|
: new S(this.type, this.attrs, this.text, e);
|
|
}
|
|
withText(e) {
|
|
return e == this.text
|
|
? this
|
|
: new S(this.type, this.attrs, e, this.marks);
|
|
}
|
|
cut(e = 0, t = this.text.length) {
|
|
return 0 == e && t == this.text.length
|
|
? this
|
|
: this.withText(this.text.slice(e, t));
|
|
}
|
|
eq(e) {
|
|
return this.sameMarkup(e) && this.text == e.text;
|
|
}
|
|
toJSON() {
|
|
let e = super.toJSON();
|
|
return (e.text = this.text), e;
|
|
}
|
|
}
|
|
function x(e, t) {
|
|
for (let n = e.length - 1; n >= 0; n--)
|
|
t = e[n].type.name + "(" + t + ")";
|
|
return t;
|
|
}
|
|
class M {
|
|
constructor(e) {
|
|
(this.validEnd = e), (this.next = []), (this.wrapCache = []);
|
|
}
|
|
static parse(e, t) {
|
|
var n;
|
|
let r,
|
|
i = new C(e, t);
|
|
if (null == i.next) return M.empty;
|
|
let o = (function e(t) {
|
|
let n = [];
|
|
do
|
|
n.push(
|
|
(function (t) {
|
|
let n = [];
|
|
do
|
|
n.push(
|
|
(function (t) {
|
|
let n = (function (t) {
|
|
if (t.eat("(")) {
|
|
let n = e(t);
|
|
return (
|
|
t.eat(")") || t.err("Missing closing paren"), n
|
|
);
|
|
}
|
|
if (/\W/.test(t.next))
|
|
t.err("Unexpected token '" + t.next + "'");
|
|
else {
|
|
let e = (function (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 (
|
|
0 == i.length &&
|
|
e.err(
|
|
"No node type or group '" + t + "' found",
|
|
),
|
|
i
|
|
);
|
|
})(t, t.next).map(
|
|
(e) => (
|
|
null == t.inline
|
|
? (t.inline = e.isInline)
|
|
: t.inline != e.isInline &&
|
|
t.err("Mixing inline and block content"),
|
|
{ type: "name", value: e }
|
|
),
|
|
);
|
|
return (
|
|
t.pos++,
|
|
1 == e.length ? e[0] : { type: "choice", exprs: e }
|
|
);
|
|
}
|
|
})(t);
|
|
for (;;)
|
|
if (t.eat("+")) n = { type: "plus", expr: n };
|
|
else if (t.eat("*")) n = { type: "star", expr: n };
|
|
else if (t.eat("?")) n = { type: "opt", expr: n };
|
|
else if (t.eat("{"))
|
|
n = (function (e, t) {
|
|
let n = T(e),
|
|
r = n;
|
|
return (
|
|
e.eat(",") && (r = "}" != e.next ? T(e) : -1),
|
|
e.eat("}") || e.err("Unclosed braced range"),
|
|
{ type: "range", min: n, max: r, expr: t }
|
|
);
|
|
})(t, n);
|
|
else break;
|
|
return n;
|
|
})(t),
|
|
);
|
|
while (t.next && ")" != t.next && "|" != t.next);
|
|
return 1 == n.length ? n[0] : { type: "seq", exprs: n };
|
|
})(t),
|
|
);
|
|
while (t.eat("|"));
|
|
return 1 == n.length ? n[0] : { type: "choice", exprs: n };
|
|
})(i);
|
|
i.next && i.err("Unexpected trailing text");
|
|
let s =
|
|
((n = (function (e) {
|
|
let t = [[]];
|
|
return (
|
|
i(
|
|
(function e(t, o) {
|
|
if ("choice" == t.type)
|
|
return t.exprs.reduce((t, n) => t.concat(e(n, o)), []);
|
|
if ("seq" == t.type)
|
|
for (let r = 0; ; r++) {
|
|
let s = e(t.exprs[r], o);
|
|
if (r == t.exprs.length - 1) return s;
|
|
i(s, (o = n()));
|
|
}
|
|
else if ("star" == t.type) {
|
|
let s = n();
|
|
return r(o, s), i(e(t.expr, s), s), [r(s)];
|
|
} else if ("plus" == t.type) {
|
|
let s = n();
|
|
return i(e(t.expr, o), s), i(e(t.expr, s), s), [r(s)];
|
|
} else if ("opt" == t.type)
|
|
return [r(o)].concat(e(t.expr, o));
|
|
else if ("range" == t.type) {
|
|
let s = o;
|
|
for (let r = 0; r < t.min; r++) {
|
|
let r = n();
|
|
i(e(t.expr, s), r), (s = r);
|
|
}
|
|
if (-1 == t.max) i(e(t.expr, s), s);
|
|
else
|
|
for (let o = t.min; o < t.max; o++) {
|
|
let o = n();
|
|
r(s, o), i(e(t.expr, s), o), (s = o);
|
|
}
|
|
return [r(s)];
|
|
} else if ("name" == t.type) return [r(o, void 0, t.value)];
|
|
else throw Error("Unknown expr type");
|
|
})(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));
|
|
}
|
|
})(o)),
|
|
(r = Object.create(null)),
|
|
(function e(t) {
|
|
let i = [];
|
|
t.forEach((e) => {
|
|
n[e].forEach(({ term: e, to: t }) => {
|
|
let r;
|
|
if (e) {
|
|
for (let t = 0; t < i.length; t++)
|
|
i[t][0] == e && (r = i[t][1]);
|
|
E(n, t).forEach((t) => {
|
|
r || i.push([e, (r = [])]), -1 == r.indexOf(t) && r.push(t);
|
|
});
|
|
}
|
|
});
|
|
});
|
|
let o = (r[t.join(",")] = new M(t.indexOf(n.length - 1) > -1));
|
|
for (let t = 0; t < i.length; t++) {
|
|
let n = i[t][1].sort(N);
|
|
o.next.push({ type: i[t][0], next: r[n.join(",")] || e(n) });
|
|
}
|
|
return o;
|
|
})(E(n, 0)));
|
|
return (
|
|
(function (e, t) {
|
|
for (let n = 0, r = [e]; n < r.length; n++) {
|
|
let e = r[n],
|
|
i = !e.validEnd,
|
|
o = [];
|
|
for (let t = 0; t < e.next.length; t++) {
|
|
let { type: n, next: s } = e.next[t];
|
|
o.push(n.name),
|
|
i && !(n.isText || n.hasRequiredAttrs()) && (i = !1),
|
|
-1 == r.indexOf(s) && r.push(s);
|
|
}
|
|
i &&
|
|
t.err(
|
|
"Only non-generatable nodes (" +
|
|
o.join(", ") +
|
|
") in a required position (see https://prosemirror.net/docs/guide/#generatable)",
|
|
);
|
|
}
|
|
})(s, i),
|
|
s
|
|
);
|
|
}
|
|
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 0 != this.next.length && 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];
|
|
return (function o(s, l) {
|
|
let a = s.matchFragment(e, r);
|
|
if (a && (!t || a.validEnd))
|
|
return n.from(l.map((e) => e.createAndFill()));
|
|
for (let e = 0; e < s.next.length; e++) {
|
|
let { type: t, next: n } = s.next[e];
|
|
if (!(t.isText || t.hasRequiredAttrs()) && -1 == i.indexOf(n)) {
|
|
i.push(n);
|
|
let e = o(n, l.concat(t));
|
|
if (e) return e;
|
|
}
|
|
}
|
|
return null;
|
|
})(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: o, next: s } = i.next[e];
|
|
o.isLeaf ||
|
|
o.hasRequiredAttrs() ||
|
|
o.name in t ||
|
|
(r.type && !s.validEnd) ||
|
|
(n.push({ match: o.contentMatch, type: o, via: r }),
|
|
(t[o.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 = [];
|
|
return (
|
|
!(function t(n) {
|
|
e.push(n);
|
|
for (let r = 0; r < n.next.length; r++)
|
|
-1 == e.indexOf(n.next[r].next) && t(n.next[r].next);
|
|
})(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")
|
|
);
|
|
}
|
|
}
|
|
M.empty = new M(!0);
|
|
class C {
|
|
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 T(e) {
|
|
/\D/.test(e.next) && e.err("Expected number, got '" + e.next + "'");
|
|
let t = Number(e.next);
|
|
return e.pos++, t;
|
|
}
|
|
function N(e, t) {
|
|
return t - e;
|
|
}
|
|
function E(e, t) {
|
|
let n = [];
|
|
return (
|
|
(function t(r) {
|
|
let i = e[r];
|
|
if (1 == i.length && !i[0].term) return t(i[0].to);
|
|
n.push(r);
|
|
for (let e = 0; e < i.length; e++) {
|
|
let { term: r, to: o } = i[e];
|
|
r || -1 != n.indexOf(o) || t(o);
|
|
}
|
|
})(t),
|
|
n.sort(N)
|
|
);
|
|
}
|
|
function O(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 A(e, t) {
|
|
let n = Object.create(null);
|
|
for (let r in e) {
|
|
let i = t && t[r];
|
|
if (void 0 === i) {
|
|
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 D(e, t, n, r) {
|
|
for (let r in t)
|
|
if (!(r in e))
|
|
throw RangeError(`Unsupported attribute ${r} for ${n} of type ${r}`);
|
|
for (let n in e) {
|
|
let r = e[n];
|
|
r.validate && r.validate(t[n]);
|
|
}
|
|
}
|
|
function R(e, t) {
|
|
let n = Object.create(null);
|
|
if (t) for (let r in t) n[r] = new P(e, r, t[r]);
|
|
return n;
|
|
}
|
|
class I {
|
|
constructor(e, t, n) {
|
|
(this.name = e),
|
|
(this.schema = t),
|
|
(this.spec = n),
|
|
(this.markSet = null),
|
|
(this.groups = n.group ? n.group.split(" ") : []),
|
|
(this.attrs = R(e, n.attrs)),
|
|
(this.defaultAttrs = O(this.attrs)),
|
|
(this.contentMatch = null),
|
|
(this.inlineContent = null),
|
|
(this.isBlock = !(n.inline || "text" == e)),
|
|
(this.isText = "text" == e);
|
|
}
|
|
get isInline() {
|
|
return !this.isBlock;
|
|
}
|
|
get isTextblock() {
|
|
return this.isBlock && this.inlineContent;
|
|
}
|
|
get isLeaf() {
|
|
return this.contentMatch == M.empty;
|
|
}
|
|
get isAtom() {
|
|
return this.isLeaf || !!this.spec.atom;
|
|
}
|
|
isInGroup(e) {
|
|
return this.groups.indexOf(e) > -1;
|
|
}
|
|
get whitespace() {
|
|
return this.spec.whitespace || (this.spec.code ? "pre" : "normal");
|
|
}
|
|
hasRequiredAttrs() {
|
|
for (let e in this.attrs) if (this.attrs[e].isRequired) return !0;
|
|
return !1;
|
|
}
|
|
compatibleContent(e) {
|
|
return this == e || this.contentMatch.compatible(e.contentMatch);
|
|
}
|
|
computeAttrs(e) {
|
|
return !e && this.defaultAttrs ? this.defaultAttrs : A(this.attrs, e);
|
|
}
|
|
create(e = null, t, r) {
|
|
if (this.isText)
|
|
throw Error("NodeType.create can't construct text nodes");
|
|
return new w(this, this.computeAttrs(e), n.from(t), s.setFrom(r));
|
|
}
|
|
createChecked(e = null, t, r) {
|
|
return (
|
|
(t = n.from(t)),
|
|
this.checkContent(t),
|
|
new w(this, this.computeAttrs(e), t, s.setFrom(r))
|
|
);
|
|
}
|
|
createAndFill(e = null, t, r) {
|
|
if (((e = this.computeAttrs(e)), (t = n.from(t)).size)) {
|
|
let e = this.contentMatch.fillBefore(t);
|
|
if (!e) return null;
|
|
t = e.append(t);
|
|
}
|
|
let i = this.contentMatch.matchFragment(t),
|
|
o = i && i.fillBefore(n.empty, !0);
|
|
return o ? new w(this, e, t.append(o), s.setFrom(r)) : null;
|
|
}
|
|
validContent(e) {
|
|
let t = this.contentMatch.matchFragment(e);
|
|
if (!t || !t.validEnd) return !1;
|
|
for (let t = 0; t < e.childCount; t++)
|
|
if (!this.allowsMarks(e.child(t).marks)) return !1;
|
|
return !0;
|
|
}
|
|
checkContent(e) {
|
|
if (!this.validContent(e))
|
|
throw RangeError(
|
|
`Invalid content for node ${this.name}: ${e.toString().slice(0, 50)}`,
|
|
);
|
|
}
|
|
checkAttrs(e) {
|
|
D(this.attrs, e, "node", this.name);
|
|
}
|
|
allowsMarkType(e) {
|
|
return null == this.markSet || this.markSet.indexOf(e) > -1;
|
|
}
|
|
allowsMarks(e) {
|
|
if (null == this.markSet) return !0;
|
|
for (let t = 0; t < e.length; t++)
|
|
if (!this.allowsMarkType(e[t].type)) return !1;
|
|
return !0;
|
|
}
|
|
allowedMarks(e) {
|
|
let t;
|
|
if (null == this.markSet) return e;
|
|
for (let n = 0; n < e.length; n++)
|
|
this.allowsMarkType(e[n].type)
|
|
? t && t.push(e[n])
|
|
: t || (t = e.slice(0, n));
|
|
return t ? (t.length ? t : s.none) : e;
|
|
}
|
|
static compile(e, t) {
|
|
let n = Object.create(null);
|
|
e.forEach((e, r) => (n[e] = new I(e, t, r)));
|
|
let r = t.spec.topNode || "doc";
|
|
if (!n[r])
|
|
throw RangeError("Schema is missing its top node type ('" + r + "')");
|
|
if (!n.text) throw RangeError("Every schema needs a 'text' type");
|
|
for (let e in n.text.attrs)
|
|
throw RangeError("The text node type should not have attributes");
|
|
return n;
|
|
}
|
|
}
|
|
class P {
|
|
constructor(e, t, n) {
|
|
(this.hasDefault = Object.prototype.hasOwnProperty.call(n, "default")),
|
|
(this.default = n.default),
|
|
(this.validate =
|
|
"string" == typeof n.validate
|
|
? (function (e, t, n) {
|
|
let r = n.split("|");
|
|
return (n) => {
|
|
let i = null === n ? "null" : typeof n;
|
|
if (0 > r.indexOf(i))
|
|
throw RangeError(
|
|
`Expected value of type ${r} for attribute ${t} on type ${e}, got ${i}`,
|
|
);
|
|
};
|
|
})(e, t, n.validate)
|
|
: n.validate);
|
|
}
|
|
get isRequired() {
|
|
return !this.hasDefault;
|
|
}
|
|
}
|
|
class L {
|
|
constructor(e, t, n, r) {
|
|
(this.name = e),
|
|
(this.rank = t),
|
|
(this.schema = n),
|
|
(this.spec = r),
|
|
(this.attrs = R(e, r.attrs)),
|
|
(this.excluded = null);
|
|
let i = O(this.attrs);
|
|
this.instance = i ? new s(this, i) : null;
|
|
}
|
|
create(e = null) {
|
|
return !e && this.instance
|
|
? this.instance
|
|
: new s(this, A(this.attrs, e));
|
|
}
|
|
static compile(e, t) {
|
|
let n = Object.create(null),
|
|
r = 0;
|
|
return e.forEach((e, i) => (n[e] = new L(e, r++, t, i))), n;
|
|
}
|
|
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) {
|
|
D(this.attrs, e, "mark", this.name);
|
|
}
|
|
excludes(e) {
|
|
return this.excluded.indexOf(e) > -1;
|
|
}
|
|
}
|
|
class z {
|
|
constructor(e) {
|
|
(this.linebreakReplacement = null), (this.cached = Object.create(null));
|
|
let n = (this.spec = {});
|
|
for (let t in e) n[t] = e[t];
|
|
(n.nodes = t.from(e.nodes)),
|
|
(n.marks = t.from(e.marks || {})),
|
|
(this.nodes = I.compile(this.spec.nodes, this)),
|
|
(this.marks = L.compile(this.spec.marks, this));
|
|
let r = Object.create(null);
|
|
for (let e in this.nodes) {
|
|
if (e in this.marks)
|
|
throw RangeError(e + " can not be both a node and a mark");
|
|
let t = this.nodes[e],
|
|
n = t.spec.content || "",
|
|
i = t.spec.marks;
|
|
if (
|
|
((t.contentMatch = r[n] || (r[n] = M.parse(n, this.nodes))),
|
|
(t.inlineContent = t.contentMatch.inlineContent),
|
|
t.spec.linebreakReplacement)
|
|
) {
|
|
if (this.linebreakReplacement)
|
|
throw RangeError("Multiple linebreak nodes defined");
|
|
if (!t.isInline || !t.isLeaf)
|
|
throw RangeError(
|
|
"Linebreak replacement nodes must be inline leaf nodes",
|
|
);
|
|
this.linebreakReplacement = t;
|
|
}
|
|
t.markSet =
|
|
"_" == i
|
|
? null
|
|
: i
|
|
? B(this, i.split(" "))
|
|
: "" != i && t.inlineContent
|
|
? null
|
|
: [];
|
|
}
|
|
for (let e in this.marks) {
|
|
let t = this.marks[e],
|
|
n = t.spec.excludes;
|
|
t.excluded = null == n ? [t] : "" == n ? [] : B(this, n.split(" "));
|
|
}
|
|
(this.nodeFromJSON = (e) => w.fromJSON(this, e)),
|
|
(this.markFromJSON = (e) => s.fromJSON(this, e)),
|
|
(this.topNodeType = this.nodes[this.spec.topNode || "doc"]),
|
|
(this.cached.wrappings = Object.create(null));
|
|
}
|
|
node(e, t = null, n, r) {
|
|
if ("string" == typeof e) e = this.nodeType(e);
|
|
else if (e instanceof I) {
|
|
if (e.schema != this)
|
|
throw RangeError(
|
|
"Node type from different schema used (" + e.name + ")",
|
|
);
|
|
} else throw RangeError("Invalid node type: " + e);
|
|
return e.createChecked(t, n, r);
|
|
}
|
|
text(e, t) {
|
|
let n = this.nodes.text;
|
|
return new S(n, n.defaultAttrs, e, s.setFrom(t));
|
|
}
|
|
mark(e, t) {
|
|
return "string" == typeof e && (e = this.marks[e]), e.create(t);
|
|
}
|
|
nodeType(e) {
|
|
let t = this.nodes[e];
|
|
if (!t) throw RangeError("Unknown node type: " + e);
|
|
return t;
|
|
}
|
|
}
|
|
function B(e, t) {
|
|
let n = [];
|
|
for (let r = 0; r < t.length; r++) {
|
|
let i = t[r],
|
|
o = e.marks[i],
|
|
s = o;
|
|
if (o) n.push(o);
|
|
else
|
|
for (let t in e.marks) {
|
|
let r = e.marks[t];
|
|
("_" == i ||
|
|
(r.spec.group && r.spec.group.split(" ").indexOf(i) > -1)) &&
|
|
n.push((s = r));
|
|
}
|
|
if (!s) throw SyntaxError("Unknown mark type: '" + t[r] + "'");
|
|
}
|
|
return n;
|
|
}
|
|
class $ {
|
|
constructor(e, t) {
|
|
(this.schema = e),
|
|
(this.rules = t),
|
|
(this.tags = []),
|
|
(this.styles = []);
|
|
let n = (this.matchedStyles = []);
|
|
t.forEach((e) => {
|
|
if (null != e.tag) this.tags.push(e);
|
|
else if (null != e.style) {
|
|
let t = /[^=]*/.exec(e.style)[0];
|
|
0 > n.indexOf(t) && n.push(t), this.styles.push(e);
|
|
}
|
|
}),
|
|
(this.normalizeLists = !this.tags.some((t) => {
|
|
if (!/^(ul|ol)\b/.test(t.tag) || !t.node) return !1;
|
|
let n = e.nodes[t.node];
|
|
return n.contentMatch.matchType(n);
|
|
}));
|
|
}
|
|
parse(e, t = {}) {
|
|
let n = new _(this, t, !1);
|
|
return n.addAll(e, s.none, t.from, t.to), n.finish();
|
|
}
|
|
parseSlice(e, t = {}) {
|
|
let n = new _(this, t, !0);
|
|
return n.addAll(e, s.none, t.from, t.to), a.maxOpen(n.finish());
|
|
}
|
|
matchTag(e, t, n) {
|
|
for (
|
|
let o = n ? this.tags.indexOf(n) + 1 : 0;
|
|
o < this.tags.length;
|
|
o++
|
|
) {
|
|
var r, i;
|
|
let n = this.tags[o];
|
|
if (
|
|
((r = e),
|
|
(i = n.tag),
|
|
(
|
|
r.matches ||
|
|
r.msMatchesSelector ||
|
|
r.webkitMatchesSelector ||
|
|
r.mozMatchesSelector
|
|
).call(r, i) &&
|
|
(void 0 === n.namespace || e.namespaceURI == n.namespace) &&
|
|
(!n.context || t.matchesContext(n.context)))
|
|
) {
|
|
if (n.getAttrs) {
|
|
let t = n.getAttrs(e);
|
|
if (!1 === t) continue;
|
|
n.attrs = t || void 0;
|
|
}
|
|
return n;
|
|
}
|
|
}
|
|
}
|
|
matchStyle(e, t, n, r) {
|
|
for (
|
|
let i = r ? this.styles.indexOf(r) + 1 : 0;
|
|
i < this.styles.length;
|
|
i++
|
|
) {
|
|
let r = this.styles[i],
|
|
o = r.style;
|
|
if (
|
|
0 == o.indexOf(e) &&
|
|
(!r.context || n.matchesContext(r.context)) &&
|
|
(!(o.length > e.length) ||
|
|
(61 == o.charCodeAt(e.length) && o.slice(e.length + 1) == t))
|
|
) {
|
|
if (r.getAttrs) {
|
|
let e = r.getAttrs(t);
|
|
if (!1 === e) continue;
|
|
r.attrs = e || void 0;
|
|
}
|
|
return r;
|
|
}
|
|
}
|
|
}
|
|
static schemaRules(e) {
|
|
let t = [];
|
|
function n(e) {
|
|
let n = null == e.priority ? 50 : e.priority,
|
|
r = 0;
|
|
for (; r < t.length; r++) {
|
|
let e = t[r];
|
|
if ((null == e.priority ? 50 : e.priority) < n) break;
|
|
}
|
|
t.splice(r, 0, e);
|
|
}
|
|
for (let t in e.marks) {
|
|
let r = e.marks[t].spec.parseDOM;
|
|
r &&
|
|
r.forEach((e) => {
|
|
n((e = q(e))), e.mark || e.ignore || e.clearMark || (e.mark = t);
|
|
});
|
|
}
|
|
for (let t in e.nodes) {
|
|
let r = e.nodes[t].spec.parseDOM;
|
|
r &&
|
|
r.forEach((e) => {
|
|
n((e = q(e))), e.node || e.ignore || e.mark || (e.node = t);
|
|
});
|
|
}
|
|
return t;
|
|
}
|
|
static fromSchema(e) {
|
|
return (
|
|
e.cached.domParser ||
|
|
(e.cached.domParser = new $(e, $.schemaRules(e)))
|
|
);
|
|
}
|
|
}
|
|
let j = {
|
|
address: !0,
|
|
article: !0,
|
|
aside: !0,
|
|
blockquote: !0,
|
|
canvas: !0,
|
|
dd: !0,
|
|
div: !0,
|
|
dl: !0,
|
|
fieldset: !0,
|
|
figcaption: !0,
|
|
figure: !0,
|
|
footer: !0,
|
|
form: !0,
|
|
h1: !0,
|
|
h2: !0,
|
|
h3: !0,
|
|
h4: !0,
|
|
h5: !0,
|
|
h6: !0,
|
|
header: !0,
|
|
hgroup: !0,
|
|
hr: !0,
|
|
li: !0,
|
|
noscript: !0,
|
|
ol: !0,
|
|
output: !0,
|
|
p: !0,
|
|
pre: !0,
|
|
section: !0,
|
|
table: !0,
|
|
tfoot: !0,
|
|
ul: !0,
|
|
},
|
|
F = {
|
|
head: !0,
|
|
noscript: !0,
|
|
object: !0,
|
|
script: !0,
|
|
style: !0,
|
|
title: !0,
|
|
},
|
|
V = { ol: !0, ul: !0 };
|
|
function H(e, t, n) {
|
|
return null != t
|
|
? !!t | (2 * ("full" === t))
|
|
: e && "pre" == e.whitespace
|
|
? 3
|
|
: -5 & n;
|
|
}
|
|
class W {
|
|
constructor(e, t, n, r, i, o) {
|
|
(this.type = e),
|
|
(this.attrs = t),
|
|
(this.marks = n),
|
|
(this.solid = r),
|
|
(this.options = o),
|
|
(this.content = []),
|
|
(this.activeMarks = s.none),
|
|
(this.match = i || (4 & o ? null : e.contentMatch));
|
|
}
|
|
findWrapping(e) {
|
|
if (!this.match) {
|
|
if (!this.type) return [];
|
|
let t = this.type.contentMatch.fillBefore(n.from(e));
|
|
if (t) this.match = this.type.contentMatch.matchFragment(t);
|
|
else {
|
|
let t = this.type.contentMatch,
|
|
n;
|
|
return (n = t.findWrapping(e.type)) ? ((this.match = t), n) : null;
|
|
}
|
|
}
|
|
return this.match.findWrapping(e.type);
|
|
}
|
|
finish(e) {
|
|
if (!(1 & this.options)) {
|
|
let e = this.content[this.content.length - 1],
|
|
t;
|
|
e &&
|
|
e.isText &&
|
|
(t = /[ \t\r\n\u000c]+$/.exec(e.text)) &&
|
|
(e.text.length == t[0].length
|
|
? this.content.pop()
|
|
: (this.content[this.content.length - 1] = e.withText(
|
|
e.text.slice(0, e.text.length - t[0].length),
|
|
)));
|
|
}
|
|
let t = n.from(this.content);
|
|
return (
|
|
!e &&
|
|
this.match &&
|
|
(t = t.append(this.match.fillBefore(n.empty, !0))),
|
|
this.type ? this.type.create(this.attrs, t, this.marks) : t
|
|
);
|
|
}
|
|
inlineContext(e) {
|
|
return this.type
|
|
? this.type.inlineContent
|
|
: this.content.length
|
|
? this.content[0].isInline
|
|
: e.parentNode &&
|
|
!j.hasOwnProperty(e.parentNode.nodeName.toLowerCase());
|
|
}
|
|
}
|
|
class _ {
|
|
constructor(e, t, n) {
|
|
(this.parser = e),
|
|
(this.options = t),
|
|
(this.isOpen = n),
|
|
(this.open = 0),
|
|
(this.localPreserveWS = !1);
|
|
let r = t.topNode,
|
|
i,
|
|
o = H(null, t.preserveWhitespace, 0) | (4 * !!n);
|
|
(i = r
|
|
? new W(
|
|
r.type,
|
|
r.attrs,
|
|
s.none,
|
|
!0,
|
|
t.topMatch || r.type.contentMatch,
|
|
o,
|
|
)
|
|
: n
|
|
? new W(null, null, s.none, !0, null, o)
|
|
: new W(e.schema.topNodeType, null, s.none, !0, null, o)),
|
|
(this.nodes = [i]),
|
|
(this.find = t.findPositions),
|
|
(this.needsBlock = !1);
|
|
}
|
|
get top() {
|
|
return this.nodes[this.open];
|
|
}
|
|
addDOM(e, t) {
|
|
3 == e.nodeType
|
|
? this.addTextNode(e, t)
|
|
: 1 == e.nodeType && this.addElement(e, t);
|
|
}
|
|
addTextNode(e, t) {
|
|
let n = e.nodeValue,
|
|
r = this.top,
|
|
i =
|
|
2 & r.options
|
|
? "full"
|
|
: this.localPreserveWS || (1 & r.options) > 0,
|
|
{ schema: o } = this.parser;
|
|
if ("full" === i || r.inlineContext(e) || /[^ \t\r\n\u000c]/.test(n)) {
|
|
if (i)
|
|
if ("full" === i) n = n.replace(/\r\n?/g, "\n");
|
|
else if (
|
|
o.linebreakReplacement &&
|
|
/[\r\n]/.test(n) &&
|
|
this.top.findWrapping(o.linebreakReplacement.create())
|
|
) {
|
|
let e = n.split(/\r?\n|\r/);
|
|
for (let n = 0; n < e.length; n++)
|
|
n && this.insertNode(o.linebreakReplacement.create(), t, !0),
|
|
e[n] && this.insertNode(o.text(e[n]), t, !/\S/.test(e[n]));
|
|
n = "";
|
|
} else n = n.replace(/\r?\n|\r/g, " ");
|
|
else if (
|
|
((n = n.replace(/[ \t\r\n\u000c]+/g, " ")),
|
|
/^[ \t\r\n\u000c]/.test(n) && this.open == this.nodes.length - 1)
|
|
) {
|
|
let t = r.content[r.content.length - 1],
|
|
i = e.previousSibling;
|
|
(!t ||
|
|
(i && "BR" == i.nodeName) ||
|
|
(t.isText && /[ \t\r\n\u000c]$/.test(t.text))) &&
|
|
(n = n.slice(1));
|
|
}
|
|
n && this.insertNode(o.text(n), t, !/\S/.test(n)), this.findInText(e);
|
|
} else this.findInside(e);
|
|
}
|
|
addElement(e, t, n) {
|
|
let r = this.localPreserveWS,
|
|
i = this.top;
|
|
("PRE" == e.tagName || /pre/.test(e.style && e.style.whiteSpace)) &&
|
|
(this.localPreserveWS = !0);
|
|
let o = e.nodeName.toLowerCase(),
|
|
s;
|
|
V.hasOwnProperty(o) &&
|
|
this.parser.normalizeLists &&
|
|
(function (e) {
|
|
for (let t = e.firstChild, n = null; t; t = t.nextSibling) {
|
|
let e = 1 == t.nodeType ? t.nodeName.toLowerCase() : null;
|
|
e && V.hasOwnProperty(e) && n
|
|
? (n.appendChild(t), (t = n))
|
|
: "li" == e
|
|
? (n = t)
|
|
: e && (n = null);
|
|
}
|
|
})(e);
|
|
let l =
|
|
(this.options.ruleFromNode && this.options.ruleFromNode(e)) ||
|
|
(s = this.parser.matchTag(e, this, n));
|
|
e: if (l ? l.ignore : F.hasOwnProperty(o))
|
|
this.findInside(e), this.ignoreFallback(e, t);
|
|
else if (!l || l.skip || l.closeParent) {
|
|
l && l.closeParent
|
|
? (this.open = Math.max(0, this.open - 1))
|
|
: l && l.skip.nodeType && (e = l.skip);
|
|
let n,
|
|
r = this.needsBlock;
|
|
if (j.hasOwnProperty(o))
|
|
i.content.length &&
|
|
i.content[0].isInline &&
|
|
this.open &&
|
|
(this.open--, (i = this.top)),
|
|
(n = !0),
|
|
i.type || (this.needsBlock = !0);
|
|
else if (!e.firstChild) {
|
|
this.leafFallback(e, t);
|
|
break e;
|
|
}
|
|
let s = l && l.skip ? t : this.readStyles(e, t);
|
|
s && this.addAll(e, s), n && this.sync(i), (this.needsBlock = r);
|
|
} else {
|
|
let n = this.readStyles(e, t);
|
|
n && this.addElementByRule(e, l, n, !1 === l.consuming ? s : void 0);
|
|
}
|
|
this.localPreserveWS = r;
|
|
}
|
|
leafFallback(e, t) {
|
|
"BR" == e.nodeName &&
|
|
this.top.type &&
|
|
this.top.type.inlineContent &&
|
|
this.addTextNode(e.ownerDocument.createTextNode("\n"), t);
|
|
}
|
|
ignoreFallback(e, t) {
|
|
"BR" != e.nodeName ||
|
|
(this.top.type && this.top.type.inlineContent) ||
|
|
this.findPlace(this.parser.schema.text("-"), t, !0);
|
|
}
|
|
readStyles(e, t) {
|
|
let n = e.style;
|
|
if (n && n.length)
|
|
for (let e = 0; e < this.parser.matchedStyles.length; e++) {
|
|
let r = this.parser.matchedStyles[e],
|
|
i = n.getPropertyValue(r);
|
|
if (i)
|
|
for (let e; ; ) {
|
|
let n = this.parser.matchStyle(r, i, this, e);
|
|
if (!n) break;
|
|
if (n.ignore) return null;
|
|
if (
|
|
((t = n.clearMark
|
|
? t.filter((e) => !n.clearMark(e))
|
|
: t.concat(
|
|
this.parser.schema.marks[n.mark].create(n.attrs),
|
|
)),
|
|
!1 === n.consuming)
|
|
)
|
|
e = n;
|
|
else break;
|
|
}
|
|
}
|
|
return t;
|
|
}
|
|
addElementByRule(e, t, n, r) {
|
|
let i, o;
|
|
if (t.node)
|
|
if ((o = this.parser.schema.nodes[t.node]).isLeaf)
|
|
this.insertNode(o.create(t.attrs), n, "BR" == e.nodeName) ||
|
|
this.leafFallback(e, n);
|
|
else {
|
|
let e = this.enter(o, t.attrs || null, n, t.preserveWhitespace);
|
|
e && ((i = !0), (n = e));
|
|
}
|
|
else {
|
|
let e = this.parser.schema.marks[t.mark];
|
|
n = n.concat(e.create(t.attrs));
|
|
}
|
|
let s = this.top;
|
|
if (o && o.isLeaf) this.findInside(e);
|
|
else if (r) this.addElement(e, n, r);
|
|
else if (t.getContent)
|
|
this.findInside(e),
|
|
t
|
|
.getContent(e, this.parser.schema)
|
|
.forEach((e) => this.insertNode(e, n, !1));
|
|
else {
|
|
let r = e;
|
|
"string" == typeof t.contentElement
|
|
? (r = e.querySelector(t.contentElement))
|
|
: "function" == typeof t.contentElement
|
|
? (r = t.contentElement(e))
|
|
: t.contentElement && (r = t.contentElement),
|
|
this.findAround(e, r, !0),
|
|
this.addAll(r, n),
|
|
this.findAround(e, r, !1);
|
|
}
|
|
i && this.sync(s) && this.open--;
|
|
}
|
|
addAll(e, t, n, r) {
|
|
let i = n || 0;
|
|
for (
|
|
let o = n ? e.childNodes[n] : e.firstChild,
|
|
s = null == r ? null : e.childNodes[r];
|
|
o != s;
|
|
o = o.nextSibling, ++i
|
|
)
|
|
this.findAtPoint(e, i), this.addDOM(o, t);
|
|
this.findAtPoint(e, i);
|
|
}
|
|
findPlace(e, t, n) {
|
|
let r, i;
|
|
for (let t = this.open, o = 0; t >= 0; t--) {
|
|
let s = this.nodes[t],
|
|
l = s.findWrapping(e);
|
|
if (
|
|
l &&
|
|
(!r || r.length > l.length + o) &&
|
|
((r = l), (i = s), !l.length)
|
|
)
|
|
break;
|
|
if (s.solid) {
|
|
if (n) break;
|
|
o += 2;
|
|
}
|
|
}
|
|
if (!r) return null;
|
|
this.sync(i);
|
|
for (let e = 0; e < r.length; e++)
|
|
t = this.enterInner(r[e], null, t, !1);
|
|
return t;
|
|
}
|
|
insertNode(e, t, n) {
|
|
if (e.isInline && this.needsBlock && !this.top.type) {
|
|
let e = this.textblockFromContext();
|
|
e && (t = this.enterInner(e, null, t));
|
|
}
|
|
let r = this.findPlace(e, t, n);
|
|
if (r) {
|
|
this.closeExtra();
|
|
let t = this.top;
|
|
t.match && (t.match = t.match.matchType(e.type));
|
|
let n = s.none;
|
|
for (let i of r.concat(e.marks))
|
|
(t.type ? t.type.allowsMarkType(i.type) : K(i.type, e.type)) &&
|
|
(n = i.addToSet(n));
|
|
return t.content.push(e.mark(n)), !0;
|
|
}
|
|
return !1;
|
|
}
|
|
enter(e, t, n, r) {
|
|
let i = this.findPlace(e.create(t), n, !1);
|
|
return i && (i = this.enterInner(e, t, n, !0, r)), i;
|
|
}
|
|
enterInner(e, t, n, r = !1, i) {
|
|
this.closeExtra();
|
|
let o = this.top;
|
|
o.match = o.match && o.match.matchType(e);
|
|
let l = H(e, i, o.options);
|
|
4 & o.options && 0 == o.content.length && (l |= 4);
|
|
let a = s.none;
|
|
return (
|
|
(n = n.filter(
|
|
(t) =>
|
|
(o.type ? !o.type.allowsMarkType(t.type) : !K(t.type, e)) ||
|
|
((a = t.addToSet(a)), !1),
|
|
)),
|
|
this.nodes.push(new W(e, t, a, r, null, l)),
|
|
this.open++,
|
|
n
|
|
);
|
|
}
|
|
closeExtra(e = !1) {
|
|
let t = this.nodes.length - 1;
|
|
if (t > this.open) {
|
|
for (; t > this.open; t--)
|
|
this.nodes[t - 1].content.push(this.nodes[t].finish(e));
|
|
this.nodes.length = this.open + 1;
|
|
}
|
|
}
|
|
finish() {
|
|
return (
|
|
(this.open = 0),
|
|
this.closeExtra(this.isOpen),
|
|
this.nodes[0].finish(!!(this.isOpen || this.options.topOpen))
|
|
);
|
|
}
|
|
sync(e) {
|
|
for (let t = this.open; t >= 0; t--)
|
|
if (this.nodes[t] == e) return (this.open = t), !0;
|
|
else this.localPreserveWS && (this.nodes[t].options |= 1);
|
|
return !1;
|
|
}
|
|
get currentPos() {
|
|
this.closeExtra();
|
|
let e = 0;
|
|
for (let t = this.open; t >= 0; t--) {
|
|
let n = this.nodes[t].content;
|
|
for (let t = n.length - 1; t >= 0; t--) e += n[t].nodeSize;
|
|
t && e++;
|
|
}
|
|
return e;
|
|
}
|
|
findAtPoint(e, t) {
|
|
if (this.find)
|
|
for (let n = 0; n < this.find.length; n++)
|
|
this.find[n].node == e &&
|
|
this.find[n].offset == t &&
|
|
(this.find[n].pos = this.currentPos);
|
|
}
|
|
findInside(e) {
|
|
if (this.find)
|
|
for (let t = 0; t < this.find.length; t++)
|
|
null == this.find[t].pos &&
|
|
1 == e.nodeType &&
|
|
e.contains(this.find[t].node) &&
|
|
(this.find[t].pos = this.currentPos);
|
|
}
|
|
findAround(e, t, n) {
|
|
if (e != t && this.find)
|
|
for (let r = 0; r < this.find.length; r++)
|
|
null == this.find[r].pos &&
|
|
1 == e.nodeType &&
|
|
e.contains(this.find[r].node) &&
|
|
t.compareDocumentPosition(this.find[r].node) & (n ? 2 : 4) &&
|
|
(this.find[r].pos = this.currentPos);
|
|
}
|
|
findInText(e) {
|
|
if (this.find)
|
|
for (let t = 0; t < this.find.length; t++)
|
|
this.find[t].node == e &&
|
|
(this.find[t].pos =
|
|
this.currentPos - (e.nodeValue.length - this.find[t].offset));
|
|
}
|
|
matchesContext(e) {
|
|
if (e.indexOf("|") > -1)
|
|
return e.split(/\s*\|\s*/).some(this.matchesContext, this);
|
|
let t = e.split("/"),
|
|
n = this.options.context,
|
|
r = !this.isOpen && (!n || n.parent.type == this.nodes[0].type),
|
|
i = -(n ? n.depth + 1 : 0) + +!r,
|
|
o = (e, s) => {
|
|
for (; e >= 0; e--) {
|
|
let l = t[e];
|
|
if ("" == l) {
|
|
if (e == t.length - 1 || 0 == e) continue;
|
|
for (; s >= i; s--) if (o(e - 1, s)) return !0;
|
|
return !1;
|
|
}
|
|
{
|
|
let e =
|
|
s > 0 || (0 == s && r)
|
|
? this.nodes[s].type
|
|
: n && s >= i
|
|
? n.node(s - i).type
|
|
: null;
|
|
if (!e || (e.name != l && !e.isInGroup(l))) return !1;
|
|
s--;
|
|
}
|
|
}
|
|
return !0;
|
|
};
|
|
return o(t.length - 1, this.open);
|
|
}
|
|
textblockFromContext() {
|
|
let e = this.options.context;
|
|
if (e)
|
|
for (let t = e.depth; t >= 0; t--) {
|
|
let n = e.node(t).contentMatchAt(e.indexAfter(t)).defaultType;
|
|
if (n && n.isTextblock && n.defaultAttrs) return n;
|
|
}
|
|
for (let e in this.parser.schema.nodes) {
|
|
let t = this.parser.schema.nodes[e];
|
|
if (t.isTextblock && t.defaultAttrs) return t;
|
|
}
|
|
}
|
|
}
|
|
function q(e) {
|
|
let t = {};
|
|
for (let n in e) t[n] = e[n];
|
|
return t;
|
|
}
|
|
function K(e, t) {
|
|
let n = t.schema.nodes;
|
|
for (let r in n) {
|
|
let i = n[r];
|
|
if (!i.allowsMarkType(e)) continue;
|
|
let o = [],
|
|
s = (e) => {
|
|
o.push(e);
|
|
for (let n = 0; n < e.edgeCount; n++) {
|
|
let { type: r, next: i } = e.edge(n);
|
|
if (r == t || (0 > o.indexOf(i) && s(i))) return !0;
|
|
}
|
|
};
|
|
if (s(i.contentMatch)) return !0;
|
|
}
|
|
}
|
|
class U {
|
|
constructor(e, t) {
|
|
(this.nodes = e), (this.marks = t);
|
|
}
|
|
serializeFragment(e, t = {}, n) {
|
|
n || (n = G(t).createDocumentFragment());
|
|
let r = n,
|
|
i = [];
|
|
return (
|
|
e.forEach((e) => {
|
|
if (i.length || e.marks.length) {
|
|
let n = 0,
|
|
o = 0;
|
|
for (; n < i.length && o < e.marks.length; ) {
|
|
let t = e.marks[o];
|
|
if (!this.marks[t.type.name]) {
|
|
o++;
|
|
continue;
|
|
}
|
|
if (!t.eq(i[n][0]) || !1 === t.type.spec.spanning) break;
|
|
n++, o++;
|
|
}
|
|
for (; n < i.length; ) r = i.pop()[1];
|
|
for (; o < e.marks.length; ) {
|
|
let n = e.marks[o++],
|
|
s = this.serializeMark(n, e.isInline, t);
|
|
s &&
|
|
(i.push([n, r]),
|
|
r.appendChild(s.dom),
|
|
(r = s.contentDOM || s.dom));
|
|
}
|
|
}
|
|
r.appendChild(this.serializeNodeInner(e, t));
|
|
}),
|
|
n
|
|
);
|
|
}
|
|
serializeNodeInner(e, t) {
|
|
let { dom: n, contentDOM: r } = Q(
|
|
G(t),
|
|
this.nodes[e.type.name](e),
|
|
null,
|
|
e.attrs,
|
|
);
|
|
if (r) {
|
|
if (e.isLeaf)
|
|
throw RangeError("Content hole not allowed in a leaf node spec");
|
|
this.serializeFragment(e.content, t, r);
|
|
}
|
|
return n;
|
|
}
|
|
serializeNode(e, t = {}) {
|
|
let n = this.serializeNodeInner(e, t);
|
|
for (let r = e.marks.length - 1; r >= 0; r--) {
|
|
let i = this.serializeMark(e.marks[r], e.isInline, t);
|
|
i && ((i.contentDOM || i.dom).appendChild(n), (n = i.dom));
|
|
}
|
|
return n;
|
|
}
|
|
serializeMark(e, t, n = {}) {
|
|
let r = this.marks[e.type.name];
|
|
return r && Q(G(n), r(e, t), null, e.attrs);
|
|
}
|
|
static renderSpec(e, t, n = null, r) {
|
|
return Q(e, t, n, r);
|
|
}
|
|
static fromSchema(e) {
|
|
return (
|
|
e.cached.domSerializer ||
|
|
(e.cached.domSerializer = new U(
|
|
this.nodesFromSchema(e),
|
|
this.marksFromSchema(e),
|
|
))
|
|
);
|
|
}
|
|
static nodesFromSchema(e) {
|
|
let t = J(e.nodes);
|
|
return t.text || (t.text = (e) => e.text), t;
|
|
}
|
|
static marksFromSchema(e) {
|
|
return J(e.marks);
|
|
}
|
|
}
|
|
function J(e) {
|
|
let t = {};
|
|
for (let n in e) {
|
|
let r = e[n].spec.toDOM;
|
|
r && (t[n] = r);
|
|
}
|
|
return t;
|
|
}
|
|
function G(e) {
|
|
return e.document || window.document;
|
|
}
|
|
let Y = new WeakMap();
|
|
function Q(e, t, n, r) {
|
|
let i, o, s;
|
|
if ("string" == typeof t) return { dom: e.createTextNode(t) };
|
|
if (null != t.nodeType) return { dom: t };
|
|
if (t.dom && null != t.dom.nodeType) return t;
|
|
let l = t[0],
|
|
a;
|
|
if ("string" != typeof l)
|
|
throw RangeError("Invalid array passed to renderSpec");
|
|
if (
|
|
r &&
|
|
(void 0 === (o = Y.get(r)) &&
|
|
Y.set(
|
|
r,
|
|
((s = null),
|
|
!(function e(t) {
|
|
if (t && "object" == typeof t)
|
|
if (Array.isArray(t))
|
|
if ("string" == typeof t[0]) s || (s = []), s.push(t);
|
|
else for (let n = 0; n < t.length; n++) e(t[n]);
|
|
else for (let n in t) e(t[n]);
|
|
})(r),
|
|
(o = s)),
|
|
),
|
|
(a = o)) &&
|
|
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 d = l.indexOf(" ");
|
|
d > 0 && ((n = l.slice(0, d)), (l = l.slice(d + 1)));
|
|
let c = n ? e.createElementNS(n, l) : e.createElement(l),
|
|
h = t[1],
|
|
p = 1;
|
|
if (
|
|
h &&
|
|
"object" == typeof h &&
|
|
null == h.nodeType &&
|
|
!Array.isArray(h)
|
|
) {
|
|
for (let e in ((p = 2), h))
|
|
if (null != h[e]) {
|
|
let t = e.indexOf(" ");
|
|
t > 0
|
|
? c.setAttributeNS(e.slice(0, t), e.slice(t + 1), h[e])
|
|
: "style" == e && c.style
|
|
? (c.style.cssText = h[e])
|
|
: c.setAttribute(e, h[e]);
|
|
}
|
|
}
|
|
for (let o = p; o < t.length; o++) {
|
|
let s = t[o];
|
|
if (0 === s) {
|
|
if (o < t.length - 1 || o > p)
|
|
throw RangeError(
|
|
"Content hole must be the only child of its parent node",
|
|
);
|
|
return { dom: c, contentDOM: c };
|
|
}
|
|
{
|
|
let { dom: t, contentDOM: o } = Q(e, s, n, r);
|
|
if ((c.appendChild(t), o)) {
|
|
if (i) throw RangeError("Multiple content holes");
|
|
i = o;
|
|
}
|
|
}
|
|
}
|
|
return { dom: c, contentDOM: i };
|
|
}
|
|
e.s(
|
|
[
|
|
"DOMParser",
|
|
() => $,
|
|
"DOMSerializer",
|
|
() => U,
|
|
"Fragment",
|
|
() => n,
|
|
"Mark",
|
|
() => s,
|
|
"MarkType",
|
|
() => L,
|
|
"Node",
|
|
() => w,
|
|
"NodeRange",
|
|
() => k,
|
|
"ReplaceError",
|
|
() => l,
|
|
"Schema",
|
|
() => z,
|
|
"Slice",
|
|
() => a,
|
|
],
|
|
47091,
|
|
);
|
|
class X {
|
|
constructor(e, t, n) {
|
|
(this.pos = e), (this.delInfo = t), (this.recover = n);
|
|
}
|
|
get deleted() {
|
|
return (8 & this.delInfo) > 0;
|
|
}
|
|
get deletedBefore() {
|
|
return (5 & this.delInfo) > 0;
|
|
}
|
|
get deletedAfter() {
|
|
return (6 & this.delInfo) > 0;
|
|
}
|
|
get deletedAcross() {
|
|
return (4 & this.delInfo) > 0;
|
|
}
|
|
}
|
|
class Z {
|
|
constructor(e, t = !1) {
|
|
if (((this.ranges = e), (this.inverted = t), !e.length && Z.empty))
|
|
return Z.empty;
|
|
}
|
|
recover(e) {
|
|
let t = 0,
|
|
n = 65535 & e;
|
|
if (!this.inverted)
|
|
for (let e = 0; e < n; e++)
|
|
t += this.ranges[3 * e + 2] - this.ranges[3 * e + 1];
|
|
return this.ranges[3 * n] + t + (e - (65535 & e)) / 65536;
|
|
}
|
|
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,
|
|
o = this.inverted ? 1 : 2;
|
|
for (let s = 0; s < this.ranges.length; s += 3) {
|
|
let l = this.ranges[s] - (this.inverted ? r : 0);
|
|
if (l > e) break;
|
|
let a = this.ranges[s + i],
|
|
d = this.ranges[s + o],
|
|
c = l + a;
|
|
if (e <= c) {
|
|
let i = a ? (e == l ? -1 : e == c ? 1 : t) : t,
|
|
o = l + r + (i < 0 ? 0 : d);
|
|
if (n) return o;
|
|
let h = e == (t < 0 ? l : c) ? null : s / 3 + (e - l) * 65536,
|
|
p = e == l ? 2 : e == c ? 1 : 4;
|
|
return (t < 0 ? e != l : e != c) && (p |= 8), new X(o, p, h);
|
|
}
|
|
r += d - a;
|
|
}
|
|
return n ? e + r : new X(e + r, 0, null);
|
|
}
|
|
touches(e, t) {
|
|
let n = 0,
|
|
r = 65535 & t,
|
|
i = this.inverted ? 2 : 1,
|
|
o = this.inverted ? 1 : 2;
|
|
for (let t = 0; t < this.ranges.length; t += 3) {
|
|
let s = this.ranges[t] - (this.inverted ? n : 0);
|
|
if (s > e) break;
|
|
let l = this.ranges[t + i];
|
|
if (e <= s + l && t == 3 * r) return !0;
|
|
n += this.ranges[t + o] - l;
|
|
}
|
|
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 o = this.ranges[r],
|
|
s = o - (this.inverted ? i : 0),
|
|
l = o + (this.inverted ? 0 : i),
|
|
a = this.ranges[r + t],
|
|
d = this.ranges[r + n];
|
|
e(s, s + a, l, l + d), (i += d - a);
|
|
}
|
|
}
|
|
invert() {
|
|
return new Z(this.ranges, !this.inverted);
|
|
}
|
|
toString() {
|
|
return (this.inverted ? "-" : "") + JSON.stringify(this.ranges);
|
|
}
|
|
static offset(e) {
|
|
return 0 == e ? Z.empty : new Z(e < 0 ? [0, -e, 0] : [0, 0, e]);
|
|
}
|
|
}
|
|
Z.empty = new Z([]);
|
|
class ee {
|
|
constructor(e, t, n = 0, r = e ? e.length : 0) {
|
|
(this.mirror = t),
|
|
(this.from = n),
|
|
(this.to = r),
|
|
(this._maps = e || []),
|
|
(this.ownData = !(e || t));
|
|
}
|
|
get maps() {
|
|
return this._maps;
|
|
}
|
|
slice(e = 0, t = this.maps.length) {
|
|
return new ee(this._maps, this.mirror, e, t);
|
|
}
|
|
appendMap(e, t) {
|
|
this.ownData ||
|
|
((this._maps = this._maps.slice()),
|
|
(this.mirror = this.mirror && this.mirror.slice()),
|
|
(this.ownData = !0)),
|
|
(this.to = this._maps.push(e)),
|
|
null != t && this.setMirror(this._maps.length - 1, t);
|
|
}
|
|
appendMapping(e) {
|
|
for (let t = 0, n = this._maps.length; t < e._maps.length; t++) {
|
|
let r = e.getMirror(t);
|
|
this.appendMap(e._maps[t], null != r && r < t ? n + r : void 0);
|
|
}
|
|
}
|
|
getMirror(e) {
|
|
if (this.mirror) {
|
|
for (let t = 0; t < this.mirror.length; t++)
|
|
if (this.mirror[t] == e) return this.mirror[t + (t % 2 ? -1 : 1)];
|
|
}
|
|
}
|
|
setMirror(e, t) {
|
|
this.mirror || (this.mirror = []), this.mirror.push(e, t);
|
|
}
|
|
appendMappingInverted(e) {
|
|
for (
|
|
let t = e.maps.length - 1, n = this._maps.length + e._maps.length;
|
|
t >= 0;
|
|
t--
|
|
) {
|
|
let r = e.getMirror(t);
|
|
this.appendMap(
|
|
e._maps[t].invert(),
|
|
null != r && r > t ? n - r - 1 : void 0,
|
|
);
|
|
}
|
|
}
|
|
invert() {
|
|
let e = new ee();
|
|
return e.appendMappingInverted(this), e;
|
|
}
|
|
map(e, t = 1) {
|
|
if (this.mirror) return this._map(e, t, !0);
|
|
for (let n = this.from; n < this.to; n++) e = this._maps[n].map(e, t);
|
|
return e;
|
|
}
|
|
mapResult(e, t = 1) {
|
|
return this._map(e, t, !1);
|
|
}
|
|
_map(e, t, n) {
|
|
let r = 0;
|
|
for (let n = this.from; n < this.to; n++) {
|
|
let i = this._maps[n].mapResult(e, t);
|
|
if (null != i.recover) {
|
|
let t = this.getMirror(n);
|
|
if (null != t && t > n && t < this.to) {
|
|
(n = t), (e = this._maps[t].recover(i.recover));
|
|
continue;
|
|
}
|
|
}
|
|
(r |= i.delInfo), (e = i.pos);
|
|
}
|
|
return n ? e : new X(e, r, null);
|
|
}
|
|
}
|
|
let et = Object.create(null);
|
|
class en {
|
|
getMap() {
|
|
return Z.empty;
|
|
}
|
|
merge(e) {
|
|
return null;
|
|
}
|
|
static fromJSON(e, t) {
|
|
if (!t || !t.stepType)
|
|
throw RangeError("Invalid input for Step.fromJSON");
|
|
let n = et[t.stepType];
|
|
if (!n) throw RangeError(`No step type ${t.stepType} defined`);
|
|
return n.fromJSON(e, t);
|
|
}
|
|
static jsonID(e, t) {
|
|
if (e in et) throw RangeError("Duplicate use of step JSON ID " + e);
|
|
return (et[e] = t), (t.prototype.jsonID = e), t;
|
|
}
|
|
}
|
|
class er {
|
|
constructor(e, t) {
|
|
(this.doc = e), (this.failed = t);
|
|
}
|
|
static ok(e) {
|
|
return new er(e, null);
|
|
}
|
|
static fail(e) {
|
|
return new er(null, e);
|
|
}
|
|
static fromReplace(e, t, n, r) {
|
|
try {
|
|
return er.ok(e.replace(t, n, r));
|
|
} catch (e) {
|
|
if (e instanceof l) return er.fail(e.message);
|
|
throw e;
|
|
}
|
|
}
|
|
}
|
|
function ei(e, t, r) {
|
|
let i = [];
|
|
for (let n = 0; n < e.childCount; n++) {
|
|
let o = e.child(n);
|
|
o.content.size && (o = o.copy(ei(o.content, t, o))),
|
|
o.isInline && (o = t(o, r, n)),
|
|
i.push(o);
|
|
}
|
|
return n.fromArray(i);
|
|
}
|
|
class eo extends en {
|
|
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 a(
|
|
ei(
|
|
t.content,
|
|
(e, t) =>
|
|
e.isAtom && t.type.allowsMarkType(this.mark.type)
|
|
? e.mark(this.mark.addToSet(e.marks))
|
|
: e,
|
|
r,
|
|
),
|
|
t.openStart,
|
|
t.openEnd,
|
|
);
|
|
return er.fromReplace(e, this.from, this.to, i);
|
|
}
|
|
invert() {
|
|
return new es(this.from, this.to, this.mark);
|
|
}
|
|
map(e) {
|
|
let t = e.mapResult(this.from, 1),
|
|
n = e.mapResult(this.to, -1);
|
|
return (t.deleted && n.deleted) || t.pos >= n.pos
|
|
? null
|
|
: new eo(t.pos, n.pos, this.mark);
|
|
}
|
|
merge(e) {
|
|
return e instanceof eo &&
|
|
e.mark.eq(this.mark) &&
|
|
this.from <= e.to &&
|
|
this.to >= e.from
|
|
? new eo(
|
|
Math.min(this.from, e.from),
|
|
Math.max(this.to, e.to),
|
|
this.mark,
|
|
)
|
|
: null;
|
|
}
|
|
toJSON() {
|
|
return {
|
|
stepType: "addMark",
|
|
mark: this.mark.toJSON(),
|
|
from: this.from,
|
|
to: this.to,
|
|
};
|
|
}
|
|
static fromJSON(e, t) {
|
|
if ("number" != typeof t.from || "number" != typeof t.to)
|
|
throw RangeError("Invalid input for AddMarkStep.fromJSON");
|
|
return new eo(t.from, t.to, e.markFromJSON(t.mark));
|
|
}
|
|
}
|
|
en.jsonID("addMark", eo);
|
|
class es extends en {
|
|
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 a(
|
|
ei(t.content, (e) => e.mark(this.mark.removeFromSet(e.marks)), e),
|
|
t.openStart,
|
|
t.openEnd,
|
|
);
|
|
return er.fromReplace(e, this.from, this.to, n);
|
|
}
|
|
invert() {
|
|
return new eo(this.from, this.to, this.mark);
|
|
}
|
|
map(e) {
|
|
let t = e.mapResult(this.from, 1),
|
|
n = e.mapResult(this.to, -1);
|
|
return (t.deleted && n.deleted) || t.pos >= n.pos
|
|
? null
|
|
: new es(t.pos, n.pos, this.mark);
|
|
}
|
|
merge(e) {
|
|
return e instanceof es &&
|
|
e.mark.eq(this.mark) &&
|
|
this.from <= e.to &&
|
|
this.to >= e.from
|
|
? new es(
|
|
Math.min(this.from, e.from),
|
|
Math.max(this.to, e.to),
|
|
this.mark,
|
|
)
|
|
: null;
|
|
}
|
|
toJSON() {
|
|
return {
|
|
stepType: "removeMark",
|
|
mark: this.mark.toJSON(),
|
|
from: this.from,
|
|
to: this.to,
|
|
};
|
|
}
|
|
static fromJSON(e, t) {
|
|
if ("number" != typeof t.from || "number" != typeof t.to)
|
|
throw RangeError("Invalid input for RemoveMarkStep.fromJSON");
|
|
return new es(t.from, t.to, e.markFromJSON(t.mark));
|
|
}
|
|
}
|
|
en.jsonID("removeMark", es);
|
|
class el extends en {
|
|
constructor(e, t) {
|
|
super(), (this.pos = e), (this.mark = t);
|
|
}
|
|
apply(e) {
|
|
let t = e.nodeAt(this.pos);
|
|
if (!t) return er.fail("No node at mark step's position");
|
|
let r = t.type.create(t.attrs, null, this.mark.addToSet(t.marks));
|
|
return er.fromReplace(
|
|
e,
|
|
this.pos,
|
|
this.pos + 1,
|
|
new a(n.from(r), 0, +!t.isLeaf),
|
|
);
|
|
}
|
|
invert(e) {
|
|
let t = e.nodeAt(this.pos);
|
|
if (t) {
|
|
let e = this.mark.addToSet(t.marks);
|
|
if (e.length == t.marks.length) {
|
|
for (let n = 0; n < t.marks.length; n++)
|
|
if (!t.marks[n].isInSet(e)) return new el(this.pos, t.marks[n]);
|
|
return new el(this.pos, this.mark);
|
|
}
|
|
}
|
|
return new ea(this.pos, this.mark);
|
|
}
|
|
map(e) {
|
|
let t = e.mapResult(this.pos, 1);
|
|
return t.deletedAfter ? null : new el(t.pos, this.mark);
|
|
}
|
|
toJSON() {
|
|
return {
|
|
stepType: "addNodeMark",
|
|
pos: this.pos,
|
|
mark: this.mark.toJSON(),
|
|
};
|
|
}
|
|
static fromJSON(e, t) {
|
|
if ("number" != typeof t.pos)
|
|
throw RangeError("Invalid input for AddNodeMarkStep.fromJSON");
|
|
return new el(t.pos, e.markFromJSON(t.mark));
|
|
}
|
|
}
|
|
en.jsonID("addNodeMark", el);
|
|
class ea extends en {
|
|
constructor(e, t) {
|
|
super(), (this.pos = e), (this.mark = t);
|
|
}
|
|
apply(e) {
|
|
let t = e.nodeAt(this.pos);
|
|
if (!t) return er.fail("No node at mark step's position");
|
|
let r = t.type.create(t.attrs, null, this.mark.removeFromSet(t.marks));
|
|
return er.fromReplace(
|
|
e,
|
|
this.pos,
|
|
this.pos + 1,
|
|
new a(n.from(r), 0, +!t.isLeaf),
|
|
);
|
|
}
|
|
invert(e) {
|
|
let t = e.nodeAt(this.pos);
|
|
return t && this.mark.isInSet(t.marks)
|
|
? new el(this.pos, this.mark)
|
|
: this;
|
|
}
|
|
map(e) {
|
|
let t = e.mapResult(this.pos, 1);
|
|
return t.deletedAfter ? null : new ea(t.pos, this.mark);
|
|
}
|
|
toJSON() {
|
|
return {
|
|
stepType: "removeNodeMark",
|
|
pos: this.pos,
|
|
mark: this.mark.toJSON(),
|
|
};
|
|
}
|
|
static fromJSON(e, t) {
|
|
if ("number" != typeof t.pos)
|
|
throw RangeError("Invalid input for RemoveNodeMarkStep.fromJSON");
|
|
return new ea(t.pos, e.markFromJSON(t.mark));
|
|
}
|
|
}
|
|
en.jsonID("removeNodeMark", ea);
|
|
class ed extends en {
|
|
constructor(e, t, n, r = !1) {
|
|
super(),
|
|
(this.from = e),
|
|
(this.to = t),
|
|
(this.slice = n),
|
|
(this.structure = r);
|
|
}
|
|
apply(e) {
|
|
return this.structure && eh(e, this.from, this.to)
|
|
? er.fail("Structure replace would overwrite content")
|
|
: er.fromReplace(e, this.from, this.to, this.slice);
|
|
}
|
|
getMap() {
|
|
return new Z([this.from, this.to - this.from, this.slice.size]);
|
|
}
|
|
invert(e) {
|
|
return new ed(
|
|
this.from,
|
|
this.from + this.slice.size,
|
|
e.slice(this.from, this.to),
|
|
);
|
|
}
|
|
map(e) {
|
|
let t = e.mapResult(this.from, 1),
|
|
n = e.mapResult(this.to, -1);
|
|
return t.deletedAcross && n.deletedAcross
|
|
? null
|
|
: new ed(t.pos, Math.max(t.pos, n.pos), this.slice, this.structure);
|
|
}
|
|
merge(e) {
|
|
if (!(e instanceof ed) || e.structure || this.structure) return null;
|
|
if (
|
|
this.from + this.slice.size != e.from ||
|
|
this.slice.openEnd ||
|
|
e.slice.openStart
|
|
)
|
|
if (e.to != this.from || this.slice.openStart || e.slice.openEnd)
|
|
return null;
|
|
else {
|
|
let t =
|
|
this.slice.size + e.slice.size == 0
|
|
? a.empty
|
|
: new a(
|
|
e.slice.content.append(this.slice.content),
|
|
e.slice.openStart,
|
|
this.slice.openEnd,
|
|
);
|
|
return new ed(e.from, this.to, t, this.structure);
|
|
}
|
|
{
|
|
let t =
|
|
this.slice.size + e.slice.size == 0
|
|
? a.empty
|
|
: new a(
|
|
this.slice.content.append(e.slice.content),
|
|
this.slice.openStart,
|
|
e.slice.openEnd,
|
|
);
|
|
return new ed(
|
|
this.from,
|
|
this.to + (e.to - e.from),
|
|
t,
|
|
this.structure,
|
|
);
|
|
}
|
|
}
|
|
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(e, t) {
|
|
if ("number" != typeof t.from || "number" != typeof t.to)
|
|
throw RangeError("Invalid input for ReplaceStep.fromJSON");
|
|
return new ed(t.from, t.to, a.fromJSON(e, t.slice), !!t.structure);
|
|
}
|
|
}
|
|
en.jsonID("replace", ed);
|
|
class ec extends en {
|
|
constructor(e, t, n, r, i, o, s = !1) {
|
|
super(),
|
|
(this.from = e),
|
|
(this.to = t),
|
|
(this.gapFrom = n),
|
|
(this.gapTo = r),
|
|
(this.slice = i),
|
|
(this.insert = o),
|
|
(this.structure = s);
|
|
}
|
|
apply(e) {
|
|
if (
|
|
this.structure &&
|
|
(eh(e, this.from, this.gapFrom) || eh(e, this.gapTo, this.to))
|
|
)
|
|
return er.fail("Structure gap-replace would overwrite content");
|
|
let t = e.slice(this.gapFrom, this.gapTo);
|
|
if (t.openStart || t.openEnd) return er.fail("Gap is not a flat range");
|
|
let n = this.slice.insertAt(this.insert, t.content);
|
|
return n
|
|
? er.fromReplace(e, this.from, this.to, n)
|
|
: er.fail("Content does not fit in gap");
|
|
}
|
|
getMap() {
|
|
return new Z([
|
|
this.from,
|
|
this.gapFrom - this.from,
|
|
this.insert,
|
|
this.gapTo,
|
|
this.to - this.gapTo,
|
|
this.slice.size - this.insert,
|
|
]);
|
|
}
|
|
invert(e) {
|
|
let t = this.gapTo - this.gapFrom;
|
|
return new ec(
|
|
this.from,
|
|
this.from + this.slice.size + t,
|
|
this.from + this.insert,
|
|
this.from + this.insert + t,
|
|
e
|
|
.slice(this.from, this.to)
|
|
.removeBetween(this.gapFrom - this.from, this.gapTo - this.from),
|
|
this.gapFrom - this.from,
|
|
this.structure,
|
|
);
|
|
}
|
|
map(e) {
|
|
let t = e.mapResult(this.from, 1),
|
|
n = e.mapResult(this.to, -1),
|
|
r = this.from == this.gapFrom ? t.pos : e.map(this.gapFrom, -1),
|
|
i = this.to == this.gapTo ? n.pos : e.map(this.gapTo, 1);
|
|
return (t.deletedAcross && n.deletedAcross) || r < t.pos || i > n.pos
|
|
? null
|
|
: new ec(t.pos, n.pos, r, i, 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(e, t) {
|
|
if (
|
|
"number" != typeof t.from ||
|
|
"number" != typeof t.to ||
|
|
"number" != typeof t.gapFrom ||
|
|
"number" != typeof t.gapTo ||
|
|
"number" != typeof t.insert
|
|
)
|
|
throw RangeError("Invalid input for ReplaceAroundStep.fromJSON");
|
|
return new ec(
|
|
t.from,
|
|
t.to,
|
|
t.gapFrom,
|
|
t.gapTo,
|
|
a.fromJSON(e, t.slice),
|
|
t.insert,
|
|
!!t.structure,
|
|
);
|
|
}
|
|
}
|
|
function eh(e, t, n) {
|
|
let r = e.resolve(t),
|
|
i = n - t,
|
|
o = r.depth;
|
|
for (; i > 0 && o > 0 && r.indexAfter(o) == r.node(o).childCount; )
|
|
o--, i--;
|
|
if (i > 0) {
|
|
let e = r.node(o).maybeChild(r.indexAfter(o));
|
|
for (; i > 0; ) {
|
|
if (!e || e.isLeaf) return !0;
|
|
(e = e.firstChild), i--;
|
|
}
|
|
}
|
|
return !1;
|
|
}
|
|
function ep(e, t, r, i = r.contentMatch, o = !0) {
|
|
let s = e.doc.nodeAt(t),
|
|
l = [],
|
|
d = t + 1;
|
|
for (let t = 0; t < s.childCount; t++) {
|
|
let c = s.child(t),
|
|
h = d + c.nodeSize,
|
|
p = i.matchType(c.type);
|
|
if (p) {
|
|
i = p;
|
|
for (let t = 0; t < c.marks.length; t++)
|
|
r.allowsMarkType(c.marks[t].type) ||
|
|
e.step(new es(d, h, c.marks[t]));
|
|
if (o && c.isText && "pre" != r.whitespace) {
|
|
let e,
|
|
t = /\r?\n|\r/g,
|
|
i;
|
|
for (; (e = t.exec(c.text)); )
|
|
i ||
|
|
(i = new a(
|
|
n.from(r.schema.text(" ", r.allowedMarks(c.marks))),
|
|
0,
|
|
0,
|
|
)),
|
|
l.push(new ed(d + e.index, d + e.index + e[0].length, i));
|
|
}
|
|
} else l.push(new ed(d, h, a.empty));
|
|
d = h;
|
|
}
|
|
if (!i.validEnd) {
|
|
let t = i.fillBefore(n.empty, !0);
|
|
e.replace(d, d, new a(t, 0, 0));
|
|
}
|
|
for (let t = l.length - 1; t >= 0; t--) e.step(l[t]);
|
|
}
|
|
function eu(e) {
|
|
let t = e.parent.content.cutByIndex(e.startIndex, e.endIndex);
|
|
for (let n = e.depth, r = 0, i = 0; ; --n) {
|
|
let o = e.$from.node(n),
|
|
s = e.$from.index(n) + r,
|
|
l = e.$to.indexAfter(n) - i;
|
|
if (n < e.depth && o.canReplace(s, l, t)) return n;
|
|
if (
|
|
0 == n ||
|
|
o.type.spec.isolating ||
|
|
!(
|
|
(0 == s || o.canReplace(s, o.childCount)) &&
|
|
(l == o.childCount || o.canReplace(0, l))
|
|
)
|
|
)
|
|
break;
|
|
s && (r = 1), l < o.childCount && (i = 1);
|
|
}
|
|
return null;
|
|
}
|
|
function ef(e, t, n = null, r = e) {
|
|
let i = (function (e, t) {
|
|
let { parent: n, startIndex: r, endIndex: i } = e,
|
|
o = n.contentMatchAt(r).findWrapping(t);
|
|
if (!o) return null;
|
|
let s = o.length ? o[0] : t;
|
|
return n.canReplaceWith(r, i, s) ? o : null;
|
|
})(e, t),
|
|
o =
|
|
i &&
|
|
(function (e, t) {
|
|
let { parent: n, startIndex: r, endIndex: i } = e,
|
|
o = n.child(r),
|
|
s = t.contentMatch.findWrapping(o.type);
|
|
if (!s) return null;
|
|
let l = (s.length ? s[s.length - 1] : t).contentMatch;
|
|
for (let e = r; l && e < i; e++) l = l.matchType(n.child(e).type);
|
|
return l && l.validEnd ? s : null;
|
|
})(r, t);
|
|
return o
|
|
? i.map(em).concat({ type: t, attrs: n }).concat(o.map(em))
|
|
: null;
|
|
}
|
|
function em(e) {
|
|
return { type: e, attrs: null };
|
|
}
|
|
function eg(e, t, n, r) {
|
|
t.forEach((i, o) => {
|
|
if (i.isText) {
|
|
let s,
|
|
l = /\r?\n|\r/g;
|
|
for (; (s = l.exec(i.text)); ) {
|
|
let i = e.mapping.slice(r).map(n + 1 + o + s.index);
|
|
e.replaceWith(
|
|
i,
|
|
i + 1,
|
|
t.type.schema.linebreakReplacement.create(),
|
|
);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
function ey(e, t, n, r) {
|
|
t.forEach((i, o) => {
|
|
if (i.type == i.type.schema.linebreakReplacement) {
|
|
let i = e.mapping.slice(r).map(n + 1 + o);
|
|
e.replaceWith(i, i + 1, t.type.schema.text("\n"));
|
|
}
|
|
});
|
|
}
|
|
function eb(e, t, n = 1, r) {
|
|
let i = e.resolve(t),
|
|
o = i.depth - n,
|
|
s = (r && r[r.length - 1]) || i.parent;
|
|
if (
|
|
o < 0 ||
|
|
i.parent.type.spec.isolating ||
|
|
!i.parent.canReplace(i.index(), i.parent.childCount) ||
|
|
!s.type.validContent(
|
|
i.parent.content.cutByIndex(i.index(), i.parent.childCount),
|
|
)
|
|
)
|
|
return !1;
|
|
for (let e = i.depth - 1, t = n - 2; e > o; e--, t--) {
|
|
let n = i.node(e),
|
|
o = i.index(e);
|
|
if (n.type.spec.isolating) return !1;
|
|
let s = n.content.cutByIndex(o, n.childCount),
|
|
l = r && r[t + 1];
|
|
l && (s = s.replaceChild(0, l.type.create(l.attrs)));
|
|
let a = (r && r[t]) || n;
|
|
if (!n.canReplace(o + 1, n.childCount) || !a.type.validContent(s))
|
|
return !1;
|
|
}
|
|
let l = i.indexAfter(o),
|
|
a = r && r[0];
|
|
return i.node(o).canReplaceWith(l, l, a ? a.type : i.node(o + 1).type);
|
|
}
|
|
function ek(e, t) {
|
|
let n = e.resolve(t),
|
|
r = n.index();
|
|
return ev(n.nodeBefore, n.nodeAfter) && n.parent.canReplace(r, r + 1);
|
|
}
|
|
function ev(e, t) {
|
|
return !!(
|
|
e &&
|
|
t &&
|
|
!e.isLeaf &&
|
|
(function (e, t) {
|
|
t.content.size || e.type.compatibleContent(t.type);
|
|
let n = e.contentMatchAt(e.childCount),
|
|
{ linebreakReplacement: r } = e.type.schema;
|
|
for (let i = 0; i < t.childCount; i++) {
|
|
let o = t.child(i),
|
|
s = o.type == r ? e.type.schema.nodes.text : o.type;
|
|
if (!(n = n.matchType(s)) || !e.type.allowsMarks(o.marks))
|
|
return !1;
|
|
}
|
|
return n.validEnd;
|
|
})(e, t)
|
|
);
|
|
}
|
|
function ew(e, t, n = -1) {
|
|
let r = e.resolve(t);
|
|
for (let e = r.depth; ; e--) {
|
|
let i,
|
|
o,
|
|
s = r.index(e);
|
|
if (
|
|
(e == r.depth
|
|
? ((i = r.nodeBefore), (o = r.nodeAfter))
|
|
: n > 0
|
|
? ((i = r.node(e + 1)), s++, (o = r.node(e).maybeChild(s)))
|
|
: ((i = r.node(e).maybeChild(s - 1)), (o = r.node(e + 1))),
|
|
i && !i.isTextblock && ev(i, o) && r.node(e).canReplace(s, s + 1))
|
|
)
|
|
return t;
|
|
if (0 == e) break;
|
|
t = n < 0 ? r.before(e) : r.after(e);
|
|
}
|
|
}
|
|
function eS(e, t, n) {
|
|
let r = e.resolve(t);
|
|
if (!n.content.size) return t;
|
|
let i = n.content;
|
|
for (let e = 0; e < n.openStart; e++) i = i.firstChild.content;
|
|
for (let e = 1; e <= (0 == n.openStart && n.size ? 2 : 1); e++)
|
|
for (let t = r.depth; t >= 0; t--) {
|
|
let n =
|
|
t == r.depth
|
|
? 0
|
|
: r.pos <= (r.start(t + 1) + r.end(t + 1)) / 2
|
|
? -1
|
|
: 1,
|
|
o = r.index(t) + +(n > 0),
|
|
s = r.node(t),
|
|
l = !1;
|
|
if (1 == e) l = s.canReplace(o, o, i);
|
|
else {
|
|
let e = s.contentMatchAt(o).findWrapping(i.firstChild.type);
|
|
l = e && s.canReplaceWith(o, o, e[0]);
|
|
}
|
|
if (l)
|
|
return 0 == n ? r.pos : n < 0 ? r.before(t + 1) : r.after(t + 1);
|
|
}
|
|
return null;
|
|
}
|
|
function ex(e, t, n = t, r = a.empty) {
|
|
if (t == n && !r.size) return null;
|
|
let i = e.resolve(t),
|
|
o = e.resolve(n);
|
|
return eM(i, o, r) ? new ed(t, n, r) : new eC(i, o, r).fit();
|
|
}
|
|
function eM(e, t, n) {
|
|
return (
|
|
!n.openStart &&
|
|
!n.openEnd &&
|
|
e.start() == t.start() &&
|
|
e.parent.canReplace(e.index(), t.index(), n.content)
|
|
);
|
|
}
|
|
en.jsonID("replaceAround", ec);
|
|
class eC {
|
|
constructor(e, t, r) {
|
|
(this.$from = e),
|
|
(this.$to = t),
|
|
(this.unplaced = r),
|
|
(this.frontier = []),
|
|
(this.placed = n.empty);
|
|
for (let t = 0; t <= e.depth; t++) {
|
|
let n = e.node(t);
|
|
this.frontier.push({
|
|
type: n.type,
|
|
match: n.contentMatchAt(e.indexAfter(t)),
|
|
});
|
|
}
|
|
for (let t = e.depth; t > 0; t--)
|
|
this.placed = n.from(e.node(t).copy(this.placed));
|
|
}
|
|
get depth() {
|
|
return this.frontier.length - 1;
|
|
}
|
|
fit() {
|
|
for (; this.unplaced.size; ) {
|
|
let e = this.findFittable();
|
|
e ? this.placeNodes(e) : this.openMore() || this.dropNode();
|
|
}
|
|
let e = this.mustMoveInline(),
|
|
t = this.placed.size - this.depth - this.$from.depth,
|
|
n = this.$from,
|
|
r = this.close(e < 0 ? this.$to : n.doc.resolve(e));
|
|
if (!r) return null;
|
|
let i = this.placed,
|
|
o = n.depth,
|
|
s = r.depth;
|
|
for (; o && s && 1 == i.childCount; )
|
|
(i = i.firstChild.content), o--, s--;
|
|
let l = new a(i, o, s);
|
|
return e > -1
|
|
? new ec(n.pos, e, this.$to.pos, this.$to.end(), l, t)
|
|
: l.size || n.pos != this.$to.pos
|
|
? new ed(n.pos, r.pos, l)
|
|
: null;
|
|
}
|
|
findFittable() {
|
|
let e = this.unplaced.openStart;
|
|
for (
|
|
let t = this.unplaced.content, n = 0, r = this.unplaced.openEnd;
|
|
n < e;
|
|
n++
|
|
) {
|
|
let i = t.firstChild;
|
|
if ((t.childCount > 1 && (r = 0), i.type.spec.isolating && r <= n)) {
|
|
e = n;
|
|
break;
|
|
}
|
|
t = i.content;
|
|
}
|
|
for (let t = 1; t <= 2; t++)
|
|
for (let r = 1 == t ? e : this.unplaced.openStart; r >= 0; r--) {
|
|
let e = null,
|
|
i = (
|
|
r
|
|
? (e = eE(this.unplaced.content, r - 1).firstChild).content
|
|
: this.unplaced.content
|
|
).firstChild;
|
|
for (let o = this.depth; o >= 0; o--) {
|
|
let { type: s, match: l } = this.frontier[o],
|
|
a,
|
|
d = null;
|
|
if (
|
|
1 == t &&
|
|
(i
|
|
? l.matchType(i.type) || (d = l.fillBefore(n.from(i), !1))
|
|
: e && s.compatibleContent(e.type))
|
|
)
|
|
return {
|
|
sliceDepth: r,
|
|
frontierDepth: o,
|
|
parent: e,
|
|
inject: d,
|
|
};
|
|
if (2 == t && i && (a = l.findWrapping(i.type)))
|
|
return { sliceDepth: r, frontierDepth: o, parent: e, wrap: a };
|
|
if (e && l.matchType(e.type)) break;
|
|
}
|
|
}
|
|
}
|
|
openMore() {
|
|
let { content: e, openStart: t, openEnd: n } = this.unplaced,
|
|
r = eE(e, t);
|
|
return (
|
|
!!r.childCount &&
|
|
!r.firstChild.isLeaf &&
|
|
((this.unplaced = new a(
|
|
e,
|
|
t + 1,
|
|
Math.max(n, r.size + t >= e.size - n ? t + 1 : 0),
|
|
)),
|
|
!0)
|
|
);
|
|
}
|
|
dropNode() {
|
|
let { content: e, openStart: t, openEnd: n } = this.unplaced,
|
|
r = eE(e, t);
|
|
if (r.childCount <= 1 && t > 0) {
|
|
let i = e.size - t <= t + r.size;
|
|
this.unplaced = new a(eT(e, t - 1, 1), t - 1, i ? t - 1 : n);
|
|
} else this.unplaced = new a(eT(e, t, 1), t, n);
|
|
}
|
|
placeNodes({
|
|
sliceDepth: e,
|
|
frontierDepth: t,
|
|
parent: r,
|
|
inject: i,
|
|
wrap: o,
|
|
}) {
|
|
for (; this.depth > t; ) this.closeFrontierNode();
|
|
if (o) for (let e = 0; e < o.length; e++) this.openFrontierNode(o[e]);
|
|
let s = this.unplaced,
|
|
l = r ? r.content : s.content,
|
|
d = s.openStart - e,
|
|
c = 0,
|
|
h = [],
|
|
{ match: p, type: u } = this.frontier[t];
|
|
if (i) {
|
|
for (let e = 0; e < i.childCount; e++) h.push(i.child(e));
|
|
p = p.matchFragment(i);
|
|
}
|
|
let f = l.size + e - (s.content.size - s.openEnd);
|
|
for (; c < l.childCount; ) {
|
|
let e = l.child(c),
|
|
t = p.matchType(e.type);
|
|
if (!t) break;
|
|
(++c > 1 || 0 == d || e.content.size) &&
|
|
((p = t),
|
|
h.push(
|
|
(function e(t, r, i) {
|
|
if (r <= 0) return t;
|
|
let o = t.content;
|
|
return (
|
|
r > 1 &&
|
|
(o = o.replaceChild(
|
|
0,
|
|
e(o.firstChild, r - 1, 1 == o.childCount ? i - 1 : 0),
|
|
)),
|
|
r > 0 &&
|
|
((o = t.type.contentMatch.fillBefore(o).append(o)),
|
|
i <= 0 &&
|
|
(o = o.append(
|
|
t.type.contentMatch
|
|
.matchFragment(o)
|
|
.fillBefore(n.empty, !0),
|
|
))),
|
|
t.copy(o)
|
|
);
|
|
})(
|
|
e.mark(u.allowedMarks(e.marks)),
|
|
1 == c ? d : 0,
|
|
c == l.childCount ? f : -1,
|
|
),
|
|
));
|
|
}
|
|
let m = c == l.childCount;
|
|
m || (f = -1),
|
|
(this.placed = eN(this.placed, t, n.from(h))),
|
|
(this.frontier[t].match = p),
|
|
m &&
|
|
f < 0 &&
|
|
r &&
|
|
r.type == this.frontier[this.depth].type &&
|
|
this.frontier.length > 1 &&
|
|
this.closeFrontierNode();
|
|
for (let e = 0, t = l; e < f; e++) {
|
|
let e = t.lastChild;
|
|
this.frontier.push({
|
|
type: e.type,
|
|
match: e.contentMatchAt(e.childCount),
|
|
}),
|
|
(t = e.content);
|
|
}
|
|
this.unplaced = m
|
|
? 0 == e
|
|
? a.empty
|
|
: new a(eT(s.content, e - 1, 1), e - 1, f < 0 ? s.openEnd : e - 1)
|
|
: new a(eT(s.content, e, c), s.openStart, s.openEnd);
|
|
}
|
|
mustMoveInline() {
|
|
if (!this.$to.parent.isTextblock) return -1;
|
|
let e = this.frontier[this.depth],
|
|
t;
|
|
if (
|
|
!e.type.isTextblock ||
|
|
!eO(this.$to, this.$to.depth, e.type, e.match, !1) ||
|
|
(this.$to.depth == this.depth &&
|
|
(t = this.findCloseLevel(this.$to)) &&
|
|
t.depth == this.depth)
|
|
)
|
|
return -1;
|
|
let { depth: n } = this.$to,
|
|
r = this.$to.after(n);
|
|
for (; n > 1 && r == this.$to.end(--n); ) ++r;
|
|
return r;
|
|
}
|
|
findCloseLevel(e) {
|
|
t: for (let t = Math.min(this.depth, e.depth); t >= 0; t--) {
|
|
let { match: n, type: r } = this.frontier[t],
|
|
i = t < e.depth && e.end(t + 1) == e.pos + (e.depth - (t + 1)),
|
|
o = eO(e, t, r, n, i);
|
|
if (o) {
|
|
for (let n = t - 1; n >= 0; n--) {
|
|
let { match: t, type: r } = this.frontier[n],
|
|
i = eO(e, n, r, t, !0);
|
|
if (!i || i.childCount) continue t;
|
|
}
|
|
return {
|
|
depth: t,
|
|
fit: o,
|
|
move: i ? e.doc.resolve(e.after(t + 1)) : e,
|
|
};
|
|
}
|
|
}
|
|
}
|
|
close(e) {
|
|
let t = this.findCloseLevel(e);
|
|
if (!t) return null;
|
|
for (; this.depth > t.depth; ) this.closeFrontierNode();
|
|
t.fit.childCount && (this.placed = eN(this.placed, t.depth, t.fit)),
|
|
(e = t.move);
|
|
for (let n = t.depth + 1; n <= e.depth; n++) {
|
|
let t = e.node(n),
|
|
r = t.type.contentMatch.fillBefore(t.content, !0, e.index(n));
|
|
this.openFrontierNode(t.type, t.attrs, r);
|
|
}
|
|
return e;
|
|
}
|
|
openFrontierNode(e, t = null, r) {
|
|
let i = this.frontier[this.depth];
|
|
(i.match = i.match.matchType(e)),
|
|
(this.placed = eN(this.placed, this.depth, n.from(e.create(t, r)))),
|
|
this.frontier.push({ type: e, match: e.contentMatch });
|
|
}
|
|
closeFrontierNode() {
|
|
let e = this.frontier.pop().match.fillBefore(n.empty, !0);
|
|
e.childCount &&
|
|
(this.placed = eN(this.placed, this.frontier.length, e));
|
|
}
|
|
}
|
|
function eT(e, t, n) {
|
|
return 0 == t
|
|
? e.cutByIndex(n, e.childCount)
|
|
: e.replaceChild(
|
|
0,
|
|
e.firstChild.copy(eT(e.firstChild.content, t - 1, n)),
|
|
);
|
|
}
|
|
function eN(e, t, n) {
|
|
return 0 == t
|
|
? e.append(n)
|
|
: e.replaceChild(
|
|
e.childCount - 1,
|
|
e.lastChild.copy(eN(e.lastChild.content, t - 1, n)),
|
|
);
|
|
}
|
|
function eE(e, t) {
|
|
for (let n = 0; n < t; n++) e = e.firstChild.content;
|
|
return e;
|
|
}
|
|
function eO(e, t, n, r, i) {
|
|
let o = e.node(t),
|
|
s = i ? e.indexAfter(t) : e.index(t);
|
|
if (s == o.childCount && !n.compatibleContent(o.type)) return null;
|
|
let l = r.fillBefore(o.content, !0, s);
|
|
return l &&
|
|
!(function (e, t, n) {
|
|
for (let r = n; r < t.childCount; r++)
|
|
if (!e.allowsMarks(t.child(r).marks)) return !0;
|
|
return !1;
|
|
})(n, o.content, s)
|
|
? l
|
|
: null;
|
|
}
|
|
function eA(e, t) {
|
|
let n = [],
|
|
r = Math.min(e.depth, t.depth);
|
|
for (let i = r; i >= 0; i--) {
|
|
let r = e.start(i);
|
|
if (
|
|
r < e.pos - (e.depth - i) ||
|
|
t.end(i) > t.pos + (t.depth - i) ||
|
|
e.node(i).type.spec.isolating ||
|
|
t.node(i).type.spec.isolating
|
|
)
|
|
break;
|
|
(r == t.start(i) ||
|
|
(i == e.depth &&
|
|
i == t.depth &&
|
|
e.parent.inlineContent &&
|
|
t.parent.inlineContent &&
|
|
i &&
|
|
t.start(i - 1) == r - 1)) &&
|
|
n.push(i);
|
|
}
|
|
return n;
|
|
}
|
|
class eD extends en {
|
|
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 er.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 er.fromReplace(
|
|
e,
|
|
this.pos,
|
|
this.pos + 1,
|
|
new a(n.from(i), 0, +!t.isLeaf),
|
|
);
|
|
}
|
|
getMap() {
|
|
return Z.empty;
|
|
}
|
|
invert(e) {
|
|
return new eD(this.pos, this.attr, e.nodeAt(this.pos).attrs[this.attr]);
|
|
}
|
|
map(e) {
|
|
let t = e.mapResult(this.pos, 1);
|
|
return t.deletedAfter ? null : new eD(t.pos, this.attr, this.value);
|
|
}
|
|
toJSON() {
|
|
return {
|
|
stepType: "attr",
|
|
pos: this.pos,
|
|
attr: this.attr,
|
|
value: this.value,
|
|
};
|
|
}
|
|
static fromJSON(e, t) {
|
|
if ("number" != typeof t.pos || "string" != typeof t.attr)
|
|
throw RangeError("Invalid input for AttrStep.fromJSON");
|
|
return new eD(t.pos, t.attr, t.value);
|
|
}
|
|
}
|
|
en.jsonID("attr", eD);
|
|
class eR extends en {
|
|
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 er.ok(n);
|
|
}
|
|
getMap() {
|
|
return Z.empty;
|
|
}
|
|
invert(e) {
|
|
return new eR(this.attr, e.attrs[this.attr]);
|
|
}
|
|
map(e) {
|
|
return this;
|
|
}
|
|
toJSON() {
|
|
return { stepType: "docAttr", attr: this.attr, value: this.value };
|
|
}
|
|
static fromJSON(e, t) {
|
|
if ("string" != typeof t.attr)
|
|
throw RangeError("Invalid input for DocAttrStep.fromJSON");
|
|
return new eR(t.attr, t.value);
|
|
}
|
|
}
|
|
en.jsonID("docAttr", eR);
|
|
let eI = class extends Error {};
|
|
((eI = function e(t) {
|
|
let n = Error.call(this, t);
|
|
return (n.__proto__ = e.prototype), n;
|
|
}).prototype = Object.create(Error.prototype)),
|
|
(eI.prototype.constructor = eI),
|
|
(eI.prototype.name = "TransformError");
|
|
class eP {
|
|
constructor(e) {
|
|
(this.doc = e),
|
|
(this.steps = []),
|
|
(this.docs = []),
|
|
(this.mapping = new ee());
|
|
}
|
|
get before() {
|
|
return this.docs.length ? this.docs[0] : this.doc;
|
|
}
|
|
step(e) {
|
|
let t = this.maybeStep(e);
|
|
if (t.failed) throw new eI(t.failed);
|
|
return this;
|
|
}
|
|
maybeStep(e) {
|
|
let t = e.apply(this.doc);
|
|
return t.failed || this.addStep(e, t.doc), t;
|
|
}
|
|
get docChanged() {
|
|
return this.steps.length > 0;
|
|
}
|
|
changedRange() {
|
|
let e = 1e9,
|
|
t = -1e9;
|
|
for (let n = 0; n < this.mapping.maps.length; n++) {
|
|
let r = this.mapping.maps[n];
|
|
n && ((e = r.map(e, 1)), (t = r.map(t, -1))),
|
|
r.forEach((n, r, i, o) => {
|
|
(e = Math.min(e, i)), (t = Math.max(t, o));
|
|
});
|
|
}
|
|
return 1e9 == e ? null : { from: e, to: t };
|
|
}
|
|
addStep(e, t) {
|
|
this.docs.push(this.doc),
|
|
this.steps.push(e),
|
|
this.mapping.appendMap(e.getMap()),
|
|
(this.doc = t);
|
|
}
|
|
replace(e, t = e, n = a.empty) {
|
|
let r = ex(this.doc, e, t, n);
|
|
return r && this.step(r), this;
|
|
}
|
|
replaceWith(e, t, r) {
|
|
return this.replace(e, t, new a(n.from(r), 0, 0));
|
|
}
|
|
delete(e, t) {
|
|
return this.replace(e, t, a.empty);
|
|
}
|
|
insert(e, t) {
|
|
return this.replaceWith(e, e, t);
|
|
}
|
|
replaceRange(e, t, r) {
|
|
return (
|
|
!(function (e, t, r, i) {
|
|
if (!i.size) return e.deleteRange(t, r);
|
|
let o = e.doc.resolve(t),
|
|
s = e.doc.resolve(r);
|
|
if (eM(o, s, i)) return e.step(new ed(t, r, i));
|
|
let l = eA(o, s);
|
|
0 == l[l.length - 1] && l.pop();
|
|
let d = -(o.depth + 1);
|
|
l.unshift(d);
|
|
for (let e = o.depth, t = o.pos - 1; e > 0; e--, t--) {
|
|
let n = o.node(e).type.spec;
|
|
if (n.defining || n.definingAsContext || n.isolating) break;
|
|
l.indexOf(e) > -1
|
|
? (d = e)
|
|
: o.before(e) == t && l.splice(1, 0, -e);
|
|
}
|
|
let c = l.indexOf(d),
|
|
h = [],
|
|
p = i.openStart;
|
|
for (let e = i.content, t = 0; ; t++) {
|
|
let n = e.firstChild;
|
|
if ((h.push(n), t == i.openStart)) break;
|
|
e = n.content;
|
|
}
|
|
for (let e = p - 1; e >= 0; e--) {
|
|
var u;
|
|
let t = h[e],
|
|
n = (u = t.type).spec.defining || u.spec.definingForContent;
|
|
if (n && !t.sameMarkup(o.node(Math.abs(d) - 1))) p = e;
|
|
else if (n || !t.type.isTextblock) break;
|
|
}
|
|
for (let t = i.openStart; t >= 0; t--) {
|
|
let d = (t + p + 1) % (i.openStart + 1),
|
|
u = h[d];
|
|
if (u)
|
|
for (let t = 0; t < l.length; t++) {
|
|
let h = l[(t + c) % l.length],
|
|
p = !0;
|
|
h < 0 && ((p = !1), (h = -h));
|
|
let f = o.node(h - 1),
|
|
m = o.index(h - 1);
|
|
if (f.canReplaceWith(m, m, u.type, u.marks))
|
|
return e.replace(
|
|
o.before(h),
|
|
p ? s.after(h) : r,
|
|
new a(
|
|
(function e(t, r, i, o, s) {
|
|
if (r < i) {
|
|
let n = t.firstChild;
|
|
t = t.replaceChild(
|
|
0,
|
|
n.copy(e(n.content, r + 1, i, o, n)),
|
|
);
|
|
}
|
|
if (r > o) {
|
|
let e = s.contentMatchAt(0),
|
|
r = e.fillBefore(t).append(t);
|
|
t = r.append(
|
|
e.matchFragment(r).fillBefore(n.empty, !0),
|
|
);
|
|
}
|
|
return t;
|
|
})(i.content, 0, i.openStart, d),
|
|
d,
|
|
i.openEnd,
|
|
),
|
|
);
|
|
}
|
|
}
|
|
let f = e.steps.length;
|
|
for (
|
|
let n = l.length - 1;
|
|
n >= 0 && (e.replace(t, r, i), !(e.steps.length > f));
|
|
n--
|
|
) {
|
|
let e = l[n];
|
|
e < 0 || ((t = o.before(e)), (r = s.after(e)));
|
|
}
|
|
})(this, e, t, r),
|
|
this
|
|
);
|
|
}
|
|
replaceRangeWith(e, t, r) {
|
|
var i = e,
|
|
o = t;
|
|
if (!r.isInline && i == o && this.doc.resolve(i).parent.content.size) {
|
|
let e = (function (e, t, n) {
|
|
let r = e.resolve(t);
|
|
if (r.parent.canReplaceWith(r.index(), r.index(), n)) return t;
|
|
if (0 == r.parentOffset)
|
|
for (let e = r.depth - 1; e >= 0; e--) {
|
|
let t = r.index(e);
|
|
if (r.node(e).canReplaceWith(t, t, n)) return r.before(e + 1);
|
|
if (t > 0) return null;
|
|
}
|
|
if (r.parentOffset == r.parent.content.size)
|
|
for (let e = r.depth - 1; e >= 0; e--) {
|
|
let t = r.indexAfter(e);
|
|
if (r.node(e).canReplaceWith(t, t, n)) return r.after(e + 1);
|
|
if (t < r.node(e).childCount) break;
|
|
}
|
|
return null;
|
|
})(this.doc, i, r.type);
|
|
null != e && (i = o = e);
|
|
}
|
|
return this.replaceRange(i, o, new a(n.from(r), 0, 0)), this;
|
|
}
|
|
deleteRange(e, t) {
|
|
return (
|
|
!(function (e, t, n) {
|
|
let r = e.doc.resolve(t),
|
|
i = e.doc.resolve(n),
|
|
o = eA(r, i);
|
|
for (let t = 0; t < o.length; t++) {
|
|
let n = o[t],
|
|
s = t == o.length - 1;
|
|
if ((s && 0 == n) || r.node(n).type.contentMatch.validEnd)
|
|
return e.delete(r.start(n), i.end(n));
|
|
if (
|
|
n > 0 &&
|
|
(s ||
|
|
r.node(n - 1).canReplace(r.index(n - 1), i.indexAfter(n - 1)))
|
|
)
|
|
return e.delete(r.before(n), i.after(n));
|
|
}
|
|
for (let o = 1; o <= r.depth && o <= i.depth; o++)
|
|
if (
|
|
t - r.start(o) == r.depth - o &&
|
|
n > r.end(o) &&
|
|
i.end(o) - n != i.depth - o &&
|
|
r.start(o - 1) == i.start(o - 1) &&
|
|
r.node(o - 1).canReplace(r.index(o - 1), i.index(o - 1))
|
|
)
|
|
return e.delete(r.before(o), n);
|
|
e.delete(t, n);
|
|
})(this, e, t),
|
|
this
|
|
);
|
|
}
|
|
lift(e, t) {
|
|
return (
|
|
!(function (e, t, r) {
|
|
let { $from: i, $to: o, depth: s } = t,
|
|
l = i.before(s + 1),
|
|
d = o.after(s + 1),
|
|
c = l,
|
|
h = d,
|
|
p = n.empty,
|
|
u = 0;
|
|
for (let e = s, t = !1; e > r; e--)
|
|
t || i.index(e) > 0
|
|
? ((t = !0), (p = n.from(i.node(e).copy(p))), u++)
|
|
: c--;
|
|
let f = n.empty,
|
|
m = 0;
|
|
for (let e = s, t = !1; e > r; e--)
|
|
t || o.after(e + 1) < o.end(e)
|
|
? ((t = !0), (f = n.from(o.node(e).copy(f))), m++)
|
|
: h++;
|
|
e.step(
|
|
new ec(c, h, l, d, new a(p.append(f), u, m), p.size - u, !0),
|
|
);
|
|
})(this, e, t),
|
|
this
|
|
);
|
|
}
|
|
join(e, t = 1) {
|
|
return (
|
|
!(function (e, t, n) {
|
|
let r = null,
|
|
{ linebreakReplacement: i } = e.doc.type.schema,
|
|
o = e.doc.resolve(t - n),
|
|
s = o.node().type;
|
|
if (i && s.inlineContent) {
|
|
let e = "pre" == s.whitespace,
|
|
t = !!s.contentMatch.matchType(i);
|
|
e && !t ? (r = !1) : !e && t && (r = !0);
|
|
}
|
|
let l = e.steps.length;
|
|
if (!1 === r) {
|
|
let r = e.doc.resolve(t + n);
|
|
ey(e, r.node(), r.before(), l);
|
|
}
|
|
s.inlineContent &&
|
|
ep(
|
|
e,
|
|
t + n - 1,
|
|
s,
|
|
o.node().contentMatchAt(o.index()),
|
|
null == r,
|
|
);
|
|
let d = e.mapping.slice(l),
|
|
c = d.map(t - n);
|
|
if ((e.step(new ed(c, d.map(t + n, -1), a.empty, !0)), !0 === r)) {
|
|
let t = e.doc.resolve(c);
|
|
eg(e, t.node(), t.before(), e.steps.length);
|
|
}
|
|
})(this, e, t),
|
|
this
|
|
);
|
|
}
|
|
wrap(e, t) {
|
|
return (
|
|
!(function (e, t, r) {
|
|
let i = n.empty;
|
|
for (let e = r.length - 1; e >= 0; e--) {
|
|
if (i.size) {
|
|
let t = r[e].type.contentMatch.matchFragment(i);
|
|
if (!t || !t.validEnd)
|
|
throw RangeError(
|
|
"Wrapper type given to Transform.wrap does not form valid content of its parent wrapper",
|
|
);
|
|
}
|
|
i = n.from(r[e].type.create(r[e].attrs, i));
|
|
}
|
|
let o = t.start,
|
|
s = t.end;
|
|
e.step(new ec(o, s, o, s, new a(i, 0, 0), r.length, !0));
|
|
})(this, e, t),
|
|
this
|
|
);
|
|
}
|
|
setBlockType(e, t = e, r, i = null) {
|
|
var o = this;
|
|
if (!r.isTextblock)
|
|
throw RangeError("Type given to setBlockType should be a textblock");
|
|
let s = o.steps.length;
|
|
return (
|
|
o.doc.nodesBetween(e, t, (e, t) => {
|
|
var l, d, c;
|
|
let h,
|
|
p,
|
|
u = "function" == typeof i ? i(e) : i;
|
|
if (
|
|
e.isTextblock &&
|
|
!e.hasMarkup(r, u) &&
|
|
((l = o.doc),
|
|
(d = o.mapping.slice(s).map(t)),
|
|
(c = r),
|
|
(p = (h = l.resolve(d)).index()),
|
|
h.parent.canReplaceWith(p, p + 1, c))
|
|
) {
|
|
let i = null;
|
|
if (r.schema.linebreakReplacement) {
|
|
let e = "pre" == r.whitespace,
|
|
t = !!r.contentMatch.matchType(r.schema.linebreakReplacement);
|
|
e && !t ? (i = !1) : !e && t && (i = !0);
|
|
}
|
|
!1 === i && ey(o, e, t, s),
|
|
ep(o, o.mapping.slice(s).map(t, 1), r, void 0, null === i);
|
|
let l = o.mapping.slice(s),
|
|
d = l.map(t, 1),
|
|
c = l.map(t + e.nodeSize, 1);
|
|
return (
|
|
o.step(
|
|
new ec(
|
|
d,
|
|
c,
|
|
d + 1,
|
|
c - 1,
|
|
new a(n.from(r.create(u, null, e.marks)), 0, 0),
|
|
1,
|
|
!0,
|
|
),
|
|
),
|
|
!0 === i && eg(o, e, t, s),
|
|
!1
|
|
);
|
|
}
|
|
}),
|
|
this
|
|
);
|
|
}
|
|
setNodeMarkup(e, t, r = null, i) {
|
|
return (
|
|
!(function (e, t, r, i, o) {
|
|
let s = e.doc.nodeAt(t);
|
|
if (!s) throw RangeError("No node at given position");
|
|
r || (r = s.type);
|
|
let l = r.create(i, null, o || s.marks);
|
|
if (s.isLeaf) return e.replaceWith(t, t + s.nodeSize, l);
|
|
if (!r.validContent(s.content))
|
|
throw RangeError("Invalid content for node type " + r.name);
|
|
e.step(
|
|
new ec(
|
|
t,
|
|
t + s.nodeSize,
|
|
t + 1,
|
|
t + s.nodeSize - 1,
|
|
new a(n.from(l), 0, 0),
|
|
1,
|
|
!0,
|
|
),
|
|
);
|
|
})(this, e, t, r, i),
|
|
this
|
|
);
|
|
}
|
|
setNodeAttribute(e, t, n) {
|
|
return this.step(new eD(e, t, n)), this;
|
|
}
|
|
setDocAttribute(e, t) {
|
|
return this.step(new eR(e, t)), this;
|
|
}
|
|
addNodeMark(e, t) {
|
|
return this.step(new el(e, t)), this;
|
|
}
|
|
removeNodeMark(e, t) {
|
|
let n = this.doc.nodeAt(e);
|
|
if (!n) throw RangeError("No node at position " + e);
|
|
if (t instanceof s) t.isInSet(n.marks) && this.step(new ea(e, t));
|
|
else {
|
|
let r = n.marks,
|
|
i,
|
|
o = [];
|
|
for (; (i = t.isInSet(r)); )
|
|
o.push(new ea(e, i)), (r = i.removeFromSet(r));
|
|
for (let e = o.length - 1; e >= 0; e--) this.step(o[e]);
|
|
}
|
|
return this;
|
|
}
|
|
split(e, t = 1, r) {
|
|
return (
|
|
!(function (e, t, r = 1, i) {
|
|
let o = e.doc.resolve(t),
|
|
s = n.empty,
|
|
l = n.empty;
|
|
for (let e = o.depth, t = o.depth - r, a = r - 1; e > t; e--, a--) {
|
|
s = n.from(o.node(e).copy(s));
|
|
let t = i && i[a];
|
|
l = n.from(t ? t.type.create(t.attrs, l) : o.node(e).copy(l));
|
|
}
|
|
e.step(new ed(t, t, new a(s.append(l), r, r), !0));
|
|
})(this, e, t, r),
|
|
this
|
|
);
|
|
}
|
|
addMark(e, t, n) {
|
|
var r;
|
|
let i, o, s, l;
|
|
return (
|
|
(r = this),
|
|
(s = []),
|
|
(l = []),
|
|
r.doc.nodesBetween(e, t, (r, a, d) => {
|
|
if (!r.isInline) return;
|
|
let c = r.marks;
|
|
if (!n.isInSet(c) && d.type.allowsMarkType(n.type)) {
|
|
let d = Math.max(a, e),
|
|
h = Math.min(a + r.nodeSize, t),
|
|
p = n.addToSet(c);
|
|
for (let e = 0; e < c.length; e++)
|
|
c[e].isInSet(p) ||
|
|
(i && i.to == d && i.mark.eq(c[e])
|
|
? (i.to = h)
|
|
: s.push((i = new es(d, h, c[e]))));
|
|
o && o.to == d ? (o.to = h) : l.push((o = new eo(d, h, n)));
|
|
}
|
|
}),
|
|
s.forEach((e) => r.step(e)),
|
|
l.forEach((e) => r.step(e)),
|
|
this
|
|
);
|
|
}
|
|
removeMark(e, t, n) {
|
|
var r;
|
|
let i, o;
|
|
return (
|
|
(r = this),
|
|
(i = []),
|
|
(o = 0),
|
|
r.doc.nodesBetween(e, t, (r, s) => {
|
|
if (!r.isInline) return;
|
|
o++;
|
|
let l = null;
|
|
if (n instanceof L) {
|
|
let e = r.marks,
|
|
t;
|
|
for (; (t = n.isInSet(e)); )
|
|
(l || (l = [])).push(t), (e = t.removeFromSet(e));
|
|
} else n ? n.isInSet(r.marks) && (l = [n]) : (l = r.marks);
|
|
if (l && l.length) {
|
|
let n = Math.min(s + r.nodeSize, t);
|
|
for (let t = 0; t < l.length; t++) {
|
|
let r = l[t],
|
|
a;
|
|
for (let e = 0; e < i.length; e++) {
|
|
let t = i[e];
|
|
t.step == o - 1 && r.eq(i[e].style) && (a = t);
|
|
}
|
|
a
|
|
? ((a.to = n), (a.step = o))
|
|
: i.push({ style: r, from: Math.max(s, e), to: n, step: o });
|
|
}
|
|
}
|
|
}),
|
|
i.forEach((e) => r.step(new es(e.from, e.to, e.style))),
|
|
this
|
|
);
|
|
}
|
|
clearIncompatible(e, t, n) {
|
|
return ep(this, e, t, n), this;
|
|
}
|
|
}
|
|
e.s(
|
|
[
|
|
"Mapping",
|
|
() => ee,
|
|
"RemoveMarkStep",
|
|
() => es,
|
|
"ReplaceAroundStep",
|
|
() => ec,
|
|
"ReplaceStep",
|
|
() => ed,
|
|
"Transform",
|
|
() => eP,
|
|
"canJoin",
|
|
() => ek,
|
|
"canSplit",
|
|
() => eb,
|
|
"dropPoint",
|
|
() => eS,
|
|
"findWrapping",
|
|
() => ef,
|
|
"joinPoint",
|
|
() => ew,
|
|
"liftTarget",
|
|
() => eu,
|
|
"replaceStep",
|
|
() => ex,
|
|
],
|
|
545773,
|
|
);
|
|
};
|
|
|
|
export default moduleFactory;
|