@fewangsit/wangsvue 1.5.219-alpha.1 → 1.5.219-alpha.2

package/vendor/prosemirror-state/dist/index.es.js

@@ -1,14 +1,16 @@
-import { b as m, F as x, N as B, M as J } from "../../prosemirror-model/dist/index.es.js";
-import { R as P, b as K, T as $ } from "../../prosemirror-transform/dist/index.es.js";
-const M = /* @__PURE__ */ Object.create(null);
-class l {
+import { b as Slice, F as Fragment, N as Node, M as Mark } from "../../prosemirror-model/dist/index.es.js";
+import { R as ReplaceStep, b as ReplaceAroundStep, T as Transform } from "../../prosemirror-transform/dist/index.es.js";
+const classesById = /* @__PURE__ */ Object.create(null);
+class Selection {
   /**
   Initialize a selection with the head and anchor and ranges. If no
   ranges are given, constructs a single range across `$anchor` and
   `$head`.
   */
-  constructor(e, t, r) {
-    this.$anchor = e, this.$head = t, this.ranges = r || [new q(e.min(t), e.max(t))];
+  constructor($anchor, $head, ranges) {
+    this.$anchor = $anchor;
+    this.$head = $head;
+    this.ranges = ranges || [new SelectionRange($anchor.min($head), $anchor.max($head))];
   }
   /**
   The selection's anchor, as an unresolved position.
@@ -50,41 +52,51 @@ class l {
   Indicates whether the selection contains any content.
   */
   get empty() {
-    let e = this.ranges;
-    for (let t = 0; t < e.length; t++)
-      if (e[t].$from.pos != e[t].$to.pos)
-        return !1;
-    return !0;
+    let ranges = this.ranges;
+    for (let i = 0; i < ranges.length; i++)
+      if (ranges[i].$from.pos != ranges[i].$to.pos)
+        return false;
+    return true;
   }
   /**
   Get the content of this selection as a slice.
   */
   content() {
-    return this.$from.doc.slice(this.from, this.to, !0);
+    return this.$from.doc.slice(this.from, this.to, true);
   }
   /**
   Replace the selection with a slice or, if no slice is given,
   delete the selection. Will append to the given transaction.
   */
-  replace(e, t = m.empty) {
-    let r = t.content.lastChild, n = null;
-    for (let a = 0; a < t.openEnd; a++)
-      n = r, r = r.lastChild;
-    let s = e.steps.length, o = this.ranges;
-    for (let a = 0; a < o.length; a++) {
-      let { $from: c, $to: u } = o[a], h = e.mapping.slice(s);
-      e.replaceRange(h.map(c.pos), h.map(u.pos), a ? m.empty : t), a == 0 && I(e, s, (r ? r.isInline : n && n.isTextblock) ? -1 : 1);
+  replace(tr, content = Slice.empty) {
+    let lastNode = content.content.lastChild, lastParent = null;
+    for (let i = 0; i < content.openEnd; i++) {
+      lastParent = lastNode;
+      lastNode = lastNode.lastChild;
+    }
+    let mapFrom = tr.steps.length, ranges = this.ranges;
+    for (let i = 0; i < ranges.length; i++) {
+      let { $from, $to } = ranges[i], mapping = tr.mapping.slice(mapFrom);
+      tr.replaceRange(mapping.map($from.pos), mapping.map($to.pos), i ? Slice.empty : content);
+      if (i == 0)
+        selectionToInsertionEnd(tr, mapFrom, (lastNode ? lastNode.isInline : lastParent && lastParent.isTextblock) ? -1 : 1);
     }
   }
   /**
   Replace the selection with the given node, appending the changes
   to the given transaction.
   */
-  replaceWith(e, t) {
-    let r = e.steps.length, n = this.ranges;
-    for (let s = 0; s < n.length; s++) {
-      let { $from: o, $to: a } = n[s], c = e.mapping.slice(r), u = c.map(o.pos), h = c.map(a.pos);
-      s ? e.deleteRange(u, h) : (e.replaceRangeWith(u, h, t), I(e, r, t.isInline ? -1 : 1));
+  replaceWith(tr, node) {
+    let mapFrom = tr.steps.length, ranges = this.ranges;
+    for (let i = 0; i < ranges.length; i++) {
+      let { $from, $to } = ranges[i], mapping = tr.mapping.slice(mapFrom);
+      let from = mapping.map($from.pos), to = mapping.map($to.pos);
+      if (i) {
+        tr.deleteRange(from, to);
+      } else {
+        tr.replaceRangeWith(from, to, node);
+        selectionToInsertionEnd(tr, mapFrom, node.isInline ? -1 : 1);
+      }
     }
   }
   /**
@@ -94,14 +106,14 @@ class l {
   selections. Will return null when no valid selection position is
   found.
   */
-  static findFrom(e, t, r = !1) {
-    let n = e.parent.inlineContent ? new f(e) : g(e.node(0), e.parent, e.pos, e.index(), t, r);
-    if (n)
-      return n;
-    for (let s = e.depth - 1; s >= 0; s--) {
-      let o = t < 0 ? g(e.node(0), e.node(s), e.before(s + 1), e.index(s), t, r) : g(e.node(0), e.node(s), e.after(s + 1), e.index(s) + 1, t, r);
-      if (o)
-        return o;
+  static findFrom($pos, dir, textOnly = false) {
+    let inner = $pos.parent.inlineContent ? new TextSelection($pos) : findSelectionIn($pos.node(0), $pos.parent, $pos.pos, $pos.index(), dir, textOnly);
+    if (inner)
+      return inner;
+    for (let depth = $pos.depth - 1; depth >= 0; depth--) {
+      let found = dir < 0 ? findSelectionIn($pos.node(0), $pos.node(depth), $pos.before(depth + 1), $pos.index(depth), dir, textOnly) : findSelectionIn($pos.node(0), $pos.node(depth), $pos.after(depth + 1), $pos.index(depth) + 1, dir, textOnly);
+      if (found)
+        return found;
     }
     return null;
   }
@@ -110,8 +122,8 @@ class l {
   position. Searches forward first by default, but if `bias` is
   negative, it will search backwards first.
   */
-  static near(e, t = 1) {
-    return this.findFrom(e, t) || this.findFrom(e, -t) || new d(e.node(0));
+  static near($pos, bias = 1) {
+    return this.findFrom($pos, bias) || this.findFrom($pos, -bias) || new AllSelection($pos.node(0));
   }
   /**
   Find the cursor or leaf node selection closest to the start of
@@ -119,27 +131,27 @@ class l {
   [`AllSelection`](https://prosemirror.net/docs/ref/#state.AllSelection) if no valid position
   exists.
   */
-  static atStart(e) {
-    return g(e, e, 0, 0, 1) || new d(e);
+  static atStart(doc) {
+    return findSelectionIn(doc, doc, 0, 0, 1) || new AllSelection(doc);
   }
   /**
   Find the cursor or leaf node selection closest to the end of the
   given document.
   */
-  static atEnd(e) {
-    return g(e, e, e.content.size, e.childCount, -1) || new d(e);
+  static atEnd(doc) {
+    return findSelectionIn(doc, doc, doc.content.size, doc.childCount, -1) || new AllSelection(doc);
   }
   /**
   Deserialize the JSON representation of a selection. Must be
   implemented for custom classes (as a static class method).
   */
-  static fromJSON(e, t) {
-    if (!t || !t.type)
+  static fromJSON(doc, json) {
+    if (!json || !json.type)
       throw new RangeError("Invalid input for Selection.fromJSON");
-    let r = M[t.type];
-    if (!r)
-      throw new RangeError(`No selection type ${t.type} defined`);
-    return r.fromJSON(e, t);
+    let cls = classesById[json.type];
+    if (!cls)
+      throw new RangeError(`No selection type ${json.type} defined`);
+    return cls.fromJSON(doc, json);
   }
   /**
   To be able to deserialize selections from JSON, custom selection
@@ -147,10 +159,12 @@ class l {
   can be disambiguated. Try to pick something that's unlikely to
   clash with classes from other modules.
   */
-  static jsonID(e, t) {
-    if (e in M)
-      throw new RangeError("Duplicate use of selection JSON ID " + e);
-    return M[e] = t, t.prototype.jsonID = e, t;
+  static jsonID(id, selectionClass) {
+    if (id in classesById)
+      throw new RangeError("Duplicate use of selection JSON ID " + id);
+    classesById[id] = selectionClass;
+    selectionClass.prototype.jsonID = id;
+    return selectionClass;
   }
   /**
   Get a [bookmark](https://prosemirror.net/docs/ref/#state.SelectionBookmark) for this selection,
@@ -162,28 +176,34 @@ class l {
   returns the bookmark for that.
   */
   getBookmark() {
-    return f.between(this.$anchor, this.$head).getBookmark();
+    return TextSelection.between(this.$anchor, this.$head).getBookmark();
   }
 }
-l.prototype.visible = !0;
-class q {
+Selection.prototype.visible = true;
+class SelectionRange {
   /**
   Create a range.
   */
-  constructor(e, t) {
-    this.$from = e, this.$to = t;
+  constructor($from, $to) {
+    this.$from = $from;
+    this.$to = $to;
   }
 }
-let R = !1;
-function T(i) {
-  !R && !i.parent.inlineContent && (R = !0, console.warn("TextSelection endpoint not pointing into a node with inline content (" + i.parent.type.name + ")"));
+let warnedAboutTextSelection = false;
+function checkTextSelection($pos) {
+  if (!warnedAboutTextSelection && !$pos.parent.inlineContent) {
+    warnedAboutTextSelection = true;
+    console["warn"]("TextSelection endpoint not pointing into a node with inline content (" + $pos.parent.type.name + ")");
+  }
 }
-class f extends l {
+class TextSelection extends Selection {
   /**
   Construct a text selection between the given points.
   */
-  constructor(e, t = e) {
-    T(e), T(t), super(e, t);
+  constructor($anchor, $head = $anchor) {
+    checkTextSelection($anchor);
+    checkTextSelection($head);
+    super($anchor, $head);
   }
   /**
   Returns a resolved position if this is a cursor selection (an
@@ -192,24 +212,26 @@ class f extends l {
   get $cursor() {
     return this.$anchor.pos == this.$head.pos ? this.$head : null;
   }
-  map(e, t) {
-    let r = e.resolve(t.map(this.head));
-    if (!r.parent.inlineContent)
-      return l.near(r);
-    let n = e.resolve(t.map(this.anchor));
-    return new f(n.parent.inlineContent ? n : r, r);
-  }
-  replace(e, t = m.empty) {
-    if (super.replace(e, t), t == m.empty) {
-      let r = this.$from.marksAcross(this.$to);
-      r && e.ensureMarks(r);
+  map(doc, mapping) {
+    let $head = doc.resolve(mapping.map(this.head));
+    if (!$head.parent.inlineContent)
+      return Selection.near($head);
+    let $anchor = doc.resolve(mapping.map(this.anchor));
+    return new TextSelection($anchor.parent.inlineContent ? $anchor : $head, $head);
+  }
+  replace(tr, content = Slice.empty) {
+    super.replace(tr, content);
+    if (content == Slice.empty) {
+      let marks = this.$from.marksAcross(this.$to);
+      if (marks)
+        tr.ensureMarks(marks);
     }
   }
-  eq(e) {
-    return e instanceof f && e.anchor == this.anchor && e.head == this.head;
+  eq(other) {
+    return other instanceof TextSelection && other.anchor == this.anchor && other.head == this.head;
   }
   getBookmark() {
-    return new k(this.anchor, this.head);
+    return new TextBookmark(this.anchor, this.head);
   }
   toJSON() {
     return { type: "text", anchor: this.anchor, head: this.head };
@@ -217,17 +239,17 @@ class f extends l {
   /**
   @internal
   */
-  static fromJSON(e, t) {
-    if (typeof t.anchor != "number" || typeof t.head != "number")
+  static fromJSON(doc, json) {
+    if (typeof json.anchor != "number" || typeof json.head != "number")
       throw new RangeError("Invalid input for TextSelection.fromJSON");
-    return new f(e.resolve(t.anchor), e.resolve(t.head));
+    return new TextSelection(doc.resolve(json.anchor), doc.resolve(json.head));
   }
   /**
   Create a text selection from non-resolved positions.
   */
-  static create(e, t, r = t) {
-    let n = e.resolve(t);
-    return new this(n, r == t ? n : e.resolve(r));
+  static create(doc, anchor, head = anchor) {
+    let $anchor = doc.resolve(anchor);
+    return new this($anchor, head == anchor ? $anchor : doc.resolve(head));
   }
   /**
   Return a text selection that spans the given positions or, if
@@ -237,106 +259,127 @@ class f extends l {
   [`Selection.near`](https://prosemirror.net/docs/ref/#state.Selection^near) when the document
   doesn't contain a valid text position.
   */
-  static between(e, t, r) {
-    let n = e.pos - t.pos;
-    if ((!r || n) && (r = n >= 0 ? 1 : -1), !t.parent.inlineContent) {
-      let s = l.findFrom(t, r, !0) || l.findFrom(t, -r, !0);
-      if (s)
-        t = s.$head;
+  static between($anchor, $head, bias) {
+    let dPos = $anchor.pos - $head.pos;
+    if (!bias || dPos)
+      bias = dPos >= 0 ? 1 : -1;
+    if (!$head.parent.inlineContent) {
+      let found = Selection.findFrom($head, bias, true) || Selection.findFrom($head, -bias, true);
+      if (found)
+        $head = found.$head;
       else
-        return l.near(t, r);
+        return Selection.near($head, bias);
     }
-    return e.parent.inlineContent || (n == 0 ? e = t : (e = (l.findFrom(e, -r, !0) || l.findFrom(e, r, !0)).$anchor, e.pos < t.pos != n < 0 && (e = t))), new f(e, t);
+    if (!$anchor.parent.inlineContent) {
+      if (dPos == 0) {
+        $anchor = $head;
+      } else {
+        $anchor = (Selection.findFrom($anchor, -bias, true) || Selection.findFrom($anchor, bias, true)).$anchor;
+        if ($anchor.pos < $head.pos != dPos < 0)
+          $anchor = $head;
+      }
+    }
+    return new TextSelection($anchor, $head);
   }
 }
-l.jsonID("text", f);
-class k {
-  constructor(e, t) {
-    this.anchor = e, this.head = t;
+Selection.jsonID("text", TextSelection);
+class TextBookmark {
+  constructor(anchor, head) {
+    this.anchor = anchor;
+    this.head = head;
   }
-  map(e) {
-    return new k(e.map(this.anchor), e.map(this.head));
+  map(mapping) {
+    return new TextBookmark(mapping.map(this.anchor), mapping.map(this.head));
   }
-  resolve(e) {
-    return f.between(e.resolve(this.anchor), e.resolve(this.head));
+  resolve(doc) {
+    return TextSelection.between(doc.resolve(this.anchor), doc.resolve(this.head));
   }
 }
-class p extends l {
+class NodeSelection extends Selection {
   /**
   Create a node selection. Does not verify the validity of its
   argument.
   */
-  constructor(e) {
-    let t = e.nodeAfter, r = e.node(0).resolve(e.pos + t.nodeSize);
-    super(e, r), this.node = t;
+  constructor($pos) {
+    let node = $pos.nodeAfter;
+    let $end = $pos.node(0).resolve($pos.pos + node.nodeSize);
+    super($pos, $end);
+    this.node = node;
   }
-  map(e, t) {
-    let { deleted: r, pos: n } = t.mapResult(this.anchor), s = e.resolve(n);
-    return r ? l.near(s) : new p(s);
+  map(doc, mapping) {
+    let { deleted, pos } = mapping.mapResult(this.anchor);
+    let $pos = doc.resolve(pos);
+    if (deleted)
+      return Selection.near($pos);
+    return new NodeSelection($pos);
   }
   content() {
-    return new m(x.from(this.node), 0, 0);
+    return new Slice(Fragment.from(this.node), 0, 0);
   }
-  eq(e) {
-    return e instanceof p && e.anchor == this.anchor;
+  eq(other) {
+    return other instanceof NodeSelection && other.anchor == this.anchor;
   }
   toJSON() {
     return { type: "node", anchor: this.anchor };
   }
   getBookmark() {
-    return new N(this.anchor);
+    return new NodeBookmark(this.anchor);
   }
   /**
   @internal
   */
-  static fromJSON(e, t) {
-    if (typeof t.anchor != "number")
+  static fromJSON(doc, json) {
+    if (typeof json.anchor != "number")
       throw new RangeError("Invalid input for NodeSelection.fromJSON");
-    return new p(e.resolve(t.anchor));
+    return new NodeSelection(doc.resolve(json.anchor));
   }
   /**
   Create a node selection from non-resolved positions.
   */
-  static create(e, t) {
-    return new p(e.resolve(t));
+  static create(doc, from) {
+    return new NodeSelection(doc.resolve(from));
   }
   /**
   Determines whether the given node may be selected as a node
   selection.
   */
-  static isSelectable(e) {
-    return !e.isText && e.type.spec.selectable !== !1;
+  static isSelectable(node) {
+    return !node.isText && node.type.spec.selectable !== false;
   }
 }
-p.prototype.visible = !1;
-l.jsonID("node", p);
-class N {
-  constructor(e) {
-    this.anchor = e;
-  }
-  map(e) {
-    let { deleted: t, pos: r } = e.mapResult(this.anchor);
-    return t ? new k(r, r) : new N(r);
-  }
-  resolve(e) {
-    let t = e.resolve(this.anchor), r = t.nodeAfter;
-    return r && p.isSelectable(r) ? new p(t) : l.near(t);
+NodeSelection.prototype.visible = false;
+Selection.jsonID("node", NodeSelection);
+class NodeBookmark {
+  constructor(anchor) {
+    this.anchor = anchor;
+  }
+  map(mapping) {
+    let { deleted, pos } = mapping.mapResult(this.anchor);
+    return deleted ? new TextBookmark(pos, pos) : new NodeBookmark(pos);
+  }
+  resolve(doc) {
+    let $pos = doc.resolve(this.anchor), node = $pos.nodeAfter;
+    if (node && NodeSelection.isSelectable(node))
+      return new NodeSelection($pos);
+    return Selection.near($pos);
   }
 }
-class d extends l {
+class AllSelection extends Selection {
   /**
   Create an all-selection over the given document.
   */
-  constructor(e) {
-    super(e.resolve(0), e.resolve(e.content.size));
+  constructor(doc) {
+    super(doc.resolve(0), doc.resolve(doc.content.size));
   }
-  replace(e, t = m.empty) {
-    if (t == m.empty) {
-      e.delete(0, e.doc.content.size);
-      let r = l.atStart(e.doc);
-      r.eq(e.selection) || e.setSelection(r);
-    } else
-      super.replace(e, t);
+  replace(tr, content = Slice.empty) {
+    if (content == Slice.empty) {
+      tr.delete(0, tr.doc.content.size);
+      let sel = Selection.atStart(tr.doc);
+      if (!sel.eq(tr.selection))
+        tr.setSelection(sel);
+    } else {
+      super.replace(tr, content);
+    }
   }
   toJSON() {
     return { type: "all" };
@@ -344,64 +387,71 @@ class d extends l {
   /**
   @internal
   */
-  static fromJSON(e) {
-    return new d(e);
+  static fromJSON(doc) {
+    return new AllSelection(doc);
   }
-  map(e) {
-    return new d(e);
+  map(doc) {
+    return new AllSelection(doc);
   }
-  eq(e) {
-    return e instanceof d;
+  eq(other) {
+    return other instanceof AllSelection;
   }
   getBookmark() {
-    return z;
+    return AllBookmark;
   }
 }
-l.jsonID("all", d);
-const z = {
+Selection.jsonID("all", AllSelection);
+const AllBookmark = {
   map() {
     return this;
   },
-  resolve(i) {
-    return new d(i);
+  resolve(doc) {
+    return new AllSelection(doc);
   }
 };
-function g(i, e, t, r, n, s = !1) {
-  if (e.inlineContent)
-    return f.create(i, t);
-  for (let o = r - (n > 0 ? 0 : 1); n > 0 ? o < e.childCount : o >= 0; o += n) {
-    let a = e.child(o);
-    if (a.isAtom) {
-      if (!s && p.isSelectable(a))
-        return p.create(i, t - (n < 0 ? a.nodeSize : 0));
-    } else {
-      let c = g(i, a, t + n, n < 0 ? a.childCount : 0, n, s);
-      if (c)
-        return c;
+function findSelectionIn(doc, node, pos, index, dir, text = false) {
+  if (node.inlineContent)
+    return TextSelection.create(doc, pos);
+  for (let i = index - (dir > 0 ? 0 : 1); dir > 0 ? i < node.childCount : i >= 0; i += dir) {
+    let child = node.child(i);
+    if (!child.isAtom) {
+      let inner = findSelectionIn(doc, child, pos + dir, dir < 0 ? child.childCount : 0, dir, text);
+      if (inner)
+        return inner;
+    } else if (!text && NodeSelection.isSelectable(child)) {
+      return NodeSelection.create(doc, pos - (dir < 0 ? child.nodeSize : 0));
     }
-    t += a.nodeSize * n;
+    pos += child.nodeSize * dir;
   }
   return null;
 }
-function I(i, e, t) {
-  let r = i.steps.length - 1;
-  if (r < e)
+function selectionToInsertionEnd(tr, startLen, bias) {
+  let last = tr.steps.length - 1;
+  if (last < startLen)
     return;
-  let n = i.steps[r];
-  if (!(n instanceof P || n instanceof K))
+  let step = tr.steps[last];
+  if (!(step instanceof ReplaceStep || step instanceof ReplaceAroundStep))
     return;
-  let s = i.mapping.maps[r], o;
-  s.forEach((a, c, u, h) => {
-    o == null && (o = h);
-  }), i.setSelection(l.near(i.doc.resolve(o), t));
+  let map = tr.mapping.maps[last], end;
+  map.forEach((_from, _to, _newFrom, newTo) => {
+    if (end == null)
+      end = newTo;
+  });
+  tr.setSelection(Selection.near(tr.doc.resolve(end), bias));
 }
-const b = 1, E = 2, F = 4;
-class W extends $ {
+const UPDATED_SEL = 1, UPDATED_MARKS = 2, UPDATED_SCROLL = 4;
+class Transaction extends Transform {
   /**
   @internal
   */
-  constructor(e) {
-    super(e.doc), this.curSelectionFor = 0, this.updated = 0, this.meta = /* @__PURE__ */ Object.create(null), this.time = Date.now(), this.curSelection = e.selection, this.storedMarks = e.storedMarks;
+  constructor(state) {
+    super(state.doc);
+    this.curSelectionFor = 0;
+    this.updated = 0;
+    this.meta = /* @__PURE__ */ Object.create(null);
+    this.time = Date.now();
+    this.curSelection = state.selection;
+    this.storedMarks = state.storedMarks;
   }
   /**
   The transaction's current selection. This defaults to the editor
@@ -410,200 +460,240 @@ class W extends $ {
   [`setSelection`](https://prosemirror.net/docs/ref/#state.Transaction.setSelection).
   */
   get selection() {
-    return this.curSelectionFor < this.steps.length && (this.curSelection = this.curSelection.map(this.doc, this.mapping.slice(this.curSelectionFor)), this.curSelectionFor = this.steps.length), this.curSelection;
+    if (this.curSelectionFor < this.steps.length) {
+      this.curSelection = this.curSelection.map(this.doc, this.mapping.slice(this.curSelectionFor));
+      this.curSelectionFor = this.steps.length;
+    }
+    return this.curSelection;
   }
   /**
   Update the transaction's current selection. Will determine the
   selection that the editor gets when the transaction is applied.
   */
-  setSelection(e) {
-    if (e.$from.doc != this.doc)
+  setSelection(selection) {
+    if (selection.$from.doc != this.doc)
       throw new RangeError("Selection passed to setSelection must point at the current document");
-    return this.curSelection = e, this.curSelectionFor = this.steps.length, this.updated = (this.updated | b) & -3, this.storedMarks = null, this;
+    this.curSelection = selection;
+    this.curSelectionFor = this.steps.length;
+    this.updated = (this.updated | UPDATED_SEL) & -3;
+    this.storedMarks = null;
+    return this;
   }
   /**
   Whether the selection was explicitly updated by this transaction.
   */
   get selectionSet() {
-    return (this.updated & b) > 0;
+    return (this.updated & UPDATED_SEL) > 0;
   }
   /**
   Set the current stored marks.
   */
-  setStoredMarks(e) {
-    return this.storedMarks = e, this.updated |= E, this;
+  setStoredMarks(marks) {
+    this.storedMarks = marks;
+    this.updated |= UPDATED_MARKS;
+    return this;
   }
   /**
   Make sure the current stored marks or, if that is null, the marks
   at the selection, match the given set of marks. Does nothing if
   this is already the case.
   */
-  ensureMarks(e) {
-    return J.sameSet(this.storedMarks || this.selection.$from.marks(), e) || this.setStoredMarks(e), this;
+  ensureMarks(marks) {
+    if (!Mark.sameSet(this.storedMarks || this.selection.$from.marks(), marks))
+      this.setStoredMarks(marks);
+    return this;
   }
   /**
   Add a mark to the set of stored marks.
   */
-  addStoredMark(e) {
-    return this.ensureMarks(e.addToSet(this.storedMarks || this.selection.$head.marks()));
+  addStoredMark(mark) {
+    return this.ensureMarks(mark.addToSet(this.storedMarks || this.selection.$head.marks()));
   }
   /**
   Remove a mark or mark type from the set of stored marks.
   */
-  removeStoredMark(e) {
-    return this.ensureMarks(e.removeFromSet(this.storedMarks || this.selection.$head.marks()));
+  removeStoredMark(mark) {
+    return this.ensureMarks(mark.removeFromSet(this.storedMarks || this.selection.$head.marks()));
   }
   /**
   Whether the stored marks were explicitly set for this transaction.
   */
   get storedMarksSet() {
-    return (this.updated & E) > 0;
+    return (this.updated & UPDATED_MARKS) > 0;
   }
   /**
   @internal
   */
-  addStep(e, t) {
-    super.addStep(e, t), this.updated = this.updated & -3, this.storedMarks = null;
+  addStep(step, doc) {
+    super.addStep(step, doc);
+    this.updated = this.updated & -3;
+    this.storedMarks = null;
   }
   /**
   Update the timestamp for the transaction.
   */
-  setTime(e) {
-    return this.time = e, this;
+  setTime(time) {
+    this.time = time;
+    return this;
   }
   /**
   Replace the current selection with the given slice.
   */
-  replaceSelection(e) {
-    return this.selection.replace(this, e), this;
+  replaceSelection(slice) {
+    this.selection.replace(this, slice);
+    return this;
   }
   /**
   Replace the selection with the given node. When `inheritMarks` is
   true and the content is inline, it inherits the marks from the
   place where it is inserted.
   */
-  replaceSelectionWith(e, t = !0) {
-    let r = this.selection;
-    return t && (e = e.mark(this.storedMarks || (r.empty ? r.$from.marks() : r.$from.marksAcross(r.$to) || J.none))), r.replaceWith(this, e), this;
+  replaceSelectionWith(node, inheritMarks = true) {
+    let selection = this.selection;
+    if (inheritMarks)
+      node = node.mark(this.storedMarks || (selection.empty ? selection.$from.marks() : selection.$from.marksAcross(selection.$to) || Mark.none));
+    selection.replaceWith(this, node);
+    return this;
   }
   /**
   Delete the selection.
   */
   deleteSelection() {
-    return this.selection.replace(this), this;
+    this.selection.replace(this);
+    return this;
   }
   /**
   Replace the given range, or the selection if no range is given,
   with a text node containing the given string.
   */
-  insertText(e, t, r) {
-    let n = this.doc.type.schema;
-    if (t == null)
-      return e ? this.replaceSelectionWith(n.text(e), !0) : this.deleteSelection();
-    {
-      if (r == null && (r = t), r = r ?? t, !e)
-        return this.deleteRange(t, r);
-      let s = this.storedMarks;
-      if (!s) {
-        let o = this.doc.resolve(t);
-        s = r == t ? o.marks() : o.marksAcross(this.doc.resolve(r));
+  insertText(text, from, to) {
+    let schema = this.doc.type.schema;
+    if (from == null) {
+      if (!text)
+        return this.deleteSelection();
+      return this.replaceSelectionWith(schema.text(text), true);
+    } else {
+      if (to == null)
+        to = from;
+      to = to == null ? from : to;
+      if (!text)
+        return this.deleteRange(from, to);
+      let marks = this.storedMarks;
+      if (!marks) {
+        let $from = this.doc.resolve(from);
+        marks = to == from ? $from.marks() : $from.marksAcross(this.doc.resolve(to));
       }
-      return this.replaceRangeWith(t, r, n.text(e, s)), this.selection.empty || this.setSelection(l.near(this.selection.$to)), this;
+      this.replaceRangeWith(from, to, schema.text(text, marks));
+      if (!this.selection.empty)
+        this.setSelection(Selection.near(this.selection.$to));
+      return this;
     }
   }
   /**
   Store a metadata property in this transaction, keyed either by
   name or by plugin.
   */
-  setMeta(e, t) {
-    return this.meta[typeof e == "string" ? e : e.key] = t, this;
+  setMeta(key, value) {
+    this.meta[typeof key == "string" ? key : key.key] = value;
+    return this;
   }
   /**
   Retrieve a metadata property for a given name or plugin.
   */
-  getMeta(e) {
-    return this.meta[typeof e == "string" ? e : e.key];
+  getMeta(key) {
+    return this.meta[typeof key == "string" ? key : key.key];
   }
   /**
   Returns true if this transaction doesn't contain any metadata,
   and can thus safely be extended.
   */
   get isGeneric() {
-    for (let e in this.meta)
-      return !1;
-    return !0;
+    for (let _ in this.meta)
+      return false;
+    return true;
   }
   /**
   Indicate that the editor should scroll the selection into view
   when updated to the state produced by this transaction.
   */
   scrollIntoView() {
-    return this.updated |= F, this;
+    this.updated |= UPDATED_SCROLL;
+    return this;
   }
   /**
   True when this transaction has had `scrollIntoView` called on it.
   */
   get scrolledIntoView() {
-    return (this.updated & F) > 0;
+    return (this.updated & UPDATED_SCROLL) > 0;
   }
 }
-function D(i, e) {
-  return !e || !i ? i : i.bind(e);
+function bind(f, self) {
+  return !self || !f ? f : f.bind(self);
 }
-class S {
-  constructor(e, t, r) {
-    this.name = e, this.init = D(t.init, r), this.apply = D(t.apply, r);
+class FieldDesc {
+  constructor(name, desc, self) {
+    this.name = name;
+    this.init = bind(desc.init, self);
+    this.apply = bind(desc.apply, self);
   }
 }
-const L = [
-  new S("doc", {
-    init(i) {
-      return i.doc || i.schema.topNodeType.createAndFill();
+const baseFields = [
+  new FieldDesc("doc", {
+    init(config) {
+      return config.doc || config.schema.topNodeType.createAndFill();
     },
-    apply(i) {
-      return i.doc;
+    apply(tr) {
+      return tr.doc;
     }
   }),
-  new S("selection", {
-    init(i, e) {
-      return i.selection || l.atStart(e.doc);
+  new FieldDesc("selection", {
+    init(config, instance) {
+      return config.selection || Selection.atStart(instance.doc);
     },
-    apply(i) {
-      return i.selection;
+    apply(tr) {
+      return tr.selection;
     }
   }),
-  new S("storedMarks", {
-    init(i) {
-      return i.storedMarks || null;
+  new FieldDesc("storedMarks", {
+    init(config) {
+      return config.storedMarks || null;
     },
-    apply(i, e, t, r) {
-      return r.selection.$cursor ? i.storedMarks : null;
+    apply(tr, _marks, _old, state) {
+      return state.selection.$cursor ? tr.storedMarks : null;
     }
   }),
-  new S("scrollToSelection", {
+  new FieldDesc("scrollToSelection", {
     init() {
       return 0;
     },
-    apply(i, e) {
-      return i.scrolledIntoView ? e + 1 : e;
+    apply(tr, prev) {
+      return tr.scrolledIntoView ? prev + 1 : prev;
     }
   })
 ];
-class O {
-  constructor(e, t) {
-    this.schema = e, this.plugins = [], this.pluginsByKey = /* @__PURE__ */ Object.create(null), this.fields = L.slice(), t && t.forEach((r) => {
-      if (this.pluginsByKey[r.key])
-        throw new RangeError("Adding different instances of a keyed plugin (" + r.key + ")");
-      this.plugins.push(r), this.pluginsByKey[r.key] = r, r.spec.state && this.fields.push(new S(r.key, r.spec.state, r));
-    });
+class Configuration {
+  constructor(schema, plugins) {
+    this.schema = schema;
+    this.plugins = [];
+    this.pluginsByKey = /* @__PURE__ */ Object.create(null);
+    this.fields = baseFields.slice();
+    if (plugins)
+      plugins.forEach((plugin) => {
+        if (this.pluginsByKey[plugin.key])
+          throw new RangeError("Adding different instances of a keyed plugin (" + plugin.key + ")");
+        this.plugins.push(plugin);
+        this.pluginsByKey[plugin.key] = plugin;
+        if (plugin.spec.state)
+          this.fields.push(new FieldDesc(plugin.key, plugin.spec.state, plugin));
+      });
   }
 }
-class w {
+class EditorState {
   /**
   @internal
   */
-  constructor(e) {
-    this.config = e;
+  constructor(config) {
+    this.config = config;
   }
   /**
   The schema of the state's document.
@@ -620,20 +710,20 @@ class w {
   /**
   Apply the given transaction to produce a new state.
   */
-  apply(e) {
-    return this.applyTransaction(e).state;
+  apply(tr) {
+    return this.applyTransaction(tr).state;
   }
   /**
   @internal
   */
-  filterTransaction(e, t = -1) {
-    for (let r = 0; r < this.config.plugins.length; r++)
-      if (r != t) {
-        let n = this.config.plugins[r];
-        if (n.spec.filterTransaction && !n.spec.filterTransaction.call(n, e, this))
-          return !1;
+  filterTransaction(tr, ignore = -1) {
+    for (let i = 0; i < this.config.plugins.length; i++)
+      if (i != ignore) {
+        let plugin = this.config.plugins[i];
+        if (plugin.spec.filterTransaction && !plugin.spec.filterTransaction.call(plugin, tr, this))
+          return false;
       }
-    return !0;
+    return true;
   }
   /**
   Verbose variant of [`apply`](https://prosemirror.net/docs/ref/#state.EditorState.apply) that
@@ -642,58 +732,64 @@ class w {
   hooks](https://prosemirror.net/docs/ref/#state.PluginSpec.filterTransaction) of
   plugins) along with the new state.
   */
-  applyTransaction(e) {
-    if (!this.filterTransaction(e))
+  applyTransaction(rootTr) {
+    if (!this.filterTransaction(rootTr))
       return { state: this, transactions: [] };
-    let t = [e], r = this.applyInner(e), n = null;
+    let trs = [rootTr], newState = this.applyInner(rootTr), seen = null;
     for (; ; ) {
-      let s = !1;
-      for (let o = 0; o < this.config.plugins.length; o++) {
-        let a = this.config.plugins[o];
-        if (a.spec.appendTransaction) {
-          let c = n ? n[o].n : 0, u = n ? n[o].state : this, h = c < t.length && a.spec.appendTransaction.call(a, c ? t.slice(c) : t, u, r);
-          if (h && r.filterTransaction(h, o)) {
-            if (h.setMeta("appendedTransaction", e), !n) {
-              n = [];
-              for (let y = 0; y < this.config.plugins.length; y++)
-                n.push(y < o ? { state: r, n: t.length } : { state: this, n: 0 });
+      let haveNew = false;
+      for (let i = 0; i < this.config.plugins.length; i++) {
+        let plugin = this.config.plugins[i];
+        if (plugin.spec.appendTransaction) {
+          let n = seen ? seen[i].n : 0, oldState = seen ? seen[i].state : this;
+          let tr = n < trs.length && plugin.spec.appendTransaction.call(plugin, n ? trs.slice(n) : trs, oldState, newState);
+          if (tr && newState.filterTransaction(tr, i)) {
+            tr.setMeta("appendedTransaction", rootTr);
+            if (!seen) {
+              seen = [];
+              for (let j = 0; j < this.config.plugins.length; j++)
+                seen.push(j < i ? { state: newState, n: trs.length } : { state: this, n: 0 });
             }
-            t.push(h), r = r.applyInner(h), s = !0;
+            trs.push(tr);
+            newState = newState.applyInner(tr);
+            haveNew = true;
           }
-          n && (n[o] = { state: r, n: t.length });
+          if (seen)
+            seen[i] = { state: newState, n: trs.length };
         }
       }
-      if (!s)
-        return { state: r, transactions: t };
+      if (!haveNew)
+        return { state: newState, transactions: trs };
     }
   }
   /**
   @internal
   */
-  applyInner(e) {
-    if (!e.before.eq(this.doc))
+  applyInner(tr) {
+    if (!tr.before.eq(this.doc))
       throw new RangeError("Applying a mismatched transaction");
-    let t = new w(this.config), r = this.config.fields;
-    for (let n = 0; n < r.length; n++) {
-      let s = r[n];
-      t[s.name] = s.apply(e, this[s.name], this, t);
+    let newInstance = new EditorState(this.config), fields = this.config.fields;
+    for (let i = 0; i < fields.length; i++) {
+      let field = fields[i];
+      newInstance[field.name] = field.apply(tr, this[field.name], this, newInstance);
     }
-    return t;
+    return newInstance;
   }
   /**
   Start a [transaction](https://prosemirror.net/docs/ref/#state.Transaction) from this state.
   */
   get tr() {
-    return new W(this);
+    return new Transaction(this);
   }
   /**
   Create a new state.
   */
-  static create(e) {
-    let t = new O(e.doc ? e.doc.type.schema : e.schema, e.plugins), r = new w(t);
-    for (let n = 0; n < t.fields.length; n++)
-      r[t.fields[n].name] = t.fields[n].init(e, r);
-    return r;
+  static create(config) {
+    let $config = new Configuration(config.doc ? config.doc.type.schema : config.schema, config.plugins);
+    let instance = new EditorState($config);
+    for (let i = 0; i < $config.fields.length; i++)
+      instance[$config.fields[i].name] = $config.fields[i].init(config, instance);
+    return instance;
   }
   /**
   Create a new state based on this one, but with an adjusted set
@@ -703,13 +799,14 @@ class w {
   [`init`](https://prosemirror.net/docs/ref/#state.StateField.init) method, passing in the new
   configuration object..
   */
-  reconfigure(e) {
-    let t = new O(this.schema, e.plugins), r = t.fields, n = new w(t);
-    for (let s = 0; s < r.length; s++) {
-      let o = r[s].name;
-      n[o] = this.hasOwnProperty(o) ? this[o] : r[s].init(e, n);
+  reconfigure(config) {
+    let $config = new Configuration(this.schema, config.plugins);
+    let fields = $config.fields, instance = new EditorState($config);
+    for (let i = 0; i < fields.length; i++) {
+      let name = fields[i].name;
+      instance[name] = this.hasOwnProperty(name) ? this[name] : fields[i].init(config, instance);
     }
-    return n;
+    return instance;
   }
   /**
   Serialize this state to JSON. If you want to serialize the state
@@ -718,16 +815,19 @@ class w {
   a string or number, in which case it is ignored, to support the
   way `JSON.stringify` calls `toString` methods.
   */
-  toJSON(e) {
-    let t = { doc: this.doc.toJSON(), selection: this.selection.toJSON() };
-    if (this.storedMarks && (t.storedMarks = this.storedMarks.map((r) => r.toJSON())), e && typeof e == "object")
-      for (let r in e) {
-        if (r == "doc" || r == "selection")
+  toJSON(pluginFields) {
+    let result = { doc: this.doc.toJSON(), selection: this.selection.toJSON() };
+    if (this.storedMarks)
+      result.storedMarks = this.storedMarks.map((m) => m.toJSON());
+    if (pluginFields && typeof pluginFields == "object")
+      for (let prop in pluginFields) {
+        if (prop == "doc" || prop == "selection")
           throw new RangeError("The JSON fields `doc` and `selection` are reserved");
-        let n = e[r], s = n.spec.state;
-        s && s.toJSON && (t[r] = s.toJSON.call(n, this[n.key]));
+        let plugin = pluginFields[prop], state = plugin.spec.state;
+        if (state && state.toJSON)
+          result[prop] = state.toJSON.call(plugin, this[plugin.key]);
       }
-    return t;
+    return result;
   }
   /**
   Deserialize a JSON representation of a state. `config` should
@@ -736,85 +836,99 @@ class w {
   to deserialize the state of plugins, by associating plugin
   instances with the property names they use in the JSON object.
   */
-  static fromJSON(e, t, r) {
-    if (!t)
+  static fromJSON(config, json, pluginFields) {
+    if (!json)
       throw new RangeError("Invalid input for EditorState.fromJSON");
-    if (!e.schema)
+    if (!config.schema)
       throw new RangeError("Required config field 'schema' missing");
-    let n = new O(e.schema, e.plugins), s = new w(n);
-    return n.fields.forEach((o) => {
-      if (o.name == "doc")
-        s.doc = B.fromJSON(e.schema, t.doc);
-      else if (o.name == "selection")
-        s.selection = l.fromJSON(s.doc, t.selection);
-      else if (o.name == "storedMarks")
-        t.storedMarks && (s.storedMarks = t.storedMarks.map(e.schema.markFromJSON));
-      else {
-        if (r)
-          for (let a in r) {
-            let c = r[a], u = c.spec.state;
-            if (c.key == o.name && u && u.fromJSON && Object.prototype.hasOwnProperty.call(t, a)) {
-              s[o.name] = u.fromJSON.call(c, e, t[a], s);
+    let $config = new Configuration(config.schema, config.plugins);
+    let instance = new EditorState($config);
+    $config.fields.forEach((field) => {
+      if (field.name == "doc") {
+        instance.doc = Node.fromJSON(config.schema, json.doc);
+      } else if (field.name == "selection") {
+        instance.selection = Selection.fromJSON(instance.doc, json.selection);
+      } else if (field.name == "storedMarks") {
+        if (json.storedMarks)
+          instance.storedMarks = json.storedMarks.map(config.schema.markFromJSON);
+      } else {
+        if (pluginFields)
+          for (let prop in pluginFields) {
+            let plugin = pluginFields[prop], state = plugin.spec.state;
+            if (plugin.key == field.name && state && state.fromJSON && Object.prototype.hasOwnProperty.call(json, prop)) {
+              instance[field.name] = state.fromJSON.call(plugin, config, json[prop], instance);
               return;
             }
           }
-        s[o.name] = o.init(e, s);
+        instance[field.name] = field.init(config, instance);
       }
-    }), s;
+    });
+    return instance;
   }
 }
-function A(i, e, t) {
-  for (let r in i) {
-    let n = i[r];
-    n instanceof Function ? n = n.bind(e) : r == "handleDOMEvents" && (n = A(n, e, {})), t[r] = n;
-  }
-  return t;
+function bindProps(obj, self, target) {
+  for (let prop in obj) {
+    let val = obj[prop];
+    if (val instanceof Function)
+      val = val.bind(self);
+    else if (prop == "handleDOMEvents")
+      val = bindProps(val, self, {});
+    target[prop] = val;
+  }
+  return target;
 }
-class G {
+class Plugin {
   /**
   Create a plugin.
   */
-  constructor(e) {
-    this.spec = e, this.props = {}, e.props && A(e.props, this, this.props), this.key = e.key ? e.key.key : C("plugin");
+  constructor(spec) {
+    this.spec = spec;
+    this.props = {};
+    if (spec.props)
+      bindProps(spec.props, this, this.props);
+    this.key = spec.key ? spec.key.key : createKey("plugin");
   }
   /**
   Extract the plugin's state field from an editor state.
   */
-  getState(e) {
-    return e[this.key];
+  getState(state) {
+    return state[this.key];
   }
 }
-const v = /* @__PURE__ */ Object.create(null);
-function C(i) {
-  return i in v ? i + "$" + ++v[i] : (v[i] = 0, i + "$");
+const keys = /* @__PURE__ */ Object.create(null);
+function createKey(name) {
+  if (name in keys)
+    return name + "$" + ++keys[name];
+  keys[name] = 0;
+  return name + "$";
 }
-class H {
+class PluginKey {
   /**
   Create a plugin key.
   */
-  constructor(e = "key") {
-    this.key = C(e);
+  constructor(name = "key") {
+    this.key = createKey(name);
   }
   /**
   Get the active plugin with this key, if any, from an editor
   state.
   */
-  get(e) {
-    return e.config.pluginsByKey[this.key];
+  get(state) {
+    return state.config.pluginsByKey[this.key];
   }
   /**
   Get the plugin's state from an editor state.
   */
-  getState(e) {
-    return e[this.key];
+  getState(state) {
+    return state[this.key];
   }
 }
 export {
-  d as A,
-  w as E,
-  p as N,
-  G as P,
-  l as S,
-  f as T,
-  H as a
+  AllSelection as A,
+  EditorState as E,
+  NodeSelection as N,
+  Plugin as P,
+  Selection as S,
+  TextSelection as T,
+  PluginKey as a
 };