@vc-shell/framework 2.0.0-alpha.2 → 2.0.0-alpha.3

package/dist/vendor-prosemirror-markdown-rpUTSG_Q.js

@@ -0,0 +1,663 @@
+import { d as O, M as w } from "./vendor-prosemirror-model-DAA3avbR.js";
+import { M as S } from "./vendor-markdown-it-Bs9KEWkF.js";
+const D = new O({
+  nodes: {
+    doc: {
+      content: "block+"
+    },
+    paragraph: {
+      content: "inline*",
+      group: "block",
+      parseDOM: [{ tag: "p" }],
+      toDOM() {
+        return ["p", 0];
+      }
+    },
+    blockquote: {
+      content: "block+",
+      group: "block",
+      parseDOM: [{ tag: "blockquote" }],
+      toDOM() {
+        return ["blockquote", 0];
+      }
+    },
+    horizontal_rule: {
+      group: "block",
+      parseDOM: [{ tag: "hr" }],
+      toDOM() {
+        return ["div", ["hr"]];
+      }
+    },
+    heading: {
+      attrs: { level: { default: 1 } },
+      content: "(text | image)*",
+      group: "block",
+      defining: !0,
+      parseDOM: [
+        { tag: "h1", attrs: { level: 1 } },
+        { tag: "h2", attrs: { level: 2 } },
+        { tag: "h3", attrs: { level: 3 } },
+        { tag: "h4", attrs: { level: 4 } },
+        { tag: "h5", attrs: { level: 5 } },
+        { tag: "h6", attrs: { level: 6 } }
+      ],
+      toDOM(e) {
+        return ["h" + e.attrs.level, 0];
+      }
+    },
+    code_block: {
+      content: "text*",
+      group: "block",
+      code: !0,
+      defining: !0,
+      marks: "",
+      attrs: { params: { default: "" } },
+      parseDOM: [{ tag: "pre", preserveWhitespace: "full", getAttrs: (e) => ({ params: e.getAttribute("data-params") || "" }) }],
+      toDOM(e) {
+        return ["pre", e.attrs.params ? { "data-params": e.attrs.params } : {}, ["code", 0]];
+      }
+    },
+    ordered_list: {
+      content: "list_item+",
+      group: "block",
+      attrs: { order: { default: 1 }, tight: { default: !1 } },
+      parseDOM: [{ tag: "ol", getAttrs(e) {
+        return {
+          order: e.hasAttribute("start") ? +e.getAttribute("start") : 1,
+          tight: e.hasAttribute("data-tight")
+        };
+      } }],
+      toDOM(e) {
+        return ["ol", {
+          start: e.attrs.order == 1 ? null : e.attrs.order,
+          "data-tight": e.attrs.tight ? "true" : null
+        }, 0];
+      }
+    },
+    bullet_list: {
+      content: "list_item+",
+      group: "block",
+      attrs: { tight: { default: !1 } },
+      parseDOM: [{ tag: "ul", getAttrs: (e) => ({ tight: e.hasAttribute("data-tight") }) }],
+      toDOM(e) {
+        return ["ul", { "data-tight": e.attrs.tight ? "true" : null }, 0];
+      }
+    },
+    list_item: {
+      content: "block+",
+      defining: !0,
+      parseDOM: [{ tag: "li" }],
+      toDOM() {
+        return ["li", 0];
+      }
+    },
+    text: {
+      group: "inline"
+    },
+    image: {
+      inline: !0,
+      attrs: {
+        src: {},
+        alt: { default: null },
+        title: { default: null }
+      },
+      group: "inline",
+      draggable: !0,
+      parseDOM: [{ tag: "img[src]", getAttrs(e) {
+        return {
+          src: e.getAttribute("src"),
+          title: e.getAttribute("title"),
+          alt: e.getAttribute("alt")
+        };
+      } }],
+      toDOM(e) {
+        return ["img", e.attrs];
+      }
+    },
+    hard_break: {
+      inline: !0,
+      group: "inline",
+      selectable: !1,
+      parseDOM: [{ tag: "br" }],
+      toDOM() {
+        return ["br"];
+      }
+    }
+  },
+  marks: {
+    em: {
+      parseDOM: [
+        { tag: "i" },
+        { tag: "em" },
+        { style: "font-style=italic" },
+        { style: "font-style=normal", clearMark: (e) => e.type.name == "em" }
+      ],
+      toDOM() {
+        return ["em"];
+      }
+    },
+    strong: {
+      parseDOM: [
+        { tag: "strong" },
+        { tag: "b", getAttrs: (e) => e.style.fontWeight != "normal" && null },
+        { style: "font-weight=400", clearMark: (e) => e.type.name == "strong" },
+        { style: "font-weight", getAttrs: (e) => /^(bold(er)?|[5-9]\d{2,})$/.test(e) && null }
+      ],
+      toDOM() {
+        return ["strong"];
+      }
+    },
+    link: {
+      attrs: {
+        href: {},
+        title: { default: null }
+      },
+      inclusive: !1,
+      parseDOM: [{ tag: "a[href]", getAttrs(e) {
+        return { href: e.getAttribute("href"), title: e.getAttribute("title") };
+      } }],
+      toDOM(e) {
+        return ["a", e.attrs];
+      }
+    },
+    code: {
+      code: !0,
+      parseDOM: [{ tag: "code" }],
+      toDOM() {
+        return ["code"];
+      }
+    }
+  }
+});
+function B(e, t) {
+  if (e.isText && t.isText && w.sameSet(e.marks, t.marks))
+    return e.withText(e.text + t.text);
+}
+class C {
+  constructor(t, r) {
+    this.schema = t, this.tokenHandlers = r, this.stack = [{ type: t.topNodeType, attrs: null, content: [], marks: w.none }];
+  }
+  top() {
+    return this.stack[this.stack.length - 1];
+  }
+  push(t) {
+    this.stack.length && this.top().content.push(t);
+  }
+  // Adds the given text to the current position in the document,
+  // using the current marks as styling.
+  addText(t) {
+    if (!t)
+      return;
+    let r = this.top(), i = r.content, s = i[i.length - 1], a = this.schema.text(t, r.marks), l;
+    s && (l = B(s, a)) ? i[i.length - 1] = l : i.push(a);
+  }
+  // Adds the given mark to the set of active marks.
+  openMark(t) {
+    let r = this.top();
+    r.marks = t.addToSet(r.marks);
+  }
+  // Removes the given mark from the set of active marks.
+  closeMark(t) {
+    let r = this.top();
+    r.marks = t.removeFromSet(r.marks);
+  }
+  parseTokens(t) {
+    for (let r = 0; r < t.length; r++) {
+      let i = t[r], s = this.tokenHandlers[i.type];
+      if (!s)
+        throw new Error("Token type `" + i.type + "` not supported by Markdown parser");
+      s(this, i, t, r);
+    }
+  }
+  // Add a node at the current position.
+  addNode(t, r, i) {
+    let s = this.top(), a = t.createAndFill(r, i, s ? s.marks : []);
+    return a ? (this.push(a), a) : null;
+  }
+  // Wrap subsequent content in a node of the given type.
+  openNode(t, r) {
+    this.stack.push({ type: t, attrs: r, content: [], marks: w.none });
+  }
+  // Close and return the node that is currently on top of the stack.
+  closeNode() {
+    let t = this.stack.pop();
+    return this.addNode(t.type, t.attrs, t.content);
+  }
+}
+function k(e, t, r, i) {
+  return e.getAttrs ? e.getAttrs(t, r, i) : e.attrs instanceof Function ? e.attrs(t) : e.attrs;
+}
+function b(e, t) {
+  return e.noCloseToken || t == "code_inline" || t == "code_block" || t == "fence";
+}
+function _(e) {
+  return e[e.length - 1] == `
+` ? e.slice(0, e.length - 1) : e;
+}
+function M() {
+}
+function N(e, t) {
+  let r = /* @__PURE__ */ Object.create(null);
+  for (let i in t) {
+    let s = t[i];
+    if (s.block) {
+      let a = e.nodeType(s.block);
+      b(s, i) ? r[i] = (l, g, o, n) => {
+        l.openNode(a, k(s, g, o, n)), l.addText(_(g.content)), l.closeNode();
+      } : (r[i + "_open"] = (l, g, o, n) => l.openNode(a, k(s, g, o, n)), r[i + "_close"] = (l) => l.closeNode());
+    } else if (s.node) {
+      let a = e.nodeType(s.node);
+      r[i] = (l, g, o, n) => l.addNode(a, k(s, g, o, n));
+    } else if (s.mark) {
+      let a = e.marks[s.mark];
+      b(s, i) ? r[i] = (l, g, o, n) => {
+        l.openMark(a.create(k(s, g, o, n))), l.addText(_(g.content)), l.closeMark(a);
+      } : (r[i + "_open"] = (l, g, o, n) => l.openMark(a.create(k(s, g, o, n))), r[i + "_close"] = (l) => l.closeMark(a));
+    } else if (s.ignore)
+      b(s, i) ? r[i] = M : (r[i + "_open"] = M, r[i + "_close"] = M);
+    else
+      throw new RangeError("Unrecognized parsing spec " + JSON.stringify(s));
+  }
+  return r.text = (i, s) => i.addText(s.content), r.inline = (i, s) => i.parseTokens(s.children), r.softbreak = r.softbreak || ((i) => i.addText(" ")), r;
+}
+class v {
+  /**
+  Create a parser with the given configuration. You can configure
+  the markdown-it parser to parse the dialect you want, and provide
+  a description of the ProseMirror entities those tokens map to in
+  the `tokens` object, which maps token names to descriptions of
+  what to do with them. Such a description is an object, and may
+  have the following properties:
+  */
+  constructor(t, r, i) {
+    this.schema = t, this.tokenizer = r, this.tokens = i, this.tokenHandlers = N(t, i);
+  }
+  /**
+  Parse a string as [CommonMark](http://commonmark.org/) markup,
+  and create a ProseMirror document as prescribed by this parser's
+  rules.
+  
+  The second argument, when given, is passed through to the
+  [Markdown
+  parser](https://markdown-it.github.io/markdown-it/#MarkdownIt.parse).
+  */
+  parse(t, r = {}) {
+    let i = new C(this.schema, this.tokenHandlers), s;
+    i.parseTokens(this.tokenizer.parse(t, r));
+    do
+      s = i.closeNode();
+    while (i.stack.length);
+    return s || this.schema.topNodeType.createAndFill();
+  }
+}
+function T(e, t) {
+  for (; ++t < e.length; )
+    if (e[t].type != "list_item_open")
+      return e[t].hidden;
+  return !1;
+}
+new v(D, S("commonmark", { html: !1 }), {
+  blockquote: { block: "blockquote" },
+  paragraph: { block: "paragraph" },
+  list_item: { block: "list_item" },
+  bullet_list: { block: "bullet_list", getAttrs: (e, t, r) => ({ tight: T(t, r) }) },
+  ordered_list: { block: "ordered_list", getAttrs: (e, t, r) => ({
+    order: +e.attrGet("start") || 1,
+    tight: T(t, r)
+  }) },
+  heading: { block: "heading", getAttrs: (e) => ({ level: +e.tag.slice(1) }) },
+  code_block: { block: "code_block", noCloseToken: !0 },
+  fence: { block: "code_block", getAttrs: (e) => ({ params: e.info || "" }), noCloseToken: !0 },
+  hr: { node: "horizontal_rule" },
+  image: { node: "image", getAttrs: (e) => ({
+    src: e.attrGet("src"),
+    title: e.attrGet("title") || null,
+    alt: e.children[0] && e.children[0].content || null
+  }) },
+  hardbreak: { node: "hard_break" },
+  em: { mark: "em" },
+  strong: { mark: "strong" },
+  link: { mark: "link", getAttrs: (e) => ({
+    href: e.attrGet("href"),
+    title: e.attrGet("title") || null
+  }) },
+  code_inline: { mark: "code", noCloseToken: !0 }
+});
+const $ = { open: "", close: "", mixable: !0 };
+class E {
+  /**
+  Construct a serializer with the given configuration. The `nodes`
+  object should map node names in a given schema to function that
+  take a serializer state and such a node, and serialize the node.
+  */
+  constructor(t, r, i = {}) {
+    this.nodes = t, this.marks = r, this.options = i;
+  }
+  /**
+  Serialize the content of the given node to
+  [CommonMark](http://commonmark.org/).
+  */
+  serialize(t, r = {}) {
+    r = Object.assign({}, this.options, r);
+    let i = new z(this.nodes, this.marks, r);
+    return i.renderContent(t), i.out;
+  }
+}
+const W = new E({
+  blockquote(e, t) {
+    e.wrapBlock("> ", null, t, () => e.renderContent(t));
+  },
+  code_block(e, t) {
+    const r = t.textContent.match(/`{3,}/gm), i = r ? r.sort().slice(-1)[0] + "`" : "```";
+    e.write(i + (t.attrs.params || "") + `
+`), e.text(t.textContent, !1), e.write(`
+`), e.write(i), e.closeBlock(t);
+  },
+  heading(e, t) {
+    e.write(e.repeat("#", t.attrs.level) + " "), e.renderInline(t, !1), e.closeBlock(t);
+  },
+  horizontal_rule(e, t) {
+    e.write(t.attrs.markup || "---"), e.closeBlock(t);
+  },
+  bullet_list(e, t) {
+    e.renderList(t, "  ", () => (t.attrs.bullet || "*") + " ");
+  },
+  ordered_list(e, t) {
+    let r = t.attrs.order || 1, i = String(r + t.childCount - 1).length, s = e.repeat(" ", i + 2);
+    e.renderList(t, s, (a) => {
+      let l = String(r + a);
+      return e.repeat(" ", i - l.length) + l + ". ";
+    });
+  },
+  list_item(e, t) {
+    e.renderContent(t);
+  },
+  paragraph(e, t) {
+    e.renderInline(t), e.closeBlock(t);
+  },
+  image(e, t) {
+    e.write("![" + e.esc(t.attrs.alt || "") + "](" + t.attrs.src.replace(/[\(\)]/g, "\\$&") + (t.attrs.title ? ' "' + t.attrs.title.replace(/"/g, '\\"') + '"' : "") + ")");
+  },
+  hard_break(e, t, r, i) {
+    for (let s = i + 1; s < r.childCount; s++)
+      if (r.child(s).type != t.type) {
+        e.write(`\\
+`);
+        return;
+      }
+  },
+  text(e, t) {
+    e.text(t.text, !e.inAutolink);
+  }
+}, {
+  em: { open: "*", close: "*", mixable: !0, expelEnclosingWhitespace: !0 },
+  strong: { open: "**", close: "**", mixable: !0, expelEnclosingWhitespace: !0 },
+  link: {
+    open(e, t, r, i) {
+      return e.inAutolink = L(t, r, i), e.inAutolink ? "<" : "[";
+    },
+    close(e, t, r, i) {
+      let { inAutolink: s } = e;
+      return e.inAutolink = void 0, s ? ">" : "](" + t.attrs.href.replace(/[\(\)"]/g, "\\$&") + (t.attrs.title ? ` "${t.attrs.title.replace(/"/g, '\\"')}"` : "") + ")";
+    },
+    mixable: !0
+  },
+  code: {
+    open(e, t, r, i) {
+      return A(r.child(i), -1);
+    },
+    close(e, t, r, i) {
+      return A(r.child(i - 1), 1);
+    },
+    escape: !1
+  }
+});
+function A(e, t) {
+  let r = /`+/g, i, s = 0;
+  if (e.isText)
+    for (; i = r.exec(e.text); )
+      s = Math.max(s, i[0].length);
+  let a = s > 0 && t > 0 ? " `" : "`";
+  for (let l = 0; l < s; l++)
+    a += "`";
+  return s > 0 && t < 0 && (a += " "), a;
+}
+function L(e, t, r) {
+  if (e.attrs.title || !/^\w+:/.test(e.attrs.href))
+    return !1;
+  let i = t.child(r);
+  return !i.isText || i.text != e.attrs.href || i.marks[i.marks.length - 1] != e ? !1 : r == t.childCount - 1 || !e.isInSet(t.child(r + 1).marks);
+}
+let z = class {
+  /**
+  @internal
+  */
+  constructor(t, r, i) {
+    this.nodes = t, this.marks = r, this.options = i, this.delim = "", this.out = "", this.closed = null, this.inAutolink = void 0, this.atBlockStart = !1, this.inTightList = !1, typeof this.options.tightLists > "u" && (this.options.tightLists = !1), typeof this.options.hardBreakNodeName > "u" && (this.options.hardBreakNodeName = "hard_break");
+  }
+  /**
+  @internal
+  */
+  flushClose(t = 2) {
+    if (this.closed) {
+      if (this.atBlank() || (this.out += `
+`), t > 1) {
+        let r = this.delim, i = /\s+$/.exec(r);
+        i && (r = r.slice(0, r.length - i[0].length));
+        for (let s = 1; s < t; s++)
+          this.out += r + `
+`;
+      }
+      this.closed = null;
+    }
+  }
+  /**
+  @internal
+  */
+  getMark(t) {
+    let r = this.marks[t];
+    if (!r) {
+      if (this.options.strict !== !1)
+        throw new Error(`Mark type \`${t}\` not supported by Markdown renderer`);
+      r = $;
+    }
+    return r;
+  }
+  /**
+  Render a block, prefixing each line with `delim`, and the first
+  line in `firstDelim`. `node` should be the node that is closed at
+  the end of the block, and `f` is a function that renders the
+  content of the block.
+  */
+  wrapBlock(t, r, i, s) {
+    let a = this.delim;
+    this.write(r ?? t), this.delim += t, s(), this.delim = a, this.closeBlock(i);
+  }
+  /**
+  @internal
+  */
+  atBlank() {
+    return /(^|\n)$/.test(this.out);
+  }
+  /**
+  Ensure the current content ends with a newline.
+  */
+  ensureNewLine() {
+    this.atBlank() || (this.out += `
+`);
+  }
+  /**
+  Prepare the state for writing output (closing closed paragraphs,
+  adding delimiters, and so on), and then optionally add content
+  (unescaped) to the output.
+  */
+  write(t) {
+    this.flushClose(), this.delim && this.atBlank() && (this.out += this.delim), t && (this.out += t);
+  }
+  /**
+  Close the block for the given node.
+  */
+  closeBlock(t) {
+    this.closed = t;
+  }
+  /**
+  Add the given text to the document. When escape is not `false`,
+  it will be escaped.
+  */
+  text(t, r = !0) {
+    let i = t.split(`
+`);
+    for (let s = 0; s < i.length; s++)
+      this.write(), !r && i[s][0] == "[" && /(^|[^\\])\!$/.test(this.out) && (this.out = this.out.slice(0, this.out.length - 1) + "\\!"), this.out += r ? this.esc(i[s], this.atBlockStart) : i[s], s != i.length - 1 && (this.out += `
+`);
+  }
+  /**
+  Render the given node as a block.
+  */
+  render(t, r, i) {
+    if (this.nodes[t.type.name])
+      this.nodes[t.type.name](this, t, r, i);
+    else {
+      if (this.options.strict !== !1)
+        throw new Error("Token type `" + t.type.name + "` not supported by Markdown renderer");
+      t.type.isLeaf || (t.type.inlineContent ? this.renderInline(t) : this.renderContent(t), t.isBlock && this.closeBlock(t));
+    }
+  }
+  /**
+  Render the contents of `parent` as block nodes.
+  */
+  renderContent(t) {
+    t.forEach((r, i, s) => this.render(r, t, s));
+  }
+  /**
+  Render the contents of `parent` as inline content.
+  */
+  renderInline(t, r = !0) {
+    this.atBlockStart = r;
+    let i = [], s = "", a = (l, g, o) => {
+      let n = l ? l.marks : [];
+      l && l.type.name === this.options.hardBreakNodeName && (n = n.filter((h) => {
+        if (o + 1 == t.childCount)
+          return !1;
+        let c = t.child(o + 1);
+        return h.isInSet(c.marks) && (!c.isText || /\S/.test(c.text));
+      }));
+      let m = s;
+      if (s = "", l && l.isText && n.some((h) => {
+        let c = this.getMark(h.type.name);
+        return c && c.expelEnclosingWhitespace && !h.isInSet(i);
+      })) {
+        let [h, c, u] = /^(\s*)(.*)$/m.exec(l.text);
+        c && (m += c, l = u ? l.withText(u) : null, l || (n = i));
+      }
+      if (l && l.isText && n.some((h) => {
+        let c = this.getMark(h.type.name);
+        return c && c.expelEnclosingWhitespace && !this.isMarkAhead(t, o + 1, h);
+      })) {
+        let [h, c, u] = /^(.*?)(\s*)$/m.exec(l.text);
+        u && (s = u, l = c ? l.withText(c) : null, l || (n = i));
+      }
+      let d = n.length ? n[n.length - 1] : null, x = d && this.getMark(d.type.name).escape === !1, f = n.length - (x ? 1 : 0);
+      t: for (let h = 0; h < f; h++) {
+        let c = n[h];
+        if (!this.getMark(c.type.name).mixable)
+          break;
+        for (let u = 0; u < i.length; u++) {
+          let y = i[u];
+          if (!this.getMark(y.type.name).mixable)
+            break;
+          if (c.eq(y)) {
+            h > u ? n = n.slice(0, u).concat(c).concat(n.slice(u, h)).concat(n.slice(h + 1, f)) : u > h && (n = n.slice(0, h).concat(n.slice(h + 1, u)).concat(c).concat(n.slice(u, f)));
+            continue t;
+          }
+        }
+      }
+      let p = 0;
+      for (; p < Math.min(i.length, f) && n[p].eq(i[p]); )
+        ++p;
+      for (; p < i.length; )
+        this.text(this.markString(i.pop(), !1, t, o), !1);
+      if (m && this.text(m), l) {
+        for (; i.length < f; ) {
+          let h = n[i.length];
+          i.push(h), this.text(this.markString(h, !0, t, o), !1), this.atBlockStart = !1;
+        }
+        x && l.isText ? this.text(this.markString(d, !0, t, o) + l.text + this.markString(d, !1, t, o + 1), !1) : this.render(l, t, o), this.atBlockStart = !1;
+      }
+      l?.isText && l.nodeSize > 0 && (this.atBlockStart = !1);
+    };
+    t.forEach(a), a(null, 0, t.childCount), this.atBlockStart = !1;
+  }
+  /**
+  Render a node's content as a list. `delim` should be the extra
+  indentation added to all lines except the first in an item,
+  `firstDelim` is a function going from an item index to a
+  delimiter for the first line of the item.
+  */
+  renderList(t, r, i) {
+    this.closed && this.closed.type == t.type ? this.flushClose(3) : this.inTightList && this.flushClose(1);
+    let s = typeof t.attrs.tight < "u" ? t.attrs.tight : this.options.tightLists, a = this.inTightList;
+    this.inTightList = s, t.forEach((l, g, o) => {
+      o && s && this.flushClose(1), this.wrapBlock(r, i(o), t, () => this.render(l, t, o));
+    }), this.inTightList = a;
+  }
+  /**
+  Escape the given string so that it can safely appear in Markdown
+  content. If `startOfLine` is true, also escape characters that
+  have special meaning only at the start of the line.
+  */
+  esc(t, r = !1) {
+    return t = t.replace(/[`*\\~\[\]_]/g, (i, s) => i == "_" && s > 0 && s + 1 < t.length && t[s - 1].match(/\w/) && t[s + 1].match(/\w/) ? i : "\\" + i), r && (t = t.replace(/^(\+[ ]|[\-*>])/, "\\$&").replace(/^(\s*)(#{1,6})(\s|$)/, "$1\\$2$3").replace(/^(\s*\d+)\.\s/, "$1\\. ")), this.options.escapeExtraCharacters && (t = t.replace(this.options.escapeExtraCharacters, "\\$&")), t;
+  }
+  /**
+  @internal
+  */
+  quote(t) {
+    let r = t.indexOf('"') == -1 ? '""' : t.indexOf("'") == -1 ? "''" : "()";
+    return r[0] + t + r[1];
+  }
+  /**
+  Repeat the given string `n` times.
+  */
+  repeat(t, r) {
+    let i = "";
+    for (let s = 0; s < r; s++)
+      i += t;
+    return i;
+  }
+  /**
+  Get the markdown string for a given opening or closing mark.
+  */
+  markString(t, r, i, s) {
+    let a = this.getMark(t.type.name), l = r ? a.open : a.close;
+    return typeof l == "string" ? l : l(this, t, i, s);
+  }
+  /**
+  Get leading and trailing whitespace from a string. Values of
+  leading or trailing property of the return object will be undefined
+  if there is no match.
+  */
+  getEnclosingWhitespace(t) {
+    return {
+      leading: (t.match(/^(\s+)/) || [void 0])[0],
+      trailing: (t.match(/(\s+)$/) || [void 0])[0]
+    };
+  }
+  /**
+  @internal
+  */
+  isMarkAhead(t, r, i) {
+    for (; ; r++) {
+      if (r >= t.childCount)
+        return !1;
+      let s = t.child(r);
+      if (s.type.name != this.options.hardBreakNodeName)
+        return i.isInSet(s.marks);
+      r++;
+    }
+  }
+};
+export {
+  z as M,
+  W as d
+};