@openpresentation/opf-editor 0.26.2 → 0.26.4

package/dist/source-pane.js

@@ -9,7 +9,8 @@ import { buildProblems, summarize } from "./source-problems.js";
 import { analyzeSyntax, findDuplicateKeys } from "./source-syntax.js";
 import { createSchemaValue, schemaAtPath, schemaVariants } from "./schema.js";
 import { catalogKindAt } from "@openpresentation/opf/schema";
-import { locateJson } from "./source-ranges.js";
+import { locateText } from "./source-ranges.js";
+import { scanMarkdown } from "@openpresentation/opf/source";
 import { listCatalogRecords } from "./catalogs.js";
 
 // The source pane (RR-98): the OPF document as JSON, YAML or Markdown, with the file name, the format menu, Format, Copy
@@ -33,6 +34,7 @@ const ICONS = {
   Check: '<path d="M20 6 9 17l-5-5"/>',
   CircleX: '<circle cx="12" cy="12" r="10"/><path d="m15 9-6 6"/><path d="m9 9 6 6"/>',
   Info: '<circle cx="12" cy="12" r="10"/><path d="M12 16v-4"/><path d="M12 8h.01"/>',
+  Sparkles: '<path d="m12 3-1.912 5.813a2 2 0 0 1-1.275 1.275L3 12l5.813 1.912a2 2 0 0 1 1.275 1.275L12 21l1.912-5.813a2 2 0 0 1 1.275-1.275L21 12l-5.813-1.912a2 2 0 0 1-1.275-1.275L12 3Z"/>',
 };
 function icon(name, size = 14) {
   const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
@@ -170,10 +172,18 @@ export function createSourcePane(container, options = {}) {
   const formatAction = actionButton("Format (fix indentation)", "Braces", "format");
   formatAction.title = "Format (fix indentation), Shift+Alt+F";
   formatAction.setAttribute("aria-keyshortcuts", "Shift+Alt+F");
+  // The old Format (a rewrite through OPF's own writer) is its own command: it drops the comments of YAML and Markdown, so it asks first.
+  const canonicalAction = actionButton("Canonicalize with OPF", "Sparkles", "canonicalize");
+  canonicalAction.title = "Canonicalize with OPF: rewrite the text the way OPF writes it (drops comments)";
   const copyAction = actionButton("Copy source", "Copy", "copy");
   const downloadAction = actionButton("Download source", "Download", "download");
   bar.append(file, actions);
 
+  const confirm = el("div", "opf-source-confirm", { role: "alertdialog", "aria-labelledby": `${id}-confirm-text`, hidden: "" });
+  const confirmText = el("p", "opf-source-confirm-text", { id: `${id}-confirm-text` });
+  const confirmAccept = Object.assign(el("button", "opf-source-confirm-accept", { type: "button" }), { textContent: "Canonicalize anyway" });
+  const confirmCancel = Object.assign(el("button", "opf-source-confirm-cancel", { type: "button" }), { textContent: "Cancel" });
+  confirm.append(confirmText, confirmAccept, confirmCancel);
   const code = el("div", "opf-source-code");
   const status = el("div", "opf-source-status", { role: "status", "aria-live": "polite" });
 
@@ -185,7 +195,7 @@ export function createSourcePane(container, options = {}) {
   const list = el("ul", "opf-source-findings-list", { id: `${id}-findings` });
   findingsRegion.append(toggle, list);
 
-  root.append(bar, code, findingsRegion, status);
+  root.append(bar, confirm, code, findingsRegion, status);
   container.append(root);
 
   // ---- Document <-> text --------------------------------------------------------------------------------------------
@@ -233,6 +243,7 @@ export function createSourcePane(container, options = {}) {
     language: formatOf(format).language,
     readOnly,
     completions: options.completions !== false,
+    smartListEnter: options.smartListEnter,
     catalogs: options.catalogs ?? editor.catalogs,
     describedBy: `${id}-findings`,
     onChange: () => schedule(),
@@ -246,6 +257,7 @@ export function createSourcePane(container, options = {}) {
 
   // ---- Applying edits -----------------------------------------------------------------------------------------------
   function schedule() {
+    closeConfirm(false);
     clearTimeout(timer);
     clearTimeout(syntaxTimer);
     if (delay === 0) { flush(); return; }
@@ -325,6 +337,7 @@ export function createSourcePane(container, options = {}) {
 
   /** Show `value` as the text of the current format, as an external change. */
   function show(value) {
+    closeConfirm(false);
     baseline = value;
     shownInvalid = false;
     control.update(value, false, null, `${id}-findings`);
@@ -632,6 +645,7 @@ export function createSourcePane(container, options = {}) {
     nameButton.setAttribute("aria-label", `Rename ${name}`);
     formatLabel.textContent = `.opf.${current.extension}`;
     root.dataset.format = current.id;
+    canonicalAction.hidden = current.id === "json";
     for (const item of menuItems) item.setAttribute("aria-checked", String(item.dataset.format === current.id));
   }
 
@@ -670,6 +684,61 @@ export function createSourcePane(container, options = {}) {
     return true;
   }
   formatAction.addEventListener("click", () => { formatDocument(); });
+
+  // Canonicalize with OPF: the text rewritten through core's writer (the old Format). Unlike Format it drops comments, so it asks first and says how many.
+  function droppedComments(text) {
+    if (format === "yaml") return scanYamlComments(text).count;
+    if (format !== "md") return 0;
+    const scan = scanMarkdown(text);
+    let count = scan.comments.filter((comment) => comment.kind === "comment").length;
+    if (scan.frontMatter) count += scanYamlComments(text.slice(scan.frontMatter.yamlFrom, scan.frontMatter.yamlTo)).count;
+    for (const fence of scan.fences) if (fence.kind === "opf-slide" || fence.kind === "opf-block") count += scanYamlComments(text.slice(fence.bodyFrom, fence.bodyTo)).count;
+    return count;
+  }
+  let pendingCanonical = null;
+  function closeConfirm(returnFocus) {
+    if (confirm.hidden) return;
+    confirm.hidden = true;
+    pendingCanonical = null;
+    if (returnFocus) control.api.focus();
+  }
+  /** Rewrite the text through OPF's own writer. Asks first when that drops comments (`confirmed: true` has asked already). Returns "applied", "unchanged", "confirm" (waiting for the answer) or "refused". */
+  function canonicalize({ confirmed = false } = {}) {
+    flush();
+    if (readOnly || format === "json" || destroyed) return "refused";
+    if (dirty) { announce("Fix the errors first: the text cannot be read as a document."); control.api.say("Fix the errors first: the text cannot be read as a document."); return "refused"; }
+    let written;
+    try { written = write(format, deck()); } catch (error) { announce(`Cannot canonicalize: ${errorText(error)}`); return "refused"; }
+    const before = control.api.getValue();
+    if (written.text === before) { announce("Already canonical"); control.api.say("Already canonical"); return "unchanged"; }
+    const count = droppedComments(before);
+    if (count > 0 && !confirmed) {
+      pendingCanonical = written.text;
+      confirmText.textContent = `Canonicalizing rewrites the text the way OPF writes it, and drops ${plural(count, "comment")}. Undo brings ${count === 1 ? "it" : "them"} back.`;
+      confirm.hidden = false;
+      confirmAccept.focus();
+      control.api.say(confirmText.textContent);
+      return "confirm";
+    }
+    closeConfirm(false);
+    control.api.replaceDiff(written.text);
+    flush();
+    control.api.focus();
+    announce("Canonicalized");
+    control.api.say(count > 0 ? `Canonicalized. ${plural(count, "comment")} dropped.` : "Canonicalized");
+    return "applied";
+  }
+  canonicalAction.addEventListener("click", () => { canonicalize(); });
+  confirmAccept.addEventListener("click", () => { closeConfirm(false); canonicalize({ confirmed: true }); });
+  confirmCancel.addEventListener("click", () => closeConfirm(true));
+  confirm.addEventListener("keydown", (event) => {
+    if (event.key === "Escape") { event.preventDefault(); event.stopPropagation(); closeConfirm(true); }
+    else if (event.key === "Tab") {
+      const order = [confirmAccept, confirmCancel], at = order.indexOf(document.activeElement);
+      event.preventDefault();
+      order[(at + (event.shiftKey ? order.length - 1 : 1)) % order.length].focus();
+    }
+  });
   copyAction.addEventListener("click", async () => {
     const info = currentFile();
     try {
@@ -752,11 +821,9 @@ export function createSourcePane(container, options = {}) {
     flush();
     const text = control.api.getValue();
     const segments = String(focus.path ?? "").replace(/^\//, "").split("/").filter(Boolean).map((part) => part.replaceAll("~1", "/").replaceAll("~0", "~"));
-    if (format === "json") {
-      const wanted = focus.field ? locateJson(text, [...segments, focus.field], "value") : null;
-      const where = wanted?.exact ? wanted : locateJson(text, segments, "value");
-      if (where) { control.api.setSelection(where.from, where.to); control.api.focus(); return; }
-    }
+    const wanted = focus.field ? locateText(format, text, [...segments, focus.field], "value") : null;
+    const where = wanted?.exact ? wanted : locateText(format, text, segments, "value");
+    if (where) { control.api.setSelection(where.from, where.to); control.api.focus(); return; }
     focusPath(focus.path ?? "");
   }
   const fixActions = {
@@ -913,6 +980,7 @@ export function createSourcePane(container, options = {}) {
   root.toggleAttribute("data-readonly", readOnly);
   nameButton.disabled = readOnly;
   formatAction.disabled = readOnly;
+  canonicalAction.disabled = readOnly;
   renderFindings();
   syncAttributes();
 
@@ -936,6 +1004,8 @@ export function createSourcePane(container, options = {}) {
     getFormat: () => format,
     /** Move the cursor to the line of a JSON Pointer in the current format (best effort for YAML and Markdown). Returns the line. */
     focusPath: (path) => focusPath(path),
+    /** Canonicalize with OPF (rewrite through core's writer; asks before dropping comments). See `canonicalize` in the pane. */
+    canonicalize,
     /** The source text exactly as shown, with any edit still waiting applied first. */
     getText() { flush(); return control.api.getValue(); },
     getName: () => name,
@@ -946,6 +1016,7 @@ export function createSourcePane(container, options = {}) {
       root.toggleAttribute("data-readonly", readOnly);
       nameButton.disabled = readOnly;
       formatAction.disabled = readOnly;
+      canonicalAction.disabled = readOnly;
       control.setReadOnly(readOnly);
     },
     /** The problems drawn in the text now, in position order: `{ from, to, severity, message, next, rule, fixes }` at source offsets. */

package/dist/source-problems.js

@@ -2,7 +2,8 @@
 // column) and the quick fixes that go with it. The pane lists them in the panel and draws them in the text with the same objects.
 import { describeFinding, segmentsOf } from "./source-messages.js";
 import { fixesForFinding } from "./source-fixes.js";
-import { lineColumn, locateJson, partOf } from "./source-ranges.js";
+import { textFixesForFinding } from "./source-fixes-text.js";
+import { lineColumn, locateText, partOf } from "./source-ranges.js";
 
 const SEVERITY_ORDER = { error: 0, warning: 1, info: 2 };
 
@@ -30,8 +31,9 @@ export function buildProblems({ format, text, findings, context = {}, actions =
     const { message, next } = describeFinding(finding, context);
     let range = null;
     if (finding.range) range = { from: finding.range.from, to: finding.range.to };
-    else if (format === "json" && finding.kind !== "syntax" && finding.path !== undefined && finding.ruleId?.startsWith("opf/")) {
-      const located = locateJson(text, segmentsOf(finding.path), partOf(finding));
+    else if (finding.kind !== "syntax" && finding.path !== undefined && finding.ruleId?.startsWith("opf/")) {
+      // The finding names a field of the document: core finds it in the text of any format.
+      const located = locateText(format, text, segmentsOf(finding.path), partOf(finding));
       if (located) range = { from: located.from, to: located.to };
     }
     if (!range && Number.isInteger(finding.location?.offset)) range = { from: finding.location.offset, to: finding.location.offset + Math.max(0, finding.location.length ?? 0) };
@@ -40,7 +42,7 @@ export function buildProblems({ format, text, findings, context = {}, actions =
       if (fix.action === "switch-format") fixes.push({ id: fix.id, title: fix.title, safe: fix.safe === true, run: () => actions.switchFormat?.(fix.format) });
       else fixes.push({ ...fix, edits: toEdits(fix.edits) });
     }
-    if (format === "json" && finding.kind !== "syntax") fixes.push(...fixesForFinding(finding, text, context));
+    if (finding.kind !== "syntax") fixes.push(...(format === "json" ? fixesForFinding(finding, text, context) : textFixesForFinding(format, finding, text, context)));
     for (const fix of finding.fixes ?? []) { const row = coreFix(fix, actions); if (row) fixes.push(row); }
     const row = { finding, index, severity: finding.severity, message, next, rule: finding.ruleId, path: finding.path ?? "", fixes };
     if (range) {

package/dist/source-ranges.js

@@ -14,15 +14,18 @@ export function lineColumn(text, offset) {
 }
 
 /**
- * The range of `segments` in the JSON `text`, or null (core's `locate`, which reads text that does not parse). `part`: "value" (default), "key" (the
- * property name), "entry" (key to the end of the value), "colon" (the key and its colon) or "open" (the first character of the value, the `{` of an
- * object). A path that is not there gives the range of its nearest container, with `exact: false`.
+ * The range of `segments` in `text` of `format` ("json", "yaml" or "md"), or null (core's `locate`, which reads text that does not parse). `part`:
+ * "value" (default), "key" (the property name), "entry" (key to the end of the value), "colon" (the key and its colon) or "open" (the first character
+ * of the value, the `{` of an object). A path that is not there gives the range of its nearest container, with `exact: false`.
  */
-export function locateJson(text, segments, part = "value") {
-  const range = locate(text, "json", segments.map(String), { part });
+export function locateText(format, text, segments, part = "value") {
+  const range = locate(text, format, segments.map(String), { part });
   return range ? { from: range.offset, to: range.offset + range.length, exact: range.exact !== false } : null;
 }
 
+/** `locateText` for JSON. */
+export const locateJson = (text, segments, part = "value") => locateText("json", text, segments, part);
+
 /** The part of the text a finding is about, by what it says (VALIDATOR-HINTS section 4). */
 export function partOf(finding) {
   const keyword = finding.validation?.keyword;

package/dist/source-snippets.js

@@ -2,6 +2,8 @@
 // OPF fragment with numbered placeholders and rendered per format (JSON here; YAML and Markdown follow in phase 2), then handed to CodeMirror's
 // snippet engine, which walks the tab stops. Plain functions, no DOM.
 
+import { Document as YamlDocument } from "yaml";
+
 const PLACEHOLDER = Symbol("opf-placeholder");
 
 /**
@@ -70,6 +72,8 @@ export const SNIPPETS = Object.freeze([
   { prefix: "reference", where: "reference", description: "A reference a slide can cite", fragment: { id: ph(1, "smith2020"), text: ph(2, "Citation") } },
   { prefix: "dataset", where: "dataset", description: "A table of data that charts and tables can share", name: ph(1, "sales"), fragment: { columns: [ph(2, "Category"), ph(3, "Value")], rows: [[ph(4, "A"), ph(5, "1", { raw: true })]] } },
   { prefix: "deck", where: "deck", description: "A starter deck", fragment: { name: ph(1, "Deck name"), slides: [{ title: ph(2, "Title") }] } },
+  // Speaker notes in Markdown: a `Note:` line (JSON and YAML have the `notes` property for it).
+  { prefix: "notes", where: "markdown", key: "notes", description: "Speaker notes for the slide", fragment: ph(1, "Speaker notes") },
 ]);
 
 /** The snippets that fit where the caret is: `where` and the path of the node (see source-json.js). */
@@ -86,8 +90,143 @@ export function snippetsFor(mode, path) {
 
 /** The JSON text of a snippet for insertion: `{ text, fields }`; a dataset is a `"name": { ... }` entry. */
 export function snippetJson(snippet, { comma = false } = {}) {
+  if (snippet.key !== undefined) {
+    const body = renderJson(snippet.fragment, { comma });
+    return { text: `${JSON.stringify(snippet.key)}: ${body.text}`, fields: body.fields };
+  }
   if (snippet.where !== "dataset") return renderJson(snippet.fragment, { comma });
   const body = renderJson(snippet.fragment, { comma });
   const key = `"${field(snippet.name)}"`;
   return { text: `${key}: ${body.text}`, fields: [{ index: snippet.name.index, text: snippet.name.text }, ...body.fields].sort((a, b) => a.index - b.index) };
 }
+
+// ---- YAML ------------------------------------------------------------------------------------------------------------------------------
+const yamlText = (text) => {
+  try { return new YamlDocument(text).toString({ lineWidth: 0 }).trimEnd(); } catch { return JSON.stringify(text); }
+};
+// A placeholder as YAML: its text between the markers, quoted when plain YAML would read it as another type or as syntax (`42`, `a: b`).
+function yamlField(placeholder) {
+  const marker = (text) => `\${${placeholder.index}${text ? `:${escapeText(text)}` : ""}}`;
+  const text = placeholder.text || (placeholder.choice ? (placeholder.value ?? "") : "");
+  if (placeholder.raw || !text) return marker(text);
+  return yamlText(text) === text ? marker(text) : `"${marker(JSON.stringify(text).slice(1, -1))}"`;
+}
+
+/** The lines of a mapping as `[{ depth, text }]` (block style; lists of lists and `columns` in flow style), recording placeholders in `fields`. */
+function yamlLines(mapping, depth, fields) {
+  const scalar = (value) => {
+    if (isPlaceholder(value)) {
+      fields.push({ index: value.index, text: value.text || (value.choice ? (value.value ?? "") : ""), ...(value.choice ? { choice: true } : {}) });
+      return yamlField(value);
+    }
+    if (value === null) return "null";
+    return typeof value === "string" ? yamlText(value) : String(value);
+  };
+  const flow = (value) => (Array.isArray(value) ? `[${value.map(flow).join(", ")}]` : scalar(value));
+  const isCollection = (value) => value !== null && typeof value === "object" && !isPlaceholder(value);
+  const lines = [];
+  for (const [key, item] of Object.entries(mapping)) {
+    if (!isCollection(item)) { lines.push({ depth, text: `${key}: ${scalar(item)}` }); continue; }
+    if (Array.isArray(item)) {
+      if (!item.length) { lines.push({ depth, text: `${key}: []` }); continue; }
+      if (key === "columns") { lines.push({ depth, text: `${key}: ${flow(item)}` }); continue; }
+      lines.push({ depth, text: `${key}:` });
+      for (const entry of item) {
+        if (Array.isArray(entry)) lines.push({ depth: depth + 1, text: `- ${flow(entry)}` });
+        else if (isCollection(entry)) {
+          const inner = yamlLines(entry, depth + 2, fields);
+          if (inner.length) inner[0] = { depth: depth + 1, text: `- ${inner[0].text}` };
+          lines.push(...inner);
+        } else lines.push({ depth: depth + 1, text: `- ${scalar(entry)}` });
+      }
+      continue;
+    }
+    if (!Object.keys(item).length) { lines.push({ depth, text: `${key}: {}` }); continue; }
+    lines.push({ depth, text: `${key}:` }, ...yamlLines(item, depth + 1, fields));
+  }
+  return lines;
+}
+
+/**
+ * `{ text, fields }`: a fragment as block-style YAML with CodeMirror snippet markers. The first line starts where the caret is (after a dash or
+ * at a key position); the others are indented relative to the line the caret is on, and `dash` more columns when the caret follows a list dash.
+ * `entry` writes the fragment as the value of that key; `name` (a placeholder) writes it under a key the author names.
+ */
+export function renderYaml(fragment, { dash = 0, entry, name } = {}) {
+  const fields = [];
+  let lines;
+  if (name !== undefined) {
+    fields.push({ index: name.index, text: name.text });
+    lines = [{ depth: 0, text: `${yamlField(name)}:` }, ...yamlLines(fragment, 1, fields)];
+  } else if (entry !== undefined) lines = yamlLines({ [entry]: fragment }, 0, fields);
+  else lines = yamlLines(fragment, 0, fields);
+  const pad = " ".repeat(dash);
+  const text = lines.map((line, index) => (index === 0 ? line.text : `${pad}${"  ".repeat(line.depth)}${line.text}`)).join("\n");
+  return { text: `${text}\${0}`, fields: fields.sort((a, b) => a.index - b.index) };
+}
+
+/** The YAML text of a snippet for insertion: `{ text, fields }`. `dash` is the width of the list dash the caret follows (2), else 0. */
+export function snippetYaml(snippet, { dash = 0 } = {}) {
+  if (snippet.key !== undefined) return renderYaml(snippet.fragment, { dash, entry: snippet.key });
+  if (snippet.where === "dataset") return renderYaml(snippet.fragment, { dash, name: snippet.name });
+  return renderYaml(snippet.fragment, { dash });
+}
+
+// ---- Markdown --------------------------------------------------------------------------------------------------------------------------
+// A placeholder as Markdown text: the marker with its text (a choice starts with its default, `column`).
+function mdField(placeholder, fields) {
+  const text = placeholder.text || (placeholder.choice ? (placeholder.value ?? "") : "");
+  fields.push({ index: placeholder.index, text, ...(placeholder.choice ? { choice: true } : {}) });
+  return `\${${placeholder.index}${text ? `:${escapeText(text)}` : ""}}`;
+}
+
+const SLIDE_OPTION_FIELDS = ["id", "type", "layout", "section", "tag"];
+
+/**
+ * `{ text, fields }`: a slide fragment as the Markdown dialect writes it (options comment, `#` title, blocks, `Note:`), with CodeMirror snippet
+ * markers. `separator` puts `---` and a blank line first (a slide after another). A `notes` snippet is one `Note:` line. The shape follows
+ * core's writer, so the result reads back as the slide the fragment describes.
+ */
+export function renderMarkdown(fragment, { separator = false, entry } = {}) {
+  const fields = [];
+  const value = (item) => (isPlaceholder(item) ? mdField(item, fields) : item === null || item === undefined ? "" : String(item));
+  if (entry === "notes") return { text: `Note: ${value(fragment)}\${0}`, fields };
+  const blocks = [];
+  const options = [];
+  for (const key of SLIDE_OPTION_FIELDS) if (typeof fragment[key] === "string" || isPlaceholder(fragment[key])) options.push(`${key}=${value(fragment[key])}`);
+  // The options comment sits directly above what follows it, as core writes it.
+  const lead = options.length ? `<!-- slide: ${options.join(" ")} -->` : "";
+  if (fragment.title !== undefined) blocks.push(`${lead ? `${lead}\n` : ""}# ${value(fragment.title)}`);
+  else if (lead) blocks.push(lead);
+  if (fragment.subtitle !== undefined) blocks.push(`## ${value(fragment.subtitle)}`);
+  const bullets = (items) => items.map((item) => `- ${value(item)}`).join("\n");
+  const csv = (rows) => rows.map((row) => row.map((cell) => value(cell)).join(",")).join("\n");
+  if (fragment.text !== undefined) blocks.push(value(fragment.text));
+  if (Array.isArray(fragment.items)) blocks.push(bullets(fragment.items));
+  for (const region of ["left", "right"]) {
+    if (fragment[region]) blocks.push(`<!-- block: region=${region} -->\n${bullets(fragment[region].items ?? [])}`);
+  }
+  if (fragment.image) blocks.push(`![${value(fragment.image.alt)}](${value(fragment.image.src)})`);
+  if (fragment.chart) blocks.push(`\`\`\`chart ${value(fragment.chart.type)}\n${csv([fragment.chart.data.columns, ...fragment.chart.data.rows])}\n\`\`\``);
+  if (fragment.quote) blocks.push(`> ${value(fragment.quote.text)}${fragment.quote.attribution === undefined ? "" : `\n> — ${value(fragment.quote.attribution)}`}`);
+  if (fragment.metric) blocks.push(`\`\`\`metric\nvalue: ${value(fragment.metric.value)}\nlabel: ${value(fragment.metric.label)}\n\`\`\``);
+  if (fragment.table) {
+    const row = (cells) => `| ${cells.map((cell) => value(cell)).join(" | ")} |`;
+    blocks.push([row(fragment.table.columns), row(fragment.table.columns.map(() => "---")), ...fragment.table.rows.map(row)].join("\n"));
+  }
+  if (fragment.code) blocks.push(`\`\`\`${value(fragment.code.language)}\n${value(fragment.code.source)}\n\`\`\``);
+  if (fragment.notes !== undefined) blocks.push(`Note: ${value(fragment.notes)}`);
+  const body = blocks.join("\n\n");
+  return { text: `${separator ? "---\n\n" : ""}${body}\${0}`, fields: fields.sort((a, b) => a.index - b.index) };
+}
+
+/** The Markdown text of a snippet for insertion at the start of a line: `{ text, fields }`. `separator`: a slide follows another. */
+export function snippetMarkdown(snippet, { separator = false } = {}) {
+  if (snippet.key !== undefined) return renderMarkdown(snippet.fragment, { entry: snippet.key });
+  return renderMarkdown(snippet.fragment, { separator });
+}
+
+/** The snippets of the Markdown body: a slide of each kind and the speaker notes. */
+export function snippetsForMarkdown() {
+  return SNIPPETS.filter((snippet) => snippet.where === "slide" || snippet.where === "markdown");
+}