@vc-shell/framework 1.2.0 → 1.2.1

package/dist/vendor-tiptap-markdown-DRc3qhBU.js

@@ -0,0 +1,826 @@
+import { E as b, z as B, N as a, M as m, A as z } from "./vendor-tiptap-core-8RGSOCZs.js";
+import { M as O, d } from "./vendor-prosemirror-markdown-OyxRuawK.js";
+import { M as C } from "./vendor-markdown-it-Czg9qJTh.js";
+import { d as P, F as w } from "./vendor-prosemirror-model-DFp4ML7B.js";
+import { t as _ } from "./vendor-markdown-it-task-lists-BxLwscWK.js";
+import { P as N, a as I } from "./vendor-prosemirror-state-DHaVEu5h.js";
+var A = Object.defineProperty, D = (r, e, t) => e in r ? A(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t, h = (r, e, t) => (D(r, typeof e != "symbol" ? e + "" : e, t), t);
+const j = b.create({
+  name: "markdownTightLists",
+  addOptions: () => ({
+    tight: !0,
+    tightClass: "tight",
+    listTypes: ["bulletList", "orderedList"]
+  }),
+  addGlobalAttributes() {
+    return [{
+      types: this.options.listTypes,
+      attributes: {
+        tight: {
+          default: this.options.tight,
+          parseHTML: (r) => r.getAttribute("data-tight") === "true" || !r.querySelector("p"),
+          renderHTML: (r) => ({
+            class: r.tight ? this.options.tightClass : null,
+            "data-tight": r.tight ? "true" : null
+          })
+        }
+      }
+    }];
+  },
+  addCommands() {
+    var r = this;
+    return {
+      toggleTight: function() {
+        let e = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : null;
+        return (t) => {
+          let {
+            editor: i,
+            commands: n
+          } = t;
+          function o(s) {
+            if (!i.isActive(s))
+              return !1;
+            const l = i.getAttributes(s);
+            return n.updateAttributes(s, {
+              tight: e ?? !(l != null && l.tight)
+            });
+          }
+          return r.options.listTypes.some((s) => o(s));
+        };
+      }
+    };
+  }
+}), v = C();
+function L(r, e) {
+  return v.inline.State.prototype.scanDelims.call({
+    src: r,
+    posMax: r.length
+  }), new v.inline.State(r, null, null, []).scanDelims(e, !0);
+}
+function y(r, e, t, i) {
+  let n = r.substring(0, t) + r.substring(t + e.length);
+  return n = n.substring(0, t + i) + e + n.substring(t + i), n;
+}
+function q(r, e, t, i) {
+  let n = t, o = r;
+  for (; n < i && !L(o, n).can_open; )
+    o = y(o, e, n, 1), n++;
+  return {
+    text: o,
+    from: n,
+    to: i
+  };
+}
+function R(r, e, t, i) {
+  let n = i, o = r;
+  for (; n > t && !L(o, n).can_close; )
+    o = y(o, e, n, -1), n--;
+  return {
+    text: o,
+    from: t,
+    to: n
+  };
+}
+function F(r, e, t, i) {
+  let n = {
+    text: r,
+    from: t,
+    to: i
+  };
+  return n = q(n.text, e, n.from, n.to), n = R(n.text, e, n.from, n.to), n.to - n.from < e.length + 1 && (n.text = n.text.substring(0, n.from) + n.text.substring(n.to + e.length)), n.text;
+}
+class W extends O {
+  constructor(e, t, i) {
+    super(e, t, i ?? {}), h(this, "inTable", !1), this.inlines = [];
+  }
+  render(e, t, i) {
+    super.render(e, t, i);
+    const n = this.inlines[this.inlines.length - 1];
+    if (n != null && n.start && n !== null && n !== void 0 && n.end) {
+      const {
+        delimiter: o,
+        start: s,
+        end: l
+      } = this.normalizeInline(n);
+      this.out = F(this.out, o, s, l), this.inlines.pop();
+    }
+  }
+  markString(e, t, i, n) {
+    const o = this.marks[e.type.name];
+    if (o.expelEnclosingWhitespace)
+      if (t)
+        this.inlines.push({
+          start: this.out.length,
+          delimiter: o.open
+        });
+      else {
+        const s = this.inlines.pop();
+        this.inlines.push({
+          ...s,
+          end: this.out.length
+        });
+      }
+    return super.markString(e, t, i, n);
+  }
+  normalizeInline(e) {
+    let {
+      start: t,
+      end: i
+    } = e;
+    for (; this.out.charAt(t).match(/\s/); )
+      t++;
+    return {
+      ...e,
+      start: t
+    };
+  }
+}
+const $ = m.create({
+  name: "markdownHTMLMark",
+  /**
+   * @return {{markdown: MarkdownMarkSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: {
+          open(r, e) {
+            var t, i;
+            return this.editor.storage.markdown.options.html ? (t = (i = S(e)) === null || i === void 0 ? void 0 : i[0]) !== null && t !== void 0 ? t : "" : (console.warn(`Tiptap Markdown: "${e.type.name}" mark is only available in html mode`), "");
+          },
+          close(r, e) {
+            var t, i;
+            return this.editor.storage.markdown.options.html && (t = (i = S(e)) === null || i === void 0 ? void 0 : i[1]) !== null && t !== void 0 ? t : "";
+          }
+        },
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+function S(r) {
+  const e = r.type.schema, t = e.text(" ", [r]), n = z(w.from(t), e).match(/^(<.*?>) (<\/.*?>)$/);
+  return n ? [n[1], n[2]] : null;
+}
+function x(r) {
+  const e = `<body>${r}</body>`;
+  return new window.DOMParser().parseFromString(e, "text/html").body;
+}
+function G(r) {
+  return r?.replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function K(r) {
+  const e = r.parentElement, t = e.cloneNode();
+  for (; e.firstChild && e.firstChild !== r; )
+    t.appendChild(e.firstChild);
+  t.childNodes.length > 0 && e.parentElement.insertBefore(t, e), e.parentElement.insertBefore(r, e), e.childNodes.length === 0 && e.remove();
+}
+function V(r) {
+  const e = r.parentNode;
+  for (; r.firstChild; )
+    e.insertBefore(r.firstChild, r);
+  e.removeChild(r);
+}
+const f = a.create({
+  name: "markdownHTMLNode",
+  addStorage() {
+    return {
+      markdown: {
+        serialize(r, e, t) {
+          this.editor.storage.markdown.options.html ? r.write(X(e, t)) : (console.warn(`Tiptap Markdown: "${e.type.name}" node is only available in html mode`), r.write(`[${e.type.name}]`)), e.isBlock && r.closeBlock(e);
+        },
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+function X(r, e) {
+  const t = r.type.schema, i = z(w.from(r), t);
+  return r.isBlock && (e instanceof w || e.type.name === t.topNodeType.name) ? J(i) : i;
+}
+function J(r) {
+  const t = x(r).firstElementChild;
+  return t.innerHTML = t.innerHTML.trim() ? `
+${t.innerHTML}
+` : `
+`, t.outerHTML;
+}
+const Q = a.create({
+  name: "blockquote"
+}), U = Q.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: d.nodes.blockquote,
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+}), Y = a.create({
+  name: "bulletList"
+}), E = Y.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize(r, e) {
+          return r.renderList(e, "  ", () => (this.editor.storage.markdown.options.bulletListMarker || "-") + " ");
+        },
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+}), Z = a.create({
+  name: "codeBlock"
+}), ee = Z.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize(r, e) {
+          r.write("```" + (e.attrs.language || "") + `
+`), r.text(e.textContent, !1), r.ensureNewLine(), r.write("```"), r.closeBlock(e);
+        },
+        parse: {
+          setup(r) {
+            var e;
+            r.set({
+              langPrefix: (e = this.options.languageClassPrefix) !== null && e !== void 0 ? e : "language-"
+            });
+          },
+          updateDOM(r) {
+            r.innerHTML = r.innerHTML.replace(/\n<\/code><\/pre>/g, "</code></pre>");
+          }
+        }
+      }
+    };
+  }
+}), te = a.create({
+  name: "hardBreak"
+}), H = te.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize(r, e, t, i) {
+          for (let n = i + 1; n < t.childCount; n++)
+            if (t.child(n).type != e.type) {
+              r.write(r.inTable ? f.storage.markdown.serialize.call(this, r, e, t) : `\\
+`);
+              return;
+            }
+        },
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+}), re = a.create({
+  name: "heading"
+}), ne = re.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: d.nodes.heading,
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+}), ie = a.create({
+  name: "horizontalRule"
+}), oe = ie.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: d.nodes.horizontal_rule,
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+}), se = a.create({
+  name: "image"
+}), ae = se.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: d.nodes.image,
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+}), le = a.create({
+  name: "listItem"
+}), de = le.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: d.nodes.list_item,
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+}), ce = a.create({
+  name: "orderedList"
+});
+function ue(r, e, t) {
+  let i = 0;
+  for (; t - i > 0 && e.child(t - i - 1).type.name === r.type.name; i++)
+    ;
+  return i;
+}
+const me = ce.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize(r, e, t, i) {
+          const n = e.attrs.start || 1, o = String(n + e.childCount - 1).length, s = r.repeat(" ", o + 2), c = ue(e, t, i) % 2 ? ") " : ". ";
+          r.renderList(e, s, (u) => {
+            const p = String(n + u);
+            return r.repeat(" ", o - p.length) + p + c;
+          });
+        },
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+}), pe = a.create({
+  name: "paragraph"
+}), he = pe.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: d.nodes.paragraph,
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+function k(r) {
+  var e, t;
+  return (e = r == null || (t = r.content) === null || t === void 0 ? void 0 : t.content) !== null && e !== void 0 ? e : [];
+}
+const ge = a.create({
+  name: "table"
+}), fe = ge.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize(r, e, t) {
+          if (!ke(e)) {
+            f.storage.markdown.serialize.call(this, r, e, t);
+            return;
+          }
+          r.inTable = !0, e.forEach((i, n, o) => {
+            if (r.write("| "), i.forEach((s, l, c) => {
+              c && r.write(" | ");
+              const u = s.firstChild;
+              u.textContent.trim() && r.renderInline(u);
+            }), r.write(" |"), r.ensureNewLine(), !o) {
+              const s = Array.from({
+                length: i.childCount
+              }).map(() => "---").join(" | ");
+              r.write(`| ${s} |`), r.ensureNewLine();
+            }
+          }), r.closeBlock(e), r.inTable = !1;
+        },
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+});
+function T(r) {
+  return r.attrs.colspan > 1 || r.attrs.rowspan > 1;
+}
+function ke(r) {
+  const e = k(r), t = e[0], i = e.slice(1);
+  return !(k(t).some((n) => n.type.name !== "tableHeader" || T(n) || n.childCount > 1) || i.some((n) => k(n).some((o) => o.type.name === "tableHeader" || T(o) || o.childCount > 1)));
+}
+const we = a.create({
+  name: "taskItem"
+}), be = we.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize(r, e) {
+          const t = e.attrs.checked ? "[x]" : "[ ]";
+          r.write(`${t} `), r.renderContent(e);
+        },
+        parse: {
+          updateDOM(r) {
+            [...r.querySelectorAll(".task-list-item")].forEach((e) => {
+              const t = e.querySelector("input");
+              e.setAttribute("data-type", "taskItem"), t && (e.setAttribute("data-checked", t.checked), t.remove());
+            });
+          }
+        }
+      }
+    };
+  }
+}), xe = a.create({
+  name: "taskList"
+}), Me = xe.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: E.storage.markdown.serialize,
+        parse: {
+          setup(r) {
+            r.use(_);
+          },
+          updateDOM(r) {
+            [...r.querySelectorAll(".contains-task-list")].forEach((e) => {
+              e.setAttribute("data-type", "taskList");
+            });
+          }
+        }
+      }
+    };
+  }
+}), ve = a.create({
+  name: "text"
+}), Se = ve.extend({
+  /**
+   * @return {{markdown: MarkdownNodeSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize(r, e) {
+          r.text(G(e.text));
+        },
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+}), Te = m.create({
+  name: "bold"
+}), ze = Te.extend({
+  /**
+   * @return {{markdown: MarkdownMarkSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: d.marks.strong,
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+}), Ce = m.create({
+  name: "code"
+}), Le = Ce.extend({
+  /**
+   * @return {{markdown: MarkdownMarkSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: d.marks.code,
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+}), ye = m.create({
+  name: "italic"
+}), $e = ye.extend({
+  /**
+   * @return {{markdown: MarkdownMarkSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: d.marks.em,
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+}), Ee = m.create({
+  name: "link"
+}), He = Ee.extend({
+  /**
+   * @return {{markdown: MarkdownMarkSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: d.marks.link,
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+}), Be = m.create({
+  name: "strike"
+}), Oe = Be.extend({
+  /**
+   * @return {{markdown: MarkdownMarkSpec}}
+   */
+  addStorage() {
+    return {
+      markdown: {
+        serialize: {
+          open: "~~",
+          close: "~~",
+          expelEnclosingWhitespace: !0
+        },
+        parse: {
+          // handled by markdown-it
+        }
+      }
+    };
+  }
+}), Pe = [U, E, ee, H, ne, oe, f, ae, de, me, he, fe, be, Me, Se, ze, Le, $, $e, He, Oe];
+function g(r) {
+  var e, t;
+  const i = (e = r.storage) === null || e === void 0 ? void 0 : e.markdown, n = (t = Pe.find((o) => o.name === r.name)) === null || t === void 0 ? void 0 : t.storage.markdown;
+  return i || n ? {
+    ...n,
+    ...i
+  } : null;
+}
+class _e {
+  constructor(e) {
+    h(this, "editor", null), this.editor = e;
+  }
+  serialize(e) {
+    const t = new W(this.nodes, this.marks, {
+      hardBreakNodeName: H.name
+    });
+    return t.renderContent(e), t.out;
+  }
+  get nodes() {
+    var e;
+    return {
+      ...Object.fromEntries(Object.keys(this.editor.schema.nodes).map((t) => [t, this.serializeNode(f)])),
+      ...Object.fromEntries((e = this.editor.extensionManager.extensions.filter((t) => t.type === "node" && this.serializeNode(t)).map((t) => [t.name, this.serializeNode(t)])) !== null && e !== void 0 ? e : [])
+    };
+  }
+  get marks() {
+    var e;
+    return {
+      ...Object.fromEntries(Object.keys(this.editor.schema.marks).map((t) => [t, this.serializeMark($)])),
+      ...Object.fromEntries((e = this.editor.extensionManager.extensions.filter((t) => t.type === "mark" && this.serializeMark(t)).map((t) => [t.name, this.serializeMark(t)])) !== null && e !== void 0 ? e : [])
+    };
+  }
+  serializeNode(e) {
+    var t;
+    return (t = g(e)) === null || t === void 0 || (t = t.serialize) === null || t === void 0 ? void 0 : t.bind({
+      editor: this.editor,
+      options: e.options
+    });
+  }
+  serializeMark(e) {
+    var t;
+    const i = (t = g(e)) === null || t === void 0 ? void 0 : t.serialize;
+    return i ? {
+      ...i,
+      open: typeof i.open == "function" ? i.open.bind({
+        editor: this.editor,
+        options: e.options
+      }) : i.open,
+      close: typeof i.close == "function" ? i.close.bind({
+        editor: this.editor,
+        options: e.options
+      }) : i.close
+    } : null;
+  }
+}
+class Ne {
+  constructor(e, t) {
+    h(this, "editor", null), h(this, "md", null);
+    let {
+      html: i,
+      linkify: n,
+      breaks: o
+    } = t;
+    this.editor = e, this.md = this.withPatchedRenderer(C({
+      html: i,
+      linkify: n,
+      breaks: o
+    }));
+  }
+  parse(e) {
+    let {
+      inline: t
+    } = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    if (typeof e == "string") {
+      this.editor.extensionManager.extensions.forEach((o) => {
+        var s;
+        return (s = g(o)) === null || s === void 0 || (s = s.parse) === null || s === void 0 || (s = s.setup) === null || s === void 0 ? void 0 : s.call({
+          editor: this.editor,
+          options: o.options
+        }, this.md);
+      });
+      const i = this.md.render(e), n = x(i);
+      return this.editor.extensionManager.extensions.forEach((o) => {
+        var s;
+        return (s = g(o)) === null || s === void 0 || (s = s.parse) === null || s === void 0 || (s = s.updateDOM) === null || s === void 0 ? void 0 : s.call({
+          editor: this.editor,
+          options: o.options
+        }, n);
+      }), this.normalizeDOM(n, {
+        inline: t,
+        content: e
+      }), n.innerHTML;
+    }
+    return e;
+  }
+  normalizeDOM(e, t) {
+    let {
+      inline: i,
+      content: n
+    } = t;
+    return this.normalizeBlocks(e), e.querySelectorAll("*").forEach((o) => {
+      var s;
+      ((s = o.nextSibling) === null || s === void 0 ? void 0 : s.nodeType) === Node.TEXT_NODE && !o.closest("pre") && (o.nextSibling.textContent = o.nextSibling.textContent.replace(/^\n/, ""));
+    }), i && this.normalizeInline(e, n), e;
+  }
+  normalizeBlocks(e) {
+    const i = Object.values(this.editor.schema.nodes).filter((n) => n.isBlock).map((n) => {
+      var o;
+      return (o = n.spec.parseDOM) === null || o === void 0 ? void 0 : o.map((s) => s.tag);
+    }).flat().filter(Boolean).join(",");
+    i && [...e.querySelectorAll(i)].forEach((n) => {
+      n.parentElement.matches("p") && K(n);
+    });
+  }
+  normalizeInline(e, t) {
+    var i;
+    if ((i = e.firstElementChild) !== null && i !== void 0 && i.matches("p")) {
+      var n, o, s, l;
+      const c = e.firstElementChild, {
+        nextElementSibling: u
+      } = c, p = (n = (o = t.match(/^\s+/)) === null || o === void 0 ? void 0 : o[0]) !== null && n !== void 0 ? n : "", M = u ? "" : (s = (l = t.match(/\s+$/)) === null || l === void 0 ? void 0 : l[0]) !== null && s !== void 0 ? s : "";
+      if (t.match(/^\n\n/)) {
+        c.innerHTML = `${c.innerHTML}${M}`;
+        return;
+      }
+      V(c), e.innerHTML = `${p}${e.innerHTML}${M}`;
+    }
+  }
+  /**
+   * @param {markdownit} md
+   */
+  withPatchedRenderer(e) {
+    const t = (i) => function() {
+      const n = i(...arguments);
+      return n === `
+` ? n : n[n.length - 1] === `
+` ? n.slice(0, -1) : n;
+    };
+    return e.renderer.rules.hardbreak = t(e.renderer.rules.hardbreak), e.renderer.rules.softbreak = t(e.renderer.rules.softbreak), e.renderer.rules.fence = t(e.renderer.rules.fence), e.renderer.rules.code_block = t(e.renderer.rules.code_block), e.renderer.renderToken = t(e.renderer.renderToken.bind(e.renderer)), e;
+  }
+}
+const Ie = b.create({
+  name: "markdownClipboard",
+  addOptions() {
+    return {
+      transformPastedText: !1,
+      transformCopiedText: !1
+    };
+  },
+  addProseMirrorPlugins() {
+    return [new N({
+      key: new I("markdownClipboard"),
+      props: {
+        clipboardTextParser: (r, e, t) => {
+          if (t || !this.options.transformPastedText)
+            return null;
+          const i = this.editor.storage.markdown.parser.parse(r, {
+            inline: !0
+          });
+          return P.fromSchema(this.editor.schema).parseSlice(x(i), {
+            preserveWhitespace: !0,
+            context: e
+          });
+        },
+        /**
+         * @param {import('prosemirror-model').Slice} slice
+         */
+        clipboardTextSerializer: (r) => this.options.transformCopiedText ? this.editor.storage.markdown.serializer.serialize(r.content) : null
+      }
+    })];
+  }
+}), We = b.create({
+  name: "markdown",
+  priority: 50,
+  addOptions() {
+    return {
+      html: !0,
+      tightLists: !0,
+      tightListClass: "tight",
+      bulletListMarker: "-",
+      linkify: !1,
+      breaks: !1,
+      transformPastedText: !1,
+      transformCopiedText: !1
+    };
+  },
+  addCommands() {
+    const r = B.Commands.config.addCommands();
+    return {
+      setContent: (e, t) => (i) => r.setContent(i.editor.storage.markdown.parser.parse(e), t)(i),
+      insertContentAt: (e, t, i) => (n) => r.insertContentAt(e, n.editor.storage.markdown.parser.parse(t, {
+        inline: !0
+      }), i)(n)
+    };
+  },
+  onBeforeCreate() {
+    this.editor.storage.markdown = {
+      options: {
+        ...this.options
+      },
+      parser: new Ne(this.editor, this.options),
+      serializer: new _e(this.editor),
+      getMarkdown: () => this.editor.storage.markdown.serializer.serialize(this.editor.state.doc)
+    }, this.editor.options.initialContent = this.editor.options.content, this.editor.options.content = this.editor.storage.markdown.parser.parse(this.editor.options.content);
+  },
+  onCreate() {
+    this.editor.options.content = this.editor.options.initialContent, delete this.editor.options.initialContent;
+  },
+  addStorage() {
+    return {
+      /// storage will be defined in onBeforeCreate() to prevent initial object overriding
+    };
+  },
+  addExtensions() {
+    return [j.configure({
+      tight: this.options.tightLists,
+      tightClass: this.options.tightListClass
+    }), Ie.configure({
+      transformPastedText: this.options.transformPastedText,
+      transformCopiedText: this.options.transformCopiedText
+    })];
+  }
+});
+export {
+  We as M
+};