@vc-shell/framework 1.2.0 → 1.2.2

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

@@ -0,0 +1,650 @@
+import { a as A, M as w } from "./vendor-prosemirror-model-DFp4ML7B.js";
+import { M as S } from "./vendor-markdown-it-Czg9qJTh.js";
+const D = new A({
+  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 C(e, t) {
+  if (e.isText && t.isText && w.sameSet(e.marks, t.marks))
+    return e.withText(e.text + t.text);
+}
+class B {
+  constructor(t, i) {
+    this.schema = t, this.tokenHandlers = i, 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 i = this.top(), r = i.content, l = r[r.length - 1], a = this.schema.text(t, i.marks), s;
+    l && (s = C(l, a)) ? r[r.length - 1] = s : r.push(a);
+  }
+  // Adds the given mark to the set of active marks.
+  openMark(t) {
+    let i = this.top();
+    i.marks = t.addToSet(i.marks);
+  }
+  // Removes the given mark from the set of active marks.
+  closeMark(t) {
+    let i = this.top();
+    i.marks = t.removeFromSet(i.marks);
+  }
+  parseTokens(t) {
+    for (let i = 0; i < t.length; i++) {
+      let r = t[i], l = this.tokenHandlers[r.type];
+      if (!l)
+        throw new Error("Token type `" + r.type + "` not supported by Markdown parser");
+      l(this, r, t, i);
+    }
+  }
+  // Add a node at the current position.
+  addNode(t, i, r) {
+    let l = this.top(), a = t.createAndFill(i, r, l ? l.marks : []);
+    return a ? (this.push(a), a) : null;
+  }
+  // Wrap subsequent content in a node of the given type.
+  openNode(t, i) {
+    this.stack.push({ type: t, attrs: i, 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, i, r) {
+  return e.getAttrs ? e.getAttrs(t, i, r) : 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 i = /* @__PURE__ */ Object.create(null);
+  for (let r in t) {
+    let l = t[r];
+    if (l.block) {
+      let a = e.nodeType(l.block);
+      b(l, r) ? i[r] = (s, g, o, n) => {
+        s.openNode(a, k(l, g, o, n)), s.addText(_(g.content)), s.closeNode();
+      } : (i[r + "_open"] = (s, g, o, n) => s.openNode(a, k(l, g, o, n)), i[r + "_close"] = (s) => s.closeNode());
+    } else if (l.node) {
+      let a = e.nodeType(l.node);
+      i[r] = (s, g, o, n) => s.addNode(a, k(l, g, o, n));
+    } else if (l.mark) {
+      let a = e.marks[l.mark];
+      b(l, r) ? i[r] = (s, g, o, n) => {
+        s.openMark(a.create(k(l, g, o, n))), s.addText(_(g.content)), s.closeMark(a);
+      } : (i[r + "_open"] = (s, g, o, n) => s.openMark(a.create(k(l, g, o, n))), i[r + "_close"] = (s) => s.closeMark(a));
+    } else if (l.ignore)
+      b(l, r) ? i[r] = M : (i[r + "_open"] = M, i[r + "_close"] = M);
+    else
+      throw new RangeError("Unrecognized parsing spec " + JSON.stringify(l));
+  }
+  return i.text = (r, l) => r.addText(l.content), i.inline = (r, l) => r.parseTokens(l.children), i.softbreak = i.softbreak || ((r) => r.addText(" ")), i;
+}
+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, i, r) {
+    this.schema = t, this.tokenizer = i, this.tokens = r, this.tokenHandlers = N(t, r);
+  }
+  /**
+  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, i = {}) {
+    let r = new B(this.schema, this.tokenHandlers), l;
+    r.parseTokens(this.tokenizer.parse(t, i));
+    do
+      l = r.closeNode();
+    while (r.stack.length);
+    return l || 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, i) => ({ tight: T(t, i) }) },
+  ordered_list: { block: "ordered_list", getAttrs: (e, t, i) => ({
+    order: +e.attrGet("start") || 1,
+    tight: T(t, i)
+  }) },
+  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, i, r = {}) {
+    this.nodes = t, this.marks = i, this.options = r;
+  }
+  /**
+  Serialize the content of the given node to
+  [CommonMark](http://commonmark.org/).
+  */
+  serialize(t, i = {}) {
+    i = Object.assign({}, this.options, i);
+    let r = new z(this.nodes, this.marks, i);
+    return r.renderContent(t), r.out;
+  }
+}
+const W = new E({
+  blockquote(e, t) {
+    e.wrapBlock("> ", null, t, () => e.renderContent(t));
+  },
+  code_block(e, t) {
+    const i = t.textContent.match(/`{3,}/gm), r = i ? i.sort().slice(-1)[0] + "`" : "```";
+    e.write(r + (t.attrs.params || "") + `
+`), e.text(t.textContent, !1), e.write(`
+`), e.write(r), 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 i = t.attrs.order || 1, r = String(i + t.childCount - 1).length, l = e.repeat(" ", r + 2);
+    e.renderList(t, l, (a) => {
+      let s = String(i + a);
+      return e.repeat(" ", r - s.length) + s + ". ";
+    });
+  },
+  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, i, r) {
+    for (let l = r + 1; l < i.childCount; l++)
+      if (i.child(l).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, i, r) {
+      return e.inAutolink = L(t, i, r), e.inAutolink ? "<" : "[";
+    },
+    close(e, t, i, r) {
+      let { inAutolink: l } = e;
+      return e.inAutolink = void 0, l ? ">" : "](" + t.attrs.href.replace(/[\(\)"]/g, "\\$&") + (t.attrs.title ? ` "${t.attrs.title.replace(/"/g, '\\"')}"` : "") + ")";
+    },
+    mixable: !0
+  },
+  code: {
+    open(e, t, i, r) {
+      return O(i.child(r), -1);
+    },
+    close(e, t, i, r) {
+      return O(i.child(r - 1), 1);
+    },
+    escape: !1
+  }
+});
+function O(e, t) {
+  let i = /`+/g, r, l = 0;
+  if (e.isText)
+    for (; r = i.exec(e.text); )
+      l = Math.max(l, r[0].length);
+  let a = l > 0 && t > 0 ? " `" : "`";
+  for (let s = 0; s < l; s++)
+    a += "`";
+  return l > 0 && t < 0 && (a += " "), a;
+}
+function L(e, t, i) {
+  if (e.attrs.title || !/^\w+:/.test(e.attrs.href))
+    return !1;
+  let r = t.child(i);
+  return !r.isText || r.text != e.attrs.href || r.marks[r.marks.length - 1] != e ? !1 : i == t.childCount - 1 || !e.isInSet(t.child(i + 1).marks);
+}
+let z = class {
+  /**
+  @internal
+  */
+  constructor(t, i, r) {
+    this.nodes = t, this.marks = i, this.options = r, 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 i = this.delim, r = /\s+$/.exec(i);
+        r && (i = i.slice(0, i.length - r[0].length));
+        for (let l = 1; l < t; l++)
+          this.out += i + `
+`;
+      }
+      this.closed = null;
+    }
+  }
+  /**
+  @internal
+  */
+  getMark(t) {
+    let i = this.marks[t];
+    if (!i) {
+      if (this.options.strict !== !1)
+        throw new Error(`Mark type \`${t}\` not supported by Markdown renderer`);
+      i = $;
+    }
+    return i;
+  }
+  /**
+  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, i, r, l) {
+    let a = this.delim;
+    this.write(i ?? t), this.delim += t, l(), this.delim = a, this.closeBlock(r);
+  }
+  /**
+  @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, i = !0) {
+    let r = t.split(`
+`);
+    for (let l = 0; l < r.length; l++)
+      this.write(), !i && r[l][0] == "[" && /(^|[^\\])\!$/.test(this.out) && (this.out = this.out.slice(0, this.out.length - 1) + "\\!"), this.out += i ? this.esc(r[l], this.atBlockStart) : r[l], l != r.length - 1 && (this.out += `
+`);
+  }
+  /**
+  Render the given node as a block.
+  */
+  render(t, i, r) {
+    if (this.nodes[t.type.name])
+      this.nodes[t.type.name](this, t, i, r);
+    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((i, r, l) => this.render(i, t, l));
+  }
+  /**
+  Render the contents of `parent` as inline content.
+  */
+  renderInline(t, i = !0) {
+    this.atBlockStart = i;
+    let r = [], l = "", a = (s, g, o) => {
+      let n = s ? s.marks : [];
+      s && s.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 = l;
+      if (l = "", s && s.isText && n.some((h) => {
+        let c = this.getMark(h.type.name);
+        return c && c.expelEnclosingWhitespace && !h.isInSet(r);
+      })) {
+        let [h, c, u] = /^(\s*)(.*)$/m.exec(s.text);
+        c && (m += c, s = u ? s.withText(u) : null, s || (n = r));
+      }
+      if (s && s.isText && n.some((h) => {
+        let c = this.getMark(h.type.name);
+        return c && c.expelEnclosingWhitespace && (o == t.childCount - 1 || !h.isInSet(t.child(o + 1).marks));
+      })) {
+        let [h, c, u] = /^(.*?)(\s*)$/m.exec(s.text);
+        u && (l = u, s = c ? s.withText(c) : null, s || (n = r));
+      }
+      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 < r.length; u++) {
+          let y = r[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(r.length, f) && n[p].eq(r[p]); )
+        ++p;
+      for (; p < r.length; )
+        this.text(this.markString(r.pop(), !1, t, o), !1);
+      if (m && this.text(m), s) {
+        for (; r.length < f; ) {
+          let h = n[r.length];
+          r.push(h), this.text(this.markString(h, !0, t, o), !1), this.atBlockStart = !1;
+        }
+        x && s.isText ? this.text(this.markString(d, !0, t, o) + s.text + this.markString(d, !1, t, o + 1), !1) : this.render(s, t, o), this.atBlockStart = !1;
+      }
+      s?.isText && s.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, i, r) {
+    this.closed && this.closed.type == t.type ? this.flushClose(3) : this.inTightList && this.flushClose(1);
+    let l = typeof t.attrs.tight < "u" ? t.attrs.tight : this.options.tightLists, a = this.inTightList;
+    this.inTightList = l, t.forEach((s, g, o) => {
+      o && l && this.flushClose(1), this.wrapBlock(i, r(o), t, () => this.render(s, 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, i = !1) {
+    return t = t.replace(/[`*\\~\[\]_]/g, (r, l) => r == "_" && l > 0 && l + 1 < t.length && t[l - 1].match(/\w/) && t[l + 1].match(/\w/) ? r : "\\" + r), i && (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 i = t.indexOf('"') == -1 ? '""' : t.indexOf("'") == -1 ? "''" : "()";
+    return i[0] + t + i[1];
+  }
+  /**
+  Repeat the given string `n` times.
+  */
+  repeat(t, i) {
+    let r = "";
+    for (let l = 0; l < i; l++)
+      r += t;
+    return r;
+  }
+  /**
+  Get the markdown string for a given opening or closing mark.
+  */
+  markString(t, i, r, l) {
+    let a = this.getMark(t.type.name), s = i ? a.open : a.close;
+    return typeof s == "string" ? s : s(this, t, r, l);
+  }
+  /**
+  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]
+    };
+  }
+};
+export {
+  z as M,
+  W as d
+};