@vizel/core 0.0.1-alpha.6 → 1.0.0

package/dist/index40.js

@@ -1,329 +1,489 @@
-import { Node as L, createBlockMarkdownSpec as N, isActive as F, findChildren as b, defaultBlockAt as x, findParentNode as w, mergeAttributes as v } from "@tiptap/core";
-import { Plugin as z, PluginKey as G, TextSelection as R, Selection as D } from "./index41.js";
-import { GapCursor as H } from "./index51.js";
-var S = (t, s) => s.view.domAtPos(t).node.offsetParent !== null, W = (t, s, o) => {
-  for (let e = t.depth; e > 0; e -= 1) {
-    const n = t.node(e), c = s(n), r = S(t.start(e), o);
-    if (c && r)
-      return {
-        pos: e > 0 ? t.before(e) : 0,
-        start: t.start(e),
-        depth: e,
-        node: n
-      };
-  }
-}, O = (t, s) => {
-  const { state: o, view: e, extensionManager: n } = t, { schema: c, selection: r } = o, { empty: d, $anchor: l } = r, i = !!n.extensions.find((u) => u.name === "gapCursor");
-  if (!d || l.parent.type !== c.nodes.detailsSummary || !i || s === "right" && l.parentOffset !== l.parent.nodeSize - 2)
-    return !1;
-  const a = w((u) => u.type === c.nodes.details)(r);
-  if (!a)
-    return !1;
-  const p = b(a.node, (u) => u.type === c.nodes.detailsContent);
-  if (!p.length || S(a.start + p[0].pos + 1, t))
-    return !1;
-  const m = o.doc.resolve(a.pos + a.node.nodeSize), h = H.findFrom(m, 1, !1);
-  if (!h)
-    return !1;
-  const { tr: y } = o, C = new H(h);
-  return y.setSelection(C), y.scrollIntoView(), e.dispatch(y), !0;
-}, j = L.create({
-  name: "details",
-  content: "detailsSummary detailsContent",
-  group: "block",
-  defining: !0,
-  isolating: !0,
-  // @ts-ignore reason: `allowGapCursor` is not a valid property by default, but the `GapCursor` extension adds it to the Nodeconfig type
-  allowGapCursor: !1,
-  addOptions() {
-    return {
-      persist: !1,
-      openClassName: "is-open",
-      HTMLAttributes: {}
-    };
-  },
-  addAttributes() {
-    return this.options.persist ? {
-      open: {
-        default: !1,
-        parseHTML: (t) => t.hasAttribute("open"),
-        renderHTML: ({ open: t }) => t ? { open: "" } : {}
-      }
-    } : [];
-  },
-  parseHTML() {
-    return [
-      {
-        tag: "details"
-      }
-    ];
-  },
-  renderHTML({ HTMLAttributes: t }) {
-    return ["details", v(this.options.HTMLAttributes, t), 0];
-  },
-  ...N({
-    nodeName: "details",
-    content: "block"
-  }),
-  addNodeView() {
-    return ({ editor: t, getPos: s, node: o, HTMLAttributes: e }) => {
-      const n = document.createElement("div"), c = v(this.options.HTMLAttributes, e, {
-        "data-type": this.name
-      });
-      Object.entries(c).forEach(([i, a]) => n.setAttribute(i, a));
-      const r = document.createElement("button");
-      r.type = "button", n.append(r);
-      const d = document.createElement("div");
-      n.append(d);
-      const l = (i) => {
-        if (i !== void 0)
-          if (i) {
-            if (n.classList.contains(this.options.openClassName))
-              return;
-            n.classList.add(this.options.openClassName);
-          } else {
-            if (!n.classList.contains(this.options.openClassName))
-              return;
-            n.classList.remove(this.options.openClassName);
-          }
-        else
-          n.classList.toggle(this.options.openClassName);
-        const a = new Event("toggleDetailsContent"), p = d.querySelector(':scope > div[data-type="detailsContent"]');
-        p?.dispatchEvent(a);
-      };
-      return o.attrs.open && setTimeout(() => l()), r.addEventListener("click", () => {
-        if (l(), !this.options.persist) {
-          t.commands.focus(void 0, { scrollIntoView: !1 });
-          return;
-        }
-        if (t.isEditable && typeof s == "function") {
-          const { from: i, to: a } = t.state.selection;
-          t.chain().command(({ tr: p }) => {
-            const f = s();
-            if (!f)
-              return !1;
-            const m = p.doc.nodeAt(f);
-            return m?.type !== this.type ? !1 : (p.setNodeMarkup(f, void 0, {
-              open: !m.attrs.open
-            }), !0);
-          }).setTextSelection({
-            from: i,
-            to: a
-          }).focus(void 0, { scrollIntoView: !1 }).run();
-        }
-      }), {
-        dom: n,
-        contentDOM: d,
-        ignoreMutation(i) {
-          return i.type === "selection" ? !1 : !n.contains(i.target) || n === i.target;
-        },
-        update: (i) => i.type !== this.type ? !1 : (i.attrs.open !== void 0 && l(i.attrs.open), !0)
-      };
-    };
-  },
-  addCommands() {
-    return {
-      setDetails: () => ({ state: t, chain: s }) => {
-        var o;
-        const { schema: e, selection: n } = t, { $from: c, $to: r } = n, d = c.blockRange(r);
-        if (!d)
-          return !1;
-        const l = t.doc.slice(d.start, d.end);
-        if (!e.nodes.detailsContent.contentMatch.matchFragment(l.content))
-          return !1;
-        const a = ((o = l.toJSON()) == null ? void 0 : o.content) || [];
-        return s().insertContentAt(
-          { from: d.start, to: d.end },
-          {
-            type: this.name,
-            content: [
-              {
-                type: "detailsSummary"
-              },
-              {
-                type: "detailsContent",
-                content: a
-              }
-            ]
-          }
-        ).setTextSelection(d.start + 2).run();
-      },
-      unsetDetails: () => ({ state: t, chain: s }) => {
-        const { selection: o, schema: e } = t, n = w((u) => u.type === this.type)(o);
-        if (!n)
-          return !1;
-        const c = b(n.node, (u) => u.type === e.nodes.detailsSummary), r = b(n.node, (u) => u.type === e.nodes.detailsContent);
-        if (!c.length || !r.length)
-          return !1;
-        const d = c[0], l = r[0], i = n.pos, a = t.doc.resolve(i), p = i + n.node.nodeSize, f = { from: i, to: p }, m = l.node.content.toJSON() || [], h = a.parent.type.contentMatch.defaultType, C = [h?.create(null, d.node.content).toJSON(), ...m];
-        return s().insertContentAt(f, C).setTextSelection(i + 1).run();
-      }
-    };
-  },
-  addKeyboardShortcuts() {
-    return {
-      Backspace: () => {
-        const { schema: t, selection: s } = this.editor.state, { empty: o, $anchor: e } = s;
-        return !o || e.parent.type !== t.nodes.detailsSummary ? !1 : e.parentOffset !== 0 ? this.editor.commands.command(({ tr: n }) => {
-          const c = e.pos - 1, r = e.pos;
-          return n.delete(c, r), !0;
-        }) : this.editor.commands.unsetDetails();
-      },
-      // Creates a new node below it if it is closed.
-      // Otherwise inside `DetailsContent`.
-      Enter: ({ editor: t }) => {
-        const { state: s, view: o } = t, { schema: e, selection: n } = s, { $head: c } = n;
-        if (c.parent.type !== e.nodes.detailsSummary)
-          return !1;
-        const r = S(c.after() + 1, t), d = r ? s.doc.nodeAt(c.after()) : c.node(-2);
-        if (!d)
-          return !1;
-        const l = r ? 0 : c.indexAfter(-1), i = x(d.contentMatchAt(l));
-        if (!i || !d.canReplaceWith(l, l, i))
-          return !1;
-        const a = i.createAndFill();
-        if (!a)
-          return !1;
-        const p = r ? c.after() + 1 : c.after(-1), f = s.tr.replaceWith(p, p, a), m = f.doc.resolve(p), h = D.near(m, 1);
-        return f.setSelection(h), f.scrollIntoView(), o.dispatch(f), !0;
-      },
-      // The default gapcursor implementation can’t handle hidden content, so we need to fix this.
-      ArrowRight: ({ editor: t }) => O(t, "right"),
-      // The default gapcursor implementation can’t handle hidden content, so we need to fix this.
-      ArrowDown: ({ editor: t }) => O(t, "down")
-    };
-  },
-  addProseMirrorPlugins() {
-    return [
-      // This plugin prevents text selections within the hidden content in `DetailsContent`.
-      // The cursor is moved to the next visible position.
-      new z({
-        key: new G("detailsSelection"),
-        appendTransaction: (t, s, o) => {
-          const { editor: e, type: n } = this;
-          if (e.view.composing || !t.some((u) => u.selectionSet) || !s.selection.empty || !o.selection.empty || !F(o, n.name))
-            return;
-          const { $from: l } = o.selection;
-          if (S(l.pos, e))
-            return;
-          const a = W(l, (u) => u.type === n, e);
-          if (!a)
-            return;
-          const p = b(
-            a.node,
-            (u) => u.type === o.schema.nodes.detailsSummary
-          );
-          if (!p.length)
-            return;
-          const f = p[0], h = (s.selection.from < o.selection.from ? "forward" : "backward") === "forward" ? a.start + f.pos : a.pos + f.pos + f.node.nodeSize, y = R.create(o.doc, h);
-          return o.tr.setSelection(y);
-        }
-      })
-    ];
-  }
-}), q = L.create({
-  name: "detailsContent",
-  content: "block+",
-  defining: !0,
-  selectable: !1,
-  addOptions() {
-    return {
-      HTMLAttributes: {}
-    };
-  },
-  parseHTML() {
-    return [
-      {
-        tag: `div[data-type="${this.name}"]`
-      }
-    ];
-  },
-  renderHTML({ HTMLAttributes: t }) {
-    return ["div", v(this.options.HTMLAttributes, t, { "data-type": this.name }), 0];
-  },
-  addNodeView() {
-    return ({ HTMLAttributes: t }) => {
-      const s = document.createElement("div"), o = v(this.options.HTMLAttributes, t, {
-        "data-type": this.name,
-        hidden: "hidden"
-      });
-      return Object.entries(o).forEach(([e, n]) => s.setAttribute(e, n)), s.addEventListener("toggleDetailsContent", () => {
-        s.toggleAttribute("hidden");
-      }), {
-        dom: s,
-        contentDOM: s,
-        ignoreMutation(e) {
-          return e.type === "selection" ? !1 : !s.contains(e.target) || s === e.target;
-        },
-        update: (e) => e.type === this.type
-      };
-    };
+import { Slice as m, Fragment as J } from "./index59.js";
+import { ReplaceStep as x, ReplaceAroundStep as C } from "./index60.js";
+const k = /* @__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, n) {
+    this.$anchor = e, this.$head = t, this.ranges = n || [new E(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 n = t.content.lastChild, i = null;
+    for (let s = 0; s < t.openEnd; s++)
+      i = n, n = n.lastChild;
+    let o = e.steps.length, a = this.ranges;
+    for (let s = 0; s < a.length; s++) {
+      let { $from: h, $to: g } = a[s], f = e.mapping.slice(o);
+      e.replaceRange(f.map(h.pos), f.map(g.pos), s ? m.empty : t), s == 0 && b(e, o, (n ? n.isInline : i && i.isTextblock) ? -1 : 1);
+    }
+  }
+  /**
+  Replace the selection with the given node, appending the changes
+  to the given transaction.
+  */
+  replaceWith(e, t) {
+    let n = e.steps.length, i = this.ranges;
+    for (let o = 0; o < i.length; o++) {
+      let { $from: a, $to: s } = i[o], h = e.mapping.slice(n), g = h.map(a.pos), f = h.map(s.pos);
+      o ? e.deleteRange(g, f) : (e.replaceRangeWith(g, f, t), b(e, n, 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, n = !1) {
+    let i = e.parent.inlineContent ? new c(e) : d(e.node(0), e.parent, e.pos, e.index(), t, n);
+    if (i)
+      return i;
+    for (let o = e.depth - 1; o >= 0; o--) {
+      let a = t < 0 ? d(e.node(0), e.node(o), e.before(o + 1), e.index(o), t, n) : d(e.node(0), e.node(o), e.after(o + 1), e.index(o) + 1, t, n);
+      if (a)
+        return a;
+    }
+    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 p(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 d(e, e, 0, 0, 1) || new p(e);
+  }
+  /**
+  Find the cursor or leaf node selection closest to the end of the
+  given document.
+  */
+  static atEnd(e) {
+    return d(e, e, e.content.size, e.childCount, -1) || new p(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 n = k[t.type];
+    if (!n)
+      throw new RangeError(`No selection type ${t.type} defined`);
+    return n.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 k)
+      throw new RangeError("Duplicate use of selection JSON ID " + e);
+    return k[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 c.between(this.$anchor, this.$head).getBookmark();
+  }
+}
+l.prototype.visible = !0;
+class E {
+  /**
+  Create a range.
+  */
+  constructor(e, t) {
+    this.$from = e, this.$to = t;
+  }
+}
+let I = !1;
+function F(r) {
+  !I && !r.parent.inlineContent && (I = !0, console.warn("TextSelection endpoint not pointing into a node with inline content (" + r.parent.type.name + ")"));
+}
+class c extends l {
+  /**
+  Construct a text selection between the given points.
+  */
+  constructor(e, t = e) {
+    F(e), F(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 n = e.resolve(t.map(this.head));
+    if (!n.parent.inlineContent)
+      return l.near(n);
+    let i = e.resolve(t.map(this.anchor));
+    return new c(i.parent.inlineContent ? i : n, n);
+  }
+  replace(e, t = m.empty) {
+    if (super.replace(e, t), t == m.empty) {
+      let n = this.$from.marksAcross(this.$to);
+      n && e.ensureMarks(n);
+    }
+  }
+  eq(e) {
+    return e instanceof c && 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 c(e.resolve(t.anchor), e.resolve(t.head));
+  }
+  /**
+  Create a text selection from non-resolved positions.
+  */
+  static create(e, t, n = t) {
+    let i = e.resolve(t);
+    return new this(i, n == t ? i : e.resolve(n));
+  }
+  /**
+  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, n) {
+    let i = e.pos - t.pos;
+    if ((!n || i) && (n = i >= 0 ? 1 : -1), !t.parent.inlineContent) {
+      let o = l.findFrom(t, n, !0) || l.findFrom(t, -n, !0);
+      if (o)
+        t = o.$head;
+      else
+        return l.near(t, n);
+    }
+    return e.parent.inlineContent || (i == 0 ? e = t : (e = (l.findFrom(e, -n, !0) || l.findFrom(e, n, !0)).$anchor, e.pos < t.pos != i < 0 && (e = t))), new c(e, t);
+  }
+}
+l.jsonID("text", c);
+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 c.between(e.resolve(this.anchor), e.resolve(this.head));
+  }
+}
+class u extends l {
+  /**
+  Create a node selection. Does not verify the validity of its
+  argument.
+  */
+  constructor(e) {
+    let t = e.nodeAfter, n = e.node(0).resolve(e.pos + t.nodeSize);
+    super(e, n), this.node = t;
+  }
+  map(e, t) {
+    let { deleted: n, pos: i } = t.mapResult(this.anchor), o = e.resolve(i);
+    return n ? l.near(o) : new u(o);
+  }
+  content() {
+    return new m(J.from(this.node), 0, 0);
+  }
+  eq(e) {
+    return e instanceof u && e.anchor == this.anchor;
+  }
+  toJSON() {
+    return { type: "node", anchor: this.anchor };
+  }
+  getBookmark() {
+    return new v(this.anchor);
+  }
+  /**
+  @internal
+  */
+  static fromJSON(e, t) {
+    if (typeof t.anchor != "number")
+      throw new RangeError("Invalid input for NodeSelection.fromJSON");
+    return new u(e.resolve(t.anchor));
+  }
+  /**
+  Create a node selection from non-resolved positions.
+  */
+  static create(e, t) {
+    return new u(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;
+  }
+}
+u.prototype.visible = !1;
+l.jsonID("node", u);
+class v {
+  constructor(e) {
+    this.anchor = e;
+  }
+  map(e) {
+    let { deleted: t, pos: n } = e.mapResult(this.anchor);
+    return t ? new y(n, n) : new v(n);
+  }
+  resolve(e) {
+    let t = e.resolve(this.anchor), n = t.nodeAfter;
+    return n && u.isSelectable(n) ? new u(t) : l.near(t);
+  }
+}
+class p 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 n = l.atStart(e.doc);
+      n.eq(e.selection) || e.setSelection(n);
+    } else
+      super.replace(e, t);
+  }
+  toJSON() {
+    return { type: "all" };
+  }
+  /**
+  @internal
+  */
+  static fromJSON(e) {
+    return new p(e);
+  }
+  map(e) {
+    return new p(e);
+  }
+  eq(e) {
+    return e instanceof p;
+  }
+  getBookmark() {
+    return D;
+  }
+}
+l.jsonID("all", p);
+const D = {
+  map() {
+    return this;
   },
-  addKeyboardShortcuts() {
-    return {
-      // Escape node on double enter
-      Enter: ({ editor: t }) => {
-        const { state: s, view: o } = t, { selection: e } = s, { $from: n, empty: c } = e, r = w(($) => $.type === this.type)(e);
-        if (!c || !r || !r.node.childCount)
-          return !1;
-        const d = n.index(r.depth), { childCount: l } = r.node;
-        if (!(l === d + 1))
-          return !1;
-        const a = r.node.type.contentMatch.defaultType, p = a?.createAndFill();
-        if (!p)
-          return !1;
-        const f = s.doc.resolve(r.pos + 1), m = l - 1, h = r.node.child(m), y = f.posAtIndex(m, r.depth);
-        if (!h.eq(p))
-          return !1;
-        const u = n.node(-3);
-        if (!u)
-          return !1;
-        const A = n.indexAfter(-3), M = x(u.contentMatchAt(A));
-        if (!M || !u.canReplaceWith(A, A, M))
-          return !1;
-        const E = M.createAndFill();
-        if (!E)
-          return !1;
-        const { tr: g } = s, T = n.after(-2);
-        g.replaceWith(T, T, E);
-        const k = g.doc.resolve(T), I = D.near(k, 1);
-        g.setSelection(I);
-        const V = y, P = y + h.nodeSize;
-        return g.delete(V, P), g.scrollIntoView(), o.dispatch(g), !0;
-      }
-    };
+  resolve(r) {
+    return new p(r);
+  }
+};
+function d(r, e, t, n, i, o = !1) {
+  if (e.inlineContent)
+    return c.create(r, t);
+  for (let a = n - (i > 0 ? 0 : 1); i > 0 ? a < e.childCount : a >= 0; a += i) {
+    let s = e.child(a);
+    if (s.isAtom) {
+      if (!o && u.isSelectable(s))
+        return u.create(r, t - (i < 0 ? s.nodeSize : 0));
+    } else {
+      let h = d(r, s, t + i, i < 0 ? s.childCount : 0, i, o);
+      if (h)
+        return h;
+    }
+    t += s.nodeSize * i;
+  }
+  return null;
+}
+function b(r, e, t) {
+  let n = r.steps.length - 1;
+  if (n < e)
+    return;
+  let i = r.steps[n];
+  if (!(i instanceof x || i instanceof C))
+    return;
+  let o = r.mapping.maps[n], a;
+  o.forEach((s, h, g, f) => {
+    a == null && (a = f);
+  }), r.setSelection(l.near(r.doc.resolve(a), t));
+}
+function N(r, e) {
+  return !e || !r ? r : r.bind(e);
+}
+class w {
+  constructor(e, t, n) {
+    this.name = e, this.init = N(t.init, n), this.apply = N(t.apply, n);
+  }
+}
+new w("doc", {
+  init(r) {
+    return r.doc || r.schema.topNodeType.createAndFill();
   },
-  ...N({
-    nodeName: "detailsContent"
-  })
-}), _ = L.create({
-  name: "detailsSummary",
-  content: "text*",
-  defining: !0,
-  selectable: !1,
-  isolating: !0,
-  addOptions() {
-    return {
-      HTMLAttributes: {}
-    };
+  apply(r) {
+    return r.doc;
+  }
+}), new w("selection", {
+  init(r, e) {
+    return r.selection || l.atStart(e.doc);
   },
-  parseHTML() {
-    return [
-      {
-        tag: "summary"
-      }
-    ];
+  apply(r) {
+    return r.selection;
+  }
+}), new w("storedMarks", {
+  init(r) {
+    return r.storedMarks || null;
   },
-  renderHTML({ HTMLAttributes: t }) {
-    return ["summary", v(this.options.HTMLAttributes, t), 0];
+  apply(r, e, t, n) {
+    return n.selection.$cursor ? r.storedMarks : null;
+  }
+}), new w("scrollToSelection", {
+  init() {
+    return 0;
   },
-  ...N({
-    nodeName: "detailsSummary",
-    content: "inline"
-  })
+  apply(r, e) {
+    return r.scrolledIntoView ? e + 1 : e;
+  }
 });
+function O(r, e, t) {
+  for (let n in r) {
+    let i = r[n];
+    i instanceof Function ? i = i.bind(e) : n == "handleDOMEvents" && (i = O(i, e, {})), t[n] = i;
+  }
+  return t;
+}
+class A {
+  /**
+  Create a plugin.
+  */
+  constructor(e) {
+    this.spec = e, this.props = {}, e.props && O(e.props, this, this.props), this.key = e.key ? e.key.key : R("plugin");
+  }
+  /**
+  Extract the plugin's state field from an editor state.
+  */
+  getState(e) {
+    return e[this.key];
+  }
+}
+const S = /* @__PURE__ */ Object.create(null);
+function R(r) {
+  return r in S ? r + "$" + ++S[r] : (S[r] = 0, r + "$");
+}
+class T {
+  /**
+  Create a plugin key.
+  */
+  constructor(e = "key") {
+    this.key = R(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 {
-  j as Details,
-  q as DetailsContent,
-  _ as DetailsSummary
+  p as AllSelection,
+  u as NodeSelection,
+  A as Plugin,
+  T as PluginKey,
+  l as Selection,
+  E as SelectionRange,
+  c as TextSelection
 };