@vizel/core 0.0.1-alpha.5 → 1.0.0

package/dist/index40.js

@@ -1,681 +1,489 @@
-import { Extension as H, commands as y, flattenExtensions as z, getExtensionField as C, generateJSON as L } from "@tiptap/core";
-import { marked as P } from "./index52.js";
-function _(e, n) {
-  const s = n.split(`
-`).flatMap((r) => [r, ""]).map((r) => `${e}${r}`).join(`
-`);
-  return s.slice(0, s.length - 1);
-}
-function O(e, n) {
-  const t = [];
-  return Array.from(e.keys()).forEach((s) => {
-    (!n || !n.marks || !n.marks.map((r) => r.type).includes(s)) && t.push(s);
-  }), t;
-}
-function F(e, n) {
-  const t = [];
-  return Array.from(n.entries()).forEach(([s, r]) => {
-    e.has(s) || t.push({ type: s, mark: r });
-  }), t;
-}
-function N(e, n, t, s) {
-  const r = !t, i = t && t.type === "text" && (!t.marks || t.marks.length === 0), o = t && t.type === "text" && t.marks && !s(n, new Map(t.marks.map((d) => [d.type, d]))), l = [];
-  if (r || i || o)
-    if (t && t.type === "text" && t.marks) {
-      const d = new Map(t.marks.map((a) => [a.type, a]));
-      Array.from(e.keys()).forEach((a) => {
-        d.has(a) || l.push(a);
-      });
-    } else (r || i) && l.push(...Array.from(e.keys()));
-  return l;
-}
-function $(e, n) {
-  let t = "";
-  return Array.from(e.keys()).reverse().forEach((s) => {
-    const r = e.get(s), i = n(s, r);
-    i && (t = i + t);
-  }), e.clear(), t;
-}
-function S(e, n, t) {
-  let s = "";
-  return Array.from(e.entries()).forEach(([r, i]) => {
-    const o = t(r, i);
-    o && (s += o), n.set(r, i);
-  }), s;
-}
-function R(e) {
-  const t = (e.raw || e.text || "").match(/^(\s*)[-+*]\s+\[([ xX])\]\s+/);
-  return t ? { isTask: !0, checked: t[2].toLowerCase() === "x", indentLevel: t[1].length } : { isTask: !1, indentLevel: 0 };
-}
-function E(e, n) {
-  return typeof e != "string" ? "json" : n;
-}
-var j = class {
-  /**
-   * Create a MarkdownManager.
-   * @param options.marked Optional marked instance to use (injected).
-   * @param options.markedOptions Optional options to pass to marked.setOptions
-   * @param options.indentation Indentation settings (style and size).
-   * @param options.extensions An array of Tiptap extensions to register for markdown parsing and rendering.
-   */
-  constructor(e) {
-    this.baseExtensions = [], this.extensions = [], this.lastParseResult = null;
-    var n, t, s, r, i;
-    this.markedInstance = (n = e?.marked) != null ? n : P, this.lexer = new this.markedInstance.Lexer(), this.indentStyle = (s = (t = e?.indentation) == null ? void 0 : t.style) != null ? s : "space", this.indentSize = (i = (r = e?.indentation) == null ? void 0 : r.size) != null ? i : 2, this.baseExtensions = e?.extensions || [], e?.markedOptions && typeof this.markedInstance.setOptions == "function" && this.markedInstance.setOptions(e.markedOptions), this.registry = /* @__PURE__ */ new Map(), this.nodeTypeRegistry = /* @__PURE__ */ new Map(), e?.extensions && (this.baseExtensions = e.extensions, z(e.extensions).forEach((l) => this.registerExtension(l, !1))), this.lexer = new this.markedInstance.Lexer();
-  }
-  /** Returns the underlying marked instance. */
-  get instance() {
-    return this.markedInstance;
-  }
-  /** Returns the correct indentCharacter (space or tab) */
-  get indentCharacter() {
-    return this.indentStyle === "space" ? " " : "	";
-  }
-  /** Returns the correct indentString repeated X times */
-  get indentString() {
-    return this.indentCharacter.repeat(this.indentSize);
-  }
-  /** Helper to quickly check whether a marked instance is available. */
-  hasMarked() {
-    return !!this.markedInstance;
-  }
-  /**
-   * Register a Tiptap extension (Node/Mark/Extension). This will read
-   * `markdownName`, `parseMarkdown`, `renderMarkdown` and `priority` from the
-   * extension config (using the same resolution used across the codebase).
-   */
-  registerExtension(e, n = !0) {
-    var t, s;
-    this.extensions.push(e);
-    const r = e.name, i = C(e, "markdownTokenName") || r, o = C(e, "parseMarkdown"), l = C(e, "renderMarkdown"), d = C(e, "markdownTokenizer"), a = (t = C(e, "markdownOptions")) != null ? t : null, c = (s = a?.indentsContent) != null ? s : !1, p = {
-      tokenName: i,
-      nodeName: r,
-      parseMarkdown: o,
-      renderMarkdown: l,
-      isIndenting: c,
-      tokenizer: d
-    };
-    if (i && o) {
-      const u = this.registry.get(i) || [];
-      u.push(p), this.registry.set(i, u);
-    }
-    if (l) {
-      const u = this.nodeTypeRegistry.get(r) || [];
-      u.push(p), this.nodeTypeRegistry.set(r, u);
-    }
-    d && this.hasMarked() && (this.registerTokenizer(d), n && (this.lexer = new this.markedInstance.Lexer()));
-  }
-  /**
-   * Register a custom tokenizer with marked.js for parsing non-standard markdown syntax.
-   */
-  registerTokenizer(e) {
-    if (!this.hasMarked())
-      return;
-    const { name: n, start: t, level: s = "inline", tokenize: r } = e, l = {
-      inlineTokens: (c) => this.lexer.inlineTokens(c),
-      blockTokens: (c) => this.lexer.blockTokens(c)
-    };
-    let d;
-    t ? d = typeof t == "function" ? t : (c) => c.indexOf(t) : d = (c) => {
-      const p = r(c, [], l);
-      return p && p.raw ? c.indexOf(p.raw) : -1;
-    };
-    const a = {
-      name: n,
-      level: s,
-      start: d,
-      tokenizer: (c, p) => {
-        const u = r(c, p, l);
-        if (u && u.type)
-          return {
-            ...u,
-            type: u.type || n,
-            raw: u.raw || "",
-            tokens: u.tokens || []
-          };
-      },
-      childTokens: []
-    };
-    this.markedInstance.use({
-      extensions: [a]
-    });
-  }
-  /** Get registered handlers for a token type and try each until one succeeds. */
-  getHandlersForToken(e) {
-    try {
-      return this.registry.get(e) || [];
-    } catch {
-      return [];
-    }
+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))];
   }
-  /** Get the first handler for a token type (for backwards compatibility). */
-  getHandlerForToken(e) {
-    const n = this.getHandlersForToken(e);
-    if (n.length > 0)
-      return n[0];
-    const t = this.getHandlersForNodeType(e);
-    return t.length > 0 ? t[0] : void 0;
-  }
-  /** Get registered handlers for a node type (for rendering). */
-  getHandlersForNodeType(e) {
-    try {
-      return this.nodeTypeRegistry.get(e) || [];
-    } catch {
-      return [];
-    }
+  /**
+  The selection's anchor, as an unresolved position.
+  */
+  get anchor() {
+    return this.$anchor.pos;
   }
   /**
-   * Serialize a ProseMirror-like JSON document (or node array) to a Markdown string
-   * using registered renderers and fallback renderers.
-   */
-  serialize(e) {
-    return e ? Array.isArray(e) ? this.renderNodes(e, e) : this.renderNodes(e, e) : "";
-  }
-  /**
-   * Parse markdown string into Tiptap JSON document using registered extension handlers.
-   */
-  parse(e) {
-    if (!this.hasMarked())
-      throw new Error("No marked instance available for parsing");
-    const n = this.markedInstance.lexer(e);
-    return {
-      type: "doc",
-      content: this.parseTokens(n)
-    };
-  }
-  /**
-   * Convert an array of marked tokens into Tiptap JSON nodes using registered extension handlers.
-   */
-  parseTokens(e) {
-    return e.map((n) => this.parseToken(n)).filter((n) => n !== null).flatMap((n) => Array.isArray(n) ? n : [n]);
-  }
-  /**
-   * Parse a single token into Tiptap JSON using the appropriate registered handler.
-   */
-  parseToken(e) {
-    if (!e.type)
-      return null;
-    if (e.type === "list")
-      return this.parseListToken(e);
-    const n = this.getHandlersForToken(e.type), t = this.createParseHelpers();
-    if (n.find((r) => {
-      if (!r.parseMarkdown)
-        return !1;
-      const i = r.parseMarkdown(e, t), o = this.normalizeParseResult(i);
-      return o && (!Array.isArray(o) || o.length > 0) ? (this.lastParseResult = o, !0) : !1;
-    }) && this.lastParseResult) {
-      const r = this.lastParseResult;
-      return this.lastParseResult = null, r;
-    }
-    return this.parseFallbackToken(e);
-  }
-  /**
-   * Parse a list token, handling mixed bullet and task list items by splitting them into separate lists.
-   * This ensures that consecutive task items and bullet items are grouped and parsed as separate list nodes.
-   *
-   * @param token The list token to parse
-   * @returns Array of parsed list nodes, or null if parsing fails
-   */
-  parseListToken(e) {
-    if (!e.items || e.items.length === 0)
-      return this.parseTokenWithHandlers(e);
-    const n = e.items.some((l) => R(l).isTask), t = e.items.some((l) => !R(l).isTask);
-    if (!n || !t || this.getHandlersForToken("taskList").length === 0)
-      return this.parseTokenWithHandlers(e);
-    const s = [];
-    let r = [], i = null;
-    for (let l = 0; l < e.items.length; l += 1) {
-      const d = e.items[l], { isTask: a, checked: c, indentLevel: p } = R(d);
-      let u = d;
-      if (a) {
-        const m = (d.raw || d.text || "").split(`
-`), g = m[0].match(/^\s*[-+*]\s+\[([ xX])\]\s+(.*)$/), h = g ? g[2] : "";
-        let k = [];
-        if (m.length > 1 && m.slice(1).join(`
-`).trim()) {
-          const T = m.slice(1), v = T.filter((A) => A.trim());
-          if (v.length > 0) {
-            const A = Math.min(...v.map((x) => x.length - x.trimStart().length)), I = T.map((x) => x.trim() ? x.slice(A) : "").join(`
-`).trim();
-            I && (k = this.markedInstance.lexer(`${I}
-`));
-          }
-        }
-        u = {
-          type: "taskItem",
-          raw: "",
-          mainContent: h,
-          indentLevel: p,
-          checked: c ?? !1,
-          text: h,
-          tokens: this.lexer.inlineTokens(h),
-          nestedTokens: k
-        };
-      }
-      const w = a ? "taskList" : "list";
-      i !== w ? (r.length > 0 && s.push({ type: i, items: r }), r = [u], i = w) : r.push(u);
-    }
-    r.length > 0 && s.push({ type: i, items: r });
-    const o = [];
-    for (let l = 0; l < s.length; l += 1) {
-      const d = s[l], a = { ...e, type: d.type, items: d.items }, c = this.parseToken(a);
-      c && (Array.isArray(c) ? o.push(...c) : o.push(c));
-    }
-    return o.length > 0 ? o : null;
+  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;
   }
   /**
-   * Parse a token using registered handlers (extracted for reuse).
-   */
-  parseTokenWithHandlers(e) {
-    if (!e.type)
-      return null;
-    const n = this.getHandlersForToken(e.type), t = this.createParseHelpers();
-    if (n.find((r) => {
-      if (!r.parseMarkdown)
+  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;
-      const i = r.parseMarkdown(e, t), o = this.normalizeParseResult(i);
-      return o && (!Array.isArray(o) || o.length > 0) ? (this.lastParseResult = o, !0) : !1;
-    }) && this.lastParseResult) {
-      const r = this.lastParseResult;
-      return this.lastParseResult = null, r;
-    }
-    return this.parseFallbackToken(e);
-  }
-  /**
-   * Creates helper functions for parsing markdown tokens.
-   * @returns An object containing helper functions for parsing.
-   */
-  createParseHelpers() {
-    return {
-      parseInline: (e) => this.parseInlineTokens(e),
-      parseChildren: (e) => this.parseTokens(e),
-      createTextNode: (e, n) => ({
-        type: "text",
-        text: e,
-        marks: n || void 0
-      }),
-      createNode: (e, n, t) => {
-        const s = {
-          type: e,
-          attrs: n || void 0,
-          content: t || void 0
-        };
-        return (!n || Object.keys(n).length === 0) && delete s.attrs, s;
-      },
-      applyMark: (e, n, t) => ({
-        mark: e,
-        content: n,
-        attrs: t && Object.keys(t).length > 0 ? t : void 0
-      })
-    };
-  }
-  /**
-   * Escape special regex characters in a string.
-   */
-  escapeRegex(e) {
-    return e.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  }
-  /**
-   * Parse inline tokens (bold, italic, links, etc.) into text nodes with marks.
-   * This is the complex part that handles mark nesting and boundaries.
-   */
-  parseInlineTokens(e) {
-    var n, t, s, r;
-    const i = [];
-    for (let o = 0; o < e.length; o += 1) {
-      const l = e[o];
-      if (l.type === "text")
-        i.push({
-          type: "text",
-          text: l.text || ""
-        });
-      else if (l.type === "html") {
-        const d = ((t = (n = l.raw) != null ? n : l.text) != null ? t : "").toString(), a = /^<\/[\s]*[\w-]+/i.test(d), c = d.match(/^<[\s]*([\w-]+)(\s|>|\/|$)/i);
-        if (!a && c && !/\/>$/.test(d)) {
-          const u = c[1], w = this.escapeRegex(u), M = new RegExp(`^<\\/\\s*${w}\\b`, "i");
-          let m = -1;
-          const g = [d];
-          for (let h = o + 1; h < e.length; h += 1) {
-            const k = e[h], f = ((r = (s = k.raw) != null ? s : k.text) != null ? r : "").toString();
-            if (g.push(f), k.type === "html" && M.test(f)) {
-              m = h;
-              break;
-            }
-          }
-          if (m !== -1) {
-            const h = g.join(""), k = {
-              type: "html",
-              raw: h,
-              text: h,
-              block: !1
-            }, f = this.parseHTMLToken(k);
-            if (f) {
-              const T = this.normalizeParseResult(f);
-              Array.isArray(T) ? i.push(...T) : T && i.push(T);
-            }
-            o = m;
-            continue;
-          }
-        }
-        const p = this.parseHTMLToken(l);
-        if (p) {
-          const u = this.normalizeParseResult(p);
-          Array.isArray(u) ? i.push(...u) : u && i.push(u);
-        }
-      } else if (l.type) {
-        const d = this.getHandlerForToken(l.type);
-        if (d && d.parseMarkdown) {
-          const a = this.createParseHelpers(), c = d.parseMarkdown(l, a);
-          if (this.isMarkResult(c)) {
-            const p = this.applyMarkToContent(c.mark, c.content, c.attrs);
-            i.push(...p);
-          } else {
-            const p = this.normalizeParseResult(c);
-            Array.isArray(p) ? i.push(...p) : p && i.push(p);
-          }
-        } else l.tokens && i.push(...this.parseInlineTokens(l.tokens));
-      }
+    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);
     }
-    return i;
-  }
-  /**
-   * Apply a mark to content nodes.
-   */
-  applyMarkToContent(e, n, t) {
-    return n.map((s) => {
-      if (s.type === "text") {
-        const r = s.marks || [], i = t ? { type: e, attrs: t } : { type: e };
-        return {
-          ...s,
-          marks: [...r, i]
-        };
-      }
-      return {
-        ...s,
-        content: s.content ? this.applyMarkToContent(e, s.content, t) : void 0
-      };
-    });
-  }
-  /**
-  * Check if a parse result represents a mark to be applied.
-  */
-  isMarkResult(e) {
-    return e && typeof e == "object" && "mark" in e;
-  }
-  /**
-   * Normalize parse results to ensure they're valid JSONContent.
-   */
-  normalizeParseResult(e) {
-    return e ? this.isMarkResult(e) ? e.content : e : null;
-  }
-  /**
-   * Fallback parsing for common tokens when no specific handler is registered.
-   */
-  parseFallbackToken(e) {
-    switch (e.type) {
-      case "paragraph":
-        return {
-          type: "paragraph",
-          content: e.tokens ? this.parseInlineTokens(e.tokens) : []
-        };
-      case "heading":
-        return {
-          type: "heading",
-          attrs: { level: e.depth || 1 },
-          content: e.tokens ? this.parseInlineTokens(e.tokens) : []
-        };
-      case "text":
-        return {
-          type: "text",
-          text: e.text || ""
-        };
-      case "html":
-        return this.parseHTMLToken(e);
-      case "space":
-        return null;
-      default:
-        return e.tokens ? this.parseTokens(e.tokens) : null;
+  }
+  /**
+  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));
     }
   }
   /**
-   * Parse HTML tokens using extensions' parseHTML methods.
-   * This allows HTML within markdown to be parsed according to extension rules.
-   */
-  parseHTMLToken(e) {
-    const n = e.text || e.raw || "";
-    if (!n.trim())
-      return null;
-    try {
-      const t = L(n, this.baseExtensions);
-      return t.type === "doc" && t.content ? e.block ? t.content : t.content.length === 1 && t.content[0].type === "paragraph" && t.content[0].content ? t.content[0].content : t.content : t;
-    } catch (t) {
-      throw new Error(`Failed to parse HTML in markdown: ${t}`);
+  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);
   }
-  renderNodeToMarkdown(e, n, t = 0, s = 0) {
-    var r;
-    if (e.type === "text")
-      return e.text || "";
-    if (!e.type)
-      return "";
-    const i = this.getHandlerForToken(e.type);
-    if (!i)
-      return "";
-    const o = {
-      renderChildren: (a, c) => {
-        const p = i.isIndenting ? s + 1 : s;
-        return !Array.isArray(a) && a.content ? this.renderNodes(a.content, e, c || "", t, p) : this.renderNodes(a, e, c || "", t, p);
-      },
-      indent: (a) => this.indentString + a,
-      wrapInBlock: _
-    }, l = {
-      index: t,
-      level: s,
-      parentType: n?.type,
-      meta: {}
-    };
-    return ((r = i.renderMarkdown) == null ? void 0 : r.call(i, e, o, l)) || "";
-  }
-  /**
-   * Render a node or an array of nodes. Parent type controls how children
-   * are joined (which determines newline insertion between children).
-   */
-  renderNodes(e, n, t = "", s = 0, r = 0) {
-    return Array.isArray(e) ? this.renderNodesWithMarkBoundaries(e, n, t, r) : e.type ? this.renderNodeToMarkdown(e, n, s, r) : "";
-  }
-  /**
-   * Render an array of nodes while properly tracking mark boundaries.
-   * This handles cases where marks span across multiple text nodes.
-   */
-  renderNodesWithMarkBoundaries(e, n, t = "", s = 0) {
-    const r = [], i = /* @__PURE__ */ new Map();
-    return e.forEach((o, l) => {
-      const d = l < e.length - 1 ? e[l + 1] : null;
-      if (o.type)
-        if (o.type === "text") {
-          let a = o.text || "";
-          const c = new Map((o.marks || []).map((h) => [h.type, h])), p = F(i, c), u = O(c, d);
-          let w = "";
-          if (u.length > 0) {
-            const h = a.match(/(\s+)$/);
-            h && (w = h[1], a = a.slice(0, -w.length));
-          }
-          u.forEach((h) => {
-            const k = c.get(h), f = this.getMarkClosing(h, k);
-            f && (a += f), i.has(h) && i.delete(h);
-          });
-          let M = "";
-          if (p.length > 0) {
-            const h = a.match(/^(\s+)/);
-            h && (M = h[1], a = a.slice(M.length));
-          }
-          p.forEach(({ type: h, mark: k }) => {
-            const f = this.getMarkOpening(h, k);
-            f && (a = f + a), u.includes(h) || i.set(h, k);
-          }), a = M + a;
-          const m = N(
-            i,
-            c,
-            d,
-            this.markSetsEqual.bind(this)
-          );
-          let g = "";
-          if (m.length > 0) {
-            const h = a.match(/(\s+)$/);
-            h && (g = h[1], a = a.slice(0, -g.length));
-          }
-          m.forEach((h) => {
-            const k = i.get(h), f = this.getMarkClosing(h, k);
-            f && (a += f), i.delete(h);
-          }), a += g, a += w, r.push(a);
-        } else {
-          const a = new Map(i), c = $(i, this.getMarkClosing.bind(this)), p = this.renderNodeToMarkdown(o, n, l, s), u = o.type === "hardBreak" ? "" : S(a, i, this.getMarkOpening.bind(this));
-          r.push(c + p + u);
-        }
-    }), r.join(t);
-  }
-  /**
-   * Get the opening markdown syntax for a mark type.
-   */
-  getMarkOpening(e, n) {
-    const t = this.getHandlersForNodeType(e), s = t.length > 0 ? t[0] : void 0;
-    if (!s || !s.renderMarkdown)
-      return "";
-    const r = "__TIPTAP_MARKDOWN_PLACEHOLDER__", i = {
-      type: e,
-      attrs: n.attrs || {},
-      content: [{ type: "text", text: r }]
-    };
-    try {
-      const o = s.renderMarkdown(
-        i,
-        {
-          renderChildren: () => r,
-          indent: (d) => d,
-          wrapInBlock: (d, a) => d + a
-        },
-        { index: 0, level: 0, parentType: "text", meta: {} }
-      ), l = o.indexOf(r);
-      return l >= 0 ? o.substring(0, l) : "";
-    } catch (o) {
-      throw new Error(`Failed to get mark opening for ${e}: ${o}`);
+  /**
+  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 };
+  }
   /**
-   * Get the closing markdown syntax for a mark type.
-   */
-  getMarkClosing(e, n) {
-    const t = this.getHandlersForNodeType(e), s = t.length > 0 ? t[0] : void 0;
-    if (!s || !s.renderMarkdown)
-      return "";
-    const r = "__TIPTAP_MARKDOWN_PLACEHOLDER__", i = {
-      type: e,
-      attrs: n.attrs || {},
-      content: [{ type: "text", text: r }]
-    };
-    try {
-      const o = s.renderMarkdown(
-        i,
-        {
-          renderChildren: () => r,
-          indent: (a) => a,
-          wrapInBlock: (a, c) => a + c
-        },
-        { index: 0, level: 0, parentType: "text", meta: {} }
-      ), l = o.indexOf(r), d = l + r.length;
-      return l >= 0 ? o.substring(d) : "";
-    } catch (o) {
-      throw new Error(`Failed to get mark closing for ${e}: ${o}`);
+  @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 {
   /**
-   * Check if two mark sets are equal.
-   */
-  markSetsEqual(e, n) {
-    return e.size !== n.size ? !1 : Array.from(e.keys()).every((t) => n.has(t));
+  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);
   }
-}, b = j, q = H.create({
-  name: "markdown",
-  addOptions() {
-    return {
-      indentation: { style: "space", size: 2 },
-      marked: void 0,
-      markedOptions: {}
-    };
+  map(e) {
+    return new p(e);
+  }
+  eq(e) {
+    return e instanceof p;
+  }
+  getBookmark() {
+    return D;
+  }
+}
+l.jsonID("all", p);
+const D = {
+  map() {
+    return this;
+  },
+  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();
+  },
+  apply(r) {
+    return r.doc;
+  }
+}), new w("selection", {
+  init(r, e) {
+    return r.selection || l.atStart(e.doc);
   },
-  addCommands() {
-    return {
-      setContent: (e, n) => {
-        if (!n?.contentType)
-          return y.setContent(e, n);
-        if (E(e, n?.contentType) !== "markdown" || !this.editor.markdown)
-          return y.setContent(e, n);
-        const s = this.editor.markdown.parse(e);
-        return y.setContent(s, n);
-      },
-      insertContent: (e, n) => {
-        if (!n?.contentType)
-          return y.insertContent(e, n);
-        if (E(e, n?.contentType) !== "markdown" || !this.editor.markdown)
-          return y.insertContent(e, n);
-        const s = this.editor.markdown.parse(e);
-        return y.insertContent(s, n);
-      },
-      insertContentAt: (e, n, t) => {
-        if (!t?.contentType)
-          return y.insertContentAt(e, n, t);
-        if (E(n, t?.contentType) !== "markdown" || !this.editor.markdown)
-          return y.insertContentAt(e, n, t);
-        const r = this.editor.markdown.parse(n);
-        return y.insertContentAt(e, r, t);
-      }
-    };
+  apply(r) {
+    return r.selection;
+  }
+}), new w("storedMarks", {
+  init(r) {
+    return r.storedMarks || null;
   },
-  addStorage() {
-    return {
-      manager: new b({
-        indentation: this.options.indentation,
-        marked: this.options.marked,
-        markedOptions: this.options.markedOptions,
-        extensions: []
-      })
-    };
+  apply(r, e, t, n) {
+    return n.selection.$cursor ? r.storedMarks : null;
+  }
+}), new w("scrollToSelection", {
+  init() {
+    return 0;
   },
-  onBeforeCreate() {
-    if (this.editor.markdown) {
-      console.error(
-        "[tiptap][markdown]: There is already a `markdown` property on the editor instance. This might lead to unexpected behavior."
-      );
-      return;
-    }
-    if (this.storage.manager = new b({
-      indentation: this.options.indentation,
-      marked: this.options.marked,
-      markedOptions: this.options.markedOptions,
-      extensions: this.editor.extensionManager.baseExtensions
-    }), this.editor.markdown = this.storage.manager, this.editor.getMarkdown = () => this.storage.manager.serialize(this.editor.getJSON()), !this.editor.options.contentType || E(this.editor.options.content, this.editor.options.contentType) !== "markdown")
-      return;
-    if (!this.editor.markdown)
-      throw new Error(
-        '[tiptap][markdown]: The `contentType` option is set to "markdown", but the Markdown extension is not added to the editor. Please add the Markdown extension to use this feature.'
-      );
-    if (this.editor.options.content === void 0 || typeof this.editor.options.content != "string")
-      throw new Error(
-        '[tiptap][markdown]: The `contentType` option is set to "markdown", but the initial content is not a string. Please provide the initial content as a markdown string.'
-      );
-    const n = this.editor.markdown.parse(this.editor.options.content);
-    this.editor.options.content = n;
+  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 {
-  q as Markdown,
-  j as MarkdownManager,
-  E as assumeContentType,
-  $ as closeMarksBeforeNode,
-  O as findMarksToClose,
-  N as findMarksToCloseAtEnd,
-  F as findMarksToOpen,
-  R as isTaskItem,
-  S as reopenMarksAfterNode,
-  _ as wrapInMarkdownBlock
+  p as AllSelection,
+  u as NodeSelection,
+  A as Plugin,
+  T as PluginKey,
+  l as Selection,
+  E as SelectionRange,
+  c as TextSelection
 };