@openpresentation/opf 0.11.4 → 0.12.1

package/dist/markdown.js

@@ -0,0 +1,1941 @@
+import { same, isRecord, parseQuoteLines, levelsFromIndents, parseCodeFence, splitWhen, runText, isPlainRun, FORMATTING, fenceCode } from './chunk-V2537ENL.js';
+import { lintPresentation } from './chunk-MWPMJE6P.js';
+import { validatePresentation } from './chunk-JKVKYVWL.js';
+import './chunk-HOBSL7AJ.js';
+import './chunk-S5W34SIJ.js';
+import './chunk-E34DJ5LL.js';
+import './chunk-4LAM3N6S.js';
+import { parseDocument, YAMLMap, Scalar, stringify } from 'yaml';
+
+// src/markdown/canon.ts
+var FORMAT_KEYS = FORMATTING;
+function canonRun(run) {
+  if (typeof run === "string") return run;
+  if (!isRecord(run) || typeof run.text !== "string") return void 0;
+  const out = { text: run.text };
+  for (const [key, value] of Object.entries(run)) {
+    if (key === "text") continue;
+    if (!FORMAT_KEYS.includes(key)) return void 0;
+    if (value === false || value === void 0) continue;
+    out[key] = value;
+  }
+  return Object.keys(out).length === 1 ? out.text : out;
+}
+var sameFormat = (a, b) => {
+  const keys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
+  keys.delete("text");
+  for (const key of keys) if (a[key] !== b[key]) return false;
+  return true;
+};
+function canonText(value) {
+  if (typeof value === "string") return value;
+  if (!Array.isArray(value)) return void 0;
+  const merged = [];
+  for (const raw of value) {
+    const run = canonRun(raw);
+    if (run === void 0) return void 0;
+    if (runText(run) === "") continue;
+    const last = merged.at(-1);
+    if (last !== void 0) {
+      if (typeof last === "string" && typeof run === "string") {
+        merged[merged.length - 1] = last + run;
+        continue;
+      }
+      if (typeof last === "object" && typeof run === "object" && sameFormat(last, run)) {
+        merged[merged.length - 1] = { ...last, text: last.text + run.text };
+        continue;
+      }
+    }
+    merged.push(run);
+  }
+  if (merged.length === 0) return "";
+  if (merged.every(isPlainRun)) return merged.map(runText).join("");
+  return merged;
+}
+function canonItem(item) {
+  if (typeof item === "string" || Array.isArray(item)) return canonText(item);
+  if (!isRecord(item)) return void 0;
+  for (const key of Object.keys(item)) if (key !== "text" && key !== "level" && key !== "description") return void 0;
+  const text = canonText(item.text);
+  if (text === void 0) return void 0;
+  const level = item.level === void 0 ? 0 : item.level;
+  if (!Number.isInteger(level) || level < 0) return void 0;
+  const description = item.description === void 0 ? void 0 : canonText(item.description);
+  if (item.description !== void 0 && description === void 0) return void 0;
+  if (level === 0 && description === void 0) return text;
+  const out = { text };
+  if (description !== void 0) out.description = description;
+  if (level !== 0) out.level = level;
+  return out;
+}
+var levelOf = (item) => isRecord(item) && typeof item.level === "number" ? item.level : 0;
+function canonItems(value) {
+  if (!Array.isArray(value) || value.length === 0) return void 0;
+  const items = [];
+  let previous = -1;
+  for (const raw of value) {
+    const item = canonItem(raw);
+    if (item === void 0) return void 0;
+    const level = levelOf(item);
+    if (level > previous + 1 || previous < 0 && level !== 0) return void 0;
+    previous = level;
+    items.push(item);
+  }
+  return items;
+}
+var only = (value, keys) => Object.keys(value).every((key) => keys.includes(key));
+function canonQuote(value) {
+  if (typeof value === "string") return value;
+  if (!isRecord(value) || !only(value, ["text", "attribution", "source"]) || typeof value.text !== "string") return void 0;
+  for (const key of ["attribution", "source"]) if (value[key] !== void 0 && typeof value[key] !== "string") return void 0;
+  if (value.source !== void 0 && value.attribution === void 0) return void 0;
+  if (value.attribution === void 0) return value.text;
+  const out = { text: value.text, attribution: value.attribution };
+  if (value.source !== void 0) out.source = value.source;
+  return out;
+}
+function canonCode(value) {
+  if (typeof value === "string") return value;
+  if (!isRecord(value) || !only(value, ["source", "language", "filename"]) || typeof value.source !== "string") return void 0;
+  for (const key of ["language", "filename"]) if (value[key] !== void 0 && (typeof value[key] !== "string" || value[key] === "")) return void 0;
+  if (value.language === void 0 && value.filename === void 0) return value.source;
+  const out = { source: value.source };
+  if (value.language !== void 0) out.language = value.language;
+  if (value.filename !== void 0) out.filename = value.filename;
+  return out;
+}
+function canonMetric(value) {
+  if (typeof value === "string" || typeof value === "number") return value;
+  if (!isRecord(value) || !only(value, ["value", "label", "description", "unit", "delta", "trend"])) return void 0;
+  if (typeof value.value !== "string" && typeof value.value !== "number") return void 0;
+  const out = { value: value.value };
+  for (const key of ["label", "description", "unit", "delta", "trend"]) {
+    const entry = value[key];
+    if (entry === void 0) continue;
+    if (typeof entry !== "string" && !(key === "delta" && typeof entry === "number")) return void 0;
+    out[key] = entry;
+  }
+  return Object.keys(out).length === 1 ? out.value : out;
+}
+function canonAsset(value) {
+  if (typeof value === "string") return value;
+  if (!isRecord(value) || !only(value, ["src", "alt", "title"]) || typeof value.src !== "string") return void 0;
+  for (const key of ["alt", "title"]) if (value[key] !== void 0 && typeof value[key] !== "string") return void 0;
+  const out = { src: value.src };
+  if (value.alt !== void 0) out.alt = value.alt;
+  if (value.title !== void 0) out.title = value.title;
+  return Object.keys(out).length === 1 ? out.src : out;
+}
+function canonCell(cell) {
+  if (cell === null) return cell;
+  if (typeof cell === "string" || Array.isArray(cell)) return canonText(cell);
+  return void 0;
+}
+function canonTable(value) {
+  if (!isRecord(value) || !only(value, ["columns", "rows"]) || !Array.isArray(value.rows)) return void 0;
+  const out = {};
+  if (value.columns !== void 0) {
+    if (!Array.isArray(value.columns) || value.columns.length === 0) return void 0;
+    const columns = value.columns.map((cell) => cell === null ? null : typeof cell === "string" || Array.isArray(cell) ? canonText(cell) : void 0);
+    if (columns.includes(void 0) || columns.every((cell) => cell === null || cell === "")) return void 0;
+    out.columns = columns;
+  }
+  const rows = [];
+  for (const row of value.rows) {
+    if (!Array.isArray(row)) return void 0;
+    const cells = row.map(canonCell);
+    if (cells.includes(void 0)) return void 0;
+    rows.push(cells);
+  }
+  out.rows = rows;
+  return out;
+}
+function canonChart(value) {
+  if (!isRecord(value) || !only(value, ["type", "data"]) || typeof value.type !== "string" || !isRecord(value.data)) return void 0;
+  const data = value.data;
+  if (Array.isArray(data.columns) && Array.isArray(data.rows) && only(data, ["columns", "rows"])) {
+    if (!data.columns.every((column) => typeof column === "string") || data.columns.length === 0 || data.rows.length === 0) return void 0;
+    for (const row of data.rows) if (!Array.isArray(row) || !row.every((cell) => cell === null || ["string", "number", "boolean"].includes(typeof cell))) return void 0;
+    return { type: value.type, data: { columns: data.columns, rows: data.rows } };
+  }
+  if (typeof data.src === "string" && only(data, ["src", "sheet", "range", "columns"])) return { type: value.type, data };
+  return void 0;
+}
+function canonEvent(event) {
+  if (!isRecord(event) || !only(event, ["when", "what", "description"]) || typeof event.what !== "string") return void 0;
+  for (const key of ["when", "description"]) if (event[key] !== void 0 && typeof event[key] !== "string") return void 0;
+  const out = {};
+  if (event.when !== void 0) out.when = event.when;
+  out.what = event.what;
+  if (event.description !== void 0) out.description = event.description;
+  return out;
+}
+function canonTimeline(value) {
+  const events = Array.isArray(value) ? value : isRecord(value) && only(value, ["name", "description", "events"]) ? value.events : void 0;
+  if (!Array.isArray(events) || events.length === 0) return void 0;
+  const canon = events.map(canonEvent);
+  if (canon.includes(void 0)) return void 0;
+  if (Array.isArray(value)) return canon;
+  for (const key of ["name", "description"]) if (value[key] !== void 0 && typeof value[key] !== "string") return void 0;
+  const { name, description } = value;
+  if (name === void 0 && description === void 0) return canon;
+  const out = {};
+  if (name !== void 0) out.name = name;
+  if (description !== void 0) out.description = description;
+  out.events = canon;
+  return out;
+}
+function canonContent(key, value) {
+  switch (key) {
+    case "text":
+      return canonText(value);
+    case "items":
+    case "bullets":
+      return canonItems(value);
+    case "quote":
+      return canonQuote(value);
+    case "code":
+      return canonCode(value);
+    case "metric":
+      return canonMetric(value);
+    case "image":
+    case "video":
+      return canonAsset(value);
+    case "table":
+      return canonTable(value);
+    case "chart":
+      return canonChart(value);
+    case "timeline":
+      return canonTimeline(value);
+    default:
+      return void 0;
+  }
+}
+
+// src/markdown/inline.ts
+var PUNCT = /[\p{P}\p{S}]/u;
+var WS = /\s/u;
+var ALNUM = /[\p{L}\p{N}]/u;
+var ASCII_PUNCT = /^[!-/:-@[-`{-~]$/;
+var MAX_DEPTH = 16;
+var MAX_TARGET = 2e3;
+var MAX_SPAN = 300;
+var SPAN_FLAGS = {
+  bold: "bold",
+  italic: "italic",
+  underline: "underline",
+  strike: "strikethrough",
+  strikethrough: "strikethrough",
+  sup: "superscript",
+  superscript: "superscript",
+  sub: "subscript",
+  subscript: "subscript"
+};
+var SPAN_VALUES = { color: "color", size: "fontSize", fontsize: "fontSize", font: "fontFamily", fontfamily: "fontFamily" };
+function parseAttributes(source) {
+  const pairs = [];
+  let i = 0;
+  while (i < source.length) {
+    while (i < source.length && /[\s,]/.test(source[i])) i++;
+    if (i >= source.length) break;
+    const key = /^[A-Za-z][\w-]*/.exec(source.slice(i))?.[0];
+    if (!key) return { pairs, error: `Expected an attribute name at ${JSON.stringify(source.slice(i, i + 12))}.` };
+    i += key.length;
+    if (source[i] !== "=") {
+      pairs.push([key, true]);
+      continue;
+    }
+    i++;
+    if (source[i] === '"') {
+      let j = i + 1;
+      while (j < source.length && source[j] !== '"') j += source[j] === "\\" ? 2 : 1;
+      if (j >= source.length) return { pairs, error: `Unterminated quoted value for ${key}.` };
+      try {
+        pairs.push([key, JSON.parse(source.slice(i, j + 1))]);
+      } catch {
+        return { pairs, error: `Invalid quoted value for ${key}; use JSON string escapes.` };
+      }
+      i = j + 1;
+    } else {
+      const value = /^[^\s,"]+/.exec(source.slice(i))?.[0];
+      if (!value) return { pairs, error: `Missing value for ${key}.` };
+      pairs.push([key, value]);
+      i += value.length;
+    }
+  }
+  return { pairs };
+}
+function spanStyle(source, issue) {
+  const style = {};
+  const { pairs, error } = parseAttributes(source);
+  if (error) issue("markdown/span-attributes", `${error} A span reads {bold italic color=#ff0000 size=24 font="Open Sans"}.`);
+  for (const [rawKey, value] of pairs) {
+    const key = rawKey.toLowerCase();
+    const flag = SPAN_FLAGS[key];
+    const field = SPAN_VALUES[key];
+    if (flag) {
+      if (value === true || value === "true") style[flag] = true;
+      else if (value !== "false") issue("markdown/span-attributes", `Span flag ${rawKey} takes no value (or =true/false).`);
+    } else if (field === "fontSize") {
+      const size = value === true ? Number.NaN : Number(value);
+      if (Number.isFinite(size) && size > 0) style.fontSize = size;
+      else issue("markdown/span-attributes", `Span size must be a positive number, not ${JSON.stringify(value)}.`);
+    } else if (field) {
+      if (typeof value === "string" && value) style[field] = value;
+      else issue("markdown/span-attributes", `Span ${rawKey} needs a value.`);
+    } else issue("markdown/span-attributes", `Unknown span attribute ${JSON.stringify(rawKey)}. Known: bold, italic, underline, strike, sup, sub, color, size, font.`);
+  }
+  return style;
+}
+var TAGS = { u: "underline", sup: "superscript", sub: "subscript" };
+function matchBracket(s, start) {
+  let depth = 0;
+  for (let i = start; i < s.length; i++) {
+    const c = s[i];
+    if (c === "\\") i++;
+    else if (c === "[") depth++;
+    else if (c === "]" && --depth === 0) return i;
+  }
+  return -1;
+}
+var ANGLE_AT = /<([^<>\n]*)>/y;
+function readDestination(s, open) {
+  let i = open + 1;
+  while (s[i] === " ") i++;
+  let url = "";
+  if (s[i] === "<") {
+    ANGLE_AT.lastIndex = i;
+    const angle = ANGLE_AT.exec(s);
+    if (!angle) return void 0;
+    url = unescapeInline(angle[1]);
+    i += angle[0].length;
+  } else {
+    let depth = 0;
+    const from = i;
+    for (; i < s.length && i - from <= MAX_TARGET; i++) {
+      const c = s[i];
+      if (c === "\\" && ASCII_PUNCT.test(s[i + 1] ?? "")) {
+        i++;
+        continue;
+      }
+      if (/\s/.test(c)) break;
+      if (c === "(") depth++;
+      else if (c === ")") {
+        if (depth === 0) break;
+        depth--;
+      }
+    }
+    if (i - from > MAX_TARGET) return void 0;
+    url = unescapeInline(s.slice(from, i));
+  }
+  while (s[i] === " ") i++;
+  let title;
+  if (s[i] === '"' || s[i] === "'") {
+    const quote = s[i];
+    let j = i + 1;
+    while (j < s.length && j - i <= MAX_TARGET && s[j] !== quote) j += s[j] === "\\" ? 2 : 1;
+    if (j >= s.length || j - i > MAX_TARGET) return void 0;
+    title = unescapeInline(s.slice(i + 1, j));
+    i = j + 1;
+    while (s[i] === " ") i++;
+  }
+  if (s[i] !== ")") return void 0;
+  return title === void 0 ? { url, end: i + 1 } : { url, end: i + 1, title };
+}
+function unescapeInline(text) {
+  return text.replace(/\\([!-/:-@[-`{-~])/g, "$1");
+}
+function flanking(prev, next, ch) {
+  const left = !WS.test(next) && (!PUNCT.test(next) || WS.test(prev) || PUNCT.test(prev));
+  const right = !WS.test(prev) && (!PUNCT.test(prev) || WS.test(next) || PUNCT.test(next));
+  if (ch === "_") return { canOpen: left && (!right || PUNCT.test(prev)), canClose: right && (!left || PUNCT.test(next)) };
+  return { canOpen: left, canClose: right };
+}
+function bracketPairs(s) {
+  const pairs = /* @__PURE__ */ new Map();
+  const open = [];
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (c === "\\") i++;
+    else if (c === "[") open.push(i);
+    else if (c === "]" && open.length) pairs.set(open.pop(), i);
+  }
+  return pairs;
+}
+var TAG_AT = /<(\/?)(u|sup|sub)>/iy;
+var BR_AT = /<br\s*\/?>/iy;
+var AUTOLINK_AT = /<([A-Za-z][A-Za-z0-9+.-]{1,31}:[^\s<>]*)>/y;
+function tokenize(s, issue, depth, budget) {
+  const tokens = [];
+  const pairs = bracketPairs(s);
+  let text = "";
+  const flush = () => {
+    if (text) tokens.push({ t: "text", v: text });
+    text = "";
+  };
+  const before = (i) => i > 0 ? s[i - 1] : " ";
+  for (let i = 0; i < s.length; ) {
+    const c = s[i];
+    if (c === "\\" && i + 1 < s.length && ASCII_PUNCT.test(s[i + 1])) {
+      text += s[i + 1];
+      i += 2;
+      continue;
+    }
+    if (c === "[") {
+      const close = depth < MAX_DEPTH ? pairs.get(i) ?? -1 : -1;
+      if (close > 0) {
+        const next = s[close + 1];
+        if (next === "(" && budget.left > 0) {
+          const dest = readDestination(s, close + 1);
+          budget.left -= dest ? dest.end - close : Math.min(MAX_TARGET, s.length - close);
+          if (dest) {
+            flush();
+            tokens.push({ t: "node", children: parseSegs(s.slice(i + 1, close), issue, depth + 1, budget), apply: dest.url ? { link: dest.url } : {} });
+            i = dest.end;
+            continue;
+          }
+        } else if (next === "{") {
+          const end = s.slice(close + 2, close + 2 + MAX_SPAN).indexOf("}") + close + 2;
+          if (end > close + 1 && !s.slice(close + 2, end).includes("\n")) {
+            flush();
+            tokens.push({ t: "node", children: parseSegs(s.slice(i + 1, close), issue, depth + 1, budget), apply: spanStyle(s.slice(close + 2, end), issue) });
+            i = end + 1;
+            continue;
+          }
+        }
+      }
+      text += c;
+      i++;
+      continue;
+    }
+    if (c === "<") {
+      TAG_AT.lastIndex = i;
+      const tag = TAG_AT.exec(s);
+      if (tag) {
+        flush();
+        tokens.push({ t: "tag", name: TAGS[tag[2].toLowerCase()], close: tag[1] === "/", matched: false });
+        i += tag[0].length;
+        continue;
+      }
+      BR_AT.lastIndex = i;
+      const br = BR_AT.exec(s);
+      if (br) {
+        text += "\n";
+        i += br[0].length;
+        continue;
+      }
+      AUTOLINK_AT.lastIndex = i;
+      const auto = AUTOLINK_AT.exec(s);
+      if (auto) {
+        flush();
+        tokens.push({ t: "node", children: [{ text: auto[1], style: {} }], apply: { link: auto[1] } });
+        i += auto[0].length;
+        continue;
+      }
+    }
+    if (c === "*" || c === "_" || c === "~") {
+      let j = i;
+      while (s[j] === c) j++;
+      const n = j - i;
+      if (n <= 3 && (c !== "~" || n === 2)) {
+        flush();
+        const { canOpen, canClose } = flanking(before(i), s[j] ?? " ", c);
+        tokens.push({ t: "delim", ch: c, n, orig: n, canOpen, canClose, opens: [], closes: [] });
+        i = j;
+        continue;
+      }
+      text += s.slice(i, j);
+      i = j;
+      continue;
+    }
+    text += c;
+    i++;
+  }
+  flush();
+  return tokens;
+}
+function resolve(tokens) {
+  const stack = [];
+  for (let k = 0; k < tokens.length; k++) {
+    const token = tokens[k];
+    if (token.t === "tag") {
+      if (!token.close) stack.push(k);
+      else {
+        for (let s = stack.length - 1; s >= 0; s--) {
+          const other = tokens[stack[s]];
+          if (other?.t === "tag" && other.name === token.name && !other.matched) {
+            other.matched = token.matched = true;
+            stack.length = s;
+            break;
+          }
+        }
+      }
+      continue;
+    }
+    if (token.t !== "delim") continue;
+    if (token.canClose) {
+      while (token.n > 0) {
+        let found = -1;
+        for (let s = stack.length - 1; s >= 0; s--) {
+          const other = tokens[stack[s]];
+          if (other?.t === "delim" && other.ch === token.ch && other.n > 0 && other.canOpen) {
+            if ((other.canClose || token.canOpen) && (other.orig + token.orig) % 3 === 0 && !(other.orig % 3 === 0 && token.orig % 3 === 0)) continue;
+            found = s;
+            break;
+          }
+        }
+        if (found < 0) break;
+        const opener = tokens[stack[found]];
+        const use = token.ch === "~" ? 2 : Math.min(opener.n, token.n) >= 2 ? 2 : 1;
+        const style = token.ch === "~" ? "strikethrough" : use === 2 ? "bold" : "italic";
+        opener.n -= use;
+        token.n -= use;
+        opener.opens.push(style);
+        token.closes.push(style);
+        stack.length = opener.n > 0 ? found + 1 : found;
+      }
+    }
+    if (token.n > 0 && token.canOpen) stack.push(k);
+  }
+}
+function addStyle(base, add) {
+  return { ...add, ...base };
+}
+function parseSegs(s, issue, depth, budget) {
+  const tokens = tokenize(s, issue, depth, budget);
+  resolve(tokens);
+  const segs = [];
+  const counts = {};
+  const current = () => {
+    const style = {};
+    for (const key of ["bold", "italic", "strikethrough", "underline", "superscript", "subscript"]) if ((counts[key] ?? 0) > 0) style[key] = true;
+    return style;
+  };
+  const push = (text, style = current()) => {
+    if (text) segs.push({ text, style });
+  };
+  for (const token of tokens) {
+    if (token.t === "text") push(token.v);
+    else if (token.t === "node") for (const child of token.children) segs.push({ text: child.text, style: addStyle(child.style, addStyle(token.apply, current())) });
+    else if (token.t === "tag") {
+      if (!token.matched) push(`<${token.close ? "/" : ""}${token.name === "underline" ? "u" : token.name === "superscript" ? "sup" : "sub"}>`);
+      else counts[token.name] = (counts[token.name] ?? 0) + (token.close ? -1 : 1);
+    } else {
+      for (const style of token.closes) counts[style] = (counts[style] ?? 0) - 1;
+      push(token.ch.repeat(token.n));
+      for (const style of [...token.opens].reverse()) counts[style] = (counts[style] ?? 0) + 1;
+    }
+  }
+  return segs;
+}
+var sameStyle = (a, b) => {
+  const keys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
+  for (const key of keys) if (a[key] !== b[key]) return false;
+  return true;
+};
+function parseInlineSegments(text, issue = () => {
+}) {
+  const merged = [];
+  const budget = { left: 40 * text.length + 1e3 };
+  for (const seg of parseSegs(text, issue, 0, budget)) {
+    const last = merged.at(-1);
+    if (last && sameStyle(last.style, seg.style)) last.text += seg.text;
+    else merged.push({ text: seg.text, style: seg.style });
+  }
+  return merged;
+}
+var toRun = (seg) => {
+  const keys = Object.keys(seg.style);
+  if (!keys.length) return seg.text;
+  const run = { text: seg.text };
+  for (const key of FORMATTING) if (seg.style[key] !== void 0) run[key] = seg.style[key];
+  return run;
+};
+function parseInline(text, issue = () => {
+}) {
+  const segs = parseInlineSegments(text, issue);
+  if (!segs.length) return "";
+  if (segs.every((seg) => !Object.keys(seg.style).length)) return segs.map((seg) => seg.text).join("");
+  return segs.map(toRun);
+}
+function parsePlainInline(text, issue = () => {
+}) {
+  const segs = parseInlineSegments(text, issue);
+  if (segs.some((seg) => Object.keys(seg.style).length)) issue("markdown/formatting-dropped", "This field holds plain text, so bold, italic, links and other formatting in it were dropped.");
+  return segs.map((seg) => seg.text).join("");
+}
+var BLOCK_START = [
+  /^#{1,6}(?:\s|$)/,
+  // heading
+  /^>/,
+  // quote
+  /^[-+*](?:\s|$)/,
+  // bullet
+  /^\d{1,9}[.)](?:\s|$)/,
+  // numbered item
+  /^(?:`{3,}|~{3,})/,
+  // fence
+  /^-{3,}\s*$/,
+  // slide separator
+  /^\|/,
+  // table
+  /^!\[/,
+  // image
+  /^Notes?:/,
+  // speaker notes
+  /^<!--/,
+  // comment
+  /^:(?:\s|$)/
+  // list item description
+];
+function escapeLineStart(line) {
+  if (!BLOCK_START.some((pattern) => pattern.test(line))) return line;
+  const match = /^(\d{1,9})([.)])/.exec(line);
+  if (match) return `${match[1]}\\${line.slice(match[1].length)}`;
+  const notes = /^(Notes?)(:)/.exec(line);
+  if (notes) return `${notes[1]}\\${line.slice(notes[1].length)}`;
+  return `\\${line}`;
+}
+function escapeInline(text) {
+  let out = "";
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    const next = text[i + 1];
+    if (c === "\\") out += next === void 0 || ASCII_PUNCT.test(next) ? "\\\\" : c;
+    else if (c === "*" || c === "[" || c === "]") out += `\\${c}`;
+    else if (c === "<") out += next !== void 0 && /[A-Za-z/!]/.test(next) ? "\\<" : c;
+    else if (c === "_") out += ALNUM.test(text[i - 1] ?? "") && ALNUM.test(text[i + 1] ?? "") ? c : "\\_";
+    else if (c === "~") out += text[i - 1] === "~" || text[i + 1] === "~" ? "\\~" : c;
+    else out += c;
+  }
+  return out;
+}
+function serializeRun(run, breakText) {
+  const text = runText(run);
+  if (typeof run === "string") return text.split("\n").map(escapeInline).join(breakText);
+  if (!isRecord(run) || typeof run.text !== "string") return void 0;
+  for (const key of Object.keys(run)) if (key !== "text" && !FORMATTING.includes(key)) return void 0;
+  const lead = /^\s*/.exec(text)[0];
+  const trail = /\s*$/.exec(text.slice(lead.length))[0];
+  const core = text.slice(lead.length, text.length - trail.length);
+  const edge = (s) => s.split("\n").map(escapeInline).join(breakText);
+  if (!core) return edge(text);
+  let out = core.split("\n").map(escapeInline).join(breakText);
+  if (run.color !== void 0 || run.fontSize !== void 0 || run.fontFamily !== void 0) {
+    const attrs = [];
+    if (run.color !== void 0) attrs.push(`color=${attrValue(String(run.color))}`);
+    if (run.fontSize !== void 0) attrs.push(`size=${String(run.fontSize)}`);
+    if (run.fontFamily !== void 0) attrs.push(`font=${attrValue(String(run.fontFamily))}`);
+    out = `[${out}]{${attrs.join(" ")}}`;
+  }
+  if (run.subscript === true) out = `<sub>${out}</sub>`;
+  if (run.superscript === true) out = `<sup>${out}</sup>`;
+  if (run.underline === true) out = `<u>${out}</u>`;
+  if (run.strikethrough === true) out = `~~${out}~~`;
+  if (run.italic === true) out = `*${out}*`;
+  if (run.bold === true) out = `**${out}**`;
+  if (run.link !== void 0) {
+    const url = String(run.link);
+    if (!url || /[\n\r<>]/.test(url)) return void 0;
+    out = `[${out}](${/^[^\s()]+$/.test(url) ? url : `<${url}>`})`;
+  }
+  return edge(lead) + out + edge(trail);
+}
+var attrValue = (value) => /^[^\s,"}]+$/.test(value) ? value : JSON.stringify(value);
+function serializeRuns(value, mode = "paragraph") {
+  const runs = typeof value === "string" ? [value] : Array.isArray(value) ? value : void 0;
+  if (!runs) return void 0;
+  const parts = [];
+  for (const run of runs) {
+    const part = serializeRun(run, mode === "cell" ? "<br>" : "\\\n");
+    if (part === void 0) return void 0;
+    parts.push(part);
+  }
+  const lines = parts.join("").split("\n");
+  return mode === "cell" ? [lines.join("")] : lines.map(escapeLineStart);
+}
+function splitLines(source) {
+  const lines = [];
+  let start = 0;
+  let no = 1;
+  let i = 0;
+  while (i < source.length) {
+    const c = source[i];
+    if (c === "\n" || c === "\r") {
+      lines.push({ text: source.slice(start, i), start, end: i, no: no++ });
+      if (c === "\r" && source[i + 1] === "\n") i++;
+      i++;
+      start = i;
+    } else i++;
+  }
+  if (start < source.length) lines.push({ text: source.slice(start), start, end: source.length, no });
+  return lines;
+}
+var Ctx = class {
+  constructor(source) {
+    this.source = source;
+    for (let i = 0; i < source.length; i++) {
+      if (source[i] === "\r") {
+        if (source[i + 1] === "\n") i++;
+        this.lineStarts.push(i + 1);
+      } else if (source[i] === "\n") this.lineStarts.push(i + 1);
+    }
+  }
+  source;
+  diagnostics = [];
+  /** JSON Pointer in the converted document to the source range that produced it. */
+  ranges = /* @__PURE__ */ new Map();
+  lineStarts = [0];
+  location(range) {
+    let lo = 0;
+    let hi = this.lineStarts.length;
+    while (lo + 1 < hi) {
+      const mid = lo + hi >> 1;
+      if ((this.lineStarts[mid] ?? 0) <= range.start) lo = mid;
+      else hi = mid;
+    }
+    return { offset: range.start, length: Math.max(0, range.end - range.start), line: lo + 1, column: range.start - (this.lineStarts[lo] ?? 0) + 1 };
+  }
+  report(ruleId, severity, message, help, range, path = "") {
+    this.diagnostics.push({ ruleId, severity, scope: "document", path, message, help, location: this.location(range) });
+  }
+  error(rule, message, help, range, path = "") {
+    this.report(`markdown/${rule}`, "error", message, help, range, path);
+  }
+  warn(rule, message, help, range, path = "") {
+    this.report(`markdown/${rule}`, "warning", message, help, range, path);
+  }
+  get errors() {
+    return this.diagnostics.filter((d) => d.severity === "error").length;
+  }
+  /** The source range of a JSON Pointer, falling back to the nearest ancestor that has one. */
+  rangeOf(pointer) {
+    for (let path = pointer; ; path = path.slice(0, path.lastIndexOf("/"))) {
+      const found = this.ranges.get(path);
+      if (found) return found;
+      if (!path) return void 0;
+    }
+  }
+};
+var lineRange = (first, last = first) => ({ start: first.start, end: last.end });
+function readYamlMapping(text, base, ctx, rule, context) {
+  const keys = /* @__PURE__ */ new Map();
+  const doc = parseDocument(text, { schema: "core", uniqueKeys: true, merge: false, prettyErrors: false });
+  let ok = true;
+  for (const error of doc.errors) {
+    ok = false;
+    const [start, end] = error.pos;
+    ctx.error(rule, `YAML: ${error.message.split("\n")[0]}`, "Fix the YAML syntax. Front matter and embedded blocks hold JSON-compatible YAML: mappings, sequences and scalars, no anchors or tags.", { start: base + start, end: base + Math.max(end, start) });
+  }
+  if (!ok) return { value: {}, keys, ok };
+  if (doc.contents === null) return { value: {}, keys, ok };
+  if (!(doc.contents instanceof YAMLMap)) {
+    ctx.error(`${rule}-not-mapping`, "Expected a YAML mapping of keys and values.", "Write `key: value` lines; a list or a bare value is not accepted here.", context);
+    return { value: {}, keys, ok: false };
+  }
+  for (const pair of doc.contents.items) {
+    const key = pair.key;
+    const name = key instanceof Scalar ? String(key.value) : void 0;
+    if (name !== void 0 && key?.range) keys.set(name, { start: base + key.range[0], end: base + (pair.value?.range?.[1] ?? key.range[1]) });
+  }
+  let value;
+  try {
+    value = doc.toJS({ maxAliasCount: 0 });
+  } catch (error) {
+    ctx.error(rule, `YAML: ${error.message}`, "Anchors and aliases are not accepted; write each value out.", context);
+    return { value: {}, keys, ok: false };
+  }
+  const bad = nonJson(value);
+  if (bad) {
+    ctx.error(rule, `YAML value is not JSON-compatible (${bad}).`, "Quote special numbers such as .inf or .nan to keep them as strings.", context);
+    return { value: {}, keys, ok: false };
+  }
+  return { value, keys, ok };
+}
+function nonJson(value) {
+  if (typeof value === "number") return Number.isFinite(value) ? void 0 : "a number that is not finite";
+  if (value === null || typeof value === "string" || typeof value === "boolean") return void 0;
+  if (Array.isArray(value)) return value.map(nonJson).find(Boolean);
+  if (isRecord(value)) return Object.values(value).map(nonJson).find(Boolean);
+  return `a ${typeof value}`;
+}
+function writeYaml(value) {
+  for (const blockQuote of [true, false]) {
+    const text = stringify(value, { indent: 2, lineWidth: 0, minContentWidth: 0, blockQuote, defaultStringType: "PLAIN", defaultKeyType: "PLAIN" });
+    const doc = parseDocument(text, { schema: "core", uniqueKeys: true, merge: false });
+    if (!doc.errors.length && same(doc.toJS({ maxAliasCount: 0 }), value)) return text.endsWith("\n") ? text : `${text}
+`;
+  }
+  return void 0;
+}
+var DECIMAL = /^-?(?:0|[1-9]\d*)(?:\.\d+)?$/;
+function scalarText(value) {
+  if (typeof value === "number") return DECIMAL.test(String(value)) ? String(value) : JSON.stringify(String(value));
+  const plain = value !== "" && value === value.trim() && !value.startsWith('"') && !/[\r\n]/.test(value) && !DECIMAL.test(value);
+  return plain ? value : JSON.stringify(value);
+}
+function readCsv(text) {
+  const rows = [];
+  let row = [];
+  let i = 0;
+  const n = text.length;
+  const endRecord = () => {
+    rows.push(row);
+    row = [];
+  };
+  while (i < n) {
+    while (text[i] === " " || text[i] === "	") i++;
+    if (text[i] === '"') {
+      let value = "";
+      i++;
+      for (; ; ) {
+        if (i >= n) return { rows, error: "A quoted field is not closed." };
+        if (text[i] === '"') {
+          if (text[i + 1] === '"') {
+            value += '"';
+            i += 2;
+            continue;
+          }
+          i++;
+          break;
+        }
+        value += text[i++];
+      }
+      while (text[i] === " " || text[i] === "	") i++;
+      if (i < n && text[i] !== "," && text[i] !== "\n" && text[i] !== "\r") return { rows, error: "Text follows a closing quote." };
+      row.push({ value, quoted: true });
+    } else {
+      let j = i;
+      while (j < n && text[j] !== "," && text[j] !== "\n" && text[j] !== "\r") j++;
+      row.push({ value: text.slice(i, j).trim(), quoted: false });
+      i = j;
+    }
+    if (text[i] === ",") {
+      i++;
+      if (i >= n || text[i] === "\n" || text[i] === "\r") row.push({ value: "", quoted: false });
+      continue;
+    }
+    if (text[i] === "\r" && text[i + 1] === "\n") i++;
+    i++;
+    endRecord();
+  }
+  if (row.length) endRecord();
+  return { rows };
+}
+var needsQuotes = (value) => /[",\r\n]/.test(value) || value !== value.trim() || value === "";
+function csvField(cell, header = false) {
+  if (cell === null) return "";
+  if (typeof cell === "number") return String(cell);
+  if (typeof cell === "boolean") return String(cell);
+  const text = String(cell);
+  const ambiguous = !header && (DECIMAL.test(text) || /^(?:true|false)$/.test(text));
+  return needsQuotes(text) || ambiguous ? `"${text.replaceAll('"', '""')}"` : text;
+}
+var OPFMarkdownError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = "OPFMarkdownError";
+    this.code = code;
+    this.details = details;
+  }
+};
+
+// src/markdown/parse.ts
+var SLIDE_OPTION_KEYS = ["id", "type", "layout", "section", "tag", "hidden", "beat"];
+var BLOCK_OPTION_KEYS = ["id", "type", "as", "region"];
+var BLANK = /^\s*$/;
+var FENCE_OPEN = /^( {0,3})(`{3,}|~{3,})(.*)$/;
+var SEPARATOR = /^-{3,}[ \t]*$/;
+var HEADING = /^ {0,3}(#{1,6})(?:[ \t]+(.*?))?[ \t]*$/;
+var QUOTE = /^ {0,3}>/;
+var LIST_ITEM = /^([ \t]*)([-+*]|\d{1,9}[.)])(?:[ \t]+(.*))?$/;
+var TABLE_ROW = /^ {0,3}\|/;
+var TABLE_DELIMITER = /^ {0,3}\|?[ \t]*:?-+:?[ \t]*(?:\|[ \t]*:?-+:?[ \t]*)*\|?[ \t]*$/;
+var IMAGE = /^ {0,3}!\[/;
+var COMMENT = /^ {0,3}<!--/;
+var NOTES = /^(Notes?):[ \t]*(.*)$/;
+var indentWidth = (space) => [...space].reduce((width, char) => width + (char === "	" ? 4 : 1), 0);
+function fenceClose(open) {
+  return new RegExp(`^ {0,3}${open[0] === "`" ? "`" : "~"}{${open.length},}[ \\t]*$`);
+}
+function fenceStart(text) {
+  const match = FENCE_OPEN.exec(text);
+  if (!match) return void 0;
+  if (match[2][0] === "`" && match[3].includes("`")) return void 0;
+  return { fence: match[2], info: match[3].trim() };
+}
+var tableStart = (lines, i) => TABLE_ROW.test(lines[i].text) && lines[i + 1] !== void 0 && TABLE_DELIMITER.test(lines[i + 1].text) && lines[i + 1].text.includes("-");
+function listMarker(text) {
+  const match = LIST_ITEM.exec(text);
+  if (!match) return void 0;
+  const marker = match[2];
+  const ordered = /^\d/.test(marker);
+  return { indent: indentWidth(match[1]), marker, content: match[3] ?? "", ordered, family: ordered ? marker.slice(-1) : marker };
+}
+function interrupts(lines, i) {
+  const text = lines[i].text;
+  if (BLANK.test(text) || fenceStart(text) || HEADING.test(text) && !/^ {0,3}#{7}/.test(text) || QUOTE.test(text) || COMMENT.test(text) || NOTES.test(text) || SEPARATOR.test(text)) return true;
+  if (tableStart(lines, i)) return true;
+  if (IMAGE.test(text) && /^ {0,3}!\[(?:[^\]\\]|\\.)*\]\(.*\)[ \t]*$/.test(text)) return true;
+  const item = listMarker(text);
+  return !!item && item.indent < 4 && item.content.trim() !== "" && (!item.ordered || /^0*1[.)]$/.test(item.marker));
+}
+function splitSegments(lines, split) {
+  const segments = [[]];
+  let fence;
+  let comment = false;
+  let notes = false;
+  const hasContent = (segment) => segment.some((line) => !BLANK.test(line.text) && !/^\s*<!--.*-->\s*$/.test(line.text));
+  for (const line of lines) {
+    const text = line.text;
+    const current = segments.at(-1);
+    if (fence !== void 0) {
+      if (fenceClose(fence).test(text)) fence = void 0;
+      current.push(line);
+      continue;
+    }
+    if (comment) {
+      if (text.includes("-->")) comment = false;
+      current.push(line);
+      continue;
+    }
+    if (SEPARATOR.test(text)) {
+      segments.push([]);
+      notes = false;
+      continue;
+    }
+    if (split === "headings" && /^#(?:[ \t]|$)/.test(text) && hasContent(current)) {
+      segments.push([line]);
+      notes = false;
+      continue;
+    }
+    if (!notes) {
+      const open = fenceStart(text);
+      if (open) fence = open.fence;
+      else if (COMMENT.test(text) && !text.includes("-->", text.indexOf("<!--") + 4)) comment = true;
+      else if (NOTES.test(text)) notes = true;
+    }
+    current.push(line);
+  }
+  return segments;
+}
+function joinParagraph(lines) {
+  let out = "";
+  lines.forEach((raw, k) => {
+    let text = raw.trim();
+    let separator = " ";
+    if (k < lines.length - 1) {
+      const slashes = /\\+$/.exec(text)?.[0].length ?? 0;
+      if (slashes % 2 === 1) {
+        text = text.slice(0, -1);
+        separator = "\n";
+      }
+    }
+    out += text + (k < lines.length - 1 ? separator : "");
+  });
+  return out;
+}
+var bold = (value) => typeof value === "string" ? [{ text: value, bold: true }] : value.map((run) => typeof run === "string" ? { text: run, bold: true } : { ...run, bold: true });
+function parseOptions(text, keys, kind, ctx, range) {
+  const { pairs, error } = parseAttributes(text);
+  const help = `A ${kind} options comment reads <!-- ${kind}: ${kind === "slide" ? 'id=cover layout=title section="Part 1" hidden' : "id=chart-1 as=bullets region=top:left"} -->. Keys: ${keys.join(", ")}.`;
+  if (error) {
+    ctx.error("options-syntax", error, help, range);
+    return void 0;
+  }
+  const out = {};
+  let ok = true;
+  for (const [key, value] of pairs) {
+    if (!keys.includes(key)) {
+      ctx.error("options-unknown-key", `Unknown ${kind} option ${JSON.stringify(key)}.`, `${help} Anything else goes in a fenced opf-${kind} block.`, range);
+      ok = false;
+    } else if (key === "hidden") {
+      if (value === true || value === "true") out.hidden = true;
+      else if (value === "false") out.hidden = false;
+      else {
+        ctx.error("options-value", `hidden takes true or false, not ${JSON.stringify(value)}.`, help, range);
+        ok = false;
+      }
+    } else if (value === true) {
+      ctx.error("options-value", `Option ${key} needs a value: ${key}=value.`, help, range);
+      ok = false;
+    } else if (key === "beat" && out.beat !== void 0) out.beat = [...Array.isArray(out.beat) ? out.beat : [out.beat], value];
+    else if (key in out) {
+      ctx.error("options-duplicate", `Option ${key} is given twice.`, help, range);
+      ok = false;
+    } else if (key === "as" && value !== "bullets" && value !== "video") {
+      ctx.error("options-value", `as takes bullets (a list stored as bullets) or video (an image line stored as video), not ${JSON.stringify(value)}.`, help, range);
+      ok = false;
+    } else out[key] = value;
+  }
+  return ok ? out : void 0;
+}
+var SlideParser = class {
+  constructor(ctx, lines, path) {
+    this.ctx = ctx;
+    this.lines = lines;
+    this.path = path;
+  }
+  ctx;
+  lines;
+  path;
+  slide = {};
+  blocks = [];
+  slideOptions;
+  slideOptionsRange;
+  pending;
+  title;
+  subtitle;
+  notes;
+  extras;
+  notesRange;
+  i = 0;
+  issueAt(range) {
+    return (rule, message) => rule === "markdown/formatting-dropped" ? this.ctx.warn("formatting-dropped", message, "Use a plain string here, or put the field in a fenced opf-slide block.", range) : this.ctx.error(rule.replace(/^markdown\//, ""), message, "Fix the inline syntax.", range);
+  }
+  inline(text, range) {
+    return parseInline(text, this.issueAt(range));
+  }
+  plain(text, range) {
+    return parsePlainInline(text, this.issueAt(range));
+  }
+  run() {
+    const { lines, ctx } = this;
+    while (this.i < lines.length) {
+      const start = this.i;
+      const line = lines[start];
+      if (BLANK.test(line.text)) {
+        this.i++;
+        continue;
+      }
+      if (COMMENT.test(line.text)) this.comment();
+      else if (NOTES.test(line.text)) this.parseNotes();
+      else if (fenceStart(line.text)) this.fence();
+      else if (HEADING.test(line.text) && !/^ {0,3}#{7}/.test(line.text)) this.heading();
+      else if (QUOTE.test(line.text)) this.quote();
+      else if (tableStart(lines, start)) this.table();
+      else if (this.imageLine()) ; else if (listMarker(line.text) && listMarker(line.text).indent < 4) this.list();
+      else this.paragraph();
+      if (this.i === start) this.i++;
+    }
+    if (this.pending) ctx.error("options-orphan", "A block options comment is not followed by a block.", "Put the <!-- block: ... --> comment directly before the block it describes.", this.pending.range, this.path);
+    return this.finish();
+  }
+  add(block) {
+    if (this.pending) {
+      block.options = this.pending.options;
+      this.pending = void 0;
+    }
+    this.blocks.push(block);
+  }
+  native(key, value, range) {
+    const block = { payload: { [key]: value }, range, key };
+    this.add(block);
+    if (block.options) {
+      const as = block.options.as;
+      const stored = as === "bullets" && key === "items" ? "bullets" : as === "video" && key === "image" ? "video" : key;
+      if (as !== void 0 && stored === key) this.ctx.error("options-value", `as=${as} does not apply to this block.`, "as=bullets goes before a list, as=video before an image line.", range, this.path);
+      block.payload = { [stored]: value };
+      block.key = stored;
+    }
+  }
+  // --- comments --------------------------------------------------------------------------------
+  comment() {
+    const { lines, ctx } = this;
+    const first = lines[this.i];
+    let end = this.i;
+    while (end < lines.length && !lines[end].text.includes("-->", end === this.i ? lines[end].text.indexOf("<!--") + 4 : 0)) end++;
+    if (end >= lines.length) {
+      end = lines.length - 1;
+      ctx.error("comment-unterminated", "An HTML comment is not closed.", "End the comment with -->.", lineRange(first, lines[end]), this.path);
+    }
+    const last = lines[end];
+    const range = lineRange(first, last);
+    const body = lines.slice(this.i, end + 1).map((line) => line.text).join(" ");
+    this.i = end + 1;
+    const match = /^\s*<!--\s*(slide|block)(?::|(?=\s*-->))([\s\S]*?)-->([\s\S]*)$/.exec(body);
+    if (!match) return;
+    const kind = match[1];
+    if (match[3].trim()) ctx.error("options-trailing", "Text follows a closing --> on the same line.", "Put content on its own line after the options comment.", range, this.path);
+    const options = parseOptions(match[2], kind === "slide" ? SLIDE_OPTION_KEYS : BLOCK_OPTION_KEYS, kind, ctx, range);
+    if (!options) return;
+    if (kind === "slide") {
+      if (this.slideOptions) ctx.error("options-duplicate", "A slide has more than one <!-- slide: ... --> comment.", "Merge the options into one comment.", range, this.path);
+      else {
+        this.slideOptions = options;
+        this.slideOptionsRange = range;
+      }
+    } else if (this.pending) ctx.error("options-duplicate", "Two block options comments in a row.", "Merge them into one comment.", range, this.path);
+    else this.pending = { options, range };
+  }
+  // --- notes -----------------------------------------------------------------------------------
+  parseNotes() {
+    const { lines } = this;
+    const first = lines[this.i];
+    const match = NOTES.exec(first.text);
+    const rows = [match[2], ...lines.slice(this.i + 1).map((line) => line.text)];
+    while (rows.length && BLANK.test(rows[0])) rows.shift();
+    while (rows.length && BLANK.test(rows.at(-1))) rows.pop();
+    const range = lineRange(first, lines.at(-1));
+    this.notesRange = range;
+    this.notes = rows.join("\n");
+    this.i = lines.length;
+  }
+  // --- headings --------------------------------------------------------------------------------
+  heading() {
+    const { lines, ctx } = this;
+    const line = lines[this.i++];
+    const match = HEADING.exec(line.text);
+    const level = match[1].length;
+    const text = (match[2] ?? "").replace(/(?:^|[ \t]+)#+[ \t]*$/, "").trim();
+    const range = lineRange(line);
+    if (!text) {
+      ctx.error("empty-heading", "A heading has no text.", "Write the title after the #, or remove the line.", range, this.path);
+      return;
+    }
+    if (level === 1) {
+      if (this.title !== void 0) ctx.error("duplicate-title", "A slide has more than one # title.", "Use --- to start a new slide, or `##` for the subtitle.", range, `${this.path}/title`);
+      else {
+        this.title = this.plain(text, range);
+        ctx.ranges.set(`${this.path}/title`, range);
+      }
+    } else if (level === 2) {
+      if (this.subtitle !== void 0) ctx.error("duplicate-subtitle", "A slide has more than one ## subtitle.", "A slide has one subtitle. Use a paragraph for further lines.", range, `${this.path}/subtitle`);
+      else {
+        this.subtitle = this.plain(text, range);
+        ctx.ranges.set(`${this.path}/subtitle`, range);
+      }
+    } else {
+      ctx.warn("heading-demoted", `A level-${level} heading has no OPF form, so it became a bold paragraph.`, "Only # (title) and ## (subtitle) are slide fields. Use a bold paragraph on purpose to silence this.", range, this.path);
+      this.native("text", bold(this.inline(text, range)), range);
+    }
+  }
+  // --- paragraph -------------------------------------------------------------------------------
+  paragraph() {
+    const { lines } = this;
+    const first = this.i;
+    const rows = [];
+    do
+      rows.push(lines[this.i++].text);
+    while (this.i < lines.length && !interrupts(lines, this.i));
+    const range = lineRange(lines[first], lines[this.i - 1]);
+    this.native("text", this.inline(joinParagraph(rows), range), range);
+  }
+  // --- quote -----------------------------------------------------------------------------------
+  quote() {
+    const { lines, ctx } = this;
+    const first = this.i;
+    const rows = [];
+    while (this.i < lines.length && QUOTE.test(lines[this.i].text)) rows.push(lines[this.i++].text.replace(/^ {0,3}> ?/, ""));
+    const range = lineRange(lines[first], lines[this.i - 1]);
+    while (rows.length && BLANK.test(rows[0])) rows.shift();
+    while (rows.length && BLANK.test(rows.at(-1))) rows.pop();
+    if (!rows.length) {
+      ctx.error("empty-quote", "A block quote has no text.", "Write the quote after >.", range, this.path);
+      return;
+    }
+    const parsed = parseQuoteLines(rows);
+    const paragraphs = [[]];
+    for (const row of parsed.text) {
+      if (BLANK.test(row)) paragraphs.push([]);
+      else paragraphs.at(-1).push(row);
+    }
+    const text = this.plain(
+      paragraphs.filter((paragraph) => paragraph.length).map(joinParagraph).join("\n\n"),
+      range
+    );
+    const value = { text };
+    if (parsed.attribution !== void 0) value.attribution = this.plain(parsed.attribution, range);
+    if (parsed.source !== void 0) value.source = this.plain(parsed.source, range);
+    this.native("quote", Object.keys(value).length === 1 ? value.text : value, range);
+  }
+  // --- lists -----------------------------------------------------------------------------------
+  list() {
+    const { lines, ctx } = this;
+    const first = this.i;
+    const entries = [];
+    const head = listMarker(lines[first].text);
+    let topIndent = head.indent;
+    let numbered = false;
+    let i = first;
+    while (i < lines.length) {
+      const text = lines[i].text;
+      if (BLANK.test(text)) {
+        let j = i + 1;
+        while (j < lines.length && BLANK.test(lines[j].text)) j++;
+        const item2 = j < lines.length ? listMarker(lines[j].text) : void 0;
+        if (!item2) break;
+        if (item2.indent <= topIndent && item2.family !== head.family) break;
+        i = j;
+        continue;
+      }
+      const item = listMarker(text);
+      if (item) {
+        if (item.indent <= topIndent) {
+          if (item.family !== head.family) break;
+          topIndent = Math.min(topIndent, item.indent);
+        }
+        if (item.ordered) numbered = true;
+        entries.push({ indent: item.indent, rows: [item.content.trim()] });
+        i++;
+        continue;
+      }
+      const current = entries.at(-1);
+      if (!current || interrupts(lines, i)) break;
+      const description = /^([ \t]+):[ \t]+(.*)$/.exec(text);
+      if (description && indentWidth(description[1]) > current.indent && !current.description) current.description = [description[2].trim()];
+      else if (current.description) current.description.push(text.trim());
+      else current.rows.push(text);
+      i++;
+    }
+    this.i = i;
+    const last = Math.max(first, i - 1);
+    let end = last;
+    while (end > first && BLANK.test(lines[end].text)) end--;
+    const range = lineRange(lines[first], lines[end]);
+    if (numbered) ctx.warn("numbered-list", "Numbers in a list are not kept: an OPF list has no numbering, so each item became a bullet.", "Write the numbers into the text if they matter, or use a bulleted list.", range, this.path);
+    const levels = levelsFromIndents(entries.map((entry) => entry.indent));
+    const items = entries.map((entry, k) => {
+      const text = this.inline(joinParagraph(entry.rows), range);
+      const description = entry.description ? this.inline(joinParagraph(entry.description), range) : void 0;
+      const level = levels[k];
+      if (!level && description === void 0) return text;
+      const out = { text };
+      if (description !== void 0) out.description = description;
+      if (level) out.level = level;
+      return out;
+    });
+    this.native("items", items, range);
+  }
+  // --- tables ----------------------------------------------------------------------------------
+  table() {
+    const { lines, ctx } = this;
+    const first = this.i;
+    this.i += 2;
+    while (this.i < lines.length && TABLE_ROW.test(lines[this.i].text)) this.i++;
+    const range = lineRange(lines[first], lines[this.i - 1]);
+    const header = splitRow(lines[first].text);
+    const rows = lines.slice(first + 2, this.i).map((line) => splitRow(line.text));
+    const cell = (text) => this.inline(text, range);
+    const out = {};
+    if (header.some((text) => text !== "")) out.columns = header.map((text) => text === "" ? null : cell(text));
+    out.rows = rows.map((row) => {
+      if (header.length && row.length !== header.length) ctx.warn("table-ragged", `A table row has ${row.length} cells but the header has ${header.length}.`, "Give every row the same number of cells.", range, this.path);
+      const cells = row.map((text) => text === "" ? null : cell(text));
+      while (header.length && cells.length < header.length) cells.push(null);
+      return cells;
+    });
+    this.native("table", out, range);
+  }
+  // --- images ----------------------------------------------------------------------------------
+  imageLine() {
+    const { lines, ctx } = this;
+    const line = lines[this.i];
+    const text = line.text.replace(/^ {0,3}/, "");
+    if (!text.startsWith("![")) return false;
+    const close = matchBracket(text, 1);
+    if (close < 0 || text[close + 1] !== "(") return false;
+    const dest = readDestination(text, close + 1);
+    if (!dest || text.slice(dest.end).trim() !== "") return false;
+    this.i++;
+    const range = lineRange(line);
+    if (!dest.url) {
+      ctx.error("image-source", "An image has no source.", "Write the file or URL inside the parentheses: ![alt](path.png).", range, this.path);
+      return true;
+    }
+    const alt = unescapeInline(text.slice(2, close));
+    const value = { src: dest.url };
+    if (alt) value.alt = alt;
+    if (dest.title !== void 0) value.title = dest.title;
+    this.native("image", Object.keys(value).length === 1 ? value.src : value, range);
+    return true;
+  }
+  // --- fences ----------------------------------------------------------------------------------
+  fence() {
+    const { lines, ctx } = this;
+    const first = this.i;
+    const open = fenceStart(lines[first].text);
+    const close = fenceClose(open.fence);
+    let end = first + 1;
+    while (end < lines.length && !close.test(lines[end].text)) end++;
+    const terminated = end < lines.length;
+    const lastLine = terminated ? lines[end] : lines.at(-1);
+    const range = lineRange(lines[first], lastLine);
+    if (!terminated) ctx.error("fence-unterminated", "A fenced block is not closed.", `Add a closing ${open.fence} line.`, range, this.path);
+    this.i = terminated ? end + 1 : lines.length;
+    const body = lines.slice(first + 1, terminated ? end : lines.length);
+    const bodyText = body.map((line) => line.text).join("\n");
+    const bodyStart = body[0]?.start ?? lines[first].end;
+    const info = open.info;
+    const word = /^[^\s{]*/.exec(info)[0];
+    const rest = info.slice(word.length).trim();
+    if (word === "chart") this.chart(rest, bodyText, range);
+    else if (word === "metric") this.metric(body, range);
+    else if (word === "timeline") this.timeline(rest, body, range);
+    else if (word === "opf-slide") this.embeddedSlide(bodyText, bodyStart, range);
+    else if (word === "opf-block") this.embeddedBlock(bodyText, bodyStart, range);
+    else {
+      const parsed = parseCodeFence([lines[first].text, ...body.map((line) => line.text), open.fence]);
+      if (!parsed) {
+        ctx.error("code-fence", "This fenced block could not be read as code.", "Close the fence with at least as many backticks as opened it.", range, this.path);
+        return;
+      }
+      const hasMeta = parsed.language !== void 0 || parsed.filename !== void 0;
+      const value = { source: parsed.source };
+      if (parsed.language) value.language = parsed.language;
+      if (parsed.filename) value.filename = parsed.filename;
+      this.native("code", hasMeta ? value : parsed.source, range);
+    }
+  }
+  chart(rest, text, range) {
+    const { ctx } = this;
+    const type = /^[^\s]+/.exec(rest)?.[0];
+    if (!type) {
+      ctx.error("chart-type", "A chart block names its type after `chart`.", "Write ```chart column (or line, pie, bar, ...), then the data.", range, this.path);
+      return;
+    }
+    const trimmed = text.trim();
+    if (!trimmed) {
+      ctx.error("chart-data", "A chart block has no data.", "Write CSV with a header row, or a JSON object with columns and rows or a data source.", range, this.path);
+      return;
+    }
+    if (trimmed.startsWith("{")) {
+      try {
+        const data = JSON.parse(trimmed);
+        if (!isRecord(data)) throw new Error("not an object");
+        this.native("chart", { type, data }, range);
+      } catch (error) {
+        ctx.error("chart-data", `Chart JSON is invalid: ${error.message}.`, 'Write a JSON object: {"columns": [...], "rows": [[...]]} or {"src": ...}.', range, this.path);
+      }
+      return;
+    }
+    const csv = readCsv(text);
+    if (csv.error) {
+      ctx.error("chart-data", `Chart CSV is invalid: ${csv.error}`, "Quote fields that contain commas, quotes or line breaks.", range, this.path);
+      return;
+    }
+    const [head, ...body] = csv.rows.filter((row) => row.some((field) => field.value !== "" || field.quoted));
+    if (!head || !body.length) {
+      ctx.error("chart-data", "Chart CSV needs a header row and at least one data row.", "The first line names the columns.", range, this.path);
+      return;
+    }
+    const typed = (field) => field.quoted ? field.value : field.value === "" ? null : DECIMAL.test(field.value) ? Number(field.value) : field.value === "true" ? true : field.value === "false" ? false : field.value;
+    const rows = body.map((row) => row.map((field, index) => index === 0 ? field.value : typed(field)));
+    if (rows.some((row) => row.length !== head.length)) ctx.warn("chart-ragged", `A chart row has a different number of values than the ${head.length} columns.`, "Give every row one value per column.", range, this.path);
+    this.native("chart", { type, data: { columns: head.map((field) => field.value), rows } }, range);
+  }
+  metric(body, range) {
+    const { ctx } = this;
+    const allowed = ["value", "label", "description", "unit", "delta", "trend"];
+    const help = `A metric block is key: value lines. Keys: ${allowed.join(", ")}. A value is plain text, or a JSON string in double quotes.`;
+    const out = {};
+    for (const line of body) {
+      if (BLANK.test(line.text)) continue;
+      const match = /^([A-Za-z]+):[ \t]*(.*?)[ \t]*$/.exec(line.text);
+      const where = lineRange(line);
+      if (!match) {
+        ctx.error("metric-block", "Expected a key: value line.", help, where, this.path);
+        return;
+      }
+      const [, key, raw] = match;
+      if (!allowed.includes(key) || key in out || raw === "") {
+        ctx.error("metric-block", !allowed.includes(key) ? `Unknown metric key ${JSON.stringify(key)}.` : key in out ? `Metric key ${key} is given twice.` : `Metric key ${key} has no value.`, help, where, this.path);
+        return;
+      }
+      if (raw.startsWith('"')) {
+        try {
+          const value = JSON.parse(raw);
+          if (typeof value !== "string") throw new Error("not a string");
+          out[key] = value;
+        } catch {
+          ctx.error("metric-block", `The value of ${key} starts with a quote but is not a JSON string.`, help, where, this.path);
+          return;
+        }
+      } else out[key] = (key === "value" || key === "delta") && DECIMAL.test(raw) ? Number(raw) : raw;
+    }
+    if (out.value === void 0) {
+      ctx.error("metric-block", "A metric needs a value.", help, range, this.path);
+      return;
+    }
+    const ordered = {};
+    for (const key of allowed) if (out[key] !== void 0) ordered[key] = out[key];
+    this.native("metric", Object.keys(ordered).length === 1 ? ordered.value : ordered, range);
+  }
+  timeline(rest, body, range) {
+    const { ctx } = this;
+    const { pairs, error } = parseAttributes(rest);
+    const meta = {};
+    if (error) ctx.error("timeline-attributes", error, 'Write ```timeline name="Roadmap" description="..." (both optional).', range, this.path);
+    for (const [key, value] of pairs) {
+      if ((key === "name" || key === "description") && typeof value === "string") meta[key] = value;
+      else ctx.error("timeline-attributes", `Unknown timeline attribute ${JSON.stringify(key)}.`, "A timeline fence takes name and description.", range, this.path);
+    }
+    const events = [];
+    for (const line of body) {
+      if (BLANK.test(line.text)) continue;
+      if (/^[ \t]+\S/.test(line.text)) {
+        const event = events.at(-1);
+        if (!event) {
+          ctx.error("timeline-description", "An indented line must follow an event.", "Put the event first, then its description indented below it.", lineRange(line), this.path);
+          continue;
+        }
+        event.description = event.description === void 0 ? line.text.trim() : `${event.description} ${line.text.trim()}`;
+        continue;
+      }
+      const text = line.text.trim();
+      const dash = text.indexOf(" \u2014 ");
+      const split = dash > 0 && text.slice(dash + 3).trim() ? { when: text.slice(0, dash).trim(), what: text.slice(dash + 3).trim() } : splitWhen(text);
+      events.push(split ? { when: split.when, what: split.what } : { what: text });
+    }
+    if (!events.length) {
+      ctx.error("timeline-events", "A timeline has no events.", "Write one event per line: `2024 Q1 \u2014 Pilot`.", range, this.path);
+      return;
+    }
+    this.native("timeline", Object.keys(meta).length ? { ...meta, events } : events, range);
+  }
+  embeddedBlock(text, base, range) {
+    const { ctx } = this;
+    const parsed = readYamlMapping(text, base, ctx, "opf-block", range);
+    if (!parsed.ok) return;
+    if (this.pending) {
+      ctx.error("options-embedded", "A block options comment cannot precede an opf-block fence.", "Put id and type inside the opf-block YAML.", this.pending.range, this.path);
+      this.pending = void 0;
+    }
+    const keys = Object.keys(parsed.value);
+    this.blocks.push({ payload: parsed.value, range, key: keys.length === 1 ? keys[0] : void 0 });
+  }
+  embeddedSlide(text, base, range) {
+    const { ctx } = this;
+    const parsed = readYamlMapping(text, base, ctx, "opf-slide", range);
+    if (!parsed.ok) return;
+    if (this.extras) ctx.error("options-duplicate", "A slide has more than one opf-slide block.", "Merge them into one.", range, this.path);
+    else {
+      this.extras = parsed.value;
+      for (const [key, found] of parsed.keys) ctx.ranges.set(`${this.path}/${key.replaceAll("~", "~0").replaceAll("/", "~1")}`, found);
+    }
+  }
+  // --- assembly --------------------------------------------------------------------------------
+  finish() {
+    const { slide, ctx, path } = this;
+    const set = (key, value, range) => {
+      if (value === void 0) return;
+      if (Object.hasOwn(slide, key)) ctx.error("slide-property-conflict", `The slide property ${JSON.stringify(key)} is set twice.`, "Set it either in Markdown or in the opf-slide block, not both.", this.slideOptionsRange ?? range ?? { start: 0, end: 0 }, `${path}/${key}`);
+      else Object.defineProperty(slide, key, { value, enumerable: true, writable: true, configurable: true });
+    };
+    const options = this.slideOptions ?? {};
+    if (this.slideOptionsRange) for (const key of Object.keys(options)) ctx.ranges.set(`${path}/${key}`, this.slideOptionsRange);
+    set("id", options.id);
+    set("type", options.type);
+    set("beat", options.beat);
+    set("layout", options.layout);
+    set("section", options.section);
+    set("tag", options.tag);
+    set("title", this.title);
+    set("subtitle", this.subtitle);
+    const content = this.blocks.filter((block) => block.options?.region === void 0);
+    const regions = this.blocks.filter((block) => block.options?.region !== void 0);
+    const [only2] = content;
+    if (content.length === 1 && only2?.key !== void 0 && only2.options?.id === void 0 && only2.options?.type === void 0 && isContentKey(only2.key) && Object.keys(only2.payload).length === 1) {
+      slide[only2.key] = only2.payload[only2.key];
+      ctx.ranges.set(`${path}/${only2.key}`, only2.range);
+    } else if (content.length) {
+      slide.blocks = content.map((block, index) => {
+        ctx.ranges.set(`${path}/blocks/${index}`, block.range);
+        const out = {};
+        if (block.options?.id !== void 0) out.id = block.options.id;
+        if (block.options?.type !== void 0) out.type = block.options.type;
+        return Object.assign(out, block.payload);
+      });
+    }
+    for (const block of regions) {
+      const region = block.options.region;
+      const payload = {};
+      if (block.options?.id !== void 0) payload.id = block.options.id;
+      if (block.options?.type !== void 0) payload.type = block.options.type;
+      Object.assign(payload, block.payload);
+      ctx.ranges.set(`${path}/${region}`, block.range);
+      set(region, payload, block.range);
+    }
+    set("notes", this.notes || void 0, this.notesRange);
+    if (this.notesRange && this.notes) ctx.ranges.set(`${path}/notes`, this.notesRange);
+    set("hidden", options.hidden);
+    for (const [key, value] of Object.entries(this.extras ?? {})) set(key, value);
+    return slide;
+  }
+};
+var CONTENT = /* @__PURE__ */ new Set(["text", "items", "bullets", "image", "video", "chart", "table", "code", "metric", "quote", "timeline"]);
+var isContentKey = (key) => CONTENT.has(key);
+function splitRow(text) {
+  let s = text.trim();
+  if (s.startsWith("|")) s = s.slice(1);
+  const cells = [];
+  let cell = "";
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (c === "\\" && i + 1 < s.length) {
+      cell += c + s[i + 1];
+      i++;
+    } else if (c === "|") {
+      cells.push(cell.trim());
+      cell = "";
+    } else cell += c;
+  }
+  if (cell.trim() !== "" || !/\|\s*$/.test(text)) cells.push(cell.trim());
+  return cells;
+}
+function parseSlide(ctx, lines, index) {
+  const path = `/slides/${index}`;
+  const first = lines.find((line) => !BLANK.test(line.text));
+  const last = [...lines].reverse().find((line) => !BLANK.test(line.text));
+  if (first && last) ctx.ranges.set(path, lineRange(first, last));
+  return new SlideParser(ctx, lines, path).run();
+}
+function emptySegment(lines) {
+  return lines.every((line) => BLANK.test(line.text));
+}
+function parseSlideText(text) {
+  const ctx = new Ctx(text);
+  const segments = splitSegments(splitLines(text), "rules").filter((segment) => !emptySegment(segment));
+  if (segments.length !== 1) return { slide: void 0, clean: false };
+  const slide = parseSlide(ctx, segments[0], 0);
+  return { slide, clean: ctx.diagnostics.length === 0 };
+}
+function frontMatter(lines) {
+  if (!lines.length || lines[0].text.trimEnd() !== "---") return void 0;
+  for (let i = 1; i < lines.length; i++) {
+    const text = lines[i].text.trimEnd();
+    if (text === "---" || text === "...") return { yaml: { start: lines[0].end, end: lines[i].start }, end: i + 1 };
+  }
+  return "unterminated";
+}
+
+// src/markdown/emit.ts
+var CONTENT2 = ["text", "items", "bullets", "image", "video", "chart", "table", "code", "metric", "quote", "timeline"];
+var isContent = (key) => CONTENT2.includes(key);
+var ROWS = "(?:top|middle|bottom|top\\+middle|middle\\+bottom|top\\+middle\\+bottom)";
+var COLUMNS = "(?:left|center|right|left\\+center|center\\+right|left\\+center\\+right)";
+var REGION = new RegExp(`^(?:${ROWS}(?::${COLUMNS})?|${COLUMNS})$`);
+var NATIVE_SLIDE = /* @__PURE__ */ new Set(["id", "type", "layout", "section", "tag", "hidden", "beat", "title", "subtitle", "notes", "blocks", ...CONTENT2]);
+function fenceFor(body, char = "`") {
+  let longest = 2;
+  for (const line of body) for (const run of line.matchAll(char === "`" ? /`+/g : /~+/g)) longest = Math.max(longest, run[0].length);
+  return char.repeat(longest + 1);
+}
+var fenced = (info, body) => {
+  const fence = fenceFor(body);
+  return [`${fence}${info}`, ...body, fence];
+};
+var optionValue = (value) => {
+  if (value.includes("--") || /[\r\n]/.test(value)) return void 0;
+  return /^[A-Za-z0-9_][A-Za-z0-9_.:+/@#-]*$/.test(value) && value !== "true" && value !== "false" ? value : JSON.stringify(value);
+};
+var oneLine = (value) => typeof value === "string" && value !== "" && !/[\r\n]/.test(value) && value === value.trim();
+function listLines(items, marker) {
+  const lines = [];
+  for (const raw of items) {
+    const item = raw;
+    const text = isRecord(item) && !Array.isArray(item) ? item.text : item;
+    const level = isRecord(item) && !Array.isArray(item) && typeof item.level === "number" ? item.level : 0;
+    const rows = serializeRuns(text);
+    if (!rows || rows.length !== 1) return void 0;
+    const indent = "  ".repeat(level);
+    lines.push(rows[0] === "" ? `${indent}${marker}` : `${indent}${marker} ${rows[0]}`);
+    if (isRecord(item) && !Array.isArray(item) && item.description !== void 0) {
+      const description = serializeRuns(item.description);
+      if (!description || description.length !== 1 || description[0] === "") return void 0;
+      lines.push(`${indent}  : ${description[0]}`);
+    }
+  }
+  return lines;
+}
+function destination(url) {
+  if (!url || /[\r\n<>]/.test(url)) return void 0;
+  return /^[^\s()]+$/.test(url) ? url : `<${url}>`;
+}
+function imageLines(value) {
+  const asset = typeof value === "string" ? { src: value } : value;
+  const dest = destination(String(asset.src));
+  if (dest === void 0) return void 0;
+  const alt = asset.alt === void 0 ? "" : String(asset.alt);
+  if (/[\r\n]/.test(alt)) return void 0;
+  let title = "";
+  if (asset.title !== void 0) {
+    if (/[\r\n]/.test(String(asset.title))) return void 0;
+    title = ` "${String(asset.title).replace(/[\\"]/g, "\\$&")}"`;
+  }
+  return [`![${escapeInline(alt)}](${dest}${title})`];
+}
+function tableLines(table) {
+  const rows = table.rows;
+  const columns = table.columns;
+  const width = columns ? columns.length : Math.max(0, ...rows.map((row) => row.length));
+  if (!width) return void 0;
+  const cell = (value) => {
+    if (value === null) return "";
+    if (typeof value === "number") return String(value);
+    const rows2 = serializeRuns(value, "cell");
+    return rows2?.[0]?.replaceAll("|", "\\|");
+  };
+  const render = (cells) => {
+    const out = cells.map(cell);
+    return out.includes(void 0) ? void 0 : `| ${out.join(" | ")} |`;
+  };
+  const header = render(columns ?? Array.from({ length: width }, () => null));
+  const body = rows.map(render);
+  if (header === void 0 || body.includes(void 0)) return void 0;
+  return [header, `| ${Array.from({ length: width }, () => "---").join(" | ")} |`, ...body];
+}
+function chartJson(data) {
+  const entries = Object.entries(data).map(
+    ([key, value]) => key === "rows" && Array.isArray(value) ? ['  "rows": [', ...value.map((row, index) => `    ${JSON.stringify(row)}${index < value.length - 1 ? "," : ""}`), "  ]"] : [`  ${JSON.stringify(key)}: ${JSON.stringify(value)}`]
+  );
+  return ["{", ...entries.flatMap((lines, index) => lines.map((line, at) => at === lines.length - 1 && index < entries.length - 1 ? `${line},` : line)), "}"];
+}
+function chartCandidates(chart) {
+  if (!/^\S+$/.test(chart.type)) return [];
+  const data = chart.data;
+  const info = `chart ${chart.type}`;
+  const json = fenced(info, chartJson(data));
+  if (Array.isArray(data.columns) && Array.isArray(data.rows)) {
+    const body = [data.columns.map((column) => csvField(column, true)).join(","), ...data.rows.map((row) => row.map((value, index) => csvField(value, index === 0)).join(","))];
+    return [fenced(info, body), json];
+  }
+  return [json];
+}
+function timelineLines(timeline) {
+  const events = Array.isArray(timeline) ? timeline : timeline.events;
+  const meta = Array.isArray(timeline) ? {} : timeline;
+  const info = ["timeline", ...["name", "description"].filter((key) => meta[key] !== void 0).map((key) => `${key}=${JSON.stringify(meta[key])}`)].join(" ");
+  const body = [];
+  for (const event of events) {
+    for (const key of ["when", "what", "description"]) if (typeof event[key] === "string" && (/[\r\n]/.test(event[key]) || event[key] !== event[key].trim() || event[key] === "")) return void 0;
+    body.push(event.when === void 0 ? event.what : `${event.when} \u2014 ${event.what}`);
+    if (event.description !== void 0) body.push(`  ${event.description}`);
+  }
+  return fenced(info, body);
+}
+function metricLines(metric) {
+  const value = typeof metric === "object" ? metric : { value: metric };
+  const body = [];
+  for (const key of ["value", "label", "description", "unit", "delta", "trend"]) if (value[key] !== void 0) body.push(`${key}: ${scalarText(value[key])}`);
+  return fenced("metric", body);
+}
+function quoteLines(quote) {
+  const value = typeof quote === "string" ? { text: quote } : quote;
+  const lines = [];
+  const paragraphs = String(value.text).split("\n\n");
+  for (const [index, paragraph] of paragraphs.entries()) {
+    const rows = serializeRuns(paragraph);
+    if (!rows) return void 0;
+    if (index > 0) lines.push(">");
+    for (const row of rows) lines.push(row === "" ? ">" : `> ${row}`);
+  }
+  for (const key of ["attribution", "source"]) {
+    if (value[key] === void 0) continue;
+    if (!oneLine(value[key])) return void 0;
+    lines.push(`> \u2014 ${escapeInline(value[key])}`);
+  }
+  return lines;
+}
+function nativeCandidates(key, canon, marker) {
+  if (key === "chart") return chartCandidates(canon);
+  const lines = nativeLines(key, canon, marker);
+  return lines?.length ? [lines] : [];
+}
+function nativeLines(key, canon, marker) {
+  switch (key) {
+    case "text": {
+      if (canon === "") return void 0;
+      return serializeRuns(canon);
+    }
+    case "items":
+    case "bullets":
+      return listLines(canon, marker);
+    case "quote":
+      return quoteLines(canon);
+    case "code": {
+      const code = typeof canon === "string" ? { source: canon } : canon;
+      const language = code.language;
+      if (language !== void 0 && (!/^[A-Za-z0-9_+#.-]+$/.test(language) || ["chart", "metric", "timeline", "opf-slide", "opf-block"].includes(language))) return void 0;
+      return fenceCode(code.source, language, code.filename);
+    }
+    case "metric":
+      return metricLines(canon);
+    case "image":
+    case "video":
+      return imageLines(canon);
+    case "table":
+      return tableLines(canon);
+    case "timeline":
+      return timelineLines(canon);
+    default:
+      return void 0;
+  }
+}
+function blockOptionsLine(spec, as) {
+  const parts = [];
+  for (const [key, value] of [["id", spec.id], ["type", spec.type], ["as", as], ["region", spec.region]]) {
+    if (value === void 0) continue;
+    const text = typeof value === "string" ? optionValue(value) : void 0;
+    if (text === void 0) return void 0;
+    parts.push(`${key}=${text}`);
+  }
+  return parts.length ? `<!-- block: ${parts.join(" ")} -->` : "";
+}
+function nativeBlock(spec, marker) {
+  const canon = canonContent(spec.key, spec.value);
+  if (canon === void 0) return void 0;
+  const as = spec.key === "bullets" ? "bullets" : spec.key === "video" ? "video" : void 0;
+  const logical = spec.key === "bullets" ? "items" : spec.key === "video" ? "image" : spec.key;
+  const options = blockOptionsLine(spec, as);
+  if (options === void 0) return void 0;
+  for (const lines of nativeCandidates(logical, canon, marker)) {
+    const all = options ? [options, ...lines] : lines;
+    const { slide, clean } = parseSlideText(all.join("\n"));
+    if (!slide || !clean) continue;
+    const target = spec.region !== void 0 ? slide[spec.region] : spec.id !== void 0 || spec.type !== void 0 ? slide.blocks?.[0] : slide;
+    if (target && same(target[spec.key], canon)) return all;
+  }
+  return void 0;
+}
+function embed(value) {
+  const text = writeYaml(value);
+  return text === void 0 ? void 0 : fenced("opf-block", text.trimEnd().split("\n"));
+}
+function emitSlide(slide, index, mode) {
+  const path = `/slides/${index}`;
+  const embedded = [];
+  const loss = [];
+  const extras = {};
+  const sections = [];
+  const exp = {};
+  const expBlocks = [];
+  const handle = (where, reason, keep) => {
+    if (mode === "embed") {
+      embedded.push({ path: where, reason });
+      keep();
+    } else loss.push({ path: where, message: reason });
+  };
+  const options = [];
+  const optionFields = [["id", slide.id], ["type", slide.type], ["beat", slide.beat], ["layout", slide.layout], ["section", slide.section], ["tag", slide.tag]];
+  const failed = [];
+  for (const [key, value] of optionFields) {
+    if (value === void 0) continue;
+    if (key === "beat" && Array.isArray(value) && value.length >= 2 && value.every((entry) => typeof entry === "string")) {
+      const texts = value.map(optionValue);
+      if (texts.every((entry) => entry !== void 0)) options.push(...texts.map((entry) => ["beat", entry]));
+      else failed.push(key);
+      continue;
+    }
+    const text = typeof value === "string" ? optionValue(value) : void 0;
+    if (text === void 0) failed.push(key);
+    else options.push([key, text]);
+  }
+  if (slide.hidden === true) options.push(["hidden", "true"]);
+  else if (slide.hidden === false) options.push(["hidden", "false"]);
+  else if (slide.hidden !== void 0) failed.push("hidden");
+  const optionsText = options.map(([key, text]) => key === "hidden" && text === "true" ? "hidden" : `${key}=${text}`).join(" ");
+  const optionsLine = options.length ? `<!-- slide: ${optionsText} -->` : "";
+  if (optionsLine) {
+    const { slide: back, clean } = parseSlideText(optionsLine);
+    const expected = {};
+    for (const [key] of options) expected[key] = slide[key];
+    if (!back || !clean || !same(back, expected)) {
+      for (const [key] of options) failed.push(key);
+      options.length = 0;
+    }
+  }
+  for (const key of new Set(failed)) handle(`${path}/${key}`, `slide option ${key} has no <!-- slide: --> form`, () => extras[key] = slide[key]);
+  const kept = options.length ? `<!-- slide: ${options.map(([key, text]) => key === "hidden" && text === "true" ? "hidden" : `${key}=${text}`).join(" ")} -->` : "";
+  if (kept) {
+    sections.push({ lines: [kept] });
+    for (const [key] of options) exp[key] = slide[key];
+  }
+  for (const [key, mark] of [["title", "#"], ["subtitle", "##"]]) {
+    const value = slide[key];
+    if (value === void 0) continue;
+    if (oneLine(value)) {
+      const line = `${mark} ${escapeInline(value).replace(/(^|\s)(#+)$/, "$1\\$2")}`;
+      const { slide: back, clean } = parseSlideText(line);
+      if (back && clean && back[key] === value) {
+        sections.push({ lines: [line] });
+        exp[key] = value;
+        continue;
+      }
+    }
+    handle(`${path}/${key}`, `the ${key} is not a single line of plain text`, () => extras[key] = value);
+  }
+  const specs = [];
+  const handledRegions = /* @__PURE__ */ new Set();
+  if (Array.isArray(slide.blocks)) {
+    slide.blocks.forEach((block, i) => {
+      const where = `${path}/blocks/${i}`;
+      if (!isRecord(block)) return;
+      const keys = Object.keys(block).filter((key) => key !== "id" && key !== "type");
+      const only3 = keys.length === 1 && isContent(keys[0]) ? keys[0] : void 0;
+      specs.push({ spec: { key: only3 ?? "", value: only3 ? block[only3] : void 0, id: block.id, type: block.type }, where, payload: block });
+    });
+    for (const key of CONTENT2) if (slide[key] !== void 0) extras[key] = slide[key];
+  } else {
+    for (const key of CONTENT2) if (slide[key] !== void 0) specs.push({ spec: { key, value: slide[key] }, where: `${path}/${key}` });
+  }
+  for (const [key, value] of Object.entries(slide)) {
+    if (!REGION.test(key) || !isRecord(value)) continue;
+    const rest = Object.keys(value).filter((entry) => entry !== "id" && entry !== "type");
+    const only3 = rest.length === 1 && isContent(rest[0]) ? rest[0] : void 0;
+    if (only3 === void 0) continue;
+    handledRegions.add(key);
+    specs.push({ spec: { key: only3, value: value[only3], id: value.id, type: value.type, region: key }, where: `${path}/${key}`, payload: value });
+  }
+  let marker = "-";
+  for (const { spec, where, payload } of specs) {
+    const lines2 = spec.key ? nativeBlock(spec, marker) : void 0;
+    if (lines2) {
+      sections.push({ lines: lines2 });
+      const written = { ...spec.id !== void 0 ? { id: spec.id } : {}, ...spec.type !== void 0 ? { type: spec.type } : {}, [spec.key]: canonContent(spec.key, spec.value) };
+      if (spec.region !== void 0) exp[spec.region] = written;
+      else expBlocks.push(written);
+      const list = spec.key === "items" || spec.key === "bullets";
+      marker = list ? marker === "-" ? "*" : "-" : "-";
+      continue;
+    }
+    marker = "-";
+    handle(where, spec.key ? `${spec.key} content has a part with no Markdown form` : "a block with several fields or a nested group has no Markdown form", () => {
+      if (spec.region !== void 0) {
+        extras[spec.region] = slide[spec.region];
+        return;
+      }
+      const payloadValue = payload ?? { [spec.key]: spec.value };
+      const lines3 = embed(payloadValue);
+      if (!lines3) throw new OPFMarkdownError("not-representable", `The block at ${where} holds a value that YAML cannot carry exactly.`, { path: where });
+      sections.push({ lines: lines3 });
+      if (spec.region !== void 0) exp[spec.region] = structuredClone(payloadValue);
+      else expBlocks.push(structuredClone(payloadValue));
+    });
+  }
+  let notesLines;
+  if (slide.notes !== void 0) {
+    const notes = slide.notes;
+    if (typeof notes === "string" && notes !== "" && !/\r/.test(notes)) {
+      const rows = notes.split("\n");
+      const candidate = [`Note: ${rows[0]}`, ...rows.slice(1)];
+      const { slide: back, clean } = parseSlideText(candidate.join("\n"));
+      if (back && clean && back.notes === notes) {
+        notesLines = candidate;
+        exp.notes = notes;
+      }
+    }
+    if (!notesLines) handle(`${path}/notes`, "the speaker notes have no Note: form (blank edges, a --- line or a carriage return)", () => extras.notes = notes);
+  }
+  for (const [key, value] of Object.entries(slide)) if (!NATIVE_SLIDE.has(key) && !handledRegions.has(key)) handle(`${path}/${key}`, `${JSON.stringify(key)} has no Markdown form`, () => extras[key] = value);
+  if (Object.keys(extras).length) {
+    const text = writeYaml(extras);
+    if (text === void 0) throw new OPFMarkdownError("not-representable", `The slide at ${path} holds a value that YAML cannot carry exactly.`, { path });
+    sections.push({ lines: fenced("opf-slide", text.trimEnd().split("\n")) });
+    Object.assign(exp, structuredClone(extras));
+  }
+  const [only2] = expBlocks;
+  const onlyKey = only2 && Object.keys(only2).length === 1 ? Object.keys(only2)[0] : void 0;
+  if (expBlocks.length === 1 && onlyKey !== void 0 && isContent(onlyKey)) exp[onlyKey] = only2[onlyKey];
+  else if (expBlocks.length) exp.blocks = expBlocks;
+  if (notesLines) sections.push({ lines: notesLines });
+  if (!sections.length) sections.push({ lines: ["<!-- slide -->"] });
+  const lines = sections.flatMap((section, i) => i === 0 || i === 1 && kept ? section.lines : ["", ...section.lines]);
+  if (mode === "embed") {
+    const { slide: back, clean } = parseSlideText(lines.join("\n"));
+    if (!back || !clean || !same(back, exp)) throw new OPFMarkdownError("not-representable", `The slide at ${path} does not read back from its Markdown.`, { path, expected: exp, actual: back });
+  }
+  return { lines, embedded, loss };
+}
+
+// src/markdown.ts
+function markdownToOpf(markdown, options = {}) {
+  if (typeof markdown !== "string") throw new TypeError("markdownToOpf expects a string.");
+  const source = markdown;
+  const ctx = new Ctx(source);
+  let lines = splitLines(source);
+  if (lines[0]?.text.startsWith("\uFEFF")) lines = [{ ...lines[0], text: lines[0].text.slice(1), start: lines[0].start + 1 }, ...lines.slice(1)];
+  const front = {};
+  let body = lines;
+  const matter = frontMatter(lines);
+  if (matter === "unterminated") {
+    ctx.error("front-matter-unterminated", "The front matter starting on line 1 is not closed.", "Close it with a line containing only ---, or remove the opening --- (a deck without front matter starts with its first slide).", lineRange(lines[0]));
+    body = lines.slice(1);
+  } else if (matter) {
+    const range = { start: matter.yaml.start, end: matter.yaml.end };
+    const parsed = readYamlMapping(source.slice(range.start, range.end), range.start, ctx, "front-matter", range);
+    ctx.ranges.set("", range);
+    if (parsed.ok && !Object.keys(parsed.value).length && source.slice(range.start, range.end).trim()) ctx.warn("front-matter-comments", "The text between the first two --- lines is only YAML comments, so it was not read as slide content.", "A deck that starts with a slide must not start with a --- line: only front matter may open the file. Remove the first --- or add the deck properties.", range);
+    for (const [key, value] of Object.entries(parsed.value)) {
+      if (key === "slides") ctx.error("front-matter-slides", "The front matter cannot hold `slides`: slides are the Markdown that follows it.", "Remove the slides key and write the slides below the front matter, separated by ---.", parsed.keys.get("slides") ?? range, "/slides");
+      else Object.defineProperty(front, key, { value, enumerable: true, writable: true, configurable: true });
+    }
+    for (const [key, found] of parsed.keys) ctx.ranges.set(`/${key.replaceAll("~", "~0").replaceAll("/", "~1")}`, found);
+    body = lines.slice(matter.end);
+  }
+  const document = { ...options.defaults ?? {}, ...front };
+  const segments = splitSegments(body, options.split ?? "rules");
+  const slides = [];
+  segments.forEach((segment, index) => {
+    if (emptySegment(segment)) {
+      const edge = index === 0 || index === segments.length - 1;
+      if (!edge) {
+        const around = segment[0] ?? segments[index + 1]?.[0] ?? segments[index - 1]?.at(-1);
+        if (around) ctx.warn("empty-slide", "Two --- lines in a row give an empty slide, which was skipped.", "Remove the extra ---, or write <!-- slide --> to keep an empty slide.", lineRange(around));
+      }
+      return;
+    }
+    slides.push(parseSlide(ctx, segment, slides.length));
+  });
+  document.slides = slides;
+  if (!slides.length) ctx.error("no-slides", "The Markdown has no slides.", "Write at least one slide: a # title or any content, with --- between slides.", { start: 0, end: Math.min(1, source.length) }, "/slides");
+  else if (options.validate !== false) {
+    for (const found of lintPresentation(document).diagnostics) {
+      const range = ctx.rangeOf(found.path) ?? ctx.rangeOf("") ?? { start: 0, end: 0 };
+      ctx.diagnostics.push({ ...found, location: ctx.location(range) });
+    }
+  }
+  const diagnostics = [...ctx.diagnostics].sort((a, b) => a.location.offset - b.location.offset);
+  const counts = { error: 0, warning: 0, info: 0 };
+  for (const diagnostic of diagnostics) counts[diagnostic.severity]++;
+  return { document, valid: counts.error === 0, diagnostics, counts };
+}
+function opfToMarkdown(document, options = {}) {
+  const checked = validatePresentation(document);
+  if (!checked.valid) {
+    const first = checked.errors[0];
+    throw new OPFMarkdownError("invalid-document", `The document is not valid OPF: ${first?.message ?? "unknown error"}${first?.path ? ` (${first.path})` : ""}.`, { issues: checked.errors });
+  }
+  const mode = options.unsupported === "drop" ? "drop" : "embed";
+  const { slides, ...rest } = document;
+  const parts = [];
+  if (Object.keys(rest).length) {
+    const yaml = writeYaml(rest);
+    if (yaml === void 0) throw new OPFMarkdownError("not-representable", "The deck properties hold a value that YAML cannot carry exactly.");
+    if (!same(readBack(yaml), rest)) throw new OPFMarkdownError("not-representable", "The deck properties do not read back from their front matter.");
+    parts.push(`---
+${yaml}---
+`);
+  }
+  const embedded = [];
+  const loss = [];
+  const bodies = [];
+  slides.forEach((slide, index) => {
+    const out = emitSlide(slide, index, mode);
+    embedded.push(...out.embedded);
+    loss.push(...out.loss.map((part) => `${part.path}: ${part.message}`));
+    bodies.push(out.lines.join("\n"));
+  });
+  const markdown = `${parts.length ? `${parts[0]}
+` : ""}${bodies.join("\n\n---\n\n")}
+`;
+  return { markdown, report: { lossless: loss.length === 0, native: loss.length === 0 && embedded.length === 0, embedded, loss } };
+}
+function readBack(yaml) {
+  const ctx = new Ctx(yaml);
+  return readYamlMapping(yaml, 0, ctx, "front-matter", { start: 0, end: yaml.length }).value;
+}
+
+export { OPFMarkdownError, markdownToOpf, opfToMarkdown };