@crewlethq/ui 0.29.0 → 0.31.0

package/dist/chunk-YFW4MTK4.js

@@ -0,0 +1,749 @@
+import { MARKDOWN_CALLOUT_TONES, parseMarkdownSpans, markdownInline, markdownCodeText } from './chunk-SKOYC2CF.js';
+import { Schema, Fragment } from 'prosemirror-model';
+
+function headingTag(level) {
+  return `h${Math.min(6, level + 1)}`;
+}
+function alignOf(value) {
+  return value === "center" || value === "right" ? value : "left";
+}
+function toneOf(value) {
+  return MARKDOWN_CALLOUT_TONES.includes(value) ? value : "note";
+}
+var cell = (tag) => ({
+  content: "(text | image)*",
+  marks: "_",
+  attrs: { align: { default: "left" } },
+  isolating: true,
+  parseDOM: [{ tag, getAttrs: (dom) => ({ align: alignOf(dom.getAttribute("data-align") ?? dom.style.textAlign) }) }],
+  toDOM: (node) => [tag, { "data-align": node.attrs.align }, 0]
+});
+var schema = new Schema({
+  nodes: {
+    doc: { content: "block+" },
+    paragraph: {
+      content: "inline*",
+      group: "block item_first item_rest",
+      parseDOM: [{ tag: "p" }],
+      toDOM: () => ["p", 0]
+    },
+    heading: {
+      attrs: { level: { default: 1 } },
+      // A heading is one line of Markdown, so it holds no line break.
+      content: "(text | image)*",
+      group: "block item_first",
+      defining: true,
+      // THE ELEMENT IS ONE LEVEL DOWN from the Markdown (a `#` is an `h2`), so
+      // the level it was written at travels in `data-level`, and a heading
+      // copied out of an editor reads back at the level it had. Pasted from
+      // anywhere else, an `h2` is a second level heading.
+      parseDOM: [1, 2, 3, 4, 5, 6].map((level) => ({
+        tag: `h${level}`,
+        getAttrs: (dom) => {
+          const written = Number(dom.getAttribute("data-level"));
+          return { level: written >= 1 && written <= 6 ? written : level };
+        }
+      })),
+      toDOM: (node) => [headingTag(node.attrs.level), { "data-level": String(node.attrs.level) }, 0]
+    },
+    code_block: {
+      attrs: { lang: { default: "" }, fence: { default: "```" } },
+      content: "text*",
+      marks: "",
+      group: "block",
+      code: true,
+      defining: true,
+      parseDOM: [
+        {
+          tag: "pre",
+          preserveWhitespace: "full",
+          getAttrs: (dom) => ({
+            lang: (dom.getAttribute("data-lang") ?? languageOfClass(dom.querySelector("code")?.className ?? "")).trim()
+          })
+        }
+      ],
+      toDOM: (node) => [
+        "pre",
+        { class: "md-code", ...node.attrs.lang ? { "data-lang": node.attrs.lang } : {} },
+        ["code", 0]
+      ]
+    },
+    blockquote: {
+      content: "block+",
+      group: "block item_first item_rest",
+      defining: true,
+      parseDOM: [{ tag: "blockquote" }],
+      toDOM: () => ["blockquote", 0]
+    },
+    callout: {
+      attrs: { tone: { default: "note" } },
+      content: "block+",
+      group: "block item_first item_rest",
+      defining: true,
+      parseDOM: [
+        {
+          tag: "div[data-callout]",
+          contentElement: "[data-callout-body]",
+          getAttrs: (dom) => ({ tone: toneOf(dom.getAttribute("data-callout")) })
+        }
+      ],
+      toDOM: (node) => [
+        "div",
+        { "data-callout": node.attrs.tone, role: "note" },
+        ["div", { "data-callout-body": "" }, 0]
+      ]
+    },
+    horizontal_rule: {
+      group: "block item_first item_rest",
+      parseDOM: [{ tag: "hr" }],
+      toDOM: () => ["hr"]
+    },
+    bullet_list: {
+      attrs: { marker: { default: "-" }, loose: { default: false } },
+      content: "list_item+",
+      group: "block item_first item_rest",
+      parseDOM: [{ tag: "ul" }],
+      toDOM: () => ["ul", 0]
+    },
+    ordered_list: {
+      attrs: { start: { default: 1 }, marker: { default: "." }, loose: { default: false } },
+      content: "list_item+",
+      group: "block item_first item_rest",
+      parseDOM: [
+        {
+          tag: "ol",
+          getAttrs: (dom) => ({ start: dom.hasAttribute("start") ? Number(dom.getAttribute("start")) || 1 : 1 })
+        }
+      ],
+      toDOM: (node) => ["ol", node.attrs.start === 1 ? {} : { start: node.attrs.start }, 0]
+    },
+    list_item: {
+      // null is a plain item; true and false are a task item, ticked or not.
+      attrs: { checked: { default: null } },
+      // WHAT AN ITEM CAN HOLD AND STILL BE WRITTEN BACK: the grammar reads an
+      // item's later blocks from indented lines, and an indented fence or
+      // heading is a paragraph to it. A heading is kept on the marker line;
+      // a code block is never inside an item.
+      content: "item_first item_rest*",
+      defining: true,
+      parseDOM: [
+        {
+          tag: "li",
+          getAttrs: (dom) => {
+            const box = dom.querySelector(':scope > input[type="checkbox"], :scope > p > input[type="checkbox"]');
+            return { checked: box ? box.checked || box.hasAttribute("checked") : null };
+          }
+        }
+      ],
+      toDOM: (node) => node.attrs.checked === null ? ["li", 0] : [
+        "li",
+        ["input", { type: "checkbox", disabled: "", ...node.attrs.checked ? { checked: "" } : {} }],
+        ["div", { class: "md-task-body" }, 0]
+      ]
+    },
+    table: {
+      // A column's alignment is on each of its cells, which is where the
+      // reader's renderer draws it; the header row's is what is written.
+      content: "table_row+",
+      group: "block item_first item_rest",
+      isolating: true,
+      parseDOM: [{ tag: "table" }],
+      toDOM: () => ["div", { class: "md-table" }, ["table", ["tbody", 0]]]
+    },
+    table_row: {
+      content: "(table_header | table_cell)+",
+      parseDOM: [{ tag: "tr" }],
+      toDOM: () => ["tr", 0]
+    },
+    table_header: cell("th"),
+    table_cell: cell("td"),
+    text: { group: "inline" },
+    image: {
+      inline: true,
+      group: "inline",
+      attrs: { src: { default: "" }, alt: { default: "" }, title: { default: null } },
+      draggable: true,
+      parseDOM: [
+        {
+          // A pasted picture arrives with its address in `data-src`, never
+          // `src`: the paste tree is built by hand and must load nothing.
+          tag: "img",
+          getAttrs: (dom) => ({
+            src: dom.getAttribute("data-src") ?? "",
+            alt: dom.getAttribute("alt") ?? "",
+            title: dom.getAttribute("title")
+          })
+        }
+      ],
+      toDOM: (node) => ["img", { alt: node.attrs.alt, "data-src": node.attrs.src }]
+    },
+    hard_break: {
+      inline: true,
+      group: "inline",
+      selectable: false,
+      attrs: { style: { default: "backslash" } },
+      parseDOM: [{ tag: "br" }],
+      toDOM: () => ["br"]
+    }
+  },
+  marks: {
+    // ORDER IS NESTING: a link outside the emphasis inside it, and a code
+    // span innermost, because its content is raw text.
+    link: {
+      attrs: { href: {}, title: { default: null }, auto: { default: false } },
+      inclusive: false,
+      parseDOM: [
+        {
+          tag: "a[href]",
+          getAttrs: (dom) => ({ href: dom.getAttribute("href") ?? "", title: dom.getAttribute("title") })
+        }
+      ],
+      toDOM: (mark) => ["a", { href: mark.attrs.href, rel: "noopener noreferrer" }, 0]
+    },
+    strong: {
+      attrs: { marker: { default: "**" } },
+      parseDOM: [
+        { tag: "strong" },
+        // Google Docs wraps a whole paste in a `b` that is not bold.
+        { tag: "b", getAttrs: (dom) => dom.style.fontWeight === "normal" ? false : null }
+      ],
+      toDOM: () => ["strong", 0]
+    },
+    em: {
+      attrs: { marker: { default: "*" } },
+      parseDOM: [{ tag: "em" }, { tag: "i" }],
+      toDOM: () => ["em", 0]
+    },
+    strike: {
+      parseDOM: [{ tag: "del" }, { tag: "s" }, { tag: "strike" }],
+      toDOM: () => ["del", 0]
+    },
+    code: {
+      parseDOM: [{ tag: "code" }],
+      toDOM: () => ["code", 0]
+    }
+  }
+});
+function languageOfClass(className) {
+  return /(?:^|\s)(?:language|lang)-([A-Za-z0-9_+-]+)/.exec(className)?.[1] ?? "";
+}
+function readMarkdown(markdown) {
+  const original = markdown ?? "";
+  const { lines, spans } = parseMarkdownSpans(original);
+  const blocks2 = [];
+  const byNode = /* @__PURE__ */ new WeakMap();
+  spans.forEach((span, index) => {
+    const node = blockNode(span.block);
+    const prevEnd = index === 0 ? 0 : spans[index - 1]?.end ?? 0;
+    const sep = index === 0 ? "" : "\n" + lines.slice(prevEnd, span.start).map((l) => `${l}
+`).join("");
+    const block2 = { index, node, text: lines.slice(span.start, span.end).join("\n"), sep };
+    blocks2.push(block2);
+    byNode.set(node, block2);
+  });
+  const first = spans[0];
+  const last = spans[spans.length - 1];
+  const lead = first ? lines.slice(0, first.start).map((l) => `${l}
+`).join("") : "";
+  const trail = last && last.end < lines.length ? "\n" + lines.slice(last.end).join("\n") : "";
+  const nodes = blocks2.map((b) => b.node);
+  const doc = schema.node("doc", null, nodes.length > 0 ? nodes : [schema.node("paragraph")]);
+  const crlf = /\r\n/.test(original) && !/(^|[^\r])\n/.test(original);
+  return { doc, source: { original, doc, lead, trail, blocks: blocks2, byNode, crlf } };
+}
+function blockNode(block2) {
+  switch (block2.kind) {
+    case "heading":
+      return schema.node("heading", { level: block2.level }, inline(block2.text, [], { breaks: false }));
+    case "paragraph":
+      return schema.node("paragraph", null, inline(block2.text, [], { breaks: true }));
+    case "code":
+      return schema.node(
+        "code_block",
+        { lang: block2.lang, fence: block2.fence },
+        block2.text ? schema.text(block2.text) : void 0
+      );
+    case "quote":
+      return schema.node("blockquote", null, blockNodes(block2.blocks));
+    case "callout":
+      return schema.node("callout", { tone: block2.tone }, blockNodes(block2.blocks));
+    case "rule":
+      return schema.node("horizontal_rule");
+    case "list":
+      return schema.node(
+        block2.ordered ? "ordered_list" : "bullet_list",
+        block2.ordered ? { start: block2.start, marker: block2.marker, loose: block2.loose } : { marker: block2.marker, loose: block2.loose },
+        block2.items.map((item) => schema.node("list_item", { checked: item.checked }, itemNodes(item.blocks)))
+      );
+    case "table":
+      return schema.node("table", null, [
+        row("table_header", block2.head, block2.align),
+        ...block2.rows.map((cells) => row("table_cell", cells, block2.align))
+      ]);
+  }
+}
+function blockNodes(blocks2) {
+  const nodes = blocks2.map(blockNode);
+  return nodes.length > 0 ? nodes : [schema.node("paragraph")];
+}
+function itemNodes(blocks2) {
+  const nodes = blockNodes(blocks2);
+  const item = schema.nodes.list_item;
+  const fitted = [];
+  for (const node of nodes) {
+    if (item.contentMatch.matchFragment(Fragment.from([...fitted, node]))) {
+      fitted.push(node);
+    } else {
+      fitted.push(schema.node("paragraph", null, node.textContent ? schema.text(node.textContent) : void 0));
+    }
+  }
+  return fitted;
+}
+function row(type, cells, align) {
+  const nodes = cells.map(
+    (cell2, i) => schema.node(type, { align: align[i] ?? "left" }, inline(cell2, [], { breaks: false }))
+  );
+  return schema.node("table_row", null, nodes.length > 0 ? nodes : [schema.node(type)]);
+}
+function inline(text, marks, options) {
+  const out = [];
+  walkInline(text, marks, options, out);
+  return collapse(out);
+}
+function walkInline(text, marks, options, out) {
+  let at = 0;
+  for (const { index, end, groups: g } of markdownInline(text)) {
+    if (index > at) plain(text.slice(at, index), marks, options, out);
+    at = end;
+    if (g.esc !== void 0) {
+      out.push(schema.text(g.esc, marks));
+    } else if (g.tick !== void 0) {
+      const code = markdownCodeText(g.code ?? "");
+      if (code) out.push(schema.text(code, schema.marks.code.create().addToSet(marks)));
+    } else if (g.src !== void 0) {
+      out.push(schema.node("image", { src: g.src, alt: g.alt ?? "", title: g.srcTitle ?? null }, void 0, marks));
+    } else if (g.href !== void 0) {
+      const link = schema.marks.link.create({ href: g.href, title: g.hrefTitle ?? null });
+      walkInline(g.label ?? "", link.addToSet(marks), options, out);
+    } else if (g.auto !== void 0) {
+      out.push(schema.text(g.auto, schema.marks.link.create({ href: g.auto, auto: true }).addToSet(marks)));
+    } else if (g.strong !== void 0 || g.strongUnder !== void 0) {
+      const mark = schema.marks.strong.create({ marker: g.strong !== void 0 ? "**" : "__" });
+      walkInline(g.strong ?? g.strongUnder ?? "", mark.addToSet(marks), options, out);
+    } else if (g.em !== void 0 || g.emUnder !== void 0) {
+      const mark = schema.marks.em.create({ marker: g.em !== void 0 ? "*" : "_" });
+      walkInline(g.em ?? g.emUnder ?? "", mark.addToSet(marks), options, out);
+    } else if (g.del !== void 0) {
+      walkInline(g.del, schema.marks.strike.create().addToSet(marks), options, out);
+    }
+  }
+  if (at < text.length) plain(text.slice(at), marks, options, out);
+}
+var BREAK = /( {2,}|\\)\n/;
+function plain(text, marks, options, out) {
+  const parts = options.breaks ? text.split(BREAK) : [text];
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i] ?? "";
+    if (i % 2 === 1) {
+      out.push(schema.node("hard_break", { style: part === "\\" ? "backslash" : "spaces" }, void 0, marks));
+      continue;
+    }
+    const spaced = part.replace(/[ \t\n]+/g, " ");
+    if (spaced) out.push(schema.text(spaced, marks));
+  }
+}
+function collapse(nodes) {
+  const out = [];
+  let lineStart = true;
+  let lastSpace = false;
+  for (const node of nodes) {
+    if (!node.isText) {
+      if (node.type.name === "hard_break") trimEnd(out);
+      out.push(node);
+      lineStart = node.type.name === "hard_break";
+      lastSpace = false;
+      continue;
+    }
+    let text = node.text ?? "";
+    if (lineStart || lastSpace) text = text.replace(/^ /, "");
+    if (!text) continue;
+    out.push(schema.text(text, node.marks));
+    lineStart = false;
+    lastSpace = text.endsWith(" ");
+  }
+  trimEnd(out);
+  return Fragment.from(out).content.slice();
+}
+function trimEnd(out) {
+  const last = out[out.length - 1];
+  if (!last?.isText) return;
+  const text = (last.text ?? "").replace(/ $/, "");
+  if (text) out[out.length - 1] = schema.text(text, last.marks);
+  else out.pop();
+}
+function writeMarkdown(doc, source) {
+  if (source && matchesAll(doc, source)) return source.original;
+  const used = /* @__PURE__ */ new Set();
+  let out = "";
+  let emitted = false;
+  let prev = null;
+  let prevNode = null;
+  for (let i = 0; i < doc.childCount; i++) {
+    const node = doc.child(i);
+    const known = source ? recall(node, source, used) : null;
+    const text = known ? known.text : writeBlock(node);
+    if (!known && text === "") continue;
+    if (!emitted) {
+      out = (known && known.index === 0 && source ? source.lead : "") + text;
+    } else {
+      const adjacent = known && prev && known.index === prev.index + 1;
+      out += (adjacent ? known.sep : separator(prevNode, node)) + text;
+    }
+    emitted = true;
+    prev = known;
+    prevNode = node;
+  }
+  if (source) {
+    const lastBlock = source.blocks[source.blocks.length - 1];
+    const endsAsRead = prev !== null && lastBlock !== void 0 && prev.index === lastBlock.index;
+    out += endsAsRead ? source.trail : emitted && source.original.endsWith("\n") ? "\n" : "";
+    if (source.crlf) out = out.replace(/\r?\n/g, "\r\n");
+  }
+  return out;
+}
+function matchesAll(doc, source) {
+  if (source.blocks.length === 0) return doc.childCount === 1 && doc.firstChild.childCount === 0;
+  if (doc.childCount !== source.blocks.length) return false;
+  let same = true;
+  doc.forEach((node, _offset, i) => {
+    if (source.blocks[i]?.node !== node) same = false;
+  });
+  return same;
+}
+function recall(node, source, used) {
+  const byIdentity = source.byNode.get(node);
+  if (byIdentity && !used.has(byIdentity.index)) {
+    used.add(byIdentity.index);
+    return byIdentity;
+  }
+  for (const block2 of source.blocks) {
+    if (!used.has(block2.index) && block2.node.eq(node)) {
+      used.add(block2.index);
+      return block2;
+    }
+  }
+  return null;
+}
+function separator(prev, next) {
+  if (prev && isList(prev) && isList(next) && (prev.type === next.type || bothBullet(prev, next))) return "\n\n\n";
+  return "\n\n";
+}
+function isList(node) {
+  return node.type.name === "bullet_list" || node.type.name === "ordered_list";
+}
+function bothBullet(a, b) {
+  return a.type.name === "bullet_list" && b.type.name === "bullet_list";
+}
+var RULE = "-".repeat(3);
+var SPELLINGS = [
+  { markers: "keep", escape: "light" },
+  { markers: "star", escape: "light" },
+  { markers: "star", escape: "all" }
+];
+function writeBlock(node) {
+  if (node.type.name === "paragraph" && node.childCount === 0) return "";
+  const want = signature(node);
+  let text = "";
+  for (const spelling of SPELLINGS) {
+    text = block(node, spelling);
+    const back = readMarkdown(text).doc;
+    if (back.childCount === 1 && signature(back.firstChild) === want) return text;
+  }
+  return text;
+}
+function block(node, s) {
+  switch (node.type.name) {
+    case "paragraph":
+      return lineStarts(inlineText(node, s, false).replace(/^[ \t]+|[ \t]+$/g, ""));
+    case "heading": {
+      const text = inlineText(node, s, false).trim();
+      return `${"#".repeat(node.attrs.level)} ${text.replace(/(\s)(#+)$/, "$1\\$2")}`;
+    }
+    case "code_block":
+      return codeBlock(node);
+    case "blockquote":
+      return quoted(blocks(node, s));
+    case "callout":
+      return quoted(`[!${node.attrs.tone.toUpperCase()}]
+${blocks(node, s)}`);
+    case "horizontal_rule":
+      return RULE;
+    case "bullet_list":
+    case "ordered_list":
+      return list(node, s);
+    case "table":
+      return table(node, s);
+    default:
+      return node.textContent;
+  }
+}
+function blocks(parent, s) {
+  const parts = [];
+  let prev = null;
+  parent.forEach((child) => {
+    const text = block(child, s);
+    if (parts.length > 0) parts.push(separator(prev, child));
+    parts.push(text);
+    prev = child;
+  });
+  return parts.join("");
+}
+function quoted(text) {
+  return text.split("\n").map((line) => line === "" ? ">" : `> ${line}`).join("\n");
+}
+function codeBlock(node) {
+  const text = node.textContent;
+  const lang = node.attrs.lang;
+  const closes = (fence2) => text.split("\n").some((line) => CLOSER[fence2].test(line));
+  const wanted = node.attrs.fence;
+  const other = wanted === "```" ? "~~~" : "```";
+  const fence = closes(wanted) && !closes(other) ? other : wanted;
+  return `${fence}${lang}
+${text}${text ? "\n" : ""}${fence}`;
+}
+var CLOSER = { "```": /^`{3,}[ \t]*$/, "~~~": /^~{3,}[ \t]*$/ };
+function list(node, s) {
+  const ordered = node.type.name === "ordered_list";
+  const loose = node.attrs.loose;
+  const items = [];
+  node.forEach((item, _offset, i) => {
+    const marker = ordered ? `${node.attrs.start + i}${node.attrs.marker} ` : `${node.attrs.marker} `;
+    const checked = item.attrs.checked;
+    const box = checked === null ? "" : checked ? "[x] " : "[ ] ";
+    const indent = " ".repeat(marker.length);
+    const parts = [];
+    item.forEach((child) => {
+      if (parts.length > 0) parts.push(isList(child) ? "\n" : "\n\n");
+      parts.push(block(child, s));
+    });
+    const body = parts.join("");
+    const lines = body.split("\n");
+    items.push(
+      marker + box + lines.map((line, j) => j === 0 ? line : line === "" ? "" : indent + line).join("\n")
+    );
+  });
+  return items.join(loose ? "\n\n" : "\n");
+}
+function table(node, s) {
+  const rows = [];
+  const align = [];
+  node.forEach((r, _o, ri) => {
+    const cells = [];
+    r.forEach((cell2, _co, ci) => {
+      cells.push(inlineText(cell2, s, true));
+      if (ri === 0) align[ci] = cell2.attrs.align;
+    });
+    rows.push(cells);
+  });
+  const line = (cells) => `| ${cells.join(" | ")} |`;
+  const rule = align.map((a) => a === "center" ? `:${RULE}:` : a === "right" ? `${RULE}:` : RULE);
+  return [line(rows[0] ?? [""]), `| ${rule.join(" | ")} |`, ...rows.slice(1).map(line)].join("\n");
+}
+function lineStarts(text) {
+  return text.split("\n").map(
+    (line) => line.replace(/^(#{1,6})(?=\s|$)/, "\\$1").replace(/^>/, "\\>").replace(/^([-+])(?=\s)/, "\\$1").replace(/^(\d{1,9})([.)])(?=\s)/, "$1\\$2").replace(/^(-{3,}|_{3,})\s*$/, "\\$1").replace(/^\|/, "\\|")
+  ).join("\n");
+}
+function inlineText(parent, s, cell2) {
+  const children = [];
+  parent.forEach((child) => children.push(child));
+  return marked(expel(children), s, cell2);
+}
+function linkOf(node) {
+  return node.marks.find((m) => m.type.name === "link") ?? null;
+}
+var EMPHASIS = /* @__PURE__ */ new Set(["strong", "em", "strike"]);
+function expel(nodes) {
+  const out = [];
+  nodes.forEach((node, i) => {
+    const emphasis = node.marks.filter((m2) => EMPHASIS.has(m2.type.name));
+    if (!node.isText || emphasis.length === 0 || node.marks.some((m2) => m2.type.name === "code")) {
+      out.push(node);
+      return;
+    }
+    const prev = nodes[i - 1];
+    const next = nodes[i + 1];
+    const opening = emphasis.filter((m2) => !prev || !m2.isInSet(prev.marks));
+    const closing2 = emphasis.filter((m2) => !next || !m2.isInSet(next.marks));
+    const text = node.text ?? "";
+    const m = /^(\s*)([\s\S]*?)(\s*)$/.exec(text);
+    const without = (gone) => node.marks.filter((mk) => !gone.includes(mk));
+    if (m[1]) out.push(schema.text(m[1], without(opening)));
+    if (m[2]) out.push(schema.text(m[2], node.marks));
+    if (m[3]) out.push(schema.text(m[3], without(closing2)));
+  });
+  return out;
+}
+function spanMarks(node) {
+  return node.marks.filter((m) => m.type.name !== "code");
+}
+var isLink = (mark) => mark.type.name === "link" ? 1 : 0;
+function reach(nodes, i, mark) {
+  let n = 0;
+  while (i + n < nodes.length && mark.isInSet(nodes[i + n].marks)) n++;
+  return n;
+}
+function marked(nodes, s, cell2) {
+  let out = "";
+  const open = [];
+  const close = (to) => {
+    while (open.length > to) {
+      const top = open.pop();
+      out += closing(top.mark, top.auto, s);
+    }
+  };
+  nodes.forEach((node, i) => {
+    const want = spanMarks(node);
+    let keep = 0;
+    while (keep < open.length && open[keep].mark.isInSet(want)) keep++;
+    close(keep);
+    const opening = want.filter((m) => !open.some((o) => o.mark.eq(m))).sort((a, b) => reach(nodes, i, b) - reach(nodes, i, a) || isLink(a) - isLink(b));
+    for (const mark of opening) {
+      const auto = autolink(mark, nodes, i, open.length);
+      out += auto ? "<" : opener(mark, s);
+      open.push({ mark, auto });
+    }
+    const inAuto = open.some((o) => o.auto);
+    const inLink = open.some((o) => o.mark.type.name === "link");
+    out += inAuto ? node.text ?? "" : content(node, s, cell2, nodes[i + 1], inLink);
+  });
+  close(0);
+  return out;
+}
+function autolink(mark, nodes, i, depth) {
+  if (mark.type.name !== "link" || !mark.attrs.auto) return false;
+  const node = nodes[i];
+  const href = mark.attrs.href;
+  return reach(nodes, i, mark) === 1 && node.isText && node.text === href && spanMarks(node).length === depth + 1 && !node.marks.some((m) => m.type.name === "code") && /^(https?:|mailto:)[^>\s]+$/i.test(href);
+}
+function opener(mark, s) {
+  return mark.type.name === "link" ? "[" : delimiter(mark, s);
+}
+function closing(mark, auto, s) {
+  if (auto) return ">";
+  if (mark.type.name !== "link") return delimiter(mark, s);
+  const title = mark.attrs.title;
+  return `](${destination(mark.attrs.href)}${title ? ` "${title.replace(/"/g, "'")}"` : ""})`;
+}
+function delimiter(mark, s) {
+  switch (mark.type.name) {
+    case "strong":
+      return s.markers === "keep" ? mark.attrs.marker : "**";
+    case "em":
+      return s.markers === "keep" ? mark.attrs.marker : "*";
+    default:
+      return "~~";
+  }
+}
+function content(node, s, cell2, next, inLink) {
+  if (node.type.name === "hard_break") return node.attrs.style === "spaces" ? "  \n" : "\\\n";
+  if (node.type.name === "image") {
+    const alt = node.attrs.alt.replace(/(^|[^\\])([[\]])/g, "$1\\$2");
+    const title = node.attrs.title;
+    return `![${alt}](${destination(node.attrs.src)}${title ? ` "${title.replace(/"/g, "'")}"` : ""})`;
+  }
+  const text = node.text ?? "";
+  if (node.marks.some((m) => m.type.name === "code")) return codeSpan(text, cell2);
+  const escaped = escapeText(text, s.escape, cell2, next);
+  return inLink ? escaped.replace(/(^|[^\\])\]/g, "$1\\]") : escaped;
+}
+function codeSpan(text, cell2) {
+  const longest = Math.max(0, ...(text.match(/`+/g) ?? []).map((run) => run.length));
+  const fence = "`".repeat(longest + 1);
+  const pad = (side) => side === " " || side === "`" ? " " : "";
+  const body = cell2 ? text.replace(/\|/g, "\\|") : text;
+  return `${fence}${pad(body[0] ?? "")}${body}${pad(body[body.length - 1] ?? "")}${fence}`;
+}
+var ASCII_PUNCTUATION = /[!-/:-@[-`{-~]/;
+function escapeText(text, mode, cell2, next) {
+  if (mode === "all") {
+    return text.replace(/[!-/:-@[-`{-~]/g, (c) => c === "\\" || /[\\`*_[\]<>~|!#]/.test(c) ? `\\${c}` : c);
+  }
+  const nextChar = (next?.isText ? (next.text ?? "")[0] : next ? "!" : "") ?? "";
+  let out = "";
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    const before = text[i - 1] ?? "";
+    const after = text[i + 1] ?? nextChar;
+    if (c === "\\") {
+      out += after === "" || ASCII_PUNCTUATION.test(after) ? "\\\\" : "\\";
+    } else if (c === "`" || c === "*") {
+      out += `\\${c}`;
+    } else if (c === "_") {
+      const word = /[\p{L}\p{N}]/u;
+      out += word.test(before) && word.test(after) ? "_" : "\\_";
+    } else if (c === "~") {
+      out += after === "~" || before === "~" ? "\\~" : "~";
+    } else if (c === "[") {
+      out += text.indexOf("](", i) >= 0 ? "\\[" : "[";
+    } else if (c === "<") {
+      out += /^<(https?:|mailto:)/i.test(text.slice(i)) ? "\\<" : "<";
+    } else if (c === "|" && cell2) {
+      out += "\\|";
+    } else {
+      out += c;
+    }
+  }
+  return out;
+}
+function destination(href) {
+  let depth = 0;
+  let balanced = true;
+  for (const c of href) {
+    if (c === "(") depth++;
+    if (c === ")") depth--;
+    if (depth < 0 || depth > 1) balanced = false;
+  }
+  const spaced = href.replace(/\s/g, (c) => encodeURIComponent(c));
+  return balanced && depth === 0 ? spaced : spaced.replace(/\(/g, "%28").replace(/\)/g, "%29");
+}
+function signature(node) {
+  if (node.isText) {
+    const marks = node.marks.filter((m) => m.type.name !== "link").map((m) => m.type.name).join("+");
+    const link = linkOf(node);
+    const tag = `${marks}${link ? `@${link.attrs.href}` : ""}`;
+    return [...node.text ?? ""].map((c) => c === " " ? " " : `${c}${tag ? `{${tag}}` : ""}`).join("");
+  }
+  const attrs = visibleAttrs(node);
+  let inner = "";
+  node.forEach((child) => {
+    inner += signature(child);
+  });
+  if (node.isTextblock && !node.type.spec.code) {
+    inner = inner.replace(/ +/g, " ").replace(/ ?(<hard_break[^>]*><\/>) ?/g, "$1").trim();
+  }
+  return `<${node.type.name}${attrs}>${inner}</>`;
+}
+function visibleAttrs(node) {
+  switch (node.type.name) {
+    case "heading":
+      return ` ${node.attrs.level}`;
+    case "code_block":
+      return ` ${node.attrs.lang}`;
+    case "callout":
+      return ` ${node.attrs.tone}`;
+    case "ordered_list":
+      return ` ${node.attrs.start}`;
+    case "list_item":
+      return ` ${String(node.attrs.checked)}`;
+    case "table_header":
+    case "table_cell":
+      return ` ${node.attrs.align}`;
+    case "image":
+      return ` ${node.attrs.src} ${node.attrs.alt}`;
+    default:
+      return "";
+  }
+}
+
+export { readMarkdown, schema, writeMarkdown };