quoin-editor 0.4.2 → 1.0.0

package/dist/chunk-ND5XJVK2.cjs

@@ -0,0 +1,3335 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;// src/engine/model/attrs.ts
+function sameAttrs(a, b) {
+  const left = _nullishCoalesce(a, () => ( {}));
+  const right = _nullishCoalesce(b, () => ( {}));
+  const keys = Object.keys(left);
+  return keys.length === Object.keys(right).length && keys.every((k) => left[k] === right[k]);
+}
+
+// src/engine/model/compare.ts
+var DIGITS = /^\d+$/;
+function compareCodeUnits(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function compareDigitRuns(a, b) {
+  const x = a.replace(/^0+/, "");
+  const y = b.replace(/^0+/, "");
+  if (x.length !== y.length) return x.length < y.length ? -1 : 1;
+  return compareCodeUnits(x, y) || compareCodeUnits(a, b);
+}
+function compareSegments(a, b) {
+  const aNumber = DIGITS.test(a);
+  const bNumber = DIGITS.test(b);
+  if (aNumber && bNumber) return compareDigitRuns(a, b);
+  if (aNumber !== bNumber) return aNumber ? -1 : 1;
+  return compareCodeUnits(a, b);
+}
+function compareRegionNames(a, b) {
+  const left = a.split(":");
+  const right = b.split(":");
+  const shared = Math.min(left.length, right.length);
+  for (let i = 0; i < shared; i++) {
+    const order = compareSegments(left[i], right[i]);
+    if (order !== 0) return order;
+  }
+  return left.length < right.length ? -1 : left.length > right.length ? 1 : 0;
+}
+
+// src/engine/model/same-items.ts
+var sameItems = (a, b, same = (x, y) => x === y) => a.length === b.length && a.every((item, i) => same(item, b[i]));
+
+// src/engine/model/marks.ts
+var RANK = {
+  link: 0,
+  comment: 1,
+  bold: 2,
+  italic: 3,
+  underline: 4,
+  strike: 5,
+  sub: 6,
+  sup: 7,
+  highlight: 8,
+  color: 9,
+  background: 10,
+  code: 11
+};
+var CUSTOM_RANK = 7.5;
+var STACKABLE = /* @__PURE__ */ new Set(["comment"]);
+function isCoreMark(type) {
+  return Object.hasOwn(RANK, type);
+}
+function markRank(type) {
+  return isCoreMark(type) ? RANK[type] : CUSTOM_RANK;
+}
+function markKey(mark) {
+  return STACKABLE.has(mark.type) ? `${mark.type}:${_nullishCoalesce(_optionalChain([mark, 'access', _3 => _3.attrs, 'optionalAccess', _4 => _4.id]), () => ( ""))}` : mark.type;
+}
+function sameMark(a, b) {
+  return a.type === b.type && sameAttrs(a.attrs, b.attrs);
+}
+function compareMarks(a, b) {
+  return markRank(a.type) - markRank(b.type) || compareCodeUnits(markKey(a), markKey(b));
+}
+function sortMarks(marks) {
+  return [...marks].sort(compareMarks);
+}
+function sameMarkSet(a, b) {
+  return sameItems(a, b, sameMark);
+}
+function addMark(set, mark) {
+  const key = markKey(mark);
+  return sortMarks([...set.filter((m) => markKey(m) !== key), mark]);
+}
+function removeMark(set, mark) {
+  if (typeof mark === "string") return sortMarks(set.filter((m) => m.type !== mark));
+  const key = markKey(mark);
+  return sortMarks(set.filter((m) => markKey(m) !== key));
+}
+function hasMark(set, mark) {
+  return typeof mark === "string" ? set.some((m) => m.type === mark) : set.some((m) => sameMark(m, mark));
+}
+
+// src/engine/model/inline.ts
+var OBJECT_REPLACEMENT = "\uFFFC";
+function text(value, marks = []) {
+  return { kind: "text", text: value, marks: sortMarks(marks) };
+}
+function atom(type, attrs, marks = []) {
+  return { kind: "atom", type, attrs, marks: sortMarks(marks) };
+}
+function nodeLength(node) {
+  return node.kind === "text" ? node.text.length : 1;
+}
+function withMarks(node, marks) {
+  return node.kind === "text" ? text(node.text, marks) : atom(node.type, node.attrs, marks);
+}
+function splitCodeBreaks(node) {
+  if (node.kind === "atom" || !node.text.includes("\n") || !hasMark(node.marks, "code")) return [node];
+  const withoutCode = removeMark(node.marks, "code");
+  return node.text.split(/(\n)/).map((part) => text(part, part === "\n" ? withoutCode : node.marks));
+}
+function normalizeInline(nodes) {
+  const result = [];
+  for (const node of nodes.flatMap(splitCodeBreaks)) {
+    if (node.kind === "text" && node.text === "") continue;
+    const sorted = withMarks(node, node.marks);
+    const last = result[result.length - 1];
+    if (_optionalChain([last, 'optionalAccess', _5 => _5.kind]) === "text" && sorted.kind === "text" && sameMarkSet(last.marks, sorted.marks)) {
+      result[result.length - 1] = text(last.text + sorted.text, last.marks);
+    } else {
+      result.push(sorted);
+    }
+  }
+  return result;
+}
+function inlineLength(inline) {
+  return inline.reduce((sum, node) => sum + nodeLength(node), 0);
+}
+function inlineText(inline, atomText = () => OBJECT_REPLACEMENT) {
+  return inline.map((node) => node.kind === "text" ? node.text : atomText(node)).join("");
+}
+function sliceInline(inline, from, to) {
+  const result = [];
+  let start = 0;
+  for (const node of inline) {
+    const end = start + nodeLength(node);
+    if (end > from && start < to) {
+      const cutFrom = Math.max(0, from - start);
+      result.push(node.kind === "atom" ? node : text(node.text.slice(cutFrom, to - start), node.marks));
+    }
+    start = end;
+  }
+  return normalizeInline(result);
+}
+function assertRange(inline, from, to) {
+  const length = inlineLength(inline);
+  if (from < 0 || from > to || to > length) {
+    throw new RangeError(`range ${from} to ${to} is outside 0 to ${length}`);
+  }
+  return length;
+}
+function replaceInline(inline, from, to, slice) {
+  const length = assertRange(inline, from, to);
+  return normalizeInline([...sliceInline(inline, 0, from), ...slice, ...sliceInline(inline, to, length)]);
+}
+function mapMarksInRange(inline, from, to, update) {
+  assertRange(inline, from, to);
+  const result = [];
+  let start = 0;
+  for (const node of inline) {
+    const end = start + nodeLength(node);
+    if (end <= from || start >= to) {
+      result.push(node);
+    } else if (node.kind === "atom") {
+      result.push(withMarks(node, update(node.marks)));
+    } else {
+      const cutFrom = Math.max(from, start) - start;
+      const cutTo = Math.min(to, end) - start;
+      result.push(
+        text(node.text.slice(0, cutFrom), node.marks),
+        text(node.text.slice(cutFrom, cutTo), update(node.marks)),
+        text(node.text.slice(cutTo), node.marks)
+      );
+    }
+    start = end;
+  }
+  return normalizeInline(result);
+}
+function addMarkRange(inline, from, to, mark) {
+  return mapMarksInRange(inline, from, to, (marks) => addMark(marks, mark));
+}
+function removeMarkRange(inline, from, to, mark) {
+  return mapMarksInRange(inline, from, to, (marks) => removeMark(marks, mark));
+}
+function nodeAt(inline, offset) {
+  let start = 0;
+  for (const node of inline) {
+    const end = start + nodeLength(node);
+    if (offset >= start && offset < end) return node;
+    start = end;
+  }
+  return void 0;
+}
+function isInclusiveMark(mark) {
+  return mark.type !== "link" && mark.type !== "comment";
+}
+function marksAt(inline, offset, isInclusive = isInclusiveMark) {
+  const before = _nullishCoalesce(_optionalChain([nodeAt, 'call', _6 => _6(inline, Math.max(0, offset - 1)), 'optionalAccess', _7 => _7.marks]), () => ( []));
+  const after = _nullishCoalesce(_optionalChain([nodeAt, 'call', _8 => _8(inline, offset), 'optionalAccess', _9 => _9.marks]), () => ( []));
+  return before.filter((mark) => isInclusive(mark) || hasMark(after, mark));
+}
+function equalNode(a, b) {
+  if (!sameMarkSet(a.marks, b.marks)) return false;
+  if (a.kind === "text") return b.kind === "text" && a.text === b.text;
+  return b.kind === "atom" && a.type === b.type && sameAttrs(a.attrs, b.attrs);
+}
+function equalInline(a, b) {
+  return sameItems(a, b, equalNode);
+}
+
+// src/engine/markdown/palette.ts
+var PALETTE = [
+  "default",
+  "gray",
+  "brown",
+  "orange",
+  "yellow",
+  "green",
+  "blue",
+  "purple",
+  "pink",
+  "red"
+];
+function isPaletteColor(name) {
+  return PALETTE.includes(name);
+}
+
+// src/engine/model/is-record.ts
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+
+// src/engine/blocks/data-fields.ts
+var ALIGNMENTS = ["left", "center", "right", "justify"];
+function str(value) {
+  return typeof value === "string" ? value : "";
+}
+function optionalString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function optionalNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function paletteOrUndefined(value) {
+  return typeof value === "string" && isPaletteColor(value) ? value : void 0;
+}
+function alignOrUndefined(value) {
+  return typeof value === "string" && ALIGNMENTS.includes(value) ? value : void 0;
+}
+function extraFields(data, known) {
+  const entries = Object.entries(data).filter(([key]) => !known.includes(key));
+  return entries.length ? Object.fromEntries(entries) : void 0;
+}
+function withDefined(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== void 0));
+}
+function withExtra(fields, attrs) {
+  const { extra } = attrs;
+  return { ...withDefined(fields), ...isRecord(extra) ? extra : void 0 };
+}
+function regionOf(block, name) {
+  return _nullishCoalesce(block.regions[name], () => ( []));
+}
+
+// src/engine/blocks/bookmark-spec.ts
+var KNOWN = ["url", "title", "description", "image"];
+var bookmarkSpec = {
+  type: "BOOKMARK",
+  flow: "void",
+  fromData: (data) => ({
+    attrs: withDefined({
+      url: str(data.url),
+      title: optionalString(data.title),
+      description: optionalString(data.description),
+      image: optionalString(data.image),
+      extra: extraFields(data, KNOWN)
+    }),
+    regions: {}
+  }),
+  toData: ({ attrs }) => withExtra(
+    {
+      url: str(attrs.url),
+      title: optionalString(attrs.title),
+      description: optionalString(attrs.description),
+      image: optionalString(attrs.image)
+    },
+    attrs
+  ),
+  initial: () => ({ attrs: { url: "" }, regions: {} })
+};
+
+// src/engine/blocks/callout-spec.ts
+var KNOWN2 = ["tone", "body", "icon"];
+var calloutSpec = {
+  type: "CALLOUT",
+  flow: "text",
+  primaryRegion: "body",
+  enter: "hardBreak",
+  fromData: (data, ctx) => ({
+    attrs: withDefined({ tone: str(data.tone), icon: optionalString(data.icon), extra: extraFields(data, KNOWN2) }),
+    regions: { body: ctx.inline.parse(str(data.body)) }
+  }),
+  toData: (block, ctx) => withExtra(
+    {
+      tone: str(block.attrs.tone),
+      body: ctx.inline.serialize(regionOf(block, "body"), { escapeLineStart: true }),
+      icon: optionalString(block.attrs.icon)
+    },
+    block.attrs
+  ),
+  initial: () => ({ attrs: { tone: "info" }, regions: { body: [] } })
+};
+
+// src/engine/blocks/code-spec.ts
+var KNOWN3 = ["language", "code"];
+var codeSpec = {
+  type: "CODE",
+  flow: "void",
+  fromData: (data) => ({
+    attrs: withDefined({ language: str(data.language), code: str(data.code), extra: extraFields(data, KNOWN3) }),
+    regions: {}
+  }),
+  toData: ({ attrs }) => withExtra({ language: str(attrs.language), code: str(attrs.code) }, attrs),
+  initial: () => ({ attrs: { language: "", code: "" }, regions: {} })
+};
+
+// src/engine/blocks/marker-spec.ts
+function markerSpec(type) {
+  return {
+    type,
+    flow: "void",
+    fromData: (data) => ({ attrs: withDefined({ extra: extraFields(data, []) }), regions: {} }),
+    toData: ({ attrs }) => withExtra({}, attrs),
+    initial: () => ({ attrs: {}, regions: {} })
+  };
+}
+
+// src/engine/blocks/divider-spec.ts
+var dividerSpec = markerSpec("DIVIDER");
+
+// src/engine/blocks/embed-spec.ts
+var KNOWN4 = ["url", "provider"];
+var embedSpec = {
+  type: "EMBED",
+  flow: "void",
+  fromData: (data) => ({
+    attrs: withDefined({ url: str(data.url), provider: str(data.provider), extra: extraFields(data, KNOWN4) }),
+    regions: {}
+  }),
+  toData: ({ attrs }) => withExtra({ url: str(attrs.url), provider: str(attrs.provider) }, attrs),
+  initial: () => ({ attrs: { url: "", provider: "" }, regions: {} })
+};
+
+// src/engine/blocks/file-spec.ts
+var KNOWN5 = ["storageKey", "filename", "size", "mime"];
+var fileSpec = {
+  type: "FILE",
+  flow: "void",
+  fromData: (data) => ({
+    attrs: withDefined({
+      storageKey: str(data.storageKey),
+      filename: str(data.filename),
+      size: optionalNumber(data.size),
+      mime: optionalString(data.mime),
+      extra: extraFields(data, KNOWN5)
+    }),
+    regions: {}
+  }),
+  toData: ({ attrs }) => withExtra(
+    {
+      storageKey: str(attrs.storageKey),
+      filename: str(attrs.filename),
+      size: optionalNumber(attrs.size),
+      mime: optionalString(attrs.mime)
+    },
+    attrs
+  ),
+  initial: () => ({ attrs: { storageKey: "", filename: "" }, regions: {} })
+};
+
+// src/engine/blocks/image-spec.ts
+var KNOWN6 = ["storageKey", "alt", "caption", "width", "height", "url", "align", "widthPercent"];
+var imageSpec = {
+  type: "IMAGE",
+  flow: "structured",
+  fromData: (data, ctx) => ({
+    attrs: withDefined({
+      storageKey: str(data.storageKey),
+      alt: str(data.alt),
+      width: optionalNumber(data.width),
+      height: optionalNumber(data.height),
+      url: optionalString(data.url),
+      align: alignOrUndefined(data.align),
+      widthPercent: optionalNumber(data.widthPercent),
+      extra: extraFields(data, KNOWN6)
+    }),
+    regions: { caption: ctx.inline.parse(str(data.caption)) }
+  }),
+  toData: (block, ctx) => withExtra(
+    {
+      storageKey: str(block.attrs.storageKey),
+      alt: str(block.attrs.alt),
+      caption: ctx.inline.serialize(regionOf(block, "caption")) || void 0,
+      width: optionalNumber(block.attrs.width),
+      height: optionalNumber(block.attrs.height),
+      url: optionalString(block.attrs.url),
+      align: alignOrUndefined(block.attrs.align),
+      widthPercent: optionalNumber(block.attrs.widthPercent)
+    },
+    block.attrs
+  ),
+  initial: () => ({ attrs: { storageKey: "", alt: "" }, regions: { caption: [] } })
+};
+
+// src/engine/markdown/ordered-start.ts
+var MAX_MARKER_NUMBER = 999999999;
+function orderedStart(start) {
+  return typeof start === "number" && Number.isInteger(start) && start >= 0 ? Math.min(start, MAX_MARKER_NUMBER) : 1;
+}
+
+// src/engine/markdown/line-kind.ts
+var INDENT = /^ {0,3}/;
+var TASK = /^[-*+] \[([ xX])\](?: |$)/;
+var HEADING = /^(#{1,6})(?: +|$)/;
+var CLOSING_SEQUENCE = / +#+ *$/;
+var BULLET = /^[-*+](?: |$)/;
+var ORDERED = /^(\d{1,9})[.)](?: |$)/;
+var QUOTE = /^> ?/;
+function parseLine(markdown) {
+  const line = markdown.replace(INDENT, "");
+  const after = (match) => line.slice(match[0].length);
+  const task = TASK.exec(line);
+  if (task) return { kind: "task", checked: task[1] !== " ", rest: after(task) };
+  const heading = HEADING.exec(line);
+  if (heading) {
+    return { kind: "heading", level: heading[1].length, rest: after(heading).replace(CLOSING_SEQUENCE, "") };
+  }
+  const bullet = BULLET.exec(line);
+  if (bullet) return { kind: "bullet", rest: after(bullet) };
+  const ordered = ORDERED.exec(line);
+  if (ordered) return { kind: "ordered", start: Number(ordered[1]), rest: after(ordered) };
+  const quote = QUOTE.exec(line);
+  if (quote) return { kind: "quote", rest: after(quote) };
+  return { kind: "paragraph", rest: markdown };
+}
+function linePrefix({ kind, level, checked, start }) {
+  switch (kind) {
+    case "heading":
+      return `${"#".repeat(Math.min(6, Math.max(1, _nullishCoalesce(level, () => ( 1)))))} `;
+    case "bullet":
+      return "- ";
+    case "ordered":
+      return `${orderedStart(start)}. `;
+    case "task":
+      return checked ? "- [x] " : "- [ ] ";
+    case "quote":
+      return "> ";
+    default:
+      return "";
+  }
+}
+
+// src/engine/markdown/line-markdown.ts
+var TRAILING_HASHES = /([ \t])(#+)$/;
+var protectClosingSequence = (markdown) => markdown.replace(TRAILING_HASHES, "$1\\$2");
+function lineMarkdown(line, body) {
+  return linePrefix(line) + (line.kind === "heading" ? protectClosingSequence(body) : body);
+}
+
+// src/engine/blocks/markdown-spec.ts
+var KNOWN7 = ["markdown", "align", "color", "background"];
+var markdownSpec = {
+  type: "MARKDOWN",
+  flow: "text",
+  primaryRegion: "text",
+  fromData(data, ctx) {
+    const { rest, ...line } = parseLine(str(data.markdown));
+    return {
+      attrs: withDefined({
+        ...line,
+        align: alignOrUndefined(data.align),
+        color: paletteOrUndefined(data.color),
+        background: paletteOrUndefined(data.background),
+        extra: extraFields(data, KNOWN7)
+      }),
+      regions: { text: ctx.inline.parse(rest) }
+    };
+  },
+  toData(block, ctx) {
+    const line = block.attrs;
+    const hardBreak = line.kind === "heading" ? "br" : "backslash";
+    const body = ctx.inline.serialize(regionOf(block, "text"), { escapeLineStart: true, hardBreak });
+    return withExtra(
+      {
+        markdown: lineMarkdown(line, body),
+        align: alignOrUndefined(block.attrs.align),
+        color: paletteOrUndefined(block.attrs.color),
+        background: paletteOrUndefined(block.attrs.background)
+      },
+      block.attrs
+    );
+  },
+  initial: () => ({ attrs: { kind: "paragraph" }, regions: { text: [] } }),
+  splitAttrs(attrs) {
+    const kind = attrs.kind === "heading" ? "paragraph" : attrs.kind;
+    return {
+      type: "MARKDOWN",
+      attrs: withDefined({
+        kind,
+        checked: kind === "task" ? false : void 0,
+        align: alignOrUndefined(attrs.align)
+      })
+    };
+  }
+};
+
+// src/engine/blocks/math-spec.ts
+var mathSpec = {
+  type: "MATH",
+  flow: "void",
+  fromData: (data) => ({
+    attrs: withDefined({ latex: str(data.latex), extra: extraFields(data, ["latex"]) }),
+    regions: {}
+  }),
+  toData: ({ attrs }) => withExtra({ latex: str(attrs.latex) }, attrs),
+  initial: () => ({ attrs: { latex: "" }, regions: {} })
+};
+
+// src/engine/model/count.ts
+var countOf = (value) => Number.isInteger(value) && value > 0 ? value : 0;
+
+// src/engine/blocks/table-spec.ts
+var KNOWN8 = ["rows", "header", "align", "widths"];
+var COLUMN_ALIGNS = ["left", "center", "right"];
+var CELL_WRITE = { escapePipes: true, hardBreak: "br" };
+var cellKey = (row, col) => `cell:${row}:${col}`;
+function columnAligns(value, cols) {
+  return Array.from({ length: cols }, (_, col) => {
+    const align = Array.isArray(value) ? value[col] : void 0;
+    return typeof align === "string" && COLUMN_ALIGNS.includes(align) ? align : null;
+  });
+}
+function widthList(value) {
+  return Array.isArray(value) && value.every((width) => optionalNumber(width) !== void 0) ? value : void 0;
+}
+var tableSpec = {
+  type: "TABLE",
+  flow: "structured",
+  fromData(data, ctx) {
+    const rows = Array.isArray(data.rows) ? data.rows.map((row) => Array.isArray(row) ? row : []) : [];
+    const cols = rows.reduce((widest, row) => Math.max(widest, row.length), 0);
+    const regions = {};
+    rows.forEach((row, r) => {
+      for (let c = 0; c < cols; c++) regions[cellKey(r, c)] = ctx.inline.parse(str(row[c]), { softBreak: "space" });
+    });
+    return {
+      attrs: withDefined({
+        header: data.header !== false,
+        align: columnAligns(data.align, cols),
+        widths: widthList(data.widths),
+        rows: rows.length,
+        cols,
+        extra: extraFields(data, KNOWN8)
+      }),
+      regions
+    };
+  },
+  toData(block, ctx) {
+    const { attrs } = block;
+    const cols = countOf(attrs.cols);
+    const rows = Array.from(
+      { length: countOf(attrs.rows) },
+      (_, r) => Array.from({ length: cols }, (_2, c) => ctx.inline.serialize(regionOf(block, cellKey(r, c)), CELL_WRITE))
+    );
+    return withExtra(
+      { rows, header: attrs.header !== false, align: columnAligns(attrs.align, cols), widths: widthList(attrs.widths) },
+      attrs
+    );
+  },
+  initial() {
+    const regions = {};
+    for (let r = 0; r < 3; r++) for (let c = 0; c < 2; c++) regions[cellKey(r, c)] = [];
+    return { attrs: { header: true, align: [null, null], rows: 3, cols: 2 }, regions };
+  }
+};
+
+// src/engine/blocks/toc-spec.ts
+var tocSpec = markerSpec("TOC");
+
+// src/engine/blocks/toggle-spec.ts
+var KNOWN9 = ["markdown", "open"];
+var toggleSpec = {
+  type: "TOGGLE",
+  flow: "text",
+  primaryRegion: "text",
+  fromData: (data, ctx) => ({
+    attrs: withDefined({ open: data.open === true, extra: extraFields(data, KNOWN9) }),
+    regions: { text: ctx.inline.parse(str(data.markdown)) }
+  }),
+  toData: (block, ctx) => withExtra(
+    {
+      markdown: ctx.inline.serialize(regionOf(block, "text"), { escapeLineStart: true }),
+      open: block.attrs.open === true
+    },
+    block.attrs
+  ),
+  initial: () => ({ attrs: { open: true }, regions: { text: [] } }),
+  splitAttrs: () => ({ type: "MARKDOWN", attrs: { kind: "paragraph" } })
+};
+
+// src/engine/blocks/core-specs.ts
+var coreBlockSpecs = [
+  markdownSpec,
+  calloutSpec,
+  codeSpec,
+  imageSpec,
+  fileSpec,
+  dividerSpec,
+  toggleSpec,
+  tableSpec,
+  embedSpec,
+  bookmarkSpec,
+  mathSpec,
+  tocSpec
+];
+
+// src/engine/schema/core-atoms.ts
+var mention = { type: "mention", plainText: ({ label }) => `@${label}` };
+var math = { type: "math", plainText: ({ latex }) => latex };
+var coreAtomSpecs = [mention, math];
+
+// src/engine/schema/core-marks.ts
+var CORE_MARKS = [
+  "link",
+  "comment",
+  "bold",
+  "italic",
+  "underline",
+  "strike",
+  "sub",
+  "sup",
+  "highlight",
+  "color",
+  "background",
+  "code"
+];
+var ANCHORED = /* @__PURE__ */ new Set(["link", "comment"]);
+var coreMarkSpecs = CORE_MARKS.map((type) => ({ type, inclusive: !ANCHORED.has(type) }));
+
+// src/engine/schema/create-schema.ts
+var byType = (specs) => new Map(specs.map((spec) => [spec.type, spec]));
+function createSchema(input = {}) {
+  return {
+    blocks: byType([...coreBlockSpecs, ..._nullishCoalesce(input.blocks, () => ( []))]),
+    marks: byType([...coreMarkSpecs, ..._nullishCoalesce(input.marks, () => ( []))]),
+    atoms: byType([...coreAtomSpecs, ..._nullishCoalesce(input.atoms, () => ( []))]),
+    defaultTextBlock: _nullishCoalesce(input.defaultTextBlock, () => ( "MARKDOWN"))
+  };
+}
+
+// src/engine/markdown/urls.ts
+var SAFE_SCHEMES = /* @__PURE__ */ new Set(["http:", "https:", "mailto:", "tel:", "mention:"]);
+var ASSET_SCHEMES = /* @__PURE__ */ new Set(["http:", "https:", "blob:", "data:"]);
+var SCHEME = /^([a-z][a-z0-9+.-]*):/i;
+var CONTROL = /\p{Cc}/u;
+function allowed(href, schemes) {
+  const trimmed = href.trim();
+  if (CONTROL.test(trimmed)) return null;
+  const scheme = SCHEME.exec(trimmed);
+  if (!scheme) return trimmed;
+  return schemes.has(scheme[1].toLowerCase() + ":") ? trimmed : null;
+}
+function sanitizeHref(href) {
+  return allowed(href, SAFE_SCHEMES);
+}
+function sanitizeAssetUrl(href) {
+  return allowed(href, ASSET_SCHEMES);
+}
+
+// src/engine/markdown/inline/delimiters.ts
+var WHITESPACE = /^[\p{Zs}\t\n\f\r]$/u;
+var PUNCTUATION = /^[\p{P}\p{S}]$/u;
+function isWhitespace(char) {
+  return char === "" || WHITESPACE.test(char);
+}
+function classifyDelimiterRun(before, after, char) {
+  const punctuationBefore = PUNCTUATION.test(before);
+  const punctuationAfter = PUNCTUATION.test(after);
+  const leftFlanking = !isWhitespace(after) && (!punctuationAfter || isWhitespace(before) || punctuationBefore);
+  const rightFlanking = !isWhitespace(before) && (!punctuationBefore || isWhitespace(after) || punctuationAfter);
+  if (char !== "_") return { canOpen: leftFlanking, canClose: rightFlanking };
+  return {
+    canOpen: leftFlanking && (!rightFlanking || punctuationBefore),
+    canClose: rightFlanking && (!leftFlanking || punctuationAfter)
+  };
+}
+function canPair(opener, closer) {
+  if (opener.char !== closer.char || !opener.canOpen) return false;
+  if (closer.char === "~") return opener.length === closer.length;
+  if (!opener.canClose && !closer.canOpen) return true;
+  const bothMultiplesOfThree = opener.length % 3 === 0 && closer.length % 3 === 0;
+  return (opener.length + closer.length) % 3 !== 0 || bothMultiplesOfThree;
+}
+function emphasisMark(char, used) {
+  if (char === "~") return { type: "strike" };
+  return { type: used === 2 ? "bold" : "italic" };
+}
+function pair(opener, closer) {
+  const used = closer.char === "~" ? closer.count : Math.min(2, opener.count, closer.count);
+  const range = { mark: emphasisMark(closer.char, used) };
+  opener.count -= used;
+  closer.count -= used;
+  opener.opens.push(range);
+  closer.closes.push(range);
+}
+function clampFloors(floors, length) {
+  for (const [key, floor] of floors) if (floor >= length) floors.set(key, length - 1);
+}
+function processEmphasis(stack, bottom) {
+  const openers = [];
+  const floors = /* @__PURE__ */ new Map();
+  let index = bottom;
+  while (index < stack.length) {
+    const closer = stack[index];
+    if (!closer.canClose) {
+      openers.push(closer);
+      index++;
+      continue;
+    }
+    const key = `${closer.char}${closer.canOpen}${closer.length % 3}`;
+    const floor = _nullishCoalesce(floors.get(key), () => ( -1));
+    let at = openers.length - 1;
+    while (at > floor && !canPair(openers[at], closer)) at--;
+    if (at > floor) {
+      const opener = openers[at];
+      pair(opener, closer);
+      openers.length = opener.count > 0 ? at + 1 : at;
+      clampFloors(floors, openers.length);
+      if (closer.count === 0) index++;
+    } else {
+      floors.set(key, openers.length - 1);
+      if (closer.canOpen) openers.push(closer);
+      index++;
+    }
+  }
+  stack.length = bottom;
+}
+
+// src/engine/markdown/inline/match-at.ts
+function matchAt(pattern, src, pos) {
+  pattern.lastIndex = pos;
+  return pattern.exec(src);
+}
+
+// src/engine/markdown/inline/entities.ts
+var NAMED = /* @__PURE__ */ new Map([
+  ["amp", "&"],
+  ["lt", "<"],
+  ["gt", ">"],
+  ["quot", '"'],
+  ["apos", "'"],
+  ["nbsp", "\xA0"],
+  ["copy", "\xA9"],
+  ["reg", "\xAE"],
+  ["trade", "\u2122"],
+  ["hellip", "\u2026"],
+  ["mdash", "\u2014"],
+  ["ndash", "\u2013"],
+  ["lsquo", "\u2018"],
+  ["rsquo", "\u2019"],
+  ["ldquo", "\u201C"],
+  ["rdquo", "\u201D"],
+  ["laquo", "\xAB"],
+  ["raquo", "\xBB"],
+  ["times", "\xD7"],
+  ["divide", "\xF7"],
+  ["deg", "\xB0"],
+  ["middot", "\xB7"],
+  ["bull", "\u2022"]
+]);
+var NUMERIC = /^#(?:([0-9]{1,7})|[xX]([0-9a-fA-F]{1,6}))$/;
+var ENTITY_SOURCE = "&(#[xX][0-9a-fA-F]{1,6}|#[0-9]{1,7}|[A-Za-z][A-Za-z0-9]{1,31});";
+var ENTITY_AT = new RegExp(ENTITY_SOURCE, "y");
+var ENTITIES = new RegExp(ENTITY_SOURCE, "g");
+var REPLACEMENT = "\uFFFD";
+function fromCodePoint(code) {
+  const valid = code > 0 && code <= 1114111 && (code < 55296 || code > 57343);
+  return valid ? String.fromCodePoint(code) : REPLACEMENT;
+}
+function decodeEntity(name) {
+  const numeric = NUMERIC.exec(name);
+  if (numeric) return fromCodePoint(numeric[1] ? parseInt(numeric[1], 10) : parseInt(numeric[2], 16));
+  return _nullishCoalesce(NAMED.get(name), () => ( null));
+}
+function matchEntity(src, pos) {
+  const match = matchAt(ENTITY_AT, src, pos);
+  const value = match ? decodeEntity(match[1]) : null;
+  return match && value !== null ? { value, end: pos + match[0].length } : null;
+}
+function decodeEntities(value) {
+  return value.replace(ENTITIES, (source, name) => _nullishCoalesce(decodeEntity(name), () => ( source)));
+}
+
+// src/engine/markdown/inline/escapes.ts
+var ASCII_PUNCTUATION = /^[!-/:-@[-`{-~]$/;
+var ESCAPED = /\\([!-/:-@[-`{-~])/g;
+function isEscapable(char) {
+  return char !== void 0 && ASCII_PUNCTUATION.test(char);
+}
+function unescapeMarkdown(value) {
+  return value.split(ESCAPED).map((part, index) => index % 2 === 1 ? part : decodeEntities(part)).join("");
+}
+
+// src/engine/markdown/inline/link-syntax.ts
+var URI_AUTOLINK = /<([A-Za-z][A-Za-z0-9+.-]{1,31}:[^<>\p{Cc} ]*)>/uy;
+var DOMAIN_LABEL = "[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?";
+var EMAIL_AUTOLINK = new RegExp(`<([A-Za-z0-9.!#$%&'*+/=?^_\`{|}~-]+@${DOMAIN_LABEL}(?:\\.${DOMAIN_LABEL})*)>`, "y");
+var LABEL = /\[((?:[^\\[\]]|\\[\s\S]){0,999})\]/y;
+var MAX_PAREN_DEPTH = 32;
+var TITLE_CLOSERS = /* @__PURE__ */ new Map([
+  ['"', '"'],
+  ["'", "'"],
+  ["(", ")"]
+]);
+function isSpaceOrControl(char) {
+  const code = char.charCodeAt(0);
+  return code <= 32 || code === 127;
+}
+function parseAngleDestination(src, pos) {
+  for (let p = pos + 1; p < src.length; p++) {
+    const char = src[p];
+    if (char === "\\" && p + 1 < src.length && src[p + 1] !== "\n") p++;
+    else if (char === ">") return { value: unescapeMarkdown(src.slice(pos + 1, p)), end: p + 1 };
+    else if (char === "<" || char === "\n") return null;
+  }
+  return null;
+}
+function parseLinkDestination(src, pos) {
+  if (src[pos] === "<") return parseAngleDestination(src, pos);
+  let depth = 0;
+  let p = pos;
+  for (; p < src.length; p++) {
+    const char = src[p];
+    if (char === "\\" && isEscapable(src[p + 1])) p++;
+    else if (char === "(" && depth === MAX_PAREN_DEPTH) return null;
+    else if (char === "(") depth++;
+    else if (char === ")" && depth === 0) break;
+    else if (char === ")") depth--;
+    else if (isSpaceOrControl(char)) break;
+  }
+  if (depth !== 0 || p === pos && src[p] !== ")") return null;
+  return { value: unescapeMarkdown(src.slice(pos, p)), end: p };
+}
+function parseLinkTitle(src, pos) {
+  const close = TITLE_CLOSERS.get(src[pos]);
+  if (!close) return null;
+  for (let p = pos + 1; p < src.length; p++) {
+    const char = src[p];
+    if (char === "\\") p++;
+    else if (char === close) return { value: unescapeMarkdown(src.slice(pos + 1, p)), end: p + 1 };
+    else if (close === ")" && char === "(") return null;
+  }
+  return null;
+}
+function parseAutolink(src, pos) {
+  const uri = matchAt(URI_AUTOLINK, src, pos);
+  if (uri) return { value: { href: uri[1], text: uri[1] }, end: pos + uri[0].length };
+  const email = matchAt(EMAIL_AUTOLINK, src, pos);
+  return email ? { value: { href: `mailto:${email[1]}`, text: email[1] }, end: pos + email[0].length } : null;
+}
+function parseLinkLabel(src, pos) {
+  const match = matchAt(LABEL, src, pos);
+  return match ? { value: match[1], end: pos + match[0].length } : null;
+}
+function skipLinkSpace(src, pos) {
+  let p = pos;
+  while (src[p] === " " || src[p] === "	") p++;
+  if (src[p] === "\n") p++;
+  while (src[p] === " " || src[p] === "	") p++;
+  return p;
+}
+function parseInlineLinkTail(src, pos) {
+  const destination = parseLinkDestination(src, skipLinkSpace(src, pos));
+  if (!destination) return null;
+  let p = skipLinkSpace(src, destination.end);
+  const title = p > destination.end ? parseLinkTitle(src, p) : null;
+  if (title) p = skipLinkSpace(src, title.end);
+  if (src[p] !== ")") return null;
+  const value = _optionalChain([title, 'optionalAccess', _10 => _10.value]) ? { href: destination.value, title: title.value } : { href: destination.value };
+  return { value, end: p + 1 };
+}
+function normalizeLabel(label) {
+  return label.trim().replace(/[ \t\r\n]+/g, " ").toLowerCase().toUpperCase();
+}
+
+// src/engine/markdown/inline/scanner.ts
+function normalizeRefs(refs) {
+  const result = /* @__PURE__ */ new Map();
+  for (const [label, target] of _nullishCoalesce(refs, () => ( []))) {
+    const key = normalizeLabel(label);
+    if (key && !result.has(key)) result.set(key, target);
+  }
+  return result;
+}
+function createScanner(src, options) {
+  return {
+    src,
+    softBreak: options.softBreak === "space" ? " " : "\n",
+    refs: normalizeRefs(options.refs),
+    items: [],
+    delimiters: [],
+    brackets: [],
+    closeMisses: /* @__PURE__ */ new Map(),
+    pos: 0
+  };
+}
+function pushText(scanner, value, advance) {
+  scanner.items.push({ kind: "text", text: value });
+  scanner.pos += advance;
+}
+function findClose(scanner, key, from, find) {
+  if (from >= (_nullishCoalesce(scanner.closeMisses.get(key), () => ( Infinity)))) return -1;
+  const close = find(from);
+  if (close < 0) scanner.closeMisses.set(key, from);
+  return close;
+}
+
+// src/engine/markdown/inline/close-bracket.ts
+var MENTION = "mention:";
+function matchReference(scanner, opener, after) {
+  if (scanner.refs.size === 0) return null;
+  const label = parseLinkLabel(scanner.src, after);
+  if (_optionalChain([label, 'optionalAccess', _11 => _11.value])) {
+    const target2 = scanner.refs.get(normalizeLabel(label.value));
+    return target2 ? { value: target2, end: label.end } : null;
+  }
+  const ownLabel = parseLinkLabel(scanner.src, opener.start - 1);
+  if (_optionalChain([ownLabel, 'optionalAccess', _12 => _12.end]) !== after) return null;
+  const target = scanner.refs.get(normalizeLabel(ownLabel.value));
+  return target ? { value: target, end: label ? label.end : after } : null;
+}
+function matchLink(scanner, opener) {
+  const after = scanner.pos + 1;
+  const inline = scanner.src[after] === "(" ? parseInlineLinkTail(scanner.src, after + 1) : null;
+  return _nullishCoalesce(inline, () => ( matchReference(scanner, opener, after)));
+}
+function plainText(items) {
+  let result = "";
+  for (const item of items) {
+    if (item.kind === "text" && !item.marks) result += item.text;
+    else if (item.kind === "delimiter" && item.opens.length + item.closes.length === 0) {
+      result += item.char.repeat(item.count);
+    } else return null;
+  }
+  return result;
+}
+function mentionAtom(href, label) {
+  if (!href.startsWith(MENTION) || !_optionalChain([label, 'optionalAccess', _13 => _13.startsWith, 'call', _14 => _14("@")])) return null;
+  const reference = href.slice(MENTION.length);
+  const colon = reference.indexOf(":");
+  const id = reference.slice(colon + 1);
+  if (!id) return null;
+  const attrs = { id, label: label.slice(1) };
+  return { kind: "atom", type: "mention", attrs: colon < 0 ? attrs : { ...attrs, kind: reference.slice(0, colon) } };
+}
+function formLink(scanner, opener, target) {
+  const { items } = scanner;
+  const href = sanitizeHref(target.href);
+  if (href === null) {
+    items[opener.index] = { kind: "text", text: "" };
+    return;
+  }
+  const mention2 = mentionAtom(href, plainText(items.slice(opener.index + 1)));
+  if (mention2) {
+    items.length = opener.index;
+    items.push(mention2);
+    return;
+  }
+  const attrs = target.title ? { href, title: target.title } : { href };
+  const range = { mark: { type: "link", attrs } };
+  items[opener.index] = { kind: "open", range };
+  items.push({ kind: "close", range });
+}
+function deactivateOpeners(brackets) {
+  for (let at = brackets.length - 1; at >= 0 && brackets[at].active; at--) brackets[at].active = false;
+}
+function closeBracket(scanner) {
+  const opener = scanner.brackets.pop();
+  const target = _optionalChain([opener, 'optionalAccess', _15 => _15.active]) && !opener.image ? matchLink(scanner, opener) : null;
+  if (!opener || !target) {
+    pushText(scanner, "]", 1);
+    return;
+  }
+  processEmphasis(scanner.delimiters, opener.bottom);
+  formLink(scanner, opener, target.value);
+  scanner.pos = target.end;
+  deactivateOpeners(scanner.brackets);
+}
+
+// src/engine/markdown/inline/code-span.ts
+var BACKTICK_RUNS = /`+/g;
+function findCodeClose(src, from, fence) {
+  BACKTICK_RUNS.lastIndex = from;
+  for (let run = BACKTICK_RUNS.exec(src); run; run = BACKTICK_RUNS.exec(src)) {
+    if (run[0].length === fence) return run.index;
+  }
+  return -1;
+}
+function codeSpanText(raw) {
+  const content = raw.replace(/\n/g, " ");
+  const padded = content.startsWith(" ") && content.endsWith(" ") && /[^ ]/.test(content);
+  return padded ? content.slice(1, -1) : content;
+}
+
+// src/engine/markdown/inline/active-marks.ts
+function upperBound(marks, mark) {
+  let low = 0;
+  let high = marks.length;
+  while (low < high) {
+    const middle = low + high >>> 1;
+    if (compareMarks(marks[middle], mark) <= 0) low = middle + 1;
+    else high = middle;
+  }
+  return low;
+}
+function indexOfKey(marks, mark) {
+  return upperBound(marks, mark) - 1;
+}
+function createActiveMarks() {
+  const stacks = /* @__PURE__ */ new Map();
+  const closedBelowTop = /* @__PURE__ */ new Set();
+  const shown = [];
+  const copied = /* @__PURE__ */ new Map();
+  const changed = /* @__PURE__ */ new Set();
+  let copy = [];
+  const track = (key, top) => {
+    const last = copied.get(key);
+    if (last === top || last && top && sameMark(last, top)) changed.delete(key);
+    else changed.add(key);
+  };
+  const open = (range) => {
+    const key = markKey(range.mark);
+    const stack = stacks.get(key);
+    if (stack) {
+      shown[indexOfKey(shown, range.mark)] = range.mark;
+      stack.push(range);
+    } else {
+      shown.splice(upperBound(shown, range.mark), 0, range.mark);
+      stacks.set(key, [range]);
+    }
+    track(key, range.mark);
+  };
+  const close = (range) => {
+    const key = markKey(range.mark);
+    const stack = stacks.get(key);
+    if (_optionalChain([stack, 'optionalAccess', _16 => _16.at, 'call', _17 => _17(-1)]) !== range) {
+      closedBelowTop.add(range);
+      return;
+    }
+    stack.pop();
+    while (stack.length > 0 && closedBelowTop.delete(stack[stack.length - 1])) stack.pop();
+    const index = indexOfKey(shown, range.mark);
+    const top = _optionalChain([stack, 'access', _18 => _18.at, 'call', _19 => _19(-1), 'optionalAccess', _20 => _20.mark]);
+    if (top) {
+      shown[index] = top;
+    } else {
+      shown.splice(index, 1);
+      stacks.delete(key);
+    }
+    track(key, top);
+  };
+  const current = () => {
+    if (changed.size === 0) return copy;
+    copy = [...shown];
+    for (const key of changed) {
+      const stack = stacks.get(key);
+      if (stack) copied.set(key, stack[stack.length - 1].mark);
+      else copied.delete(key);
+    }
+    changed.clear();
+    return copy;
+  };
+  return { open, close, current };
+}
+
+// src/engine/markdown/inline/inline-items.ts
+function flattenItems(items) {
+  const { open, close, current } = createActiveMarks();
+  const nodes = [];
+  let run = "";
+  let runMarks = [];
+  const flush = () => {
+    if (run) nodes.push({ kind: "text", text: run, marks: runMarks });
+    run = "";
+  };
+  const emit = (value, own = []) => {
+    if (!value) return;
+    const ranges = own.map((mark) => ({ mark }));
+    ranges.forEach(open);
+    const marks = current();
+    if (marks !== runMarks) flush();
+    run += value;
+    runMarks = marks;
+    ranges.forEach(close);
+  };
+  const emitAtom = (type, attrs) => {
+    flush();
+    nodes.push({ kind: "atom", type, attrs, marks: current() });
+  };
+  for (const item of items) {
+    if (item.kind === "text") emit(item.text, item.marks);
+    else if (item.kind === "atom") emitAtom(item.type, item.attrs);
+    else if (item.kind === "open") open(item.range);
+    else if (item.kind === "close") close(item.range);
+    else if (item.kind === "delimiter") {
+      item.closes.forEach(close);
+      emit(item.char.repeat(item.count));
+      item.opens.forEach(open);
+    } else if (!item.range) emit(item.source);
+    else if (item.tag.close) close(item.range);
+    else open(item.range);
+  }
+  flush();
+  return normalizeInline(nodes);
+}
+
+// src/engine/markdown/inline/math-span.ts
+var SPACE = /\s/;
+var DIGIT = /[0-9]/;
+function opensMath(src, pos) {
+  const next = src[pos + 1];
+  if (next === void 0 || SPACE.test(next)) return false;
+  return !(DIGIT.test(next) && (pos === 0 || SPACE.test(src[pos - 1])));
+}
+function dollarRunEnd(src, pos) {
+  let end = pos;
+  while (src[end] === "$") end++;
+  return end;
+}
+function findMathClose(src, from) {
+  for (let p = src.indexOf("$", from); p >= 0; p = src.indexOf("$", p + 1)) {
+    const before = src[p - 1];
+    if (before !== "\\" && !SPACE.test(before) && !DIGIT.test(_nullishCoalesce(src[p + 1], () => ( "")))) return p;
+  }
+  return -1;
+}
+function mathLatex(src, open, close) {
+  return src.slice(open + 1, close).replace(/\\\$/g, "$");
+}
+
+// src/engine/markdown/inline/html-tags.ts
+var OPEN_TAG = /<([A-Za-z][A-Za-z0-9]*)((?:[ \t\n]+[A-Za-z_:][\w.:-]*="[^"]*")*)[ \t\n]*(\/?)>/y;
+var CLOSE_TAG = /<\/([A-Za-z][A-Za-z0-9]*)[ \t\n]*>/y;
+var ATTRIBUTE = /([A-Za-z_:][\w.:-]*)="([^"]*)"/g;
+var ATTR_PREFIX = "data-attr-";
+var SPAN_KINDS = ["data-color", "data-bg", "data-comment", "data-mark", "data-atom"];
+var PLAIN_MARKS = /* @__PURE__ */ new Map([
+  ["u", "underline"],
+  ["b", "bold"],
+  ["strong", "bold"],
+  ["i", "italic"],
+  ["em", "italic"],
+  ["s", "strike"],
+  ["del", "strike"],
+  ["strike", "strike"],
+  ["code", "code"],
+  ["sub", "sub"],
+  ["sup", "sup"]
+]);
+var PAIRED = /* @__PURE__ */ new Set([...PLAIN_MARKS.keys(), "mark", "span"]);
+function readAttributes(source) {
+  const attributes = /* @__PURE__ */ new Map();
+  for (const [, name, value] of source.matchAll(ATTRIBUTE)) {
+    if (attributes.has(name)) return null;
+    attributes.set(name, decodeEntities(value));
+  }
+  return attributes;
+}
+function customAttrs(attributes, kind) {
+  const entries = [...attributes].filter(([name]) => name !== kind);
+  if (entries.some(([name]) => !name.startsWith(ATTR_PREFIX) || name === ATTR_PREFIX)) return null;
+  return Object.fromEntries(entries.map(([name, value]) => [name.slice(ATTR_PREFIX.length), value]));
+}
+function customSpan(kind, type, attributes) {
+  const attrs = customAttrs(attributes, kind);
+  if (!attrs || !type) return null;
+  if (kind === "data-atom") return { atom: { type, attrs } };
+  if (isCoreMark(type)) return null;
+  return { mark: Object.keys(attrs).length > 0 ? { type, attrs } : { type } };
+}
+function spanTag(attributes) {
+  const kinds = [...attributes].filter(([name]) => SPAN_KINDS.includes(name));
+  if (kinds.length !== 1) return null;
+  const [[kind, value]] = kinds;
+  if (kind === "data-mark" || kind === "data-atom") return customSpan(kind, value, attributes);
+  if (attributes.size !== 1) return null;
+  if (kind === "data-comment") return value ? { mark: { type: "comment", attrs: { id: value } } } : null;
+  if (!isPaletteColor(value)) return null;
+  return { mark: { type: kind === "data-color" ? "color" : "background", attrs: { color: value } } };
+}
+function highlightTag(attributes) {
+  if ([...attributes.keys()].some((name) => name !== "data-color")) return null;
+  const color = _nullishCoalesce(attributes.get("data-color"), () => ( ""));
+  return { mark: isPaletteColor(color) ? { type: "highlight", attrs: { color } } : { type: "highlight" } };
+}
+function describeOpenTag(name, attributes, selfClosing) {
+  if (name === "br") return attributes.size === 0 ? { lineBreak: true } : null;
+  if (selfClosing) return null;
+  const type = PLAIN_MARKS.get(name);
+  if (type) return attributes.size === 0 ? { mark: { type } } : null;
+  if (name === "mark") return highlightTag(attributes);
+  if (name === "span") return spanTag(attributes);
+  return null;
+}
+function parseInlineTag(src, pos) {
+  const close = matchAt(CLOSE_TAG, src, pos);
+  if (close) {
+    const name2 = close[1].toLowerCase();
+    return PAIRED.has(name2) ? { tag: { close: true, name: name2 }, end: pos + close[0].length } : null;
+  }
+  const open = matchAt(OPEN_TAG, src, pos);
+  const attributes = open && readAttributes(open[2]);
+  if (!open || !attributes) return null;
+  const name = open[1].toLowerCase();
+  const meaning = describeOpenTag(name, attributes, open[3] === "/");
+  return meaning && { tag: { close: false, name, ...meaning }, end: pos + open[0].length };
+}
+
+// src/engine/markdown/inline/open-angle.ts
+function findSpanClose(src, from) {
+  for (let at = src.indexOf("<", from); at >= 0; at = src.indexOf("<", at + 1)) {
+    const parsed = parseInlineTag(src, at);
+    if (_optionalChain([parsed, 'optionalAccess', _21 => _21.tag, 'access', _22 => _22.close]) && parsed.tag.name === "span") return parsed.end;
+  }
+  return -1;
+}
+function atomSpan(scanner, atom2, openEnd) {
+  const closeEnd = findClose(scanner, "span", openEnd, (from) => findSpanClose(scanner.src, from));
+  if (closeEnd < 0) {
+    pushText(scanner, scanner.src.slice(scanner.pos, openEnd), openEnd - scanner.pos);
+    return;
+  }
+  scanner.items.push({ kind: "atom", type: atom2.type, attrs: atom2.attrs });
+  scanner.pos = closeEnd;
+}
+function autolinkItem(text2, href) {
+  return href === null ? { kind: "text", text: text2 } : { kind: "text", text: text2, marks: [{ type: "link", attrs: { href } }] };
+}
+function openAngle(scanner) {
+  const { src, pos, items } = scanner;
+  const autolink = parseAutolink(src, pos);
+  if (autolink) {
+    items.push(autolinkItem(autolink.value.text, sanitizeHref(autolink.value.href)));
+    scanner.pos = autolink.end;
+    return;
+  }
+  const parsed = parseInlineTag(src, pos);
+  if (!parsed) pushText(scanner, "<", 1);
+  else if (parsed.tag.lineBreak) pushText(scanner, "\n", parsed.end - pos);
+  else if (parsed.tag.atom) atomSpan(scanner, parsed.tag.atom, parsed.end);
+  else {
+    items.push({ kind: "tag", source: src.slice(pos, parsed.end), tag: parsed.tag });
+    scanner.pos = parsed.end;
+  }
+}
+
+// src/engine/markdown/inline/pair-tags.ts
+function stackOf(openByName, name) {
+  const existing = openByName.get(name);
+  if (existing) return existing;
+  const stack = [];
+  openByName.set(name, stack);
+  return stack;
+}
+function pairTags(items) {
+  const openByName = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    if (item.kind !== "tag") continue;
+    const { close, name, mark } = item.tag;
+    if (!close) {
+      if (mark) stackOf(openByName, name).push({ item, mark });
+      continue;
+    }
+    const opener = _optionalChain([openByName, 'access', _23 => _23.get, 'call', _24 => _24(name), 'optionalAccess', _25 => _25.pop, 'call', _26 => _26()]);
+    if (!opener) continue;
+    const range = { mark: opener.mark };
+    opener.item.range = range;
+    item.range = range;
+  }
+}
+
+// src/engine/markdown/inline/parse-inline.ts
+var PLAIN = /[^\\`*_~[\]!<&$\n]+/y;
+var CODE = { type: "code" };
+function breakLine(scanner, value) {
+  scanner.items.push({ kind: "text", text: value });
+  let next = scanner.pos + 1;
+  while (scanner.src[next] === " " || scanner.src[next] === "	") next++;
+  scanner.pos = next;
+}
+function plainRun(scanner, run) {
+  if (scanner.src[scanner.pos + run.length] !== "\n") {
+    pushText(scanner, run, run.length);
+    return;
+  }
+  pushText(scanner, run.replace(/[ \t]+$/, ""), run.length);
+  breakLine(scanner, run.endsWith("  ") ? "\n" : scanner.softBreak);
+}
+function backslash(scanner) {
+  const next = scanner.src[scanner.pos + 1];
+  if (next === "\n") {
+    scanner.pos += 1;
+    breakLine(scanner, "\n");
+  } else if (isEscapable(next)) {
+    pushText(scanner, next, 2);
+  } else {
+    pushText(scanner, "\\", 1);
+  }
+}
+function runLength(src, pos, char) {
+  let end = pos;
+  while (src[end] === char) end++;
+  return end - pos;
+}
+function codeSpan(scanner) {
+  const { src, pos } = scanner;
+  const fence = runLength(src, pos, "`");
+  const close = findClose(scanner, `code${fence}`, pos + fence, (from) => findCodeClose(src, from, fence));
+  if (close < 0) {
+    pushText(scanner, "`".repeat(fence), fence);
+    return;
+  }
+  scanner.items.push({ kind: "text", text: codeSpanText(src.slice(pos + fence, close)), marks: [CODE] });
+  scanner.pos = close + fence;
+}
+function codePointBefore(src, pos) {
+  return _nullishCoalesce(Array.from(src.slice(Math.max(0, pos - 2), pos)).pop(), () => ( ""));
+}
+function codePointAt(src, pos) {
+  const code = src.codePointAt(pos);
+  return code === void 0 ? "" : String.fromCodePoint(code);
+}
+function delimiterRun(scanner, char) {
+  const { src, pos } = scanner;
+  const length = runLength(src, pos, char);
+  const end = pos + length;
+  if (char === "~" && length > 2) {
+    pushText(scanner, src.slice(pos, end), length);
+    return;
+  }
+  const flanking = classifyDelimiterRun(codePointBefore(src, pos), codePointAt(src, end), char);
+  const delimiter = {
+    kind: "delimiter",
+    char,
+    length,
+    count: length,
+    ...flanking,
+    opens: [],
+    closes: []
+  };
+  scanner.items.push(delimiter);
+  if (delimiter.canOpen || delimiter.canClose) scanner.delimiters.push(delimiter);
+  scanner.pos = end;
+}
+function openBracket(scanner, image) {
+  const width = image ? 2 : 1;
+  const { items, pos, delimiters } = scanner;
+  scanner.brackets.push({ index: items.length, start: pos + width, image, bottom: delimiters.length, active: true });
+  pushText(scanner, image ? "![" : "[", width);
+}
+function entity(scanner) {
+  const decoded = matchEntity(scanner.src, scanner.pos);
+  if (decoded) pushText(scanner, decoded.value, decoded.end - scanner.pos);
+  else pushText(scanner, "&", 1);
+}
+function math2(scanner) {
+  const { src, pos } = scanner;
+  if (src[pos + 1] === "$") {
+    const end = dollarRunEnd(src, pos);
+    pushText(scanner, src.slice(pos, end), end - pos);
+    return;
+  }
+  const close = opensMath(src, pos) ? findClose(scanner, "math", pos + 2, (from) => findMathClose(src, from)) : -1;
+  if (close < 0) {
+    pushText(scanner, "$", 1);
+    return;
+  }
+  scanner.items.push({ kind: "atom", type: "math", attrs: { latex: mathLatex(src, pos, close) } });
+  scanner.pos = close + 1;
+}
+function scanSpecial(scanner, char) {
+  if (char === "\\") backslash(scanner);
+  else if (char === "`") codeSpan(scanner);
+  else if (char === "*" || char === "_" || char === "~") delimiterRun(scanner, char);
+  else if (char === "[") openBracket(scanner, false);
+  else if (char === "!" && scanner.src[scanner.pos + 1] === "[") openBracket(scanner, true);
+  else if (char === "]") closeBracket(scanner);
+  else if (char === "<") openAngle(scanner);
+  else if (char === "&") entity(scanner);
+  else if (char === "$") math2(scanner);
+  else if (char === "\n") breakLine(scanner, scanner.softBreak);
+  else pushText(scanner, char, 1);
+}
+function parseInline(markdown, options = {}) {
+  const scanner = createScanner(markdown, options);
+  while (scanner.pos < markdown.length) {
+    const plain = matchAt(PLAIN, markdown, scanner.pos);
+    if (plain) plainRun(scanner, plain[0]);
+    else scanSpecial(scanner, markdown[scanner.pos]);
+  }
+  processEmphasis(scanner.delimiters, 0);
+  pairTags(scanner.items);
+  return flattenItems(scanner.items);
+}
+
+// src/engine/markdown/inline/escape-text.ts
+var ALWAYS_ESCAPED = /[\\`*_[\]<~$]/;
+var WORD_CHAR = /^[\p{L}\p{N}]$/u;
+var LITERAL_AFTER_BACKSLASH = /^[^\s!-/:-@[-`{-~]$/;
+var ENTITY_LIKE = /&#?[A-Za-z0-9]+;/y;
+var ORDERED_MARKER = /[0-9]+(?=[.)])/y;
+var LINE_START_SYNTAX = /* @__PURE__ */ new Set(["#", ">", "=", "+", "-"]);
+var WHITESPACE_ENTITY = { " ": "&#32;", "	": "&#9;" };
+function needsEscape(text2, index) {
+  const char = text2[index];
+  if (char === "_") return !(WORD_CHAR.test(_nullishCoalesce(text2[index - 1], () => ( ""))) && WORD_CHAR.test(_nullishCoalesce(text2[index + 1], () => ( ""))));
+  if (char === "\\") return !LITERAL_AFTER_BACKSLASH.test(_nullishCoalesce(text2[index + 1], () => ( "")));
+  return true;
+}
+function escapeEntityAmpersands(value) {
+  return value.replace(/&(?=#?[A-Za-z0-9]+;)/g, "\\&");
+}
+function breaksWithTag(text2, index, ctx) {
+  if (ctx.hardBreak === "br") return true;
+  const startsRegion = index === 0 ? !ctx.previous || ctx.previous === "\n" : text2[index - 1] === "\n";
+  const endsRegion = index === text2.length - 1 && !ctx.following;
+  return startsRegion || endsRegion;
+}
+function escapeText(text2, ctx) {
+  const last = text2.length - 1;
+  let atLineStart = ctx.lineStart;
+  let out = "";
+  for (let i = 0; i <= last; i++) {
+    const char = text2[i];
+    if (char === "\n") {
+      const tag = breaksWithTag(text2, i, ctx);
+      out += tag ? "<br>" : "\\\n";
+      atLineStart = !tag;
+      continue;
+    }
+    const lineStart = atLineStart;
+    atLineStart = false;
+    const ordered = lineStart && ctx.escapeLineStart ? matchAt(ORDERED_MARKER, text2, i) : null;
+    if (ordered) {
+      out += `${ordered[0]}\\${text2[i + ordered[0].length]}`;
+      i += ordered[0].length;
+    } else if (char === " " || char === "	") {
+      const lineEnd = text2[i + 1] === "\n" || i === last && ctx.lineEnd;
+      out += lineStart || lineEnd ? WHITESPACE_ENTITY[char] : char;
+    } else if (ALWAYS_ESCAPED.test(char) && needsEscape(text2, i)) {
+      out += `\\${char}`;
+    } else if (char === "&") {
+      out += matchAt(ENTITY_LIKE, text2, i) ? "\\&" : "&";
+    } else if (char === "!") {
+      const bracket = i === last ? ctx.next[0] === "[" : text2[i + 1] === "[";
+      out += bracket ? "\\!" : "!";
+    } else if (char === "|" && ctx.escapePipes) {
+      out += "\\|";
+    } else if (lineStart && ctx.escapeLineStart && LINE_START_SYNTAX.has(char)) {
+      out += `\\${char}`;
+    } else {
+      out += char;
+    }
+  }
+  return out;
+}
+
+// src/engine/markdown/inline/data-attributes.ts
+function dataAttributes(attrs, prefix = "data-attr-") {
+  return Object.keys(_nullishCoalesce(attrs, () => ( {}))).sort(compareCodeUnits).map((key) => [`${prefix}${key}`, attrs[key]]);
+}
+
+// src/engine/render/html-node.ts
+var ATTRIBUTE_NAME = /^[A-Za-z][A-Za-z0-9_.:-]*$/;
+var writtenAttrs = (attrs) => attrs.filter((attr) => attr[1] !== void 0 && ATTRIBUTE_NAME.test(attr[0]));
+var textOf = (nodes) => nodes.map((node) => typeof node === "string" ? node : node.tag === "br" ? " " : textOf(node.children)).join("");
+var nodeText = (nodes) => textOf(nodes).replace(/\s+/g, " ").trim();
+var element = (tag, attrs = [], children = [], html) => ({
+  tag,
+  attrs,
+  children,
+  html
+});
+
+// src/engine/render/plain-mark-tags.ts
+var PLAIN_MARK_TAGS = /* @__PURE__ */ new Map([
+  ["bold", "strong"],
+  ["italic", "em"],
+  ["underline", "u"],
+  ["strike", "s"],
+  ["sub", "sub"],
+  ["sup", "sup"],
+  ["code", "code"]
+]);
+
+// src/engine/render/mark-node.ts
+function markElement(mark) {
+  const plain = PLAIN_MARK_TAGS.get(mark.type);
+  if (plain) return element(plain);
+  const attrs = _nullishCoalesce(mark.attrs, () => ( {}));
+  switch (mark.type) {
+    case "link": {
+      const href = sanitizeHref(_nullishCoalesce(attrs.href, () => ( "")));
+      return href === null ? null : element("a", [["href", href], ["title", attrs.title], ["rel", "noopener noreferrer"]]);
+    }
+    case "comment":
+      return element("span", [["data-comment", _nullishCoalesce(attrs.id, () => ( ""))]]);
+    case "highlight":
+      return element("mark", [["data-color", attrs.color || void 0]]);
+    case "color":
+      return element("span", [["data-color", _nullishCoalesce(attrs.color, () => ( ""))]]);
+    case "background":
+      return element("span", [["data-bg", _nullishCoalesce(attrs.color, () => ( ""))]]);
+    default:
+      return element("span", [["data-mark", mark.type], ...dataAttributes(attrs)]);
+  }
+}
+
+// src/engine/markdown/inline/html-marks.ts
+function escapeAttribute(value, escapePipes) {
+  const escaped = value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/\n/g, "&#10;");
+  return escapePipes ? escaped.replace(/\|/g, "&#124;") : escaped;
+}
+function htmlTag(name, attributes, escapePipes) {
+  const written = attributes.map(([key, value]) => ` ${key}="${escapeAttribute(value, escapePipes)}"`).join("");
+  return { open: `<${name}${written}>`, close: `</${name}>` };
+}
+function markTag(mark, escapePipes) {
+  const { tag, attrs } = markElement(mark);
+  const written = attrs.filter((attr) => attr[1] !== void 0);
+  return htmlTag(mark.type === "strike" ? "del" : tag, written, escapePipes);
+}
+
+// src/engine/markdown/inline/link-markdown.ts
+function escapeFor(value, characters, escapePipes) {
+  const escaped = value.replace(characters, "\\$&");
+  const piped = escapePipes ? escaped.replace(/\|/g, "\\|") : escaped;
+  return escapeEntityAmpersands(piped).replace(/\n/g, "&#10;");
+}
+function readsBackAs(destination, href) {
+  const parsed = parseLinkDestination(`${destination})`, 0);
+  return _optionalChain([parsed, 'optionalAccess', _27 => _27.value]) === href && parsed.end === destination.length;
+}
+function linkDestination(href, escapePipes) {
+  const raw = escapeFor(href, /\\/g, escapePipes);
+  return readsBackAs(raw, href) ? raw : `<${escapeFor(href, /[\\<>]/g, escapePipes)}>`;
+}
+function linkClose(mark, escapePipes) {
+  const href = _nullishCoalesce(_optionalChain([mark, 'access', _28 => _28.attrs, 'optionalAccess', _29 => _29.href]), () => ( ""));
+  const title = _optionalChain([mark, 'access', _30 => _30.attrs, 'optionalAccess', _31 => _31.title]);
+  if (!title) return `](${linkDestination(href, escapePipes)})`;
+  const destination = href === "" ? "<>" : linkDestination(href, escapePipes);
+  return `](${destination} "${escapeFor(title, /[\\"]/g, escapePipes)}")`;
+}
+function autolinkMarkdown(text2, mark) {
+  if (_optionalChain([mark, 'access', _32 => _32.attrs, 'optionalAccess', _33 => _33.title])) return null;
+  const candidate = `<${text2}>`;
+  const parsed = parseAutolink(candidate, 0);
+  if (_optionalChain([parsed, 'optionalAccess', _34 => _34.end]) !== candidate.length) return null;
+  return parsed.value.text === text2 && parsed.value.href === _optionalChain([mark, 'access', _35 => _35.attrs, 'optionalAccess', _36 => _36.href]) ? candidate : null;
+}
+
+// src/engine/markdown/inline/atom-markdown.ts
+var MENTION_KEYS = /* @__PURE__ */ new Set(["id", "label", "kind"]);
+var DIGIT2 = /[0-9]/;
+var MATH_EDGE_HAZARD = /^\s|\s$|\\$/;
+var TRAILING_SPACE = /\s$/;
+function hasMentionShape(attrs) {
+  const { id, label, kind } = attrs;
+  if (!Object.keys(attrs).every((key) => MENTION_KEYS.has(key))) return false;
+  if (!id || label === void 0 || kind !== void 0 && (!kind || kind.includes(":"))) return false;
+  return kind !== void 0 || !id.includes(":");
+}
+function mentionHref({ id, kind }) {
+  return kind === void 0 ? `mention:${id}` : `mention:${kind}:${id}`;
+}
+function mentionMarkdown(attrs, options) {
+  const label = escapeText(attrs.label, {
+    lineStart: false,
+    lineEnd: false,
+    escapeLineStart: options.escapeLineStart,
+    escapePipes: options.escapePipes,
+    hardBreak: options.hardBreak,
+    next: "]",
+    previous: "@",
+    following: "]"
+  });
+  return `[@${label}](${linkDestination(mentionHref(attrs), options.escapePipes)})`;
+}
+function isPrettyMath(attrs, before, after, options) {
+  const { latex } = attrs;
+  if (Object.keys(attrs).length !== 1 || !latex || /[$\n]/.test(latex)) return false;
+  if (options.escapePipes && latex.includes("|")) return false;
+  const pricelike = DIGIT2.test(latex[0]) && (before === "" || TRAILING_SPACE.test(before));
+  return !MATH_EDGE_HAZARD.test(latex) && !DIGIT2.test(_nullishCoalesce(after[0], () => ( ""))) && !pricelike;
+}
+function writesMention(node, options) {
+  if (options.strict || node.type !== "mention" || !hasMentionShape(node.attrs)) return false;
+  const href = mentionHref(node.attrs);
+  return sanitizeHref(href) === href && !node.marks.some((mark) => mark.type === "link");
+}
+function atomMarkdown(node, before, after, options) {
+  if (writesMention(node, options)) return mentionMarkdown(node.attrs, options);
+  if (!options.strict && node.type === "math" && isPrettyMath(node.attrs, before, after, options)) {
+    return `$${node.attrs.latex}$`;
+  }
+  const attributes = [["data-atom", node.type], ...dataAttributes(node.attrs)];
+  const { open, close } = htmlTag("span", attributes, options.escapePipes);
+  return open + close;
+}
+
+// src/engine/markdown/inline/code-markdown.ts
+var BACKTICK_RUN = /`+/g;
+var NEEDS_PADDING = /^[ `]|[ `]$/;
+function codeSpan2(content) {
+  const lengths = new Set((_nullishCoalesce(content.match(BACKTICK_RUN), () => ( []))).map((run) => run.length));
+  let fence = 1;
+  while (lengths.has(fence)) fence++;
+  const padding = NEEDS_PADDING.test(content) && /[^ ]/.test(content) ? " " : "";
+  const ticks = "`".repeat(fence);
+  return `${ticks}${padding}${content}${padding}${ticks}`;
+}
+
+// src/engine/markdown/inline/literal-ranges.ts
+function allText(children) {
+  let content = "";
+  for (const child of children) {
+    if (child.kind !== "leaf" || child.node.kind !== "text") return null;
+    content += child.node.text;
+  }
+  return content;
+}
+function autolinkOf(range, options) {
+  const text2 = options.strict || range.mark.type !== "link" ? null : allText(range.children);
+  if (text2 === null || options.escapePipes && text2.includes("|")) return null;
+  return autolinkMarkdown(text2, range.mark);
+}
+function codeSpanOf(range, options) {
+  const content = range.mark.type === "code" ? allText(range.children) : null;
+  if (content === null || options.escapePipes && content.includes("|")) return null;
+  return codeSpan2(content);
+}
+function renderLiteral(range, options) {
+  return _nullishCoalesce(autolinkOf(range, options), () => ( codeSpanOf(range, options)));
+}
+
+// src/engine/markdown/inline/edge-chars.ts
+var OPENER = "<";
+function textStart(text2) {
+  const code = text2.codePointAt(0);
+  if (code === void 0) return "";
+  const first = String.fromCodePoint(code);
+  if (first === "\n") return first;
+  return ALWAYS_ESCAPED.test(first) ? "\\" : first;
+}
+function startOf(child, options) {
+  if (child.kind === "range") return child.mark.type === "link" && !autolinkOf(child, options) ? "[" : OPENER;
+  const { node } = child;
+  if (node.kind === "text") return textStart(node.text);
+  return writesMention(node, options) ? "[" : OPENER;
+}
+
+// src/engine/markdown/inline/inline-tree.ts
+function buildTree(nodes) {
+  const root = [];
+  const open = [];
+  nodes.forEach((node, index) => {
+    let shared = 0;
+    while (shared < open.length && shared < node.marks.length && sameMark(open[shared].mark, node.marks[shared])) {
+      shared++;
+    }
+    open.length = shared;
+    for (const mark of node.marks.slice(shared)) {
+      const range = { kind: "range", mark, children: [] };
+      (_nullishCoalesce(_optionalChain([open, 'access', _37 => _37.at, 'call', _38 => _38(-1), 'optionalAccess', _39 => _39.children]), () => ( root))).push(range);
+      open.push(range);
+    }
+    (_nullishCoalesce(_optionalChain([open, 'access', _40 => _40.at, 'call', _41 => _41(-1), 'optionalAccess', _42 => _42.children]), () => ( root))).push({ kind: "leaf", node, index });
+  });
+  return root;
+}
+
+// src/engine/markdown/inline/emphasis-delimiter.ts
+var CANDIDATES = {
+  bold: ["**", "__"],
+  italic: ["_", "*"],
+  strike: ["~~"]
+};
+function firstCodePoint(value) {
+  const code = value.codePointAt(0);
+  return code === void 0 ? "" : String.fromCodePoint(code);
+}
+function lastCodePoint(value) {
+  return _nullishCoalesce(Array.from(value.slice(-2)).pop(), () => ( ""));
+}
+function endsWithDelimiter(value, char) {
+  if (!value.endsWith(char)) return false;
+  let slashes = 0;
+  for (let at = value.length - 2; at >= 0 && value[at] === "\\"; at--) slashes++;
+  return slashes % 2 === 0;
+}
+function fuses(char, before, inner) {
+  return endsWithDelimiter(before, char) || inner.startsWith(char) || endsWithDelimiter(inner, char);
+}
+function chooseDelimiter(type, before, inner, after) {
+  const previous = lastCodePoint(before);
+  const first = firstCodePoint(inner);
+  const last = lastCodePoint(inner);
+  const following = firstCodePoint(after);
+  const chosen = CANDIDATES[type].find((delimiter) => {
+    const char = delimiter[0];
+    if (fuses(char, before, inner)) return false;
+    return classifyDelimiterRun(previous, first, char).canOpen && classifyDelimiterRun(last, following, char).canClose;
+  });
+  return _nullishCoalesce(chosen, () => ( null));
+}
+
+// src/engine/markdown/inline/range-wrapper.ts
+function isEmphasis(type) {
+  return type === "bold" || type === "italic" || type === "strike";
+}
+function linkOpen(mark, inner) {
+  return _optionalChain([mark, 'access', _43 => _43.attrs, 'optionalAccess', _44 => _44.href, 'optionalAccess', _45 => _45.startsWith, 'call', _46 => _46("mention:")]) && inner.startsWith("@") ? "[<u></u>" : "[";
+}
+function wrapRange(mark, before, inner, after, options) {
+  if (mark.type === "link") return { open: linkOpen(mark, inner), close: linkClose(mark, options.escapePipes) };
+  if (options.strict || !isEmphasis(mark.type)) return markTag(mark, options.escapePipes);
+  const following = after === "\n" ? "\\" : after;
+  const delimiter = chooseDelimiter(mark.type, before, inner, following);
+  return delimiter ? { open: delimiter, close: delimiter } : markTag(mark, options.escapePipes);
+}
+
+// src/engine/markdown/inline/render-inline.ts
+var TAIL_LENGTH = 8;
+function tailOf(before, piece) {
+  return (piece.length >= TAIL_LENGTH ? piece : before + piece).slice(-TAIL_LENGTH);
+}
+function append(frame, piece) {
+  frame.out += piece;
+  frame.tail = tailOf(frame.tail, piece);
+}
+function rangeFrame(range, before, after) {
+  const tail = tailOf(before, OPENER);
+  return { range, children: range.children, before, after, closing: OPENER, at: 0, out: "", tail };
+}
+function lastContent(node) {
+  if (!node) return "";
+  return node.kind === "text" ? node.text.slice(-1) : "\uFFFC";
+}
+function firstContent(node) {
+  if (!node) return "";
+  return node.kind === "text" ? node.text.slice(0, 1) : "\uFFFC";
+}
+function renderInline(nodes, options) {
+  function renderLeaf({ node, index }, before, after) {
+    if (node.kind === "atom") return atomMarkdown(node, before, after, options);
+    return escapeText(node.text, {
+      lineStart: before === "" || before.endsWith("\\\n"),
+      lineEnd: after === "" || after === "\n",
+      escapeLineStart: options.escapeLineStart,
+      escapePipes: options.escapePipes,
+      hardBreak: options.hardBreak,
+      next: after,
+      previous: lastContent(nodes[index - 1]),
+      following: firstContent(nodes[index + 1])
+    });
+  }
+  const root = { children: buildTree(nodes), before: "", after: "", closing: "", at: 0, out: "", tail: "" };
+  const stack = [root];
+  for (; ; ) {
+    const frame = stack[stack.length - 1];
+    if (frame.at < frame.children.length) {
+      const child = frame.children[frame.at++];
+      const next = frame.at < frame.children.length ? startOf(frame.children[frame.at], options) : frame.closing;
+      const literal = child.kind === "range" ? renderLiteral(child, options) : renderLeaf(child, frame.tail, next);
+      if (literal !== null) append(frame, literal);
+      else if (child.kind === "range") stack.push(rangeFrame(child, frame.tail, next));
+    } else {
+      stack.pop();
+      if (!frame.range) return frame.out;
+      const { open, close } = wrapRange(frame.range.mark, frame.before, frame.out, frame.after, options);
+      append(stack[stack.length - 1], open + frame.out + close);
+    }
+  }
+}
+
+// src/engine/markdown/inline/serialize-inline.ts
+function serializeInline(inline, options = {}) {
+  const nodes = normalizeInline(inline);
+  const base = {
+    escapeLineStart: _nullishCoalesce(options.escapeLineStart, () => ( false)),
+    escapePipes: _nullishCoalesce(options.escapePipes, () => ( false)),
+    hardBreak: _nullishCoalesce(options.hardBreak, () => ( "backslash"))
+  };
+  const pretty = renderInline(nodes, { ...base, strict: false });
+  return equalInline(parseInline(pretty), nodes) ? pretty : renderInline(nodes, { ...base, strict: true });
+}
+var inlineCodec = { parse: parseInline, serialize: serializeInline };
+
+// src/engine/model/new-id.ts
+function newId() {
+  const webCrypto = globalThis.crypto;
+  if (webCrypto && typeof webCrypto.randomUUID === "function") return webCrypto.randomUUID();
+  const random = () => Math.random().toString(36).slice(2, 10);
+  return `blk-${Date.now().toString(36)}-${random()}${random()}`;
+}
+
+// src/engine/markdown/block/lines.ts
+var LINE_BREAK = /\r\n|\r|\n/;
+var NULL_CHAR = /\0/g;
+var TAB_STOP = 4;
+var CODE_INDENT = 4;
+function splitLines(markdown) {
+  return markdown.replace(NULL_CHAR, "\uFFFD").split(LINE_BREAK);
+}
+var isSpaceOrTab = (char) => char === " " || char === "	";
+var isBlankChar = (char) => char === " " || char === "	" || char === "\n";
+function trimBlankEnd(text2) {
+  let end = text2.length;
+  while (end > 0 && isBlankChar(text2[end - 1])) end--;
+  return text2.slice(0, end);
+}
+function trimBlankStart(text2) {
+  let start = 0;
+  while (start < text2.length && isBlankChar(text2[start])) start++;
+  return text2.slice(start);
+}
+var trimBlank = (text2) => trimBlankStart(trimBlankEnd(text2));
+var Cursor = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this); }
+  __init() {this.line = ""}
+  __init2() {this.offset = 0}
+  __init3() {this.column = 0}
+  __init4() {this.partialTab = false}
+  reset(line) {
+    this.line = line;
+    this.offset = 0;
+    this.column = 0;
+    this.partialTab = false;
+  }
+  scan() {
+    let index = this.offset;
+    let column = this.column;
+    for (; index < this.line.length; index++) {
+      const char = this.line[index];
+      if (char === " ") column++;
+      else if (char === "	") column += TAB_STOP - column % TAB_STOP;
+      else break;
+    }
+    return { index, column };
+  }
+  get indent() {
+    return this.scan().column - this.column;
+  }
+  get indented() {
+    return this.indent >= CODE_INDENT;
+  }
+  get blank() {
+    return this.scan().index >= this.line.length;
+  }
+  get text() {
+    return this.line.slice(this.scan().index);
+  }
+  get next() {
+    return this.line[this.offset];
+  }
+  advanceToNonspace() {
+    const { index, column } = this.scan();
+    this.offset = index;
+    this.column = column;
+    this.partialTab = false;
+  }
+  advance(count, columns = false) {
+    let remaining = count;
+    while (remaining > 0 && this.offset < this.line.length) {
+      if (this.line[this.offset] !== "	") {
+        this.partialTab = false;
+        this.offset++;
+        this.column++;
+        remaining--;
+        continue;
+      }
+      const width = TAB_STOP - this.column % TAB_STOP;
+      if (!columns) {
+        this.partialTab = false;
+        this.column += width;
+        this.offset++;
+        remaining--;
+        continue;
+      }
+      const step = Math.min(width, remaining);
+      this.partialTab = width > remaining;
+      this.column += step;
+      if (!this.partialTab) this.offset++;
+      remaining -= step;
+    }
+  }
+  rest() {
+    if (!this.partialTab) return this.line.slice(this.offset);
+    return " ".repeat(TAB_STOP - this.column % TAB_STOP) + this.line.slice(this.offset + 1);
+  }
+  mark() {
+    return { offset: this.offset, column: this.column, partialTab: this.partialTab };
+  }
+  restore(snapshot) {
+    this.offset = snapshot.offset;
+    this.column = snapshot.column;
+    this.partialTab = snapshot.partialTab;
+  }
+}, _class);
+
+// src/engine/markdown/block/block-tree.ts
+function canContain(parent, child) {
+  switch (parent.kind) {
+    case "list":
+      return child === "item";
+    case "document":
+    case "quote":
+    case "item":
+    case "details":
+      return child !== "item";
+    default:
+      return false;
+  }
+}
+var joinLines = (lines) => trimBlankEnd(lines.join("\n"));
+function textLinesOf(node) {
+  if (_optionalChain([node, 'optionalAccess', _47 => _47.kind]) === "paragraph") return node.lines;
+  return _optionalChain([node, 'optionalAccess', _48 => _48.kind]) === "html" ? node.lines.map((line) => trimBlankStart(line)) : null;
+}
+
+// src/engine/markdown/block/references.ts
+function skipSpaces(src, pos) {
+  let at = pos;
+  while (src[at] === " " || src[at] === "	") at++;
+  return at;
+}
+function skipSpacesAndOneNewline(src, pos) {
+  const at = skipSpaces(src, pos);
+  return src[at] === "\n" ? skipSpaces(src, at + 1) : at;
+}
+function endOfLine(src, pos) {
+  const at = skipSpaces(src, pos);
+  if (at >= src.length) return src.length;
+  return src[at] === "\n" ? at + 1 : -1;
+}
+function parseDefinition(src) {
+  const label = parseLinkLabel(src, 0);
+  if (!label || label.value.trim() === "" || src[label.end] !== ":") return null;
+  const destination = parseLinkDestination(src, skipSpacesAndOneNewline(src, label.end + 1));
+  if (!destination) return null;
+  const titleAt = skipSpacesAndOneNewline(src, destination.end);
+  const title = titleAt > destination.end ? parseLinkTitle(src, titleAt) : null;
+  const titleEnd = title ? endOfLine(src, title.end) : -1;
+  if (title && titleEnd >= 0) {
+    const target = title.value ? { href: destination.value, title: title.value } : { href: destination.value };
+    return { label: label.value, target, end: titleEnd };
+  }
+  const end = endOfLine(src, destination.end);
+  return end < 0 ? null : { label: label.value, target: { href: destination.value }, end };
+}
+function takeReferenceDefinitions(lines, refs) {
+  if (!_optionalChain([lines, 'access', _49 => _49[0], 'optionalAccess', _50 => _50.startsWith, 'call', _51 => _51("[")])) return lines;
+  let text2 = lines.join("\n");
+  while (text2.startsWith("[")) {
+    const definition = parseDefinition(text2);
+    if (!definition) break;
+    const key = normalizeLabel(definition.label);
+    if (!refs.has(key)) refs.set(key, definition.target);
+    text2 = text2.slice(definition.end);
+  }
+  return text2 === "" ? [] : text2.split("\n");
+}
+
+// src/engine/markdown/block/summary-text.ts
+var OPENING_TAG = /^\s*<summary(?:\s[^>]*)?>/i;
+var FINAL_CLOSING_TAG = /<\/summary>[ \t]*$/i;
+var FIRST_CLOSING_TAG = /<\/summary>[\s\S]*$/i;
+function summaryText(lines) {
+  const text2 = lines.join("\n").replace(OPENING_TAG, "");
+  return trimBlank(text2.replace(FINAL_CLOSING_TAG.test(text2) ? FINAL_CLOSING_TAG : FIRST_CLOSING_TAG, ""));
+}
+
+// src/engine/markdown/block/parser-state.ts
+var MAX_NESTING = 64;
+function createParser() {
+  const document = { kind: "document", children: [] };
+  return { document, stack: [document], refs: /* @__PURE__ */ new Map(), cursor: new Cursor(), matched: 1 };
+}
+var tipOf = (parser) => parser.stack[parser.stack.length - 1];
+var canNest = (parser) => parser.stack.length < MAX_NESTING;
+var childrenOf = (node) => node.children;
+function closeTip(parser) {
+  const node = parser.stack.pop();
+  if (_optionalChain([node, 'optionalAccess', _52 => _52.kind]) === "paragraph") {
+    node.lines = takeReferenceDefinitions(node.lines, parser.refs);
+    if (node.lines.length === 0) childrenOf(tipOf(parser)).pop();
+  } else if (_optionalChain([node, 'optionalAccess', _53 => _53.kind]) === "html" && node.summaryOf) {
+    childrenOf(tipOf(parser)).pop();
+    node.summaryOf.summary = summaryText(node.lines);
+  } else if (_optionalChain([node, 'optionalAccess', _54 => _54.kind]) === "code" && node.fence === null) {
+    while (node.lines.length > 0 && /^ *$/.test(node.lines[node.lines.length - 1])) node.lines.pop();
+  }
+}
+function closeUnmatched(parser) {
+  while (parser.stack.length > parser.matched) closeTip(parser);
+}
+function addChild(parser, node) {
+  closeUnmatched(parser);
+  while (!canContain(tipOf(parser), node.kind)) closeTip(parser);
+  childrenOf(tipOf(parser)).push(node);
+  parser.stack.push(node);
+  parser.matched = parser.stack.length;
+}
+
+// src/engine/markdown/block/container-blocks.ts
+var BULLET2 = /^[*+-]/;
+var ORDERED2 = /^(\d{1,9})([.)])/;
+var MAX_MARKER_SPACES = 5;
+function consumeQuoteMarker(cursor) {
+  cursor.advanceToNonspace();
+  cursor.advance(1);
+  if (isSpaceOrTab(cursor.next)) cursor.advance(1, true);
+}
+var quoteStart = (parser) => {
+  const { cursor } = parser;
+  if (cursor.indented || !cursor.text.startsWith(">") || !canNest(parser)) return "none";
+  consumeQuoteMarker(cursor);
+  addChild(parser, { kind: "quote", children: [] });
+  return "container";
+};
+function continueQuote(parser) {
+  const { cursor } = parser;
+  if (cursor.indented || !cursor.text.startsWith(">")) return "unmatched";
+  consumeQuoteMarker(cursor);
+  return "matched";
+}
+function continueItem(parser, item) {
+  const { cursor } = parser;
+  if (cursor.blank) {
+    if (item.children.length === 0) return "unmatched";
+    cursor.advanceToNonspace();
+  } else if (cursor.indent >= item.contentOffset) {
+    cursor.advance(item.contentOffset, true);
+  } else {
+    return "unmatched";
+  }
+  return "matched";
+}
+var sameList = (a, b) => a.ordered === b.ordered && a.char === b.char;
+function readMarker(text2, interrupting) {
+  const bullet = BULLET2.exec(text2);
+  if (bullet) return { marker: { ordered: false, char: bullet[0], number: 0 }, width: 1 };
+  const ordered = ORDERED2.exec(text2);
+  if (!ordered || interrupting && Number(ordered[1]) !== 1) return null;
+  return { marker: { ordered: true, char: ordered[2], number: Number(ordered[1]) }, width: ordered[0].length };
+}
+function consumeMarkerSpacing(cursor, width) {
+  const afterMarker = cursor.mark();
+  const startColumn = cursor.column;
+  do
+    cursor.advance(1, true);
+  while (cursor.column - startColumn < MAX_MARKER_SPACES && isSpaceOrTab(cursor.next));
+  const spaces = cursor.column - startColumn;
+  if (spaces >= MAX_MARKER_SPACES || spaces < 1 || cursor.offset >= cursor.line.length) {
+    cursor.restore(afterMarker);
+    if (isSpaceOrTab(cursor.next)) cursor.advance(1, true);
+    return width + 1;
+  }
+  return width + spaces;
+}
+var itemStart = (parser, container) => {
+  const { cursor } = parser;
+  if (cursor.indented || !canNest(parser)) return "none";
+  const interrupting = container.kind === "paragraph";
+  const text2 = cursor.text;
+  const read = readMarker(text2, interrupting);
+  if (!read) return "none";
+  const next = text2[read.width];
+  if (next !== void 0 && !isSpaceOrTab(next)) return "none";
+  if (interrupting && trimBlank(text2.slice(read.width)) === "") return "none";
+  const markerOffset = cursor.indent;
+  cursor.advanceToNonspace();
+  cursor.advance(read.width, true);
+  const contentOffset = markerOffset + consumeMarkerSpacing(cursor, read.width);
+  closeUnmatched(parser);
+  const list = tipOf(parser);
+  if (list.kind !== "list" || !sameList(list.marker, read.marker)) {
+    addChild(parser, { kind: "list", marker: read.marker, children: [] });
+  }
+  addChild(parser, { kind: "item", marker: read.marker, contentOffset, children: [] });
+  return "container";
+};
+
+// src/engine/markdown/block/details-blocks.ts
+var DETAILS_OPEN = /^<details(\s[^>]*)?>/i;
+var DETAILS_CLOSE = /^<\/details>[ \t]*$/i;
+var SUMMARY_OPEN = /^<summary(?:\s[^>]*)?>/i;
+var SUMMARY_CLOSE = /<\/summary>(?:[ \t]*$|(?![\s\S]*\\$))/i;
+var OPEN_ATTRIBUTE = /(?:^|\s)open(?=[\s=/]|$)/i;
+function findOpenDetails(parser, limit) {
+  const { cursor, stack } = parser;
+  if (cursor.indented || !DETAILS_CLOSE.test(cursor.text)) return -1;
+  for (let at = limit - 1; at > 0; at--) if (stack[at].kind === "details") return at;
+  return -1;
+}
+var detailsStart = (parser) => {
+  const { cursor } = parser;
+  const match = cursor.indented || !canNest(parser) ? null : DETAILS_OPEN.exec(cursor.text);
+  if (!match) return "none";
+  cursor.advanceToNonspace();
+  cursor.advance(match[0].length);
+  addChild(parser, { kind: "details", open: OPEN_ATTRIBUTE.test(_nullishCoalesce(match[1], () => ( ""))), summary: null, children: [] });
+  return "container";
+};
+var summaryStart = (parser, container) => {
+  const { cursor } = parser;
+  const fresh = container.kind === "details" && container.summary === null && container.children.length === 0;
+  if (!fresh || cursor.indented || !SUMMARY_OPEN.test(cursor.text)) return "none";
+  addChild(parser, { kind: "html", ends: SUMMARY_CLOSE, lines: [], summaryOf: container });
+  return "leaf";
+};
+var detailsEnd = (parser) => {
+  const at = findOpenDetails(parser, parser.matched);
+  if (at < 0) return "none";
+  while (parser.stack.length > at) closeTip(parser);
+  parser.matched = parser.stack.length;
+  return "done";
+};
+
+// src/engine/markdown/block/quoin-comment.ts
+var TYPE = "[A-Za-z][\\w.:-]*";
+var COMMENT = new RegExp(`^<!--\\s*quoin:(${TYPE})(?:\\s+(\\{.*\\}))?\\s*-->[ \\t]*$`);
+var TYPE_NAME = new RegExp(`^${TYPE}$`);
+var isQuoinType = (type) => TYPE_NAME.test(type);
+function parseQuoinComment(line) {
+  const match = COMMENT.exec(line);
+  if (!match) return null;
+  const type = match[1] === "toc" ? "TOC" : match[1];
+  if (match[2] === void 0) return { type, data: {}, indent: 0 };
+  let payload;
+  try {
+    payload = JSON.parse(match[2]);
+  } catch (e) {
+    return null;
+  }
+  const { data = {}, indent = 0 } = payload;
+  if (!isRecord(data) || typeof indent !== "number" || !Number.isInteger(indent) || indent < 0) return null;
+  return { type, data, indent };
+}
+
+// src/engine/markdown/block/html-blocks.ts
+var BLOCK_TAGS = "address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|nav|noframes|ol|optgroup|option|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul";
+var TAG_NAME = "[A-Za-z][A-Za-z0-9-]*";
+var ATTRIBUTE2 = `\\s+[A-Za-z_:][A-Za-z0-9_.:-]*(?:\\s*=\\s*(?:[^"'=<>\`\\x00-\\x20]+|'[^']*'|"[^"]*"))?`;
+var COMPLETE_TAG = new RegExp(`^(?:<${TAG_NAME}(?:${ATTRIBUTE2})*\\s*/?>|</${TAG_NAME}\\s*>)\\s*$`);
+var HTML_KINDS = [
+  { start: /^<(?:script|pre|textarea|style)(?:\s|>|$)/i, end: /<\/(?:script|pre|textarea|style)>/i, interrupts: true },
+  { start: /^<!--/, end: /-->/, interrupts: true },
+  { start: /^<\?/, end: /\?>/, interrupts: true },
+  { start: /^<![A-Za-z]/, end: />/, interrupts: true },
+  { start: /^<!\[CDATA\[/, end: /\]\]>/, interrupts: true },
+  { start: new RegExp(`^</?(?:${BLOCK_TAGS})(?:\\s|/?>|$)`, "i"), end: null, interrupts: true },
+  { start: COMPLETE_TAG, end: null, interrupts: false }
+];
+var startsHtmlBlock = (line) => HTML_KINDS.some(({ start }) => start.test(line));
+var htmlBlockStart = (parser, container) => {
+  const { cursor } = parser;
+  if (cursor.indented || !cursor.text.startsWith("<")) return "none";
+  const text2 = cursor.text;
+  const lazy = parser.matched < parser.stack.length && !cursor.blank && tipOf(parser).kind === "paragraph";
+  const canStandAlone = container.kind !== "paragraph" && !lazy;
+  const kind = HTML_KINDS.find(({ start, interrupts }) => start.test(text2) && (interrupts || canStandAlone));
+  if (!kind) return "none";
+  addChild(parser, { kind: "html", ends: kind.end, lines: [] });
+  return "leaf";
+};
+var quoinCommentStart = (parser) => {
+  const { cursor } = parser;
+  const comment = cursor.indented ? null : parseQuoinComment(cursor.text);
+  if (!comment) return "none";
+  addChild(parser, { kind: "quoin", ...comment });
+  return "done";
+};
+function continueHtml(parser, node, index) {
+  if (node.ends !== null && !node.summaryOf) return "matched";
+  if (parser.cursor.blank) return "unmatched";
+  return node.ends === null && findOpenDetails(parser, index) >= 0 ? "unmatched" : "matched";
+}
+
+// src/engine/markdown/block/leaf-blocks.ts
+var ATX_HEADING = /^#{1,6}(?:[ \t]+|$)/;
+var MATH_FENCE = /^\$\$[ \t]*$/;
+var CLOSING_FENCE = /^(`{3,}|~{3,}|\${2,})[ \t]*$/;
+var THEMATIC_BREAK = /^(?:(?:\*[ \t]*){3,}|(?:_[ \t]*){3,}|(?:-[ \t]*){3,})$/;
+var SETEXT_UNDERLINE = /^(?:=+|-+)[ \t]*$/;
+function headingText(raw) {
+  const end = trimBlankEnd(raw).length;
+  let start = end;
+  while (start > 0 && raw[start - 1] === "#") start--;
+  const closing = start < end && (start === 0 || isSpaceOrTab(raw[start - 1]));
+  return trimBlank(raw.slice(0, closing ? start : end));
+}
+function openingFence(text2) {
+  const char = text2[0];
+  if (char !== "`" && char !== "~") return null;
+  let length = 0;
+  while (text2[length] === char) length++;
+  const hasBacktickInfo = char === "`" && text2.includes("`", length);
+  return length < 3 || hasBacktickInfo ? null : { char, length };
+}
+var isVerbatim = (node) => node.kind === "code" || node.kind === "math" || node.kind === "html";
+var atxHeadingStart = (parser) => {
+  const { cursor } = parser;
+  const match = cursor.indented ? null : ATX_HEADING.exec(cursor.text);
+  if (!match) return "none";
+  const text2 = headingText(cursor.text.slice(match[0].length));
+  addChild(parser, { kind: "heading", level: match[0].trim().length, text: text2 });
+  return "done";
+};
+var codeFenceStart = (parser) => {
+  const { cursor } = parser;
+  const text2 = cursor.text;
+  const opening = cursor.indented ? null : openingFence(text2);
+  if (!opening) return "none";
+  const fence = { ...opening, offset: cursor.indent };
+  addChild(parser, { kind: "code", fence, info: unescapeMarkdown(trimBlank(text2.slice(opening.length))), lines: [] });
+  return "done";
+};
+var mathFenceStart = (parser) => {
+  const { cursor } = parser;
+  if (cursor.indented || !MATH_FENCE.test(cursor.text)) return "none";
+  addChild(parser, { kind: "math", fence: { char: "$", length: 2, offset: cursor.indent }, lines: [] });
+  return "done";
+};
+var thematicBreakStart = (parser) => {
+  const { cursor } = parser;
+  if (cursor.indented || !THEMATIC_BREAK.test(cursor.text)) return "none";
+  addChild(parser, { kind: "break" });
+  return "done";
+};
+var setextHeadingStart = (parser, container) => {
+  const { cursor } = parser;
+  if (container.kind !== "paragraph" || cursor.indented || !SETEXT_UNDERLINE.test(cursor.text)) return "none";
+  const lines = takeReferenceDefinitions(container.lines, parser.refs);
+  container.lines = lines;
+  if (lines.length === 0) return "none";
+  container.lines = [];
+  addChild(parser, { kind: "heading", level: cursor.text.startsWith("=") ? 1 : 2, text: trimBlank(lines.join("\n")) });
+  return "done";
+};
+var indentedCodeStart = (parser, container) => {
+  const { cursor } = parser;
+  const tip = tipOf(parser);
+  if (!cursor.indented || cursor.blank || tip.kind === "paragraph" || container.kind === "table") return "none";
+  cursor.advance(CODE_INDENT, true);
+  addChild(parser, { kind: "code", fence: null, info: "", lines: [] });
+  return "leaf";
+};
+function closesFence(fence, text2) {
+  const match = CLOSING_FENCE.exec(text2);
+  return match !== null && match[1][0] === fence.char && match[1].length >= fence.length;
+}
+function continueCode(parser, fence) {
+  const { cursor } = parser;
+  if (fence === null) {
+    if (cursor.indented) cursor.advance(CODE_INDENT, true);
+    else if (cursor.blank) cursor.advanceToNonspace();
+    else return "unmatched";
+    return "matched";
+  }
+  if (!cursor.indented && closesFence(fence, cursor.text)) {
+    parser.stack.pop();
+    return "consumed";
+  }
+  cursor.advance(Math.min(fence.offset, cursor.indent), true);
+  return "matched";
+}
+
+// src/engine/markdown/block/tables.ts
+var DELIMITER_CELL = /^:?-+:?$/;
+function endsInHardBreak(line) {
+  let backslashes = 0;
+  while (line[line.length - 1 - backslashes] === "\\") backslashes++;
+  return backslashes % 2 === 1;
+}
+function splitRow(line) {
+  const text2 = trimBlank(line);
+  const cells = [];
+  let cell = "";
+  for (let at = 0; at < text2.length; at++) {
+    if (text2[at] === "\\" && at + 1 < text2.length) {
+      cell += text2[at] + text2[at + 1];
+      at++;
+    } else if (text2[at] === "|") {
+      cells.push(cell);
+      cell = "";
+    } else {
+      cell += text2[at];
+    }
+  }
+  cells.push(cell);
+  if (text2.startsWith("|")) cells.shift();
+  if (cell === "" && text2.endsWith("|")) cells.pop();
+  return cells.map(trimBlank);
+}
+function alignOf(cell) {
+  const left = cell.startsWith(":");
+  const right = cell.endsWith(":");
+  if (left && right) return "center";
+  if (left) return "left";
+  return right ? "right" : null;
+}
+function parseDelimiterRow(line) {
+  if (!line.includes("|")) return null;
+  const cells = splitRow(line);
+  return cells.length > 0 && cells.every((cell) => DELIMITER_CELL.test(cell)) ? cells.map(alignOf) : null;
+}
+var tableStart = (parser, container) => {
+  const { cursor } = parser;
+  if (container.kind !== "paragraph" || cursor.indented || container.lines.length === 0) return "none";
+  const headerLine = container.lines[container.lines.length - 1];
+  const align = parseDelimiterRow(cursor.text);
+  if (!align || endsInHardBreak(headerLine)) return "none";
+  const header = splitRow(headerLine);
+  if (header.length !== align.length) return "none";
+  container.lines.pop();
+  addChild(parser, { kind: "table", align, header, rows: [] });
+  return "done";
+};
+function addTableRow(table, line) {
+  const cells = splitRow(line);
+  table.rows.push(table.header.map((_, column) => _nullishCoalesce(cells[column], () => ( ""))));
+}
+
+// src/engine/markdown/block/parse-blocks.ts
+var STARTS = [
+  quoteStart,
+  atxHeadingStart,
+  codeFenceStart,
+  mathFenceStart,
+  quoinCommentStart,
+  summaryStart,
+  detailsEnd,
+  detailsStart,
+  htmlBlockStart,
+  tableStart,
+  setextHeadingStart,
+  thematicBreakStart,
+  itemStart,
+  indentedCodeStart
+];
+function continueBlock(parser, node, index) {
+  switch (node.kind) {
+    case "quote":
+      return continueQuote(parser);
+    case "item":
+      return continueItem(parser, node);
+    case "list":
+    case "details":
+      return "matched";
+    case "code":
+    case "math":
+      return continueCode(parser, node.fence);
+    case "html":
+      return continueHtml(parser, node, index);
+    case "paragraph":
+    case "table":
+      return parser.cursor.blank ? "unmatched" : "matched";
+    default:
+      return "unmatched";
+  }
+}
+function matchOpenBlocks(parser) {
+  let matched = 1;
+  while (matched < parser.stack.length) {
+    const outcome = continueBlock(parser, parser.stack[matched], matched);
+    if (outcome === "consumed") return false;
+    if (outcome === "unmatched") break;
+    matched++;
+  }
+  parser.matched = matched;
+  return true;
+}
+function openNewBlocks(parser) {
+  let container = parser.stack[parser.matched - 1];
+  while (!isVerbatim(container)) {
+    let result = "none";
+    for (const start of STARTS) {
+      result = start(parser, container);
+      if (result !== "none") break;
+    }
+    if (result === "done") return false;
+    if (result === "none") {
+      parser.cursor.advanceToNonspace();
+      break;
+    }
+    container = tipOf(parser);
+    if (result === "leaf") break;
+  }
+  return true;
+}
+function addLine(parser, node) {
+  const { cursor } = parser;
+  if (node.kind === "paragraph") node.lines.push(trimBlankStart(cursor.rest()));
+  else if (node.kind === "code" || node.kind === "math") node.lines.push(cursor.rest());
+  else if (node.kind === "table") addTableRow(node, cursor.rest());
+  else if (node.kind === "html") {
+    const line = cursor.rest();
+    node.lines.push(line);
+    if (_optionalChain([node, 'access', _55 => _55.ends, 'optionalAccess', _56 => _56.test, 'call', _57 => _57(line)])) closeTip(parser);
+  } else if (!cursor.blank) {
+    addChild(parser, { kind: "paragraph", lines: [] });
+    cursor.advanceToNonspace();
+    addLine(parser, tipOf(parser));
+  }
+}
+function feedLine(parser, raw) {
+  parser.cursor.reset(raw);
+  if (!matchOpenBlocks(parser) || !openNewBlocks(parser)) return;
+  const tip = tipOf(parser);
+  if (parser.matched < parser.stack.length && !parser.cursor.blank && tip.kind === "paragraph") {
+    addLine(parser, tip);
+    return;
+  }
+  closeUnmatched(parser);
+  addLine(parser, tipOf(parser));
+}
+function parseBlocks(markdown) {
+  const parser = createParser();
+  for (const line of splitLines(markdown)) feedLine(parser, line);
+  while (parser.stack.length > 1) closeTip(parser);
+  return { document: parser.document, refs: parser.refs };
+}
+
+// src/engine/markdown/block/alert.ts
+var ALERT_LINE = /^\[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION)\][ \t]*$/;
+var ALERT_TONES = {
+  NOTE: "info",
+  TIP: "tip",
+  IMPORTANT: "success",
+  WARNING: "warning",
+  CAUTION: "danger"
+};
+function alertOf(quote) {
+  const [first, ...children] = quote.children;
+  const match = _optionalChain([first, 'optionalAccess', _58 => _58.kind]) === "paragraph" ? ALERT_LINE.exec(first.lines[0]) : null;
+  if (_optionalChain([first, 'optionalAccess', _59 => _59.kind]) !== "paragraph" || !match) return null;
+  const paragraphs = first.lines.length > 1 ? [joinLines(first.lines.slice(1))] : [];
+  let used = 0;
+  for (const node of children) {
+    if (node.kind !== "paragraph") break;
+    paragraphs.push(joinLines(node.lines));
+    used++;
+  }
+  return { tone: ALERT_TONES[match[1]], paragraphs, rest: children.slice(used) };
+}
+
+// src/engine/markdown/block/drafts.ts
+function draft(type, data, indent) {
+  return indent > 0 ? { type, data, indent } : { type, data };
+}
+function lineDraft(line, body, indent) {
+  return draft("MARKDOWN", { markdown: lineMarkdown(line, body) }, indent);
+}
+var deeper = (ctx) => ({ ...ctx, indent: ctx.indent + 1 });
+
+// src/engine/markdown/block/inline-text.ts
+var BRACKET_LABEL = /\[((?:[^\\[\]]|\\[\s\S]){0,999})\]/g;
+function refsUsedBy(source, refs) {
+  const used = /* @__PURE__ */ new Map();
+  if (refs.size === 0) return used;
+  for (const [, label] of source.matchAll(BRACKET_LABEL)) {
+    const target = refs.get(normalizeLabel(label));
+    if (target) used.set(label, target);
+  }
+  return used;
+}
+function parseText(source, { softBreak, refs }) {
+  return parseInline(source, { softBreak, refs: refsUsedBy(source, refs) });
+}
+function canonicalInline(source, options, hardBreak) {
+  return serializeInline(parseText(source, options), { escapeLineStart: true, hardBreak });
+}
+var ESCAPED_PIPE = /\\\|/g;
+function canonicalCell(source, options) {
+  return serializeInline(parseText(source.replace(ESCAPED_PIPE, "|"), options), { escapePipes: true, hardBreak: "br" });
+}
+function canonicalParagraphs(paragraphs, options) {
+  const parts = paragraphs.map((source) => parseText(source, options));
+  const joined = parts.flatMap((part, index) => index === 0 ? part : [text("\n"), ...part]);
+  return serializeInline(normalizeInline(joined), { escapeLineStart: true });
+}
+function plainTextOf(source) {
+  return inlineText(parseInline(source, { softBreak: "space" }), () => "");
+}
+
+// src/engine/markdown/block/image-paragraph.ts
+function labelEnd(source, open) {
+  let depth = 0;
+  for (let at = open; at < source.length; at++) {
+    if (source[at] === "\\") at++;
+    else if (source[at] === "[") depth++;
+    else if (source[at] === "]" && --depth === 0) return at;
+  }
+  return -1;
+}
+function imageParagraph(source) {
+  if (!source.startsWith("![")) return null;
+  const end = labelEnd(source, 1);
+  if (end < 0 || source[end + 1] !== "(") return null;
+  const tail = parseInlineLinkTail(source, end + 2);
+  if (!tail || tail.end !== source.length) return null;
+  const url = sanitizeHref(tail.value.href);
+  if (!url) return null;
+  const alt = plainTextOf(source.slice(2, end));
+  return tail.value.title ? { alt, url, title: tail.value.title } : { alt, url };
+}
+
+// src/engine/markdown/block/leaf-drafts.ts
+var textLine = (ctx) => ({ kind: ctx.quote ? "quote" : "paragraph" });
+function paragraphDraft(node, ctx) {
+  const source = joinLines(node.lines);
+  const image = imageParagraph(source);
+  if (!image) return lineDraft(textLine(ctx), canonicalInline(source, ctx.text), ctx.indent);
+  const caption = image.title ? { caption: image.title } : {};
+  return draft("IMAGE", { storageKey: "", alt: image.alt, url: image.url, ...caption }, ctx.indent);
+}
+function headingDraft(node, ctx) {
+  if (ctx.quote) return lineDraft({ kind: "quote" }, canonicalInline(node.text, ctx.text), ctx.indent);
+  const body = canonicalInline(node.text, ctx.text, "br");
+  return lineDraft({ kind: "heading", level: node.level }, body, ctx.indent);
+}
+function htmlDraft(node, ctx) {
+  return lineDraft(textLine(ctx), canonicalInline(trimBlank(node.lines.join("\n")), ctx.text), ctx.indent);
+}
+function codeDraft(node, ctx) {
+  return draft("CODE", { language: node.info.split(/[ \t]+/)[0], code: node.lines.join("\n") }, ctx.indent);
+}
+function mathDraft(node, ctx) {
+  return draft("MATH", { latex: node.lines.join("\n") }, ctx.indent);
+}
+function tableDraft(node, ctx) {
+  const rows = [node.header, ...node.rows].map((row) => row.map((cell) => canonicalCell(cell, ctx.text)));
+  return draft("TABLE", { rows, header: true, align: node.align }, ctx.indent);
+}
+
+// src/engine/markdown/block/tree-to-blocks.ts
+function itemLine(item, lines, ctx) {
+  if (ctx.quote) return { line: { kind: "quote" }, lines };
+  if (item.marker.ordered) return { line: { kind: "ordered", start: item.marker.number }, lines };
+  const task = lines.length > 0 ? parseLine(`- ${lines[0]}`) : null;
+  if (_optionalChain([task, 'optionalAccess', _60 => _60.kind]) !== "task") return { line: { kind: "bullet" }, lines };
+  return { line: { kind: "task", checked: task.checked }, lines: [trimBlankStart(task.rest), ...lines.slice(1)] };
+}
+function itemDrafts(item, ctx) {
+  const [first, ...others] = item.children;
+  const lead = textLinesOf(first);
+  const { line, lines } = itemLine(item, _nullishCoalesce(lead, () => ( [])), ctx);
+  const body = lead ? canonicalInline(joinLines(lines), ctx.text) : "";
+  const head = lead || !ctx.quote ? [lineDraft(line, body, ctx.indent)] : [];
+  return [...head, ...convertAll(lead ? others : item.children, deeper(ctx))];
+}
+function quoteDrafts(quote, ctx) {
+  const alert = alertOf(quote);
+  const quoted = { ...ctx, quote: true };
+  if (!alert) return convertAll(quote.children, quoted);
+  const body = canonicalParagraphs(alert.paragraphs, ctx.text);
+  return [draft("CALLOUT", { tone: alert.tone, body }, ctx.indent), ...convertAll(alert.rest, quoted)];
+}
+function detailsDrafts(details, ctx) {
+  const summary = details.summary === null ? "" : canonicalInline(details.summary, { ...ctx.text, softBreak: "space" });
+  const toggle = draft("TOGGLE", { markdown: summary, open: details.open }, ctx.indent);
+  return [toggle, ...convertAll(details.children, deeper(ctx))];
+}
+function convert(node, ctx) {
+  switch (node.kind) {
+    case "paragraph":
+      return [paragraphDraft(node, ctx)];
+    case "heading":
+      return [headingDraft(node, ctx)];
+    case "break":
+      return [draft("DIVIDER", {}, ctx.indent)];
+    case "code":
+      return [codeDraft(node, ctx)];
+    case "math":
+      return [mathDraft(node, ctx)];
+    case "html":
+      return [htmlDraft(node, ctx)];
+    case "table":
+      return [tableDraft(node, ctx)];
+    case "quoin":
+      return [draft(node.type, node.data, ctx.indent + node.indent)];
+    case "quote":
+      return quoteDrafts(node, ctx);
+    case "details":
+      return detailsDrafts(node, ctx);
+    case "item":
+      return itemDrafts(node, ctx);
+    case "list":
+    case "document":
+      return convertAll(node.children, ctx);
+  }
+}
+function convertAll(nodes, ctx) {
+  return nodes.flatMap((node) => convert(node, ctx));
+}
+function treeToBlocks(document, text2) {
+  return convert(document, { indent: 0, quote: false, text: text2 });
+}
+
+// src/engine/markdown/block/from-markdown.ts
+function fromMarkdown(markdown, options = {}) {
+  const { document, refs } = parseBlocks(markdown);
+  const drafts = treeToBlocks(document, { softBreak: _nullishCoalesce(options.softBreak, () => ( "space")), refs });
+  const makeId = _nullishCoalesce(options.newId, () => ( newId));
+  return drafts.map((block) => ({ id: makeId(), ...block }));
+}
+
+// src/engine/model/doc.ts
+function createDoc(blocks) {
+  const index = /* @__PURE__ */ new Map();
+  blocks.forEach((block, i) => {
+    if (index.has(block.id)) throw new Error(`duplicate block id "${block.id}"`);
+    index.set(block.id, i);
+  });
+  return { blocks, index };
+}
+function indexOfBlock(doc, id) {
+  return _nullishCoalesce(doc.index.get(id), () => ( -1));
+}
+function requireBlockIndex(doc, id) {
+  const index = indexOfBlock(doc, id);
+  if (index < 0) throw new Error(`no block "${id}"`);
+  return index;
+}
+function blockById(doc, id) {
+  const index = doc.index.get(id);
+  return index === void 0 ? void 0 : doc.blocks[index];
+}
+function updateBlock(doc, id, update) {
+  const index = requireBlockIndex(doc, id);
+  const next = update(doc.blocks[index]);
+  const blocks = doc.blocks.map((block, i) => i === index ? next : block);
+  return next.id === id ? { blocks, index: doc.index } : createDoc(blocks);
+}
+function replaceBlocks(doc, index, deleteCount, inserted) {
+  if (index < 0 || deleteCount < 0 || index + deleteCount > doc.blocks.length) {
+    throw new RangeError(`cannot remove ${deleteCount} blocks at ${index} from ${doc.blocks.length}`);
+  }
+  return createDoc([...doc.blocks.slice(0, index), ...inserted, ...doc.blocks.slice(index + deleteCount)]);
+}
+
+// src/engine/blocks/legacy-split.ts
+var PLAIN_LINE = /^\p{L}(?:[^\r\n]*[^\s\\])?$/u;
+var BLANK_PIECE = { id: "", type: "MARKDOWN", data: { markdown: "" } };
+function pieceIds(id, count, taken) {
+  const ids = [id];
+  for (let suffix = 2; ids.length < count; suffix++) {
+    if (!taken.has(`${id}-${suffix}`)) ids.push(`${id}-${suffix}`);
+  }
+  return ids;
+}
+function readPieces(markdown) {
+  const pieces = fromMarkdown(markdown, { softBreak: "newline", newId: () => "" });
+  return pieces.length === 0 && markdown !== "" && markdown.trim() === "" ? [BLANK_PIECE] : pieces;
+}
+function splitLegacyBlock(block, baseIndent, taken = /* @__PURE__ */ new Set()) {
+  const { markdown, ...extras } = block.data;
+  if (block.type !== "MARKDOWN" || typeof markdown !== "string" || PLAIN_LINE.test(markdown)) return null;
+  const pieces = readPieces(markdown);
+  if (pieces.length === 0) return null;
+  if (pieces.length === 1 && pieces[0].type === "MARKDOWN" && pieces[0].data.markdown === markdown) return null;
+  const ids = pieceIds(block.id, pieces.length, taken);
+  return pieces.map((piece, index) => {
+    const data = index === 0 ? { ...extras, ...piece.data } : piece.data;
+    const indent = baseIndent + (_nullishCoalesce(piece.indent, () => ( 0)));
+    const id = ids[index];
+    return indent > 0 ? { ...piece, id, data, indent } : { ...piece, id, data };
+  });
+}
+
+// src/engine/blocks/unique-ids.ts
+function freeId(preferred, taken) {
+  if (!taken.has(preferred)) return preferred;
+  let suffix = 2;
+  while (taken.has(`${preferred}-${suffix}`)) suffix++;
+  return `${preferred}-${suffix}`;
+}
+function withUniqueIds(blocks, newId2) {
+  const taken = new Set(blocks.map((block) => block.id));
+  const placed = /* @__PURE__ */ new Set();
+  return blocks.map((block) => {
+    if (!placed.has(block.id)) {
+      placed.add(block.id);
+      return block;
+    }
+    const id = freeId(newId2(), taken);
+    taken.add(id);
+    return { ...block, id };
+  });
+}
+
+// src/engine/blocks/unknown-spec.ts
+function unknownBlockSpec(type) {
+  return {
+    type,
+    flow: "void",
+    fromData: (data) => ({ attrs: { data }, regions: {} }),
+    toData: ({ attrs }) => _nullishCoalesce(attrs.data, () => ( {})),
+    initial: () => ({ attrs: { data: {} }, regions: {} })
+  };
+}
+function specFor(schema, type) {
+  return _nullishCoalesce(schema.blocks.get(type), () => ( unknownBlockSpec(type)));
+}
+
+// src/engine/blocks/codec.ts
+var NO_IDS = /* @__PURE__ */ new Set();
+function createBlockCodec(schema, options = {}) {
+  const context = { inline: inlineCodec, newId: _nullishCoalesce(options.newId, () => ( newId)) };
+  const engineBlocks = /* @__PURE__ */ new WeakMap();
+  const quoinBlocks = /* @__PURE__ */ new WeakMap();
+  const splitGroups = /* @__PURE__ */ new WeakMap();
+  function convert2(block) {
+    const { attrs, regions } = specFor(schema, block.type).fromData(block.data, context);
+    return { id: block.id, type: block.type, indent: countOf(block.indent), attrs, regions };
+  }
+  function engineBlocksAmong(block, taken) {
+    const cached = engineBlocks.get(block);
+    if (_optionalChain([cached, 'optionalAccess', _61 => _61.every, 'call', _62 => _62((piece, index) => index === 0 || !taken.has(piece.id))])) return [...cached];
+    const pieces = splitLegacyBlock(block, countOf(block.indent), taken);
+    if (pieces) {
+      const blocks = pieces.map(convert2);
+      engineBlocks.set(block, blocks);
+      for (const piece of blocks) splitGroups.set(piece, { original: block, blocks });
+      return [...blocks];
+    }
+    const engine = convert2(block);
+    engineBlocks.set(block, [engine]);
+    quoinBlocks.set(engine, block);
+    return [engine];
+  }
+  function toQuoin(block) {
+    const cached = quoinBlocks.get(block);
+    if (cached) return cached;
+    const data = specFor(schema, block.type).toData(block, context);
+    const quoin = { id: block.id, type: block.type, data };
+    if (block.indent > 0) quoin.indent = block.indent;
+    quoinBlocks.set(block, quoin);
+    engineBlocks.set(quoin, [block]);
+    return quoin;
+  }
+  const toEngineBlocks = (block) => engineBlocksAmong(block, NO_IDS);
+  function docFromBlocks(blocks) {
+    const taken = new Set(blocks.map((block) => block.id));
+    return createDoc(withUniqueIds(blocks.flatMap((block) => engineBlocksAmong(block, taken)), context.newId));
+  }
+  function blocksFromDoc(doc) {
+    const result = [];
+    for (let at = 0; at < doc.blocks.length; ) {
+      const group = splitGroups.get(doc.blocks[at]);
+      const intact = _optionalChain([group, 'optionalAccess', _63 => _63.blocks, 'access', _64 => _64.every, 'call', _65 => _65((piece, offset) => doc.blocks[at + offset] === piece)]);
+      if (group && intact) {
+        result.push(group.original);
+        at += group.blocks.length;
+      } else {
+        result.push(toQuoin(doc.blocks[at]));
+        at++;
+      }
+    }
+    return result;
+  }
+  return { toEngineBlocks, toQuoin, docFromBlocks, blocksFromDoc, context };
+}
+
+// src/engine/render/block-groups.ts
+var MAX_NESTING2 = 32;
+function listKind(block) {
+  const { kind } = block.attrs;
+  if (block.type !== "MARKDOWN") return void 0;
+  return kind === "bullet" || kind === "ordered" || kind === "task" ? kind : void 0;
+}
+var isQuote = (block) => block.type === "MARKDOWN" && block.attrs.kind === "quote";
+function append2(groups, entry) {
+  const last = groups[groups.length - 1];
+  const list = listKind(entry.block);
+  if (list) {
+    if (_optionalChain([last, 'optionalAccess', _66 => _66.kind]) === "list" && last.list === list) last.items.push(entry);
+    else groups.push({ kind: "list", list, items: [entry] });
+  } else if (isQuote(entry.block)) {
+    if (_optionalChain([last, 'optionalAccess', _67 => _67.kind]) === "quote" && last.items[0].block.indent === entry.block.indent) last.items.push(entry);
+    else groups.push({ kind: "quote", items: [entry] });
+  } else {
+    groups.push({ kind: "single", entry });
+  }
+}
+function groupBlocks(blocks) {
+  const root = [];
+  const frames = [];
+  for (const block of blocks) {
+    while (frames.length > 0 && frames[frames.length - 1].owner.block.indent >= block.indent) frames.pop();
+    const frame = frames[frames.length - 1];
+    const entry = { block, excess: block.indent - (_nullishCoalesce(_optionalChain([frame, 'optionalAccess', _68 => _68.depth]), () => ( 0))), children: [] };
+    append2(_nullishCoalesce(_optionalChain([frame, 'optionalAccess', _69 => _69.owner, 'access', _70 => _70.children]), () => ( root)), entry);
+    if ((listKind(block) || block.type === "TOGGLE") && frames.length < MAX_NESTING2) {
+      frames.push({ owner: entry, depth: block.indent + 1 });
+    }
+  }
+  return root;
+}
+
+// src/engine/render/block-attrs.ts
+var indentAttr = (excess) => ["data-indent", excess > 0 ? String(excess) : void 0];
+function alignAttr(align) {
+  const value = alignOrUndefined(align);
+  return ["style", value === void 0 ? void 0 : `text-align:${value}`];
+}
+var colorAttrs = (attrs) => [
+  ["data-color", paletteOrUndefined(attrs.color)],
+  ["data-bg", paletteOrUndefined(attrs.background)]
+];
+
+// src/engine/render/table-cells.ts
+function tableCells(block) {
+  const cols = countOf(block.attrs.cols);
+  return Array.from(
+    { length: countOf(block.attrs.rows) },
+    (_, row) => Array.from({ length: cols }, (_2, col) => _nullishCoalesce(block.regions[cellKey(row, col)], () => ( [])))
+  );
+}
+
+// src/engine/render/block-plain-text.ts
+function inlinePlainText(inline, schema) {
+  return inlineText(inline, (node) => _nullishCoalesce(_optionalChain([schema, 'access', _71 => _71.atoms, 'access', _72 => _72.get, 'call', _73 => _73(node.type), 'optionalAccess', _74 => _74.plainText, 'call', _75 => _75(node.attrs)]), () => ( "")));
+}
+function tablePlainText(block, schema) {
+  return tableCells(block).map((row) => row.map((cell) => inlinePlainText(cell, schema)).join("	")).join("\n");
+}
+function blockPlainText(block, schema) {
+  const spec = schema.blocks.get(block.type);
+  if (_optionalChain([spec, 'optionalAccess', _76 => _76.toPlainText])) return spec.toPlainText(block);
+  const { attrs } = block;
+  switch (block.type) {
+    case "CODE":
+      return str(attrs.code);
+    case "IMAGE":
+      return str(attrs.alt);
+    case "FILE":
+      return str(attrs.filename);
+    case "EMBED":
+      return str(attrs.url);
+    case "BOOKMARK":
+      return str(attrs.title) || str(attrs.url);
+    case "MATH":
+      return str(attrs.latex);
+    case "TABLE":
+      return tablePlainText(block, schema);
+    default:
+      return _optionalChain([spec, 'optionalAccess', _77 => _77.primaryRegion]) ? inlinePlainText(_nullishCoalesce(block.regions[spec.primaryRegion], () => ( [])), schema) : "";
+  }
+}
+
+// src/engine/render/heading-tree.ts
+function nestHeadings(headings) {
+  const roots = [];
+  const open = [];
+  for (const heading of headings) {
+    while (open.length > 0 && open[open.length - 1].heading.level >= heading.level) open.pop();
+    const node = { heading, children: [] };
+    (_nullishCoalesce(_optionalChain([open, 'access', _78 => _78[open.length - 1], 'optionalAccess', _79 => _79.children]), () => ( roots))).push(node);
+    open.push(node);
+  }
+  return roots;
+}
+
+// src/engine/render/heading-level.ts
+function headingLevel(level) {
+  if (typeof level !== "number" || !Number.isInteger(level)) return 1;
+  return Math.min(6, Math.max(1, level));
+}
+
+// src/engine/render/headings.ts
+var headingId = (blockId) => `h-${blockId}`;
+function headingLevel2(block) {
+  if (block.type !== "MARKDOWN" || block.attrs.kind !== "heading") return null;
+  return headingLevel(block.attrs.level);
+}
+
+// src/engine/render/toc-node.ts
+function collectHeadings(blocks, schema) {
+  return blocks.flatMap((block) => {
+    const level = headingLevel2(block);
+    const text2 = level === null ? "" : blockPlainText(block, schema);
+    return level === null || text2 === "" ? [] : [{ blockId: block.id, level, text: text2 }];
+  });
+}
+function listNode(nodes) {
+  const items = nodes.map(({ heading, children }) => {
+    const link2 = element("a", [["href", `#${headingId(heading.blockId)}`]], [heading.text]);
+    return element("li", [], children.length > 0 ? [link2, listNode(children)] : [link2]);
+  });
+  return element("ul", [], items);
+}
+function tocNode(headings, excess) {
+  return element("nav", [["data-toc", ""], indentAttr(excess)], headings.length > 0 ? [listNode(nestHeadings(headings))] : []);
+}
+
+// src/engine/render/engine-blocks.ts
+function engineBlocksOf(blocks, schema) {
+  const used = new Set(blocks.map((block) => block.id));
+  let next = 0;
+  const newId2 = () => {
+    let id;
+    do
+      id = `split-${next++}`;
+    while (used.has(id));
+    return id;
+  };
+  const codec = createBlockCodec(schema, { newId: newId2 });
+  return codec.docFromBlocks(blocks).blocks;
+}
+
+// src/engine/render/inline-nodes.ts
+function atomNode(node, options) {
+  const { attrs } = node;
+  if (node.type === "mention") {
+    return element("span", [["data-mention", _nullishCoalesce(attrs.id, () => ( ""))], ["data-kind", attrs.kind || void 0]], [`@${_nullishCoalesce(attrs.label, () => ( ""))}`]);
+  }
+  if (node.type === "math") {
+    const latex = _nullishCoalesce(attrs.latex, () => ( ""));
+    const math3 = ["data-math", ""];
+    return options.renderMath ? element("span", [math3], [latex], options.renderMath(latex, { displayMode: false })) : element("span", [math3], [latex]);
+  }
+  return element("span", [["data-atom", node.type], ...dataAttributes(attrs)]);
+}
+var textNodes = (value) => value.split("\n").flatMap((line, at) => at === 0 ? [line] : [element("br"), line]);
+function inlineNodes(inline, options = {}) {
+  const root = [];
+  const open = [];
+  const current = () => _nullishCoalesce(_optionalChain([open, 'access', _80 => _80[open.length - 1], 'optionalAccess', _81 => _81.children]), () => ( root));
+  for (const node of inline) {
+    let shared = 0;
+    while (shared < open.length && shared < node.marks.length && sameMark(open[shared].mark, node.marks[shared])) {
+      shared++;
+    }
+    open.length = shared;
+    for (const mark of node.marks.slice(shared)) {
+      const wrapper = markElement(mark);
+      if (wrapper) current().push(wrapper);
+      open.push({ mark, children: _nullishCoalesce(_optionalChain([wrapper, 'optionalAccess', _82 => _82.children]), () => ( current())) });
+    }
+    current().push(...node.kind === "text" ? textNodes(node.text) : [atomNode(node, options)]);
+  }
+  return root;
+}
+
+// src/engine/render/html-env.ts
+var inlineOf = (inline, env) => inlineNodes(_nullishCoalesce(inline, () => ( [])), { renderMath: env.renderMath });
+
+// src/engine/render/embed-provider.ts
+var EMBED_FRAME = {
+  sandbox: "allow-scripts allow-same-origin allow-presentation allow-popups",
+  loading: "lazy",
+  referrerpolicy: "strict-origin-when-cross-origin"
+};
+var WEB = /* @__PURE__ */ new Set(["http:", "https:"]);
+var SECURE = /* @__PURE__ */ new Set(["https:"]);
+function parse(address) {
+  try {
+    return new URL(address);
+  } catch (e2) {
+    return null;
+  }
+}
+function plainWebUrl(address, protocols) {
+  const url = parse(address);
+  return url && protocols.has(url.protocol) && url.username === "" && url.password === "" && url.port === "" ? url : null;
+}
+function embedFrame(href, providers) {
+  const page = plainWebUrl(href, WEB);
+  if (!page) return null;
+  for (const provider of providers) {
+    const result = provider.match(page);
+    const frame = typeof result === "string" ? plainWebUrl(result, SECURE) : null;
+    if (frame) return { src: frame.href, name: provider.name };
+  }
+  return null;
+}
+
+// src/engine/render/media-nodes.ts
+var numberAttr = (value) => _optionalChain([optionalNumber, 'call', _83 => _83(value), 'optionalAccess', _84 => _84.toString, 'call', _85 => _85()]);
+var paragraph = (view, inner) => element("p", [indentAttr(view.excess)], [inner]);
+var link = (href, label) => element("a", [["href", href], ["rel", "noopener noreferrer"]], [label]);
+function assetSource(block, env) {
+  const key = str(block.attrs.storageKey);
+  const src = key === "" ? null : env.resolveAssetUrl(key);
+  return src ? sanitizeAssetUrl(src) : null;
+}
+function imageSource(block, env) {
+  const url = str(block.attrs.url);
+  return url === "" ? assetSource(block, env) : sanitizeHref(url);
+}
+function imageNode(block, view, env) {
+  const src = imageSource(block, env);
+  if (!src) return "";
+  const { attrs } = block;
+  const image = element("img", [
+    ["src", src],
+    ["alt", str(attrs.alt)],
+    ["width", numberAttr(attrs.width)],
+    ["height", numberAttr(attrs.height)],
+    ["loading", "lazy"],
+    ["decoding", "async"]
+  ]);
+  const caption = _nullishCoalesce(block.regions.caption, () => ( []));
+  const figcaption = caption.length > 0 ? [element("figcaption", [], inlineOf(caption, env))] : [];
+  return element("figure", [alignAttr(attrs.align), indentAttr(view.excess)], [image, ...figcaption]);
+}
+function fileNode(block, view, env) {
+  const href = assetSource(block, env);
+  if (!href) return "";
+  return paragraph(view, element("a", [["href", href], ["download", true]], [str(block.attrs.filename)]));
+}
+function embedNode(block, view, env) {
+  const href = sanitizeHref(str(block.attrs.url));
+  if (!href) return "";
+  const frame = env.embeds === "iframe" ? embedFrame(href, env.embedProviders) : null;
+  if (frame) {
+    const attrs = [["src", frame.src], ["title", env.frameTitle(frame.name)], ...Object.entries(EMBED_FRAME)];
+    return element("iframe", [...attrs, indentAttr(view.excess)]);
+  }
+  return paragraph(view, link(href, href));
+}
+function bookmarkNode(block, view) {
+  const href = sanitizeHref(str(block.attrs.url));
+  return href ? paragraph(view, link(href, str(block.attrs.title) || href)) : "";
+}
+
+// src/engine/render/table-node.ts
+function tableNode(block, view, env) {
+  const rows = tableCells(block);
+  const aligns = Array.isArray(block.attrs.align) ? block.attrs.align : [];
+  const row = (tag, cells) => element("tr", [], cells.map((cell, col) => element(tag, [alignAttr(aligns[col])], inlineOf(cell, env))));
+  const headed = block.attrs.header !== false && rows.length > 0;
+  const head = headed ? [element("thead", [], [row("th", rows[0])])] : [];
+  const bodyRows = headed ? rows.slice(1) : rows;
+  const body = bodyRows.length > 0 ? [element("tbody", [], bodyRows.map((cells) => row("td", cells)))] : [];
+  return element("table", [indentAttr(view.excess)], [...head, ...body]);
+}
+
+// src/engine/render/block-node.ts
+function lineNode(block, view, env) {
+  const body = inlineOf(block.regions.text, env);
+  const style = [alignAttr(block.attrs.align), ...colorAttrs(block.attrs), indentAttr(view.excess)];
+  switch (block.attrs.kind) {
+    case "heading":
+      return element(`h${_nullishCoalesce(headingLevel2(block), () => ( 1))}`, [["id", headingId(block.id)], ...style], body);
+    case "bullet":
+    case "ordered":
+      return element("li", style, [...body, ...view.children]);
+    case "task": {
+      const checked = block.attrs.checked === true;
+      const box = element("input", [
+        ["type", "checkbox"],
+        ["disabled", true],
+        ["checked", checked || void 0],
+        ["aria-label", nodeText(body) || env.taskLabel]
+      ]);
+      return element("li", [["data-checked", String(checked)], ...style], [box, " ", ...body, ...view.children]);
+    }
+    default:
+      return element("p", style, body);
+  }
+}
+function calloutNode(block, view, env) {
+  const icon = str(block.attrs.icon);
+  const mark = icon === "" ? [] : [element("span", [["data-icon", ""]], [icon])];
+  const body = element("p", [], inlineOf(block.regions.body, env));
+  const attrs = [["role", "note"], ["data-tone", str(block.attrs.tone)], indentAttr(view.excess)];
+  return element("aside", attrs, [...mark, body]);
+}
+function codeNode(block, view) {
+  const language = str(block.attrs.language);
+  const className = language === "" ? void 0 : `language-${language}`;
+  const code = element("code", [["class", className]], [str(block.attrs.code)]);
+  return element("pre", [indentAttr(view.excess)], [code]);
+}
+function mathNode(block, view, env) {
+  const latex = str(block.attrs.latex);
+  if (!env.renderMath) return element("pre", [indentAttr(view.excess)], [latex]);
+  return element("div", [["data-math", ""], indentAttr(view.excess)], [], env.renderMath(latex, { displayMode: true }));
+}
+function toggleNode(block, view, env) {
+  const summary = element("summary", [], inlineOf(block.regions.text, env));
+  const attrs = [["open", block.attrs.open === true || void 0], indentAttr(view.excess)];
+  return element("details", attrs, [summary, ...view.children]);
+}
+function blockNode(block, view, env) {
+  switch (block.type) {
+    case "MARKDOWN":
+      return lineNode(block, view, env);
+    case "CALLOUT":
+      return calloutNode(block, view, env);
+    case "CODE":
+      return codeNode(block, view);
+    case "IMAGE":
+      return imageNode(block, view, env);
+    case "FILE":
+      return fileNode(block, view, env);
+    case "DIVIDER":
+      return element("hr", [indentAttr(view.excess)]);
+    case "TOGGLE":
+      return toggleNode(block, view, env);
+    case "TABLE":
+      return tableNode(block, view, env);
+    case "EMBED":
+      return embedNode(block, view, env);
+    case "BOOKMARK":
+      return bookmarkNode(block, view);
+    case "MATH":
+      return mathNode(block, view, env);
+    case "TOC":
+      return tocNode(env.headings, view.excess);
+    default:
+      return element("div", [["data-type", block.type], indentAttr(view.excess)]);
+  }
+}
+
+// src/engine/render/embed-providers.ts
+var ID = /^[\w-]{1,64}$/;
+var DIGITS2 = /^\d{1,20}$/;
+var SPOTIFY_ID = /^[A-Za-z0-9]{1,64}$/;
+var SPOTIFY_KINDS = /* @__PURE__ */ new Set(["track", "album", "playlist", "episode", "show"]);
+var FIGMA_KINDS = /* @__PURE__ */ new Set(["file", "design", "proto", "board"]);
+var pathParts = (url) => url.pathname.split("/").filter((part) => part !== "");
+var idFrom = (candidate, pattern = ID) => candidate !== null && candidate !== void 0 && pattern.test(candidate) ? candidate : null;
+var youtube = {
+  name: "youtube",
+  match(url) {
+    const parts = pathParts(url);
+    let id = null;
+    if (url.hostname === "youtu.be") {
+      id = parts.length === 1 ? idFrom(parts[0]) : null;
+    } else if (["youtube.com", "www.youtube.com", "m.youtube.com"].includes(url.hostname)) {
+      if (parts.length === 1 && parts[0] === "watch") id = idFrom(url.searchParams.get("v"));
+      else if (parts.length === 2 && (parts[0] === "embed" || parts[0] === "shorts")) id = idFrom(parts[1]);
+    }
+    return id === null ? null : `https://www.youtube-nocookie.com/embed/${id}`;
+  }
+};
+var vimeo = {
+  name: "vimeo",
+  match(url) {
+    const parts = pathParts(url);
+    let id = null;
+    if (["vimeo.com", "www.vimeo.com"].includes(url.hostname)) {
+      id = parts.length === 1 ? idFrom(parts[0], DIGITS2) : null;
+    } else if (url.hostname === "player.vimeo.com") {
+      id = parts.length === 2 && parts[0] === "video" ? idFrom(parts[1], DIGITS2) : null;
+    }
+    return id === null ? null : `https://player.vimeo.com/video/${id}`;
+  }
+};
+var loom = {
+  name: "loom",
+  match(url) {
+    const parts = pathParts(url);
+    const onLoom = ["loom.com", "www.loom.com"].includes(url.hostname);
+    const id = onLoom && parts.length === 2 && parts[0] === "share" ? idFrom(parts[1]) : null;
+    return id === null ? null : `https://www.loom.com/embed/${id}`;
+  }
+};
+var figma = {
+  name: "figma",
+  match(url) {
+    const parts = pathParts(url);
+    const onFigma = ["figma.com", "www.figma.com"].includes(url.hostname);
+    if (!onFigma || parts.length < 2 || !FIGMA_KINDS.has(parts[0]) || idFrom(parts[1]) === null) return null;
+    return `https://www.figma.com/embed?embed_host=quoin&url=${encodeURIComponent(url.href)}`;
+  }
+};
+var codepen = {
+  name: "codepen",
+  match(url) {
+    const parts = pathParts(url);
+    if (url.hostname !== "codepen.io" || parts.length !== 3 || parts[1] !== "pen") return null;
+    const [user, , id] = parts;
+    return idFrom(user) === null || idFrom(id) === null ? null : `https://codepen.io/${user}/embed/${id}`;
+  }
+};
+var spotify = {
+  name: "spotify",
+  match(url) {
+    const parts = pathParts(url);
+    if (url.hostname !== "open.spotify.com" || parts.length !== 2 || !SPOTIFY_KINDS.has(parts[0])) return null;
+    return idFrom(parts[1], SPOTIFY_ID) === null ? null : `https://open.spotify.com/embed/${parts[0]}/${parts[1]}`;
+  }
+};
+var soundcloud = {
+  name: "soundcloud",
+  match(url) {
+    const onSoundcloud = ["soundcloud.com", "www.soundcloud.com", "m.soundcloud.com"].includes(url.hostname);
+    return onSoundcloud && pathParts(url).length >= 2 ? `https://w.soundcloud.com/player/?url=${encodeURIComponent(url.href)}` : null;
+  }
+};
+var coreEmbedProviders = [youtube, vimeo, loom, figma, codepen, spotify, soundcloud];
+
+// src/engine/render/group-nodes.ts
+function listElement({ list, items }, children) {
+  if (list !== "ordered") return element("ul", [["data-type", list === "task" ? list : void 0]], children);
+  const { start } = items[0].block.attrs;
+  return element("ol", [["start", Number.isInteger(start) && start !== 1 ? String(start) : void 0]], children);
+}
+function groupNodes(groups, env, render) {
+  const entryNode = ({ block, excess, children }) => render(block, { excess, children: groupNodes(children, env, render) }, env);
+  return groups.map((group) => {
+    if (group.kind === "single") return entryNode(group.entry);
+    if (group.kind === "quote") {
+      const lines = group.items.map(({ block }) => render(block, { excess: 0, children: [] }, env));
+      return element("blockquote", [indentAttr(group.items[0].excess)], lines);
+    }
+    return listElement(group, group.items.map(entryNode));
+  });
+}
+
+// src/engine/render/document-nodes.ts
+function documentNodes(blocks, options = {}, render = blockNode) {
+  const schema = _nullishCoalesce(options.schema, () => ( createSchema()));
+  const engine = engineBlocksOf(blocks, schema);
+  const env = {
+    resolveAssetUrl: _nullishCoalesce(options.resolveAssetUrl, () => ( sanitizeHref)),
+    renderMath: options.renderMath,
+    embeds: _nullishCoalesce(options.embeds, () => ( "link")),
+    embedProviders: [..._nullishCoalesce(options.embedProviders, () => ( [])), ...coreEmbedProviders],
+    headings: collectHeadings(engine, schema),
+    taskLabel: _nullishCoalesce(options.taskLabel, () => ( "Task")),
+    frameTitle: _nullishCoalesce(options.frameTitle, () => ( String))
+  };
+  return groupNodes(groupBlocks(engine), env, render);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.sameAttrs = sameAttrs; exports.compareRegionNames = compareRegionNames; exports.sameItems = sameItems; exports.markKey = markKey; exports.sameMark = sameMark; exports.sameMarkSet = sameMarkSet; exports.addMark = addMark; exports.removeMark = removeMark; exports.hasMark = hasMark; exports.text = text; exports.atom = atom; exports.nodeLength = nodeLength; exports.normalizeInline = normalizeInline; exports.inlineLength = inlineLength; exports.inlineText = inlineText; exports.sliceInline = sliceInline; exports.replaceInline = replaceInline; exports.addMarkRange = addMarkRange; exports.removeMarkRange = removeMarkRange; exports.marksAt = marksAt; exports.equalNode = equalNode; exports.equalInline = equalInline; exports.PALETTE = PALETTE; exports.isPaletteColor = isPaletteColor; exports.isRecord = isRecord; exports.str = str; exports.optionalString = optionalString; exports.optionalNumber = optionalNumber; exports.paletteOrUndefined = paletteOrUndefined; exports.alignOrUndefined = alignOrUndefined; exports.MAX_MARKER_NUMBER = MAX_MARKER_NUMBER; exports.orderedStart = orderedStart; exports.parseLine = parseLine; exports.countOf = countOf; exports.cellKey = cellKey; exports.coreBlockSpecs = coreBlockSpecs; exports.coreAtomSpecs = coreAtomSpecs; exports.coreMarkSpecs = coreMarkSpecs; exports.createSchema = createSchema; exports.SCHEME = SCHEME; exports.sanitizeHref = sanitizeHref; exports.sanitizeAssetUrl = sanitizeAssetUrl; exports.opensMath = opensMath; exports.dollarRunEnd = dollarRunEnd; exports.findMathClose = findMathClose; exports.mathLatex = mathLatex; exports.parseInline = parseInline; exports.dataAttributes = dataAttributes; exports.writtenAttrs = writtenAttrs; exports.nodeText = nodeText; exports.element = element; exports.markElement = markElement; exports.linkClose = linkClose; exports.serializeInline = serializeInline; exports.createDoc = createDoc; exports.indexOfBlock = indexOfBlock; exports.requireBlockIndex = requireBlockIndex; exports.blockById = blockById; exports.updateBlock = updateBlock; exports.replaceBlocks = replaceBlocks; exports.newId = newId; exports.isQuoinType = isQuoinType; exports.startsHtmlBlock = startsHtmlBlock; exports.ALERT_TONES = ALERT_TONES; exports.fromMarkdown = fromMarkdown; exports.specFor = specFor; exports.createBlockCodec = createBlockCodec; exports.listKind = listKind; exports.groupBlocks = groupBlocks; exports.headingLevel = headingLevel; exports.headingId = headingId; exports.headingLevel2 = headingLevel2; exports.inlineOf = inlineOf; exports.EMBED_FRAME = EMBED_FRAME; exports.embedFrame = embedFrame; exports.tableCells = tableCells; exports.inlinePlainText = inlinePlainText; exports.blockPlainText = blockPlainText; exports.nestHeadings = nestHeadings; exports.collectHeadings = collectHeadings; exports.blockNode = blockNode; exports.coreEmbedProviders = coreEmbedProviders; exports.engineBlocksOf = engineBlocksOf; exports.documentNodes = documentNodes;
+//# sourceMappingURL=chunk-ND5XJVK2.cjs.map