@openpresentation/opf 0.26.3 → 0.26.4

package/dist/chunk-GWJBZ4LC.js

@@ -0,0 +1,639 @@
+import { NOT_CHECKED } from './chunk-RYZPBJLB.js';
+import { readMarkdown, parseSlideText, escapeInline, serializeRuns } from './chunk-MN7DRK57.js';
+import { fenceCode } from './chunk-O6BY3AU2.js';
+import { OPFMarkdownError, writeYaml, Ctx, readYamlMapping, csvField, scalarText } from './chunk-QAEBYDKY.js';
+import { same, isRecord, runText, isPlainRun, FORMATTING } from './chunk-6NBTZYYD.js';
+import { validate } from './chunk-XFOOKVRI.js';
+import { checkCatalogsOption } from './chunk-XRMV2GMB.js';
+
+// 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"])) return void 0;
+  const text = canonText(value.text);
+  if (text === void 0) 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 typeof text === "string" ? text : { text };
+  const out = { 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", "sentiment"])) 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", "sentiment"]) {
+    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", "alt", "data"]) || typeof value.type !== "string" || !isRecord(value.data)) return void 0;
+  if (value.alt !== void 0 && typeof value.alt !== "string") return void 0;
+  const alt = value.alt === void 0 ? {} : { alt: value.alt };
+  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, ...alt, data: { columns: data.columns, rows: data.rows } };
+  }
+  return void 0;
+}
+function canonEvent(event) {
+  if (!isRecord(event) || !only(event, ["when", "what", "description", "status"]) || 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;
+  if (event.status !== void 0 && !["done", "current", "planned"].includes(event.status)) 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;
+  if (event.status !== void 0) out.status = event.status;
+  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/emit.ts
+var CONTENT = ["text", "items", "bullets", "image", "video", "chart", "table", "code", "metric", "quote", "timeline"];
+var isContent = (key) => CONTENT.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", ...CONTENT]);
+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;
+  if (typeof chart.alt === "string" && chart.alt.includes("`")) return [];
+  const info = `chart ${chart.type}${typeof chart.alt === "string" ? ` alt=${JSON.stringify(chart.alt)}` : ""}`;
+  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];
+}
+var TIMELINE_STATUS_MARKS = { done: "[x] ", current: "[>] ", planned: "[ ] " };
+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;
+    const line = event.when === void 0 ? event.what : `${event.when} \u2014 ${event.what}`;
+    if (event.status === void 0 && /^\[[x> ]\]\s+\S/.test(line)) return void 0;
+    body.push(event.status === void 0 ? line : `${TIMELINE_STATUS_MARKS[event.status]}${line}`);
+    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", "sentiment"]) if (value[key] !== void 0) body.push(`${key}: ${scalarText(value[key])}`);
+  return fenced("metric", body);
+}
+function splitParagraphs(runs) {
+  const out = [[]];
+  for (const run of runs) {
+    runText(run).split("\n\n").forEach((part, index) => {
+      if (index > 0) out.push([]);
+      if (part !== "") out.at(-1).push(typeof run === "string" ? part : { ...run, text: part });
+    });
+  }
+  return out;
+}
+function quoteLines(quote) {
+  const value = typeof quote === "string" ? { text: quote } : quote;
+  const lines = [];
+  const paragraphs = Array.isArray(value.text) ? splitParagraphs(value.text) : 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 ?? spec.pin]]) {
+    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 || spec.pin !== 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;
+    const canon = canonText(value);
+    const row = canon === void 0 ? void 0 : typeof canon === "string" ? oneLine(canon) ? escapeInline(canon) : void 0 : serializeRuns(canon)?.length === 1 ? serializeRuns(canon)[0] : void 0;
+    if (canon !== void 0 && row) {
+      const line = `${mark} ${row.replace(/(^|\s)(#+)$/, "$1\\$2")}`;
+      const { slide: back, clean } = parseSlideText(line);
+      if (back && clean && same(back[key], canon)) {
+        sections.push({ lines: [line] });
+        exp[key] = canon;
+        continue;
+      }
+    }
+    handle(`${path}/${key}`, `the ${key} has no single-line Markdown form`, () => 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 pin = typeof block.region === "string" ? block.region : void 0;
+      const keys = Object.keys(block).filter((key) => key !== "id" && key !== "type" && !(key === "region" && pin !== void 0));
+      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, ...pin !== void 0 ? { pin } : {} }, where, payload: block });
+    });
+    for (const key of CONTENT) if (slide[key] !== void 0) extras[key] = slide[key];
+  } else {
+    for (const key of CONTENT) 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.pin !== void 0 ? { region: spec.pin } : {}, [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 fromMarkdown(markdown, options = {}) {
+  if (typeof markdown !== "string") throw new TypeError("fromMarkdown expects a string.");
+  checkCatalogsOption(options.catalogs, "fromMarkdown");
+  const { ctx, document } = readMarkdown(markdown, options);
+  const source = markdown;
+  const slides = document.slides;
+  let report = { schemaValid: null, checks: NOT_CHECKED };
+  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) {
+    const checked = validate(document, options.validate === true || options.validate === void 0 ? { only: ["format", "references"], ...options.catalogs ? { catalogs: options.catalogs } : {} } : options.validate);
+    report = {
+      schemaValid: checked.schemaValid,
+      checks: { ...checked.checks, syntax: "checked" },
+      ...checked.template === void 0 ? {} : { template: checked.template },
+      ...checked.unfilledVariables === void 0 ? {} : { unfilledVariables: checked.unfilledVariables }
+    };
+    for (const found of checked.findings) {
+      const range = ctx.rangeOf(found.path) ?? ctx.rangeOf("") ?? { start: 0, end: 0 };
+      ctx.findings.push({ ...found, location: ctx.location(range) });
+    }
+  }
+  const findings = [...ctx.findings].sort((a, b) => a.location.offset - b.location.offset);
+  const counts = { error: 0, warning: 0, info: 0 };
+  for (const entry of findings) counts[entry.severity]++;
+  return { presentation: document, valid: counts.error === 0, findings, counts, ...report };
+}
+function toMarkdown(document, options = {}) {
+  const checked = validate(document, { only: ["format"] });
+  if (!checked.valid) {
+    const errors = checked.findings.filter((entry) => entry.severity === "error");
+    const first = errors[0];
+    throw new OPFMarkdownError("invalid-document", `The document is not valid OPF: ${first?.message ?? "unknown error"}${first?.path ? ` (${first.path})` : ""}.`, { issues: 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 { fromMarkdown, toMarkdown };

package/dist/{chunk-YVNFACTC.js → chunk-H5QC3X3K.js}

@@ -1,4 +1,4 @@
-import { jsonEqual, formatPointer } from './chunk-NJWI6MPT.js';
+import { jsonEqual, formatPointer } from './chunk-XFOOKVRI.js';
 import { annotationText } from './chunk-XRMV2GMB.js';
 
 // src/diff-match.ts