import { Slice as m, Fragment as x, Node as B, Mark as R } from "../../../../prosemirror-model@1.25.1/node_modules/prosemirror-model/dist/index.js";
import { ReplaceStep as P, ReplaceAroundStep as K, Transform as $ } from "../../../../prosemirror-transform@1.10.4/node_modules/prosemirror-transform/dist/index.js";
const O = /* @__PURE__ */ Object.create(null);
class l {
  /**
  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))];
  }
  /**
  The selection's anchor, as an unresolved position.
  */
  get anchor() {
    return this.$anchor.pos;
  }
  /**
  The selection's head.
  */
  get head() {
    return this.$head.pos;
  }
  /**
  The lower bound of the selection's main range.
  */
  get from() {
    return this.$from.pos;
  }
  /**
  The upper bound of the selection's main range.
  */
  get to() {
    return this.$to.pos;
  }
  /**
  The resolved lower  bound of the selection's main range.
  */
  get $from() {
    return this.ranges[0].$from;
  }
  /**
  The resolved upper bound of the selection's main range.
  */
  get $to() {
    return this.ranges[0].$to;
  }
  /**
  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;
  }
  /**
  Get the content of this selection as a slice.
  */
  content() {
    return this.$from.doc.slice(this.from, this.to, !0);
  }
  /**
  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 && E(e, s, (r ? r.isInline : n && n.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), E(e, r, t.isInline ? -1 : 1));
    }
  }
  /**
  Find a valid cursor or leaf node selection starting at the given
  position and searching back if `dir` is negative, and forward if
  positive. When `textOnly` is true, only consider cursor
  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;
    }
    return null;
  }
  /**
  Find a valid cursor or leaf node selection near the given
  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));
  }
  /**
  Find the cursor or leaf node selection closest to the start of
  the given document. Will return an
  [`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);
  }
  /**
  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);
  }
  /**
  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)
      throw new RangeError("Invalid input for Selection.fromJSON");
    let r = O[t.type];
    if (!r)
      throw new RangeError(`No selection type ${t.type} defined`);
    return r.fromJSON(e, t);
  }
  /**
  To be able to deserialize selections from JSON, custom selection
  classes must register themselves with an ID string, so that they
  can be disambiguated. Try to pick something that's unlikely to
  clash with classes from other modules.
  */
  static jsonID(e, t) {
    if (e in O)
      throw new RangeError("Duplicate use of selection JSON ID " + e);
    return O[e] = t, t.prototype.jsonID = e, t;
  }
  /**
  Get a [bookmark](https://prosemirror.net/docs/ref/#state.SelectionBookmark) for this selection,
  which is a value that can be mapped without having access to a
  current document, and later resolved to a real selection for a
  given document again. (This is used mostly by the history to
  track and restore old selections.) The default implementation of
  this method just converts the selection to a text selection and
  returns the bookmark for that.
  */
  getBookmark() {
    return f.between(this.$anchor, this.$head).getBookmark();
  }
}
l.prototype.visible = !0;
class q {
  /**
  Create a range.
  */
  constructor(e, t) {
    this.$from = e, this.$to = t;
  }
}
let I = !1;
function T(i) {
  !I && !i.parent.inlineContent && (I = !0, console.warn("TextSelection endpoint not pointing into a node with inline content (" + i.parent.type.name + ")"));
}
class f extends l {
  /**
  Construct a text selection between the given points.
  */
  constructor(e, t = e) {
    T(e), T(t), super(e, t);
  }
  /**
  Returns a resolved position if this is a cursor selection (an
  empty text selection), and null otherwise.
  */
  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);
    }
  }
  eq(e) {
    return e instanceof f && e.anchor == this.anchor && e.head == this.head;
  }
  getBookmark() {
    return new y(this.anchor, this.head);
  }
  toJSON() {
    return { type: "text", anchor: this.anchor, head: this.head };
  }
  /**
  @internal
  */
  static fromJSON(e, t) {
    if (typeof t.anchor != "number" || typeof t.head != "number")
      throw new RangeError("Invalid input for TextSelection.fromJSON");
    return new f(e.resolve(t.anchor), e.resolve(t.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));
  }
  /**
  Return a text selection that spans the given positions or, if
  they aren't text positions, find a text selection near them.
  `bias` determines whether the method searches forward (default)
  or backwards (negative number) first. Will fall back to calling
  [`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;
      else
        return l.near(t, r);
    }
    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);
  }
}
l.jsonID("text", f);
class y {
  constructor(e, t) {
    this.anchor = e, this.head = t;
  }
  map(e) {
    return new y(e.map(this.anchor), e.map(this.head));
  }
  resolve(e) {
    return f.between(e.resolve(this.anchor), e.resolve(this.head));
  }
}
class p extends l {
  /**
  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;
  }
  map(e, t) {
    let { deleted: r, pos: n } = t.mapResult(this.anchor), s = e.resolve(n);
    return r ? l.near(s) : new p(s);
  }
  content() {
    return new m(x.from(this.node), 0, 0);
  }
  eq(e) {
    return e instanceof p && e.anchor == this.anchor;
  }
  toJSON() {
    return { type: "node", anchor: this.anchor };
  }
  getBookmark() {
    return new J(this.anchor);
  }
  /**
  @internal
  */
  static fromJSON(e, t) {
    if (typeof t.anchor != "number")
      throw new RangeError("Invalid input for NodeSelection.fromJSON");
    return new p(e.resolve(t.anchor));
  }
  /**
  Create a node selection from non-resolved positions.
  */
  static create(e, t) {
    return new p(e.resolve(t));
  }
  /**
  Determines whether the given node may be selected as a node
  selection.
  */
  static isSelectable(e) {
    return !e.isText && e.type.spec.selectable !== !1;
  }
}
p.prototype.visible = !1;
l.jsonID("node", p);
class J {
  constructor(e) {
    this.anchor = e;
  }
  map(e) {
    let { deleted: t, pos: r } = e.mapResult(this.anchor);
    return t ? new y(r, r) : new J(r);
  }
  resolve(e) {
    let t = e.resolve(this.anchor), r = t.nodeAfter;
    return r && p.isSelectable(r) ? new p(t) : l.near(t);
  }
}
class d extends l {
  /**
  Create an all-selection over the given document.
  */
  constructor(e) {
    super(e.resolve(0), e.resolve(e.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);
  }
  toJSON() {
    return { type: "all" };
  }
  /**
  @internal
  */
  static fromJSON(e) {
    return new d(e);
  }
  map(e) {
    return new d(e);
  }
  eq(e) {
    return e instanceof d;
  }
  getBookmark() {
    return z;
  }
}
l.jsonID("all", d);
const z = {
  map() {
    return this;
  },
  resolve(i) {
    return new d(i);
  }
};
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;
    }
    t += a.nodeSize * n;
  }
  return null;
}
function E(i, e, t) {
  let r = i.steps.length - 1;
  if (r < e)
    return;
  let n = i.steps[r];
  if (!(n instanceof P || n instanceof K))
    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));
}
const b = 1, k = 2, F = 4;
class W extends $ {
  /**
  @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;
  }
  /**
  The transaction's current selection. This defaults to the editor
  selection [mapped](https://prosemirror.net/docs/ref/#state.Selection.map) through the steps in the
  transaction, but can be overwritten with
  [`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;
  }
  /**
  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)
      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) & ~k, this.storedMarks = null, this;
  }
  /**
  Whether the selection was explicitly updated by this transaction.
  */
  get selectionSet() {
    return (this.updated & b) > 0;
  }
  /**
  Set the current stored marks.
  */
  setStoredMarks(e) {
    return this.storedMarks = e, this.updated |= k, 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 R.sameSet(this.storedMarks || this.selection.$from.marks(), e) || this.setStoredMarks(e), this;
  }
  /**
  Add a mark to the set of stored marks.
  */
  addStoredMark(e) {
    return this.ensureMarks(e.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()));
  }
  /**
  Whether the stored marks were explicitly set for this transaction.
  */
  get storedMarksSet() {
    return (this.updated & k) > 0;
  }
  /**
  @internal
  */
  addStep(e, t) {
    super.addStep(e, t), this.updated = this.updated & ~k, this.storedMarks = null;
  }
  /**
  Update the timestamp for the transaction.
  */
  setTime(e) {
    return this.time = e, this;
  }
  /**
  Replace the current selection with the given slice.
  */
  replaceSelection(e) {
    return this.selection.replace(this, e), 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) || R.none))), r.replaceWith(this, e), this;
  }
  /**
  Delete the selection.
  */
  deleteSelection() {
    return this.selection.replace(this), 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));
      }
      return this.replaceRangeWith(t, r, n.text(e, s)), this.selection.empty || this.setSelection(l.near(this.selection.$to)), 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;
  }
  /**
  Retrieve a metadata property for a given name or plugin.
  */
  getMeta(e) {
    return this.meta[typeof e == "string" ? e : e.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;
  }
  /**
  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;
  }
  /**
  True when this transaction has had `scrollIntoView` called on it.
  */
  get scrolledIntoView() {
    return (this.updated & F) > 0;
  }
}
function D(i, e) {
  return !e || !i ? i : i.bind(e);
}
class S {
  constructor(e, t, r) {
    this.name = e, this.init = D(t.init, r), this.apply = D(t.apply, r);
  }
}
const L = [
  new S("doc", {
    init(i) {
      return i.doc || i.schema.topNodeType.createAndFill();
    },
    apply(i) {
      return i.doc;
    }
  }),
  new S("selection", {
    init(i, e) {
      return i.selection || l.atStart(e.doc);
    },
    apply(i) {
      return i.selection;
    }
  }),
  new S("storedMarks", {
    init(i) {
      return i.storedMarks || null;
    },
    apply(i, e, t, r) {
      return r.selection.$cursor ? i.storedMarks : null;
    }
  }),
  new S("scrollToSelection", {
    init() {
      return 0;
    },
    apply(i, e) {
      return i.scrolledIntoView ? e + 1 : e;
    }
  })
];
class v {
  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 w {
  /**
  @internal
  */
  constructor(e) {
    this.config = e;
  }
  /**
  The schema of the state's document.
  */
  get schema() {
    return this.config.schema;
  }
  /**
  The plugins that are active in this state.
  */
  get plugins() {
    return this.config.plugins;
  }
  /**
  Apply the given transaction to produce a new state.
  */
  apply(e) {
    return this.applyTransaction(e).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;
      }
    return !0;
  }
  /**
  Verbose variant of [`apply`](https://prosemirror.net/docs/ref/#state.EditorState.apply) that
  returns the precise transactions that were applied (which might
  be influenced by the [transaction
  hooks](https://prosemirror.net/docs/ref/#state.PluginSpec.filterTransaction) of
  plugins) along with the new state.
  */
  applyTransaction(e) {
    if (!this.filterTransaction(e))
      return { state: this, transactions: [] };
    let t = [e], r = this.applyInner(e), n = 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 M = 0; M < this.config.plugins.length; M++)
                n.push(M < o ? { state: r, n: t.length } : { state: this, n: 0 });
            }
            t.push(h), r = r.applyInner(h), s = !0;
          }
          n && (n[o] = { state: r, n: t.length });
        }
      }
      if (!s)
        return { state: r, transactions: t };
    }
  }
  /**
  @internal
  */
  applyInner(e) {
    if (!e.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);
    }
    return t;
  }
  /**
  Start a [transaction](https://prosemirror.net/docs/ref/#state.Transaction) from this state.
  */
  get tr() {
    return new W(this);
  }
  /**
  Create a new state.
  */
  static create(e) {
    let t = new v(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;
  }
  /**
  Create a new state based on this one, but with an adjusted set
  of active plugins. State fields that exist in both sets of
  plugins are kept unchanged. Those that no longer exist are
  dropped, and those that are new are initialized using their
  [`init`](https://prosemirror.net/docs/ref/#state.StateField.init) method, passing in the new
  configuration object..
  */
  reconfigure(e) {
    let t = new v(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);
    }
    return n;
  }
  /**
  Serialize this state to JSON. If you want to serialize the state
  of plugins, pass an object mapping property names to use in the
  resulting JSON object to plugin objects. The argument may also be
  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")
          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]));
      }
    return t;
  }
  /**
  Deserialize a JSON representation of a state. `config` should
  have at least a `schema` field, and should contain array of
  plugins to initialize the state with. `pluginFields` can be used
  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)
      throw new RangeError("Invalid input for EditorState.fromJSON");
    if (!e.schema)
      throw new RangeError("Required config field 'schema' missing");
    let n = new v(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);
              return;
            }
          }
        s[o.name] = o.init(e, s);
      }
    }), s;
  }
}
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;
}
class G {
  /**
  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");
  }
  /**
  Extract the plugin's state field from an editor state.
  */
  getState(e) {
    return e[this.key];
  }
}
const N = /* @__PURE__ */ Object.create(null);
function C(i) {
  return i in N ? i + "$" + ++N[i] : (N[i] = 0, i + "$");
}
class H {
  /**
  Create a plugin key.
  */
  constructor(e = "key") {
    this.key = C(e);
  }
  /**
  Get the active plugin with this key, if any, from an editor
  state.
  */
  get(e) {
    return e.config.pluginsByKey[this.key];
  }
  /**
  Get the plugin's state from an editor state.
  */
  getState(e) {
    return e[this.key];
  }
}
export {
  d as AllSelection,
  w as EditorState,
  p as NodeSelection,
  G as Plugin,
  H as PluginKey,
  l as Selection,
  q as SelectionRange,
  f as TextSelection,
  W as Transaction
};
//# sourceMappingURL=index.js.map
