@domternal/extension-markdown 0.12.0

package/dist/index.js

@@ -0,0 +1,1102 @@
+import { Extension } from '@domternal/core';
+import MarkdownIt from 'markdown-it';
+import { Slice, Mark, Fragment } from '@domternal/pm/model';
+import { PluginKey, Plugin } from '@domternal/pm/state';
+
+// src/Markdown.ts
+
+// src/parser/mathRules.ts
+var mathInlineRule = (state, silent) => {
+  const start = state.pos;
+  if (state.src.charCodeAt(start) !== 36) return false;
+  if (state.src.charCodeAt(start + 1) === 36) return false;
+  let pos = start + 1;
+  while (pos < state.posMax) {
+    const code = state.src.charCodeAt(pos);
+    if (code === 92) {
+      pos += 2;
+      continue;
+    }
+    if (code === 36) break;
+    if (code === 10) return false;
+    pos += 1;
+  }
+  if (pos >= state.posMax || pos === start + 1) return false;
+  if (/\s/.test(state.src.charAt(start + 1))) return false;
+  if (/\s/.test(state.src.charAt(pos - 1))) return false;
+  if (/\d/.test(state.src.charAt(pos + 1))) return false;
+  if (!silent) {
+    const token = state.push("math_inline", "", 0);
+    token.content = state.src.slice(start + 1, pos);
+  }
+  state.pos = pos + 1;
+  return true;
+};
+var mathBlockRule = (state, startLine, endLine, silent) => {
+  const start = (state.bMarks[startLine] ?? 0) + (state.tShift[startLine] ?? 0);
+  const lineEnd = state.eMarks[startLine];
+  const firstLine = state.src.slice(start, lineEnd);
+  if (!firstLine.startsWith("$$")) return false;
+  const singleLine = firstLine.length > 4 && firstLine.endsWith("$$");
+  if (!singleLine && firstLine.trim() !== "$$") return false;
+  if (silent) return true;
+  let content;
+  let nextLine = startLine + 1;
+  if (singleLine) {
+    content = firstLine.slice(2, -2).trim();
+  } else {
+    const lines = [];
+    let closed = false;
+    for (; nextLine < endLine; nextLine++) {
+      const lineStart = (state.bMarks[nextLine] ?? 0) + (state.tShift[nextLine] ?? 0);
+      const line = state.src.slice(lineStart, state.eMarks[nextLine]);
+      if (line.trim() === "$$") {
+        closed = true;
+        nextLine += 1;
+        break;
+      }
+      lines.push(line);
+    }
+    if (!closed) return false;
+    content = lines.join("\n");
+  }
+  const token = state.push("math_block", "", 0);
+  token.content = content;
+  token.map = [startLine, singleLine ? startLine + 1 : nextLine];
+  state.line = singleLine ? startLine + 1 : nextLine;
+  return true;
+};
+function addMathInlineRule(md) {
+  md.inline.ruler.after("escape", "math_inline", mathInlineRule);
+}
+function addMathBlockRule(md) {
+  md.block.ruler.after("fence", "math_block", mathBlockRule, {
+    alt: ["paragraph", "reference", "blockquote", "list"]
+  });
+}
+function maybeMerge(a, b) {
+  if (a.isText && b.isText && Mark.sameSet(a.marks, b.marks)) {
+    return a.withText(
+      (a.text ?? "") + (b.text ?? "")
+    );
+  }
+  return null;
+}
+var MarkdownParseState = class {
+  schema;
+  stack;
+  marks = Mark.none;
+  constructor(schema) {
+    this.schema = schema;
+    this.stack = [
+      { type: schema.topNodeType, attrs: null, content: [], discardWhenEmpty: false }
+    ];
+  }
+  top() {
+    const frame = this.stack[this.stack.length - 1];
+    if (frame === void 0) throw new Error("markdown parse stack underflow");
+    return frame;
+  }
+  /** The node type currently being built (for split decisions). */
+  topType() {
+    return this.top().type;
+  }
+  push(node) {
+    this.top().content.push(node);
+  }
+  addText(text) {
+    if (text === "") return;
+    const content = this.top().content;
+    const last = content[content.length - 1];
+    const node = this.schema.text(text, this.marks);
+    const merged = last !== void 0 ? maybeMerge(last, node) : null;
+    if (merged !== null) {
+      content[content.length - 1] = merged;
+    } else {
+      content.push(node);
+    }
+  }
+  openMark(mark) {
+    this.marks = mark.addToSet(this.marks);
+  }
+  closeMark(type) {
+    this.marks = type.removeFromSet(this.marks);
+  }
+  addNode(type, attrs, content) {
+    const node = type.createAndFill(attrs, content, type.isInline ? this.marks : void 0);
+    if (node === null) return null;
+    this.push(node);
+    return node;
+  }
+  openNode(type, attrs = null, discardWhenEmpty = false) {
+    this.stack.push({ type, attrs, content: [], discardWhenEmpty });
+  }
+  closeNode() {
+    if (this.marks.length > 0) this.marks = Mark.none;
+    const frame = this.stack.pop();
+    if (frame === void 0) throw new Error("markdown parse stack underflow");
+    if (frame.discardWhenEmpty && frame.content.length === 0) return null;
+    const node = frame.type.createAndFill(frame.attrs, frame.content);
+    if (node === null) return null;
+    this.push(node);
+    return node;
+  }
+  /**
+   * Close the innermost frame and reopen the same type after inserting
+   * `node` as a sibling: how a block-level image escapes its paragraph.
+   */
+  splitAround(node) {
+    const frame = this.stack.pop();
+    if (frame === void 0) throw new Error("markdown parse stack underflow");
+    if (frame.content.length > 0) {
+      const closed = frame.type.createAndFill(frame.attrs, frame.content);
+      if (closed !== null) this.push(closed);
+    }
+    this.push(node);
+    this.openNode(frame.type, frame.attrs, true);
+  }
+  /** Build the final document; called once after all tokens are consumed. */
+  finish() {
+    while (this.stack.length > 1) this.closeNode();
+    const frame = this.stack.pop();
+    if (frame === void 0) throw new Error("markdown parse stack underflow");
+    const doc = frame.type.createAndFill(frame.attrs, frame.content);
+    if (doc === null) throw new Error("markdown parse produced an invalid document");
+    return doc;
+  }
+};
+
+// src/parser/parser.ts
+function attrFrom(token, name) {
+  const value = token.attrGet(name);
+  return value === null || value === "" ? null : value;
+}
+function cellAlign(token) {
+  const style = token.attrGet("style");
+  if (style === null) return null;
+  const match = /text-align:\s*(left|center|right)/.exec(style);
+  const align = match?.[1];
+  return align === void 0 ? null : { textAlign: align };
+}
+function altText(token) {
+  return (token.children ?? []).filter((child) => child.type === "text" || child.type === "text_special").map((child) => child.content).join("");
+}
+var TASK_PREFIX = /^\[( |x|X)\](?: |$)/;
+function transformTaskLists(doc, schema) {
+  const taskList = schema.nodes["taskList"];
+  const taskItem = schema.nodes["taskItem"];
+  const bulletList = schema.nodes["bulletList"];
+  const listItem = schema.nodes["listItem"];
+  if (taskList === void 0 || taskItem === void 0 || bulletList === void 0 || listItem === void 0) {
+    return doc;
+  }
+  const itemMarker = (item) => {
+    if (item.type !== listItem) return null;
+    const paragraph = item.firstChild;
+    if (paragraph?.isTextblock !== true) return null;
+    const first = paragraph.firstChild;
+    if (first?.isText !== true) return null;
+    if (first.marks.length > 0) return null;
+    const match = TASK_PREFIX.exec(first.text ?? "");
+    return match === null ? null : match[1] ?? " ";
+  };
+  const convertItem = (item) => {
+    const marker = itemMarker(item);
+    const children = [];
+    item.forEach((child, _offset, index) => {
+      if (index === 0 && child.isTextblock) {
+        const inline = [];
+        child.forEach((inlineChild, _o, inlineIndex) => {
+          if (inlineIndex === 0 && inlineChild.isText) {
+            const stripped = (inlineChild.text ?? "").replace(TASK_PREFIX, "");
+            if (stripped !== "") {
+              inline.push(
+                inlineChild.withText(stripped)
+              );
+            }
+            return;
+          }
+          inline.push(inlineChild);
+        });
+        children.push(child.copy(Fragment.from(inline)));
+        return;
+      }
+      children.push(child);
+    });
+    return taskItem.create({ checked: marker === "x" || marker === "X" }, children);
+  };
+  const map = (node) => {
+    if (node.isLeaf) return node;
+    const mapped = [];
+    node.forEach((child) => {
+      mapped.push(map(child));
+    });
+    const rebuilt = node.copy(Fragment.from(mapped));
+    if (rebuilt.type !== bulletList || rebuilt.childCount === 0) return rebuilt;
+    const items = [];
+    rebuilt.forEach((item) => {
+      items.push(item);
+    });
+    if (!items.every((item) => itemMarker(item) !== null)) return rebuilt;
+    return taskList.create(null, items.map(convertItem));
+  };
+  return map(doc);
+}
+function buildMarkdownIt(schema) {
+  const md = new MarkdownIt("default", { html: false, linkify: true });
+  const hasTableSchema = schema.nodes["table"] !== void 0 && schema.nodes["tableRow"] !== void 0 && schema.nodes["tableCell"] !== void 0 && schema.nodes["tableHeader"] !== void 0;
+  if (!hasTableSchema) md.disable("table");
+  if (schema.nodes["image"] === void 0) md.disable("image");
+  if (schema.marks["strike"] === void 0) md.disable("strikethrough");
+  if (schema.marks["link"] === void 0) {
+    md.disable(["link", "linkify", "autolink"]);
+    md.set({ linkify: false });
+  }
+  if (schema.nodes["mathInline"] !== void 0) addMathInlineRule(md);
+  if (schema.nodes["mathBlock"] !== void 0) addMathBlockRule(md);
+  return md;
+}
+function createMarkdownParser(schema) {
+  const md = buildMarkdownIt(schema);
+  const handlers = {};
+  const handleTokens = (state, tokens) => {
+    for (const token of tokens) {
+      const handler = handlers[token.type];
+      if (handler === void 0) {
+        throw new Error(`No markdown token handler for "${token.type}"`);
+      }
+      handler(state, token);
+    }
+  };
+  const node = (name) => schema.nodes[name];
+  const block = (tokenName, nodeName, getAttrs, fallback) => {
+    const type = node(nodeName);
+    if (type === void 0) {
+      const fallbackType = fallback === "paragraph" ? node("paragraph") : void 0;
+      handlers[`${tokenName}_open`] = (state) => {
+        if (fallbackType !== void 0) state.openNode(fallbackType);
+      };
+      handlers[`${tokenName}_close`] = (state) => {
+        if (fallbackType !== void 0) state.closeNode();
+      };
+      return;
+    }
+    handlers[`${tokenName}_open`] = (state, token) => {
+      state.openNode(type, getAttrs?.(token) ?? null);
+    };
+    handlers[`${tokenName}_close`] = (state) => {
+      state.closeNode();
+    };
+  };
+  const inlineMark = (tokenName, markName) => {
+    const type = schema.marks[markName];
+    if (type === void 0) {
+      ignore(`${tokenName}_open`, `${tokenName}_close`);
+      return;
+    }
+    handlers[`${tokenName}_open`] = (state, token) => {
+      state.openMark(
+        type.create(
+          tokenName === "link" ? { href: attrFrom(token, "href"), title: attrFrom(token, "title") } : null
+        )
+      );
+    };
+    handlers[`${tokenName}_close`] = (state) => {
+      state.closeMark(type);
+    };
+  };
+  const cell = (tokenName, nodeName) => {
+    const cellType = node(nodeName);
+    const paragraphType = node("paragraph");
+    if (cellType === void 0 || paragraphType === void 0) return;
+    handlers[`${tokenName}_open`] = (state, token) => {
+      state.openNode(cellType, cellAlign(token));
+      state.openNode(paragraphType);
+    };
+    handlers[`${tokenName}_close`] = (state) => {
+      state.closeNode();
+      state.closeNode();
+    };
+  };
+  const ignore = (...tokenNames) => {
+    for (const name of tokenNames) {
+      handlers[name] = () => {
+      };
+    }
+  };
+  block("paragraph", "paragraph");
+  block("heading", "heading", (token) => ({ level: Number(token.tag.slice(1)) || 1 }), "paragraph");
+  block("blockquote", "blockquote");
+  block("bullet_list", "bulletList");
+  block("ordered_list", "orderedList", (token) => {
+    const start = Number(token.attrGet("start") ?? "1");
+    return { start: Number.isFinite(start) && start >= 1 ? start : 1 };
+  });
+  block("list_item", "listItem");
+  block("table", "table");
+  block("tr", "tableRow");
+  cell("th", "tableHeader");
+  cell("td", "tableCell");
+  ignore("thead_open", "thead_close", "tbody_open", "tbody_close");
+  handlers["inline"] = (state, token) => {
+    handleTokens(state, token.children ?? []);
+  };
+  handlers["text"] = (state, token) => {
+    state.addText(token.content);
+  };
+  handlers["text_special"] = (state, token) => {
+    state.addText(token.content);
+  };
+  handlers["softbreak"] = (state) => {
+    state.addText(" ");
+  };
+  const hardBreakType = node("hardBreak");
+  handlers["hardbreak"] = (state) => {
+    if (hardBreakType !== void 0) {
+      state.addNode(hardBreakType, null);
+    } else {
+      state.addText(" ");
+    }
+  };
+  const codeBlockType = node("codeBlock") ?? node("paragraph");
+  if (codeBlockType !== void 0) {
+    const addCodeBlock = (state, content, language) => {
+      const text = content.replace(/\n$/, "");
+      const attrs = codeBlockType.name === "codeBlock" ? { language } : null;
+      state.addNode(codeBlockType, attrs, text === "" ? [] : [schema.text(text)]);
+    };
+    handlers["fence"] = (state, token) => {
+      const language = token.info.trim().split(/\s+/)[0] ?? "";
+      addCodeBlock(state, token.content, language === "" ? null : language);
+    };
+    handlers["code_block"] = (state, token) => {
+      addCodeBlock(state, token.content, null);
+    };
+  }
+  const horizontalRuleType = node("horizontalRule");
+  handlers["hr"] = (state) => {
+    if (horizontalRuleType !== void 0) state.addNode(horizontalRuleType, null);
+  };
+  const codeMarkType = schema.marks["code"];
+  handlers["code_inline"] = (state, token) => {
+    if (codeMarkType === void 0) {
+      state.addText(token.content);
+      return;
+    }
+    const mark = codeMarkType.create(null);
+    state.openMark(mark);
+    state.addText(token.content);
+    state.closeMark(codeMarkType);
+  };
+  inlineMark("strong", "bold");
+  inlineMark("em", "italic");
+  inlineMark("s", "strike");
+  inlineMark("link", "link");
+  const imageType = node("image");
+  if (imageType !== void 0) {
+    handlers["image"] = (state, token) => {
+      const src = attrFrom(token, "src");
+      if (src === null) return;
+      const alt = altText(token);
+      const attrs = { src, alt: alt === "" ? null : alt, title: attrFrom(token, "title") };
+      if (imageType.isInline) {
+        state.addNode(imageType, attrs);
+        return;
+      }
+      const image = imageType.createAndFill(attrs);
+      if (image === null) return;
+      if (state.topType().name === "paragraph") {
+        state.splitAround(image);
+      } else {
+        state.addText(alt);
+      }
+    };
+  }
+  const mathInlineType = node("mathInline");
+  if (mathInlineType !== void 0) {
+    handlers["math_inline"] = (state, token) => {
+      state.addNode(mathInlineType, { latex: token.content });
+    };
+  }
+  const mathBlockType = node("mathBlock");
+  if (mathBlockType !== void 0) {
+    handlers["math_block"] = (state, token) => {
+      state.addNode(mathBlockType, { latex: token.content });
+    };
+  }
+  return {
+    parse(markdown) {
+      const state = new MarkdownParseState(schema);
+      handleTokens(state, md.parse(markdown, {}));
+      return transformTaskLists(state.finish(), schema);
+    }
+  };
+}
+function parseMarkdown(markdown, schema) {
+  return createMarkdownParser(schema).parse(markdown);
+}
+var markdownPastePluginKey = new PluginKey("markdownPaste");
+var BLOCK_SYNTAX = /^(#{1,6} |> |[-*+] |\d+\. |```|\$\$|\[( |x|X)\] |\|.{1,999}\||(---|\*\*\*|___)\s*$)/m;
+var INLINE_SYNTAX = /(\*\*[^*\n]{1,999}\*\*|__[^_\n]{1,999}__|\[[^\]\n]{1,999}\]\([^)\n]{1,999}\)|`[^`\n]{1,999}`|~~[^~\n]{1,999}~~|!\[[^\]\n]{0,999}\]\([^)\n]{1,999}\))/;
+function looksLikeMarkdown(text) {
+  return BLOCK_SYNTAX.test(text) || INLINE_SYNTAX.test(text);
+}
+function markdownPastePlugin(getParser) {
+  return new Plugin({
+    key: markdownPastePluginKey,
+    props: {
+      handlePaste(view, event) {
+        const clipboard = event.clipboardData;
+        if (clipboard === null) return false;
+        if (clipboard.getData("text/html") !== "") return false;
+        const text = clipboard.getData("text/plain");
+        if (text === "" || !looksLikeMarkdown(text)) return false;
+        if (view.state.selection.$from.parent.type.spec.code === true) return false;
+        let doc;
+        try {
+          doc = getParser().parse(text);
+        } catch {
+          return false;
+        }
+        const first = doc.content.firstChild;
+        const slice = doc.content.childCount === 1 && first !== null && first.type.name === "paragraph" ? new Slice(first.content, 0, 0) : new Slice(doc.content, 0, 0);
+        view.dispatch(view.state.tr.replaceSelection(slice).scrollIntoView());
+        return true;
+      }
+    }
+  });
+}
+
+// src/serializer/state.ts
+var BACKTICKS = /`+/g;
+function backticksFor(node, side) {
+  let len = 0;
+  const text = node.isText ? node.text ?? "" : "";
+  for (const match of text.matchAll(BACKTICKS)) {
+    len = Math.max(len, match[0].length);
+  }
+  const result = len > 0 ? "`".repeat(len + 1) : "`";
+  if (side === -1) return result + (text.startsWith("`") ? " " : "");
+  return (text.endsWith("`") ? " " : "") + result;
+}
+var MarkdownSerializerState = class {
+  nodes;
+  marks;
+  warnings = [];
+  tightLists;
+  delim = "";
+  out = "";
+  closed = null;
+  inTightList = false;
+  // True until the first content of a textblock is written; drives
+  // start-of-line escaping (a list item's first line starts after `- `,
+  // which the output buffer alone cannot reveal).
+  atBlockStart = false;
+  constructor(specs, options = {}) {
+    this.nodes = specs.nodes;
+    this.marks = specs.marks;
+    this.tightLists = options.tightLists ?? true;
+  }
+  warn(code, message, nodeType) {
+    const duplicate = this.warnings.some(
+      (w) => w.code === code && w.message === message && w.nodeType === nodeType
+    );
+    if (duplicate) return;
+    this.warnings.push(nodeType === void 0 ? { code, message } : { code, message, nodeType });
+  }
+  flushClose(size = 2) {
+    if (this.closed === null) return;
+    if (!this.atBlank()) this.out += "\n";
+    if (size > 1) {
+      let delimMin = this.delim;
+      let end = delimMin.length;
+      while (end > 0 && /\s/.test(delimMin.charAt(end - 1))) end -= 1;
+      delimMin = delimMin.slice(0, end);
+      for (let i = 1; i < size; i++) this.out += delimMin + "\n";
+    }
+    this.closed = null;
+  }
+  /**
+   * Render a block wrapped in a line prefix: `firstDelim` on its first line,
+   * `delim` on every following line (blockquote `> `, list item indent).
+   */
+  wrapBlock(delim, firstDelim, node, f) {
+    const old = this.delim;
+    this.write(firstDelim ?? delim);
+    this.delim += delim;
+    f();
+    this.delim = old;
+    this.closeBlock(node);
+  }
+  atBlank() {
+    return /(^|\n)$/.test(this.out);
+  }
+  ensureNewLine() {
+    if (!this.atBlank()) this.out += "\n";
+  }
+  write(content) {
+    this.flushClose();
+    if (this.delim !== "" && this.atBlank()) this.out += this.delim;
+    if (content !== void 0) this.out += content;
+  }
+  /** Close the block: the next write emits the separating blank line. */
+  closeBlock(node) {
+    this.closed = node;
+  }
+  text(text, escape = true) {
+    const lines = text.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      this.write();
+      const line = lines[i] ?? "";
+      if (!escape && line.startsWith("[") && /(^|[^\\])!$/.test(this.out)) {
+        this.out = this.out.slice(0, this.out.length - 1) + "\\!";
+      }
+      this.out += escape ? this.esc(line, this.atBlockStart) : line;
+      if (i !== lines.length - 1) this.out += "\n";
+    }
+  }
+  render(node, parent, index) {
+    const serializer = this.nodes[node.type.name];
+    if (serializer === void 0) {
+      this.warn(
+        "unsupported-node",
+        node.type.isLeaf ? `Node type "${node.type.name}" has no Markdown mapping; node omitted` : `Node type "${node.type.name}" has no Markdown mapping; content flattened`,
+        node.type.name
+      );
+      if (!node.type.isLeaf) {
+        if (node.type.inlineContent) {
+          this.renderInline(node);
+        } else {
+          this.renderContent(node);
+        }
+      }
+      if (node.isBlock) this.closeBlock(node);
+      return;
+    }
+    serializer(this, node, parent, index);
+  }
+  renderContent(parent) {
+    parent.forEach((node, _offset, index) => {
+      this.render(node, parent, index);
+    });
+  }
+  renderInline(parent, fromBlockStart = true) {
+    this.atBlockStart = fromBlockStart;
+    const active = [];
+    let trailing = "";
+    const progress = (node, index) => {
+      let marks = node ? node.marks : [];
+      marks = marks.filter((mark) => {
+        if (this.marks[mark.type.name] !== void 0) return true;
+        this.warn(
+          "unsupported-mark",
+          `Mark type "${mark.type.name}" has no Markdown mapping; formatting dropped`,
+          mark.type.name
+        );
+        return false;
+      });
+      if (node !== null && node.type.name === "hardBreak") {
+        marks = marks.filter((mark) => {
+          if (index + 1 === parent.childCount) return false;
+          const next = parent.child(index + 1);
+          return mark.isInSet(next.marks) && (!next.isText || /\S/.test(next.text ?? ""));
+        });
+      }
+      let leading = trailing;
+      trailing = "";
+      if (node?.isText === true && marks.some((mark) => {
+        const spec = this.marks[mark.type.name];
+        return spec?.expelEnclosingWhitespace === true;
+      })) {
+        const text = node.text ?? "";
+        let coreStart = 0;
+        while (coreStart < text.length && /\s/.test(text.charAt(coreStart))) coreStart += 1;
+        let coreEnd = text.length;
+        while (coreEnd > coreStart && /\s/.test(text.charAt(coreEnd - 1))) coreEnd -= 1;
+        const lead = text.slice(0, coreStart);
+        const core = text.slice(coreStart, coreEnd);
+        const trail = text.slice(coreEnd);
+        if (lead !== "" || trail !== "") {
+          leading += lead;
+          trailing = trail;
+          if (core === "") {
+            marks = active.slice();
+            node = null;
+          } else {
+            node = node.withText(core);
+          }
+        }
+      }
+      const inner = marks.length > 0 ? marks[marks.length - 1] : void 0;
+      const noEsc = inner !== void 0 && this.marks[inner.type.name]?.escape === false;
+      const len = marks.length - (noEsc ? 1 : 0);
+      outer: for (let i = 0; i < len; i++) {
+        const mark = marks[i];
+        if (mark === void 0) break;
+        if (this.marks[mark.type.name]?.mixable !== true) break;
+        for (let j = 0; j < active.length; j++) {
+          const other = active[j];
+          if (other === void 0) break;
+          if (this.marks[other.type.name]?.mixable !== true) break;
+          if (mark.eq(other)) {
+            if (i > j) {
+              marks = [
+                ...marks.slice(0, j),
+                mark,
+                ...marks.slice(j, i),
+                ...marks.slice(i + 1, len)
+              ];
+            } else if (j > i) {
+              marks = [
+                ...marks.slice(0, i),
+                ...marks.slice(i + 1, j),
+                mark,
+                ...marks.slice(j, len)
+              ];
+            }
+            continue outer;
+          }
+        }
+      }
+      let keep = 0;
+      while (keep < Math.min(active.length, len)) {
+        const activeMark = active[keep];
+        const nextMark = marks[keep];
+        if (activeMark === void 0 || nextMark === void 0) break;
+        if (!activeMark.eq(nextMark)) break;
+        keep += 1;
+      }
+      while (keep < active.length) {
+        const mark = active.pop();
+        if (mark === void 0) break;
+        this.text(this.markString(mark, false, parent, index), false);
+      }
+      if (leading !== "") this.text(leading);
+      if (node !== null) {
+        while (active.length < len) {
+          const mark = marks[active.length];
+          if (mark === void 0) break;
+          active.push(mark);
+          this.text(this.markString(mark, true, parent, index), false);
+          this.atBlockStart = false;
+        }
+        if (inner !== void 0 && noEsc && node.isText) {
+          this.text(
+            this.markString(inner, true, parent, index) + (node.text ?? "") + this.markString(inner, false, parent, index + 1),
+            false
+          );
+        } else {
+          this.render(node, parent, index);
+        }
+        this.atBlockStart = false;
+      }
+    };
+    parent.forEach((node, _offset, index) => {
+      progress(node, index);
+    });
+    progress(null, parent.childCount);
+    this.atBlockStart = false;
+  }
+  renderList(node, delim, firstDelim) {
+    if (this.closed !== null && this.closed.type === node.type) {
+      this.flushClose(3);
+    } else if (this.inTightList) {
+      this.flushClose(1);
+    }
+    const isTight = this.tightLists;
+    const prevTight = this.inTightList;
+    this.inTightList = isTight;
+    node.forEach((child, _offset, index) => {
+      if (index > 0 && isTight) this.flushClose(1);
+      this.wrapBlock(delim, firstDelim(index), node, () => {
+        this.render(child, node, index);
+      });
+    });
+    this.inTightList = prevTight;
+  }
+  /**
+   * Escape Markdown syntax in plain text. Beyond the CommonMark set this
+   * also escapes `|` (table cells), `$` (this package's own math rules), and
+   * `<` plus entity-like `&` (raw-HTML/autolink/entity ambiguity on external
+   * renderers): all render as the literal character everywhere.
+   */
+  esc(str, startOfLine = false) {
+    let escaped = str.replace(/[`*\\~[\]_<$|&]/g, (m, i) => {
+      if (m === "_") {
+        return i > 0 && i + 1 < str.length && /\w/.test(str[i - 1] ?? "") && /\w/.test(str[i + 1] ?? "") ? m : "\\" + m;
+      }
+      if (m === "&") return /[a-z#]/i.test(str[i + 1] ?? "") ? "\\&" : m;
+      return "\\" + m;
+    });
+    if (startOfLine) {
+      escaped = escaped.replace(/^([-*>]|\+ )/, "\\$&").replace(/^(\s*)(#{1,6})(\s|$)/, "$1\\$2$3").replace(/^(\s*\d+)\.(\s|$)/, "$1\\.$2");
+    }
+    return escaped;
+  }
+  markString(mark, open, parent, index) {
+    const spec = this.marks[mark.type.name];
+    if (spec === void 0) return "";
+    const value = open ? spec.open : spec.close;
+    return typeof value === "string" ? value : value(this, mark, parent, index);
+  }
+  /** The accumulated output; call once after rendering the document. */
+  finish() {
+    return this.out;
+  }
+};
+
+// src/serializer/specs.ts
+function attrString(node, name) {
+  const value = node.attrs[name];
+  return typeof value === "string" && value !== "" ? value : null;
+}
+function attrNumber(node, name) {
+  const value = node.attrs[name];
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function warnLossyBlockAttrs(state, node) {
+  const textAlign = attrString(node, "textAlign");
+  if (textAlign !== null && textAlign !== "left") {
+    state.warn("lossy-attribute", "Text alignment is not representable in Markdown", node.type.name);
+  }
+  if (attrString(node, "lineHeight") !== null) {
+    state.warn("lossy-attribute", "Line height is not representable in Markdown", node.type.name);
+  }
+  if (attrString(node, "backgroundColor") !== null || attrString(node, "backgroundColorToken") !== null) {
+    state.warn("lossy-attribute", "Block background color is not representable in Markdown", node.type.name);
+  }
+}
+function escapeLinkDestination(url) {
+  return url.replace(/[\\()"]/g, "\\$&");
+}
+function escapeLinkTitle(title) {
+  return title.replace(/[\\"]/g, "\\$&");
+}
+function isPlainUrl(link, parent, index) {
+  const href = link.attrs["href"];
+  if (typeof href !== "string" || attrTitle(link) !== null || !/^\w+:/.test(href)) return false;
+  const content = parent.child(index);
+  if (!content.isText || content.text !== href || content.marks[content.marks.length - 1] !== link) {
+    return false;
+  }
+  return index === parent.childCount - 1 || !link.isInSet(parent.child(index + 1).marks);
+}
+function attrTitle(mark) {
+  const title = mark.attrs["title"];
+  return typeof title === "string" && title !== "" ? title : null;
+}
+function leafText(node) {
+  const spec = node.type.spec.leafText;
+  return typeof spec === "function" ? spec(node) : null;
+}
+function serializeCell(state, cell) {
+  const sub = new MarkdownSerializerState(
+    { nodes: state.nodes, marks: state.marks },
+    { tightLists: state.tightLists }
+  );
+  sub.renderContent(cell);
+  for (const warning of sub.warnings) state.warn(warning.code, warning.message, warning.nodeType);
+  const raw = sub.finish();
+  if (cell.childCount > 1 || raw.includes("\n")) {
+    state.warn("lossy-structure", "Table cell content flattened to one line", cell.type.name);
+  }
+  return raw.replace(/\\\n/g, " ").replace(/\n+/g, " ").trim().replace(/(?<!\\)\|/g, "\\|");
+}
+function separatorFor(alignment) {
+  if (alignment === "center") return ":---:";
+  if (alignment === "right") return "---:";
+  return "---";
+}
+var table = (state, node) => {
+  if (node.childCount === 0) return;
+  const rows = [];
+  const alignments = [];
+  node.forEach((row, _rowOffset, rowIndex) => {
+    const cells = [];
+    row.forEach((cell, _cellOffset, cellIndex) => {
+      if ((attrNumber(cell, "colspan") ?? 1) > 1 || (attrNumber(cell, "rowspan") ?? 1) > 1) {
+        state.warn("lossy-structure", "Merged table cells are not representable in Markdown", node.type.name);
+      }
+      if (attrString(cell, "background") !== null) {
+        state.warn("lossy-attribute", "Table cell background is not representable in Markdown", cell.type.name);
+      }
+      if (attrString(cell, "verticalAlign") !== null) {
+        state.warn("lossy-attribute", "Table cell vertical alignment is not representable in Markdown", cell.type.name);
+      }
+      if (rowIndex === 0) {
+        alignments.push(attrString(cell, "textAlign"));
+      } else {
+        const align = attrString(cell, "textAlign");
+        if (align !== null && align !== (alignments[cellIndex] ?? null)) {
+          state.warn("lossy-attribute", "Cell text alignment differing from its column is not representable in Markdown", cell.type.name);
+        }
+      }
+      cells.push(serializeCell(state, cell));
+    });
+    rows.push(cells);
+  });
+  const columnCount = Math.max(...rows.map((cells) => cells.length), alignments.length);
+  const line = (cells) => {
+    const padded = Array.from({ length: columnCount }, (_v, i) => cells[i] ?? "");
+    return `| ${padded.join(" | ")} |`;
+  };
+  const [headerRow, ...bodyRows] = rows;
+  state.write(line(headerRow ?? []));
+  state.ensureNewLine();
+  state.write(
+    `| ${Array.from({ length: columnCount }, (_v, i) => separatorFor(alignments[i] ?? null)).join(" | ")} |`
+  );
+  for (const cells of bodyRows) {
+    state.ensureNewLine();
+    state.write(line(cells));
+  }
+  state.closeBlock(node);
+};
+var defaultNodeSerializers = {
+  text: (state, node) => {
+    state.text(node.text ?? "");
+  },
+  paragraph: (state, node) => {
+    warnLossyBlockAttrs(state, node);
+    state.renderInline(node);
+    state.closeBlock(node);
+  },
+  heading: (state, node) => {
+    warnLossyBlockAttrs(state, node);
+    const level = attrNumber(node, "level") ?? 1;
+    state.write("#".repeat(Math.min(Math.max(level, 1), 6)) + " ");
+    state.renderInline(node, false);
+    state.closeBlock(node);
+  },
+  blockquote: (state, node) => {
+    state.wrapBlock("> ", null, node, () => {
+      state.renderContent(node);
+    });
+  },
+  codeBlock: (state, node) => {
+    const runs = node.textContent.match(/`{3,}/g);
+    const fence = "`".repeat(Math.max(3, ...(runs ?? [""]).map((run) => run.length + 1)));
+    const language = (attrString(node, "language") ?? "").split(/\s+/)[0]?.replace(/`/g, "") ?? "";
+    state.write(fence + language + "\n");
+    state.text(node.textContent, false);
+    state.ensureNewLine();
+    state.write(fence);
+    state.closeBlock(node);
+  },
+  horizontalRule: (state, node) => {
+    state.write("---");
+    state.closeBlock(node);
+  },
+  hardBreak: (state, node, parent, index) => {
+    for (let i = index + 1; i < parent.childCount; i++) {
+      if (parent.child(i).type !== node.type) {
+        state.write("\\\n");
+        return;
+      }
+    }
+  },
+  bulletList: (state, node) => {
+    state.renderList(node, "  ", () => "- ");
+  },
+  orderedList: (state, node) => {
+    const start = attrNumber(node, "start") ?? 1;
+    const maxWidth = String(start + node.childCount - 1).length;
+    const indent = " ".repeat(maxWidth + 2);
+    state.renderList(node, indent, (index) => {
+      const marker = String(start + index);
+      return " ".repeat(maxWidth - marker.length) + marker + ". ";
+    });
+  },
+  listItem: (state, node) => {
+    state.renderContent(node);
+  },
+  taskList: (state, node) => {
+    state.renderList(node, "  ", () => "- ");
+  },
+  taskItem: (state, node) => {
+    state.write(`[${node.attrs["checked"] === true ? "x" : " "}] `);
+    state.renderContent(node);
+  },
+  image: (state, node) => {
+    const src = attrString(node, "src");
+    if (src === null) {
+      state.warn("unsupported-node", "Image without src omitted", node.type.name);
+      return;
+    }
+    const width = node.attrs["width"];
+    const height = node.attrs["height"];
+    if (width !== null && width !== void 0 || height !== null && height !== void 0) {
+      state.warn("lossy-attribute", "Image dimensions are not representable in Markdown", node.type.name);
+    }
+    const alt = node.attrs["alt"];
+    const title = attrString(node, "title");
+    state.write(
+      `![${state.esc(typeof alt === "string" ? alt : "")}](${escapeLinkDestination(src)}${title !== null ? ` "${escapeLinkTitle(title)}"` : ""})`
+    );
+    if (!node.isInline) state.closeBlock(node);
+  },
+  table,
+  tableRow: () => {
+  },
+  details: (state, node) => {
+    state.warn("lossy-structure", "Toggle block flattened: summary becomes a bold paragraph", node.type.name);
+    state.renderContent(node);
+  },
+  detailsSummary: (state, node) => {
+    if (node.content.size === 0) {
+      state.closeBlock(node);
+      return;
+    }
+    state.write("**");
+    state.renderInline(node, false);
+    state.write("**");
+    state.closeBlock(node);
+  },
+  detailsContent: (state, node) => {
+    state.renderContent(node);
+  },
+  emoji: (state, node) => {
+    const name = attrString(node, "name");
+    const glyph = leafText(node);
+    state.text(glyph !== null && glyph !== "" ? glyph : name !== null ? `:${name}:` : "");
+  },
+  mention: (state, node) => {
+    const label = attrString(node, "label");
+    const text = leafText(node);
+    state.text(text !== null && text !== "" ? text : label !== null ? `@${label}` : "");
+    state.warn("lossy-structure", "Mentions serialize as plain text", node.type.name);
+  },
+  mathInline: (state, node) => {
+    state.write(`$${attrString(node, "latex") ?? ""}$`);
+  },
+  mathBlock: (state, node) => {
+    state.write("$$\n");
+    state.text(attrString(node, "latex") ?? "", false);
+    state.ensureNewLine();
+    state.write("$$");
+    state.closeBlock(node);
+  },
+  tableOfContents: (state, node) => {
+    state.warn("unsupported-node", "Table of contents block omitted (generated content)", node.type.name);
+  }
+};
+var defaultMarkSpecs = {
+  bold: { open: "**", close: "**", mixable: true, expelEnclosingWhitespace: true },
+  italic: { open: "*", close: "*", mixable: true, expelEnclosingWhitespace: true },
+  strike: { open: "~~", close: "~~", mixable: true, expelEnclosingWhitespace: true },
+  code: {
+    open: (_state, _mark, parent, index) => backticksFor(parent.child(index), -1),
+    close: (_state, _mark, parent, index) => backticksFor(parent.child(index - 1), 1),
+    escape: false
+  },
+  link: {
+    open: (_state, mark, parent, index) => isPlainUrl(mark, parent, index) ? "<" : "[",
+    close: (_state, mark, parent, index) => {
+      if (isPlainUrl(mark, parent, index - 1)) return ">";
+      const href = mark.attrs["href"];
+      const title = attrTitle(mark);
+      return `](${escapeLinkDestination(typeof href === "string" ? href : "")}${title !== null ? ` "${escapeLinkTitle(title)}"` : ""})`;
+    }
+  }
+};
+
+// src/serializer/serializer.ts
+function createMarkdownSerializer(specs = {}, options = {}) {
+  const nodes = { ...defaultNodeSerializers, ...specs.nodes };
+  const marks = { ...defaultMarkSpecs, ...specs.marks };
+  return {
+    serialize(node) {
+      const state = new MarkdownSerializerState({ nodes, marks }, options);
+      if (node.isTextblock) {
+        state.renderInline(node);
+      } else {
+        state.renderContent(node);
+      }
+      return { markdown: state.finish().replace(/\n+$/, ""), warnings: state.warnings };
+    }
+  };
+}
+function serializeMarkdown(node, options = {}) {
+  const { specs, ...serializerOptions } = options;
+  return createMarkdownSerializer(specs, serializerOptions).serialize(node);
+}
+
+// src/Markdown.ts
+function getMarkdown(editor) {
+  const storage = editor.storage["markdown"];
+  const serializer = storage?.serializer ?? createMarkdownSerializer();
+  return serializer.serialize(editor.state.doc);
+}
+var Markdown = Extension.create({
+  name: "markdown",
+  addOptions() {
+    return {
+      paste: true,
+      tightLists: true,
+      specs: null
+    };
+  },
+  addStorage() {
+    return {
+      parser: null,
+      serializer: null
+    };
+  },
+  onCreate() {
+    const schema = this.editor?.state.schema;
+    if (schema !== void 0) this.storage.parser ??= createMarkdownParser(schema);
+    this.storage.serializer ??= createMarkdownSerializer(this.options.specs ?? {}, {
+      tightLists: this.options.tightLists
+    });
+  },
+  addCommands() {
+    const parserFor = (schema) => {
+      this.storage.parser ??= createMarkdownParser(schema);
+      return this.storage.parser;
+    };
+    return {
+      insertMarkdown: (markdown) => ({ state, commands }) => {
+        const doc = parserFor(state.schema).parse(markdown);
+        const first = doc.content.firstChild;
+        const content = doc.content.childCount === 1 && first !== null && first.type.name === "paragraph" ? first.content.toJSON() : doc.content.toJSON();
+        return commands.insertContent(content ?? []);
+      },
+      setMarkdownContent: (markdown, options) => ({ state, commands }) => {
+        const doc = parserFor(state.schema).parse(markdown);
+        return commands.setContent(doc.toJSON(), options);
+      }
+    };
+  },
+  addProseMirrorPlugins() {
+    if (!this.options.paste) return [];
+    return [
+      markdownPastePlugin(() => {
+        const schema = this.editor?.state.schema;
+        if (schema !== void 0) this.storage.parser ??= createMarkdownParser(schema);
+        const parser = this.storage.parser;
+        if (parser === null) throw new Error("Markdown parser is unavailable before editor create");
+        return parser;
+      })
+    ];
+  }
+});
+
+// src/download.ts
+function downloadMarkdown(editor, fileName = "document.md") {
+  const result = getMarkdown(editor);
+  const blob = new Blob([result.markdown], { type: "text/markdown;charset=utf-8" });
+  const url = URL.createObjectURL(blob);
+  const anchor = document.createElement("a");
+  anchor.href = url;
+  anchor.download = fileName;
+  anchor.rel = "noopener";
+  document.body.appendChild(anchor);
+  anchor.click();
+  anchor.remove();
+  URL.revokeObjectURL(url);
+  return result;
+}
+
+export { Markdown, backticksFor, createMarkdownParser, createMarkdownSerializer, Markdown as default, defaultMarkSpecs, defaultNodeSerializers, downloadMarkdown, getMarkdown, looksLikeMarkdown, markdownPastePlugin, markdownPastePluginKey, parseMarkdown, serializeMarkdown };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map