@openpresentation/opf-editor 0.26.3 → 0.26.5

package/dist/source-editing.js

@@ -0,0 +1,265 @@
+// Editing rules of the YAML and Markdown source (artifacts/source-editor/SPEC.md, sections 6.1 to 6.6): Enter indents the way the text is built (one
+// level in after `key:`, aligned under the key after `- key: value`, a list item continued, an empty one ended), Tab nests a Markdown list item, Backspace
+// takes a list marker away, Cmd/Ctrl+/ comments a line, and the characters that pair or wrap a selection. Commands over a CodeMirror view; no network.
+// They read the text line by line, so they need no parser and work on half-typed text; the main bundle carries them (a few kilobytes).
+import { EditorSelection, EditorState } from "@codemirror/state";
+import { EditorView } from "@codemirror/view";
+import { foldService } from "@codemirror/language";
+import { indentMore } from "@codemirror/commands";
+import { flowDepth, readEntry, readMarkers } from "./source-yaml.js";
+
+const UNIT = "  ";
+const BLOCK_HEADER = /^[|>][+-]?\d*[+-]?\s*(?:#.*)?$/;
+const LIST_ITEM = /^(\s*)([-*+]|\d{1,9}[.)])([ \t]+)(.*)$/;
+const LIST_EMPTY = /^(\s*)([-*+]|\d{1,9}[.)])[ \t]*$/;
+const QUOTE = /^(\s{0,3})>([ \t]?)(.*)$/;
+
+// ---- language data -----------------------------------------------------------------------------------------------------------------
+/** Pairs per language (SPEC 6.3): YAML pairs quotes and flow brackets, Markdown pairs `(`, `[`, `{` and backticks (not `"` or `<`), JSON keeps its own. */
+export function languageDataFor(name) {
+  if (name === "yaml") return EditorState.languageData.of(() => [{ closeBrackets: { brackets: ["[", "{", '"', "'"] } }]);
+  if (name === "markdown") return EditorState.languageData.of(() => [{ closeBrackets: { brackets: ["(", "[", "{", "`"] }, commentTokens: { block: { open: "<!--", close: "-->" } } }]);
+  return [];
+}
+
+// ---- what a line of Markdown is in -------------------------------------------------------------------------------------------------
+/**
+ * Where line `number` (1-based) of a Markdown text is: "front" (inside the front matter), "fence" (inside a code fence), "yaml-fence" (inside an
+ * `opf-slide` or `opf-block` fence) or "body". Scans from the top, which is cheap next to a key press.
+ */
+export function markdownLineKind(doc, number) {
+  let front = false;
+  let fence = null;
+  for (let index = 1; index < number; index++) {
+    const text = doc.line(index).text;
+    if (index === 1 && /^---\s*$/.test(text)) { front = true; continue; }
+    if (front) { if (/^(---|\.\.\.)\s*$/.test(text)) front = false; continue; }
+    if (fence) {
+      if (new RegExp(`^ {0,3}${fence.char}{${fence.length},}\\s*$`).test(text)) fence = null;
+      continue;
+    }
+    const open = /^ {0,3}(`{3,}|~{3,})(.*)$/.exec(text);
+    if (open && !(open[1][0] === "`" && open[2].includes("`"))) fence = { char: open[1][0], length: open[1].length, yaml: /^\s*opf-(?:slide|block)\b/.test(open[2]) };
+  }
+  const here = doc.line(number).text;
+  if (front) return /^(---|\.\.\.)\s*$/.test(here) ? "body" : "front";
+  if (fence) return new RegExp(`^ {0,3}${fence.char}{${fence.length},}\\s*$`).test(here) ? "body" : fence.yaml ? "yaml-fence" : "fence";
+  return "body";
+}
+
+// ---- Enter -------------------------------------------------------------------------------------------------------------------------
+/** The indentation (columns) of the new line after `before`, the text of the line up to the caret, in YAML; `"leave"` for an empty list item. */
+export function yamlNewlineIndent(before) {
+  const parsed = readMarkers(before);
+  if (parsed.markers.length && parsed.rest.trim() === "") return "leave";
+  const entry = readEntry(parsed.rest);
+  const content = parsed.markers.length ? parsed.restStart : parsed.indent;
+  if (!entry) return content;
+  const value = parsed.rest.slice(entry.valueStart).replace(/\s+#.*$/, "").trim();
+  if (value === "" || BLOCK_HEADER.test(value)) return parsed.restStart + entry.keyStart + UNIT.length;
+  // An unclosed flow collection continues one level in.
+  let depth = 0;
+  for (const character of value) depth += character === "[" || character === "{" ? 1 : character === "]" || character === "}" ? -1 : 0;
+  return depth > 0 ? parsed.restStart + entry.keyStart + UNIT.length : parsed.markers.length || entry.keyStart > 0 ? parsed.restStart + entry.keyStart : content;
+}
+
+// Replace each selection range with a line break and what `decide` says goes after it: `{ indent }` columns, `{ insert }` text, or `{ clear, text }` to
+// replace the whole line (an empty list item loses its marker) instead of breaking it.
+function newline(view, decide) {
+  const { state } = view;
+  if (state.readOnly) return false;
+  const update = state.changeByRange((range) => {
+    const line = state.doc.lineAt(range.from);
+    const result = decide(line.text.slice(0, range.from - line.from), line.text, line);
+    if (result.clear) return { changes: { from: line.from, to: Math.max(range.to, line.to), insert: result.text }, range: EditorSelection.cursor(line.from + result.text.length) };
+    const insert = `\n${result.insert ?? " ".repeat(result.indent ?? 0)}`;
+    return { changes: { from: range.from, to: range.to, insert }, range: EditorSelection.cursor(range.from + insert.length) };
+  });
+  view.dispatch(state.update(update, { scrollIntoView: true, userEvent: "input" }));
+  return true;
+}
+
+// The YAML rules for the line before the caret: `{ indent }` of the new line, or `{ clear, text }` for an empty list item.
+function yamlDecision(before, lists = true) {
+  // A line with only spaces before the caret keeps them: the new line gets the same indentation.
+  if (before.trim() === "") return { indent: before.length };
+  const indent = yamlNewlineIndent(before);
+  if (indent === "leave") return { clear: true, text: " ".repeat(Math.max(0, readMarkers(before).markers[0] - UNIT.length)) };
+  // After a list item that is a value (`- board`) the list goes on with the next dash; after `- key: value` the new line aligns under the key.
+  const parsed = readMarkers(before);
+  if (!lists && parsed.markers.length && !readEntry(parsed.rest)) return { indent: parsed.indent };
+  if (lists && parsed.markers.length && !readEntry(parsed.rest)) {
+    const value = parsed.rest.replace(/\s+#.*$/, "").trim();
+    if (value !== "" && !BLOCK_HEADER.test(value) && !/^[&*!]/.test(value) && flowDepth(value) === 0) return { insert: `${" ".repeat(parsed.markers.at(-1))}- ` };
+  }
+  return { indent };
+}
+
+/** Enter in YAML (SPEC 6.2). */
+export function yamlEnter(view, { lists = true } = {}) {
+  return newline(view, (before) => yamlDecision(before, lists));
+}
+
+/**
+ * Enter in Markdown (SPEC 6.2): lists and quotes continue, an empty marker ends them, a fence keeps its indentation, front matter follows YAML.
+ * `lists: false` (the `smartListEnter` option) keeps only the indentation.
+ */
+export function markdownEnter(view, { lists = true } = {}) {
+  const { state } = view;
+  return newline(view, (before, full, line) => {
+    const kind = markdownLineKind(state.doc, line.number);
+    if (kind === "front" || kind === "yaml-fence") return yamlDecision(before, lists);
+    const lead = /^\s*/.exec(before)[0];
+    if (kind === "fence" || !lists) return { indent: lead.length };
+    const atEnd = before.length === full.length;
+    // An empty item ends the list: a nested one moves out one level, a top-level one becomes an empty line.
+    const empty = LIST_EMPTY.exec(before);
+    if (empty && atEnd) return { clear: true, text: empty[1].length >= UNIT.length ? `${" ".repeat(empty[1].length - UNIT.length)}${empty[2]} ` : "" };
+    const item = LIST_ITEM.exec(before);
+    // Inside the marker itself the line just breaks.
+    if (item && before.length >= item[1].length + item[2].length + item[3].length) {
+      const marker = /^\d/.test(item[2]) ? `${Number.parseInt(item[2], 10) + 1}${item[2].slice(-1)}` : item[2];
+      return { insert: `${item[1]}${marker} ` };
+    }
+    const quote = QUOTE.exec(before);
+    if (quote) {
+      if (quote[3].trim() === "" && atEnd) return { clear: true, text: "" };
+      return { insert: `${quote[1]}> ` };
+    }
+    return { indent: lead.length };
+  });
+}
+
+// ---- Tab and Backspace in Markdown lists -------------------------------------------------------------------------------------------
+/** Tab on a list item nests it one level (two spaces); false elsewhere. */
+export function markdownTab(view) {
+  const { state } = view;
+  if (state.readOnly || state.selection.ranges.some((range) => !range.empty)) return false;
+  if (!state.selection.ranges.every((range) => LIST_ITEM.test(state.doc.lineAt(range.head).text) || LIST_EMPTY.test(state.doc.lineAt(range.head).text))) return false;
+  if (state.selection.ranges.some((range) => markdownLineKind(state.doc, state.doc.lineAt(range.head).number) !== "body")) return false;
+  return indentMore(view);
+}
+
+/** Backspace right after a list marker takes the marker away (`- |one` becomes `|one`); false elsewhere. */
+export function markdownBackspace(view) {
+  const { state } = view;
+  if (state.readOnly || state.selection.ranges.length !== 1 || !state.selection.main.empty) return false;
+  const head = state.selection.main.head;
+  const line = state.doc.lineAt(head);
+  if (markdownLineKind(state.doc, line.number) !== "body") return false;
+  const item = LIST_ITEM.exec(line.text);
+  const empty = LIST_EMPTY.exec(line.text);
+  const markerEnd = item ? item[1].length + item[2].length + item[3].length : empty ? line.text.length : -1;
+  if (markerEnd < 0 || head - line.from !== markerEnd) return false;
+  const start = line.from + (item ? item[1].length : empty[1].length);
+  view.dispatch({ changes: { from: start, to: head }, selection: { anchor: start }, userEvent: "delete.backward", scrollIntoView: true });
+  return true;
+}
+
+// ---- Comments ----------------------------------------------------------------------------------------------------------------------
+/**
+ * Cmd/Ctrl+/ in Markdown: front matter and YAML fences toggle `# `; a line of the body is wrapped in `<!-- -->` or unwrapped; an options comment
+ * says it already is one. `say` announces what could not be done.
+ */
+export function markdownToggleComment(view, say) {
+  const { state } = view;
+  if (state.readOnly) return false;
+  const lines = [];
+  for (const range of state.selection.ranges) {
+    const first = state.doc.lineAt(range.from).number;
+    let last = state.doc.lineAt(range.to).number;
+    if (!range.empty && range.to === state.doc.line(last).from && last > first) last--;
+    for (let number = first; number <= last; number++) if (!lines.includes(number)) lines.push(number);
+  }
+  const kinds = lines.map((number) => markdownLineKind(state.doc, number));
+  const texts = lines.map((number) => state.doc.line(number).text);
+  if (kinds.some((kind) => kind === "fence")) { say?.("Code in a fence has no comment syntax."); return true; }
+  if (texts.some((text) => /^\s*<!--\s*(slide|block)\b/.test(text)) && texts.length === 1) { say?.("Slide options are already a comment. Delete the line to remove them."); return true; }
+  const changes = [];
+  const yamlStyle = kinds.every((kind) => kind === "front" || kind === "yaml-fence");
+  const blank = (text) => text.trim() === "";
+  const real = lines.filter((number, index) => !blank(texts[index]));
+  if (!real.length) return true;
+  if (yamlStyle) {
+    const all = real.every((number) => /^\s*#/.test(state.doc.line(number).text));
+    const column = Math.min(...real.map((number) => /^\s*/.exec(state.doc.line(number).text)[0].length));
+    for (const number of real) {
+      const line = state.doc.line(number);
+      if (all) {
+        const match = /^(\s*)# ?/.exec(line.text);
+        changes.push({ from: line.from + match[1].length, to: line.from + match[0].length });
+      } else changes.push({ from: line.from + column, insert: "# " });
+    }
+  } else {
+    const all = real.every((number) => /^\s*<!--.*-->\s*$/.test(state.doc.line(number).text));
+    for (const number of real) {
+      const line = state.doc.line(number);
+      if (all) {
+        const match = /^(\s*)<!-- ?(.*?) ?-->(\s*)$/.exec(line.text);
+        changes.push({ from: line.from + match[1].length, to: line.to, insert: match[2] });
+      } else {
+        const lead = /^\s*/.exec(line.text)[0].length;
+        changes.push({ from: line.from + lead, insert: "<!-- " }, { from: line.to, insert: " -->" });
+      }
+    }
+  }
+  // The selection takes in the comment marks that were added or removed at its ends.
+  const set = state.changes(changes);
+  const selection = EditorSelection.create(state.selection.ranges.map((range) => EditorSelection.range(set.mapPos(range.anchor, 1), set.mapPos(range.head, 1))), state.selection.mainIndex);
+  view.dispatch(state.update({ changes: set, selection, userEvent: "input.comment", scrollIntoView: true }));
+  return true;
+}
+
+// ---- Typing over a selection in Markdown -------------------------------------------------------------------------------------------
+const WRAPPERS = { "*": "*", _: "_", "~": "~", '"': '"' };
+
+/** Typing `*`, `_`, `~` or `"` over a selection wraps it (typing `*` twice makes bold); the selection stays on the text. */
+export const markdownWrapSelection = EditorView.inputHandler.of((view, _from, _to, text) => {
+  if (text.length !== 1 || !(text in WRAPPERS) || view.state.readOnly) return false;
+  const { selection } = view.state;
+  if (selection.ranges.every((range) => range.empty)) return false;
+  const closer = WRAPPERS[text];
+  const changes = view.state.changes(selection.ranges.filter((range) => !range.empty).flatMap((range) => [{ from: range.from, insert: text }, { from: range.to, insert: closer }]));
+  view.dispatch({ changes, selection: selection.map(changes), userEvent: "input.type", scrollIntoView: true });
+  return true;
+});
+
+// ---- Folding in Markdown -----------------------------------------------------------------------------------------------------------
+const SEPARATOR = /^-{3,}[ \t]*$/;
+
+/**
+ * What a line of Markdown can fold (SPEC 6.8): the front matter (from its opening line), a fenced block (from its opening fence), and a slide (from its
+ * first line to the line before the next `---`). A `---` inside a fence or the front matter is not a separator.
+ */
+export const markdownFolding = foldService.of((state, lineStart) => {
+  const { doc } = state;
+  const line = doc.lineAt(lineStart);
+  const text = line.text;
+  const last = (number) => { const end = doc.line(number); return end.to; };
+  // The front matter.
+  if (line.number === 1 && /^---\s*$/.test(text)) {
+    for (let number = 2; number <= doc.lines; number++) if (/^(---|\.\.\.)\s*$/.test(doc.line(number).text)) return number > 2 ? { from: line.to, to: doc.line(number - 1).to } : null;
+    return null;
+  }
+  if (markdownLineKind(doc, line.number) !== "body") return null;
+  // A fenced block.
+  const open = /^( {0,3})(`{3,}|~{3,})(.*)$/.exec(text);
+  if (open && !(open[2][0] === "`" && open[3].includes("`"))) {
+    const close = new RegExp(`^ {0,3}${open[2][0]}{${open[2].length},}\\s*$`);
+    for (let number = line.number + 1; number <= doc.lines; number++) if (close.test(doc.line(number).text)) return number > line.number + 1 ? { from: line.to, to: doc.line(number - 1).to } : null;
+    return line.number < doc.lines ? { from: line.to, to: last(doc.lines) } : null;
+  }
+  // A slide: its first line (the one after the front matter or a separator, blank lines apart) folds the rest of the slide.
+  if (text.trim() === "" || SEPARATOR.test(text)) return null;
+  let before = line.number - 1;
+  while (before >= 1 && doc.line(before).text.trim() === "") before--;
+  const startsSlide = before < 1 || ((SEPARATOR.test(doc.line(before).text) || /^\.\.\.\s*$/.test(doc.line(before).text)) && markdownLineKind(doc, before) === "body");
+  if (!startsSlide) return null;
+  let end = line.number;
+  for (let number = line.number + 1; number <= doc.lines; number++) {
+    if (SEPARATOR.test(doc.line(number).text) && markdownLineKind(doc, number) === "body") break;
+    end = number;
+  }
+  while (end > line.number && doc.line(end).text.trim() === "") end--;
+  return end > line.number ? { from: line.to, to: doc.line(end).to } : null;
+});

package/dist/source-fixes-syntax.js

@@ -0,0 +1,204 @@
+// Quick fixes for the syntax problems of a YAML or Markdown source (artifacts/source-editor/VALIDATOR-HINTS.md, sections 9, 10 and 12): "Convert tabs to
+// spaces", "Insert closing quote", "Insert ]", "Add a colon", "Insert ---", "Insert closing fence", "Insert -->", "Rename to layout", "Insert column" and
+// the like. The YAML ones are core's (`analyzeYamlSyntax` returns the edits with the problem); the Markdown ones are found here from the finding's range and
+// core's `scanMarkdown`. Pure functions over the source text: each fix is `{ id, title, safe, edits: [{ from, to, insert }], caret? }`, source offsets in, so
+// the editor applies it as one undoable change that keeps the author's comments and layout.
+import { analyzeYamlSyntax, scanMarkdown } from "@openpresentation/opf/source";
+
+const lineStart = (text, offset) => text.lastIndexOf("\n", offset - 1) + 1;
+const lineEnd = (text, offset) => { const at = text.indexOf("\n", offset); return at < 0 ? text.length : at; };
+const nextLine = (text, offset) => { const end = lineEnd(text, offset); return end < text.length ? end + 1 : end; };
+const fix = (id, title, edits, extra = {}) => ({ id, title, safe: false, edits, ...extra });
+const fromCore = (entry) => ({ id: entry.id, title: entry.title, safe: entry.safe === true, edits: entry.edits.map((edit) => ({ from: edit.offset, to: edit.offset + edit.length, insert: edit.insert })), ...(entry.caret !== undefined ? { caret: entry.caret } : {}) });
+
+// ---- YAML -------------------------------------------------------------------------------------------------------------------------
+const yamlMemo = { text: null, problems: [] };
+function yamlProblems(text) {
+  if (yamlMemo.text !== text) { yamlMemo.text = text; yamlMemo.problems = analyzeYamlSyntax(text); }
+  return yamlMemo.problems;
+}
+
+/** The YAML regions of a Markdown text: its front matter and its `opf-slide` and `opf-block` fences, as `{ from, to }` of the YAML itself. */
+function markdownYamlRegions(text) {
+  const scan = scanMarkdown(text);
+  const regions = [];
+  if (scan.frontMatter) regions.push({ from: scan.frontMatter.yamlFrom, to: scan.frontMatter.yamlTo });
+  for (const fence of scan.fences) if (fence.kind === "opf-slide" || fence.kind === "opf-block") regions.push({ from: fence.bodyFrom, to: fence.bodyTo });
+  return regions;
+}
+
+/** The problem that starts where `finding` does, in the YAML `text` (`shift` is where `text` starts in the source). */
+function yamlHit(problems, finding, shift) {
+  const at = (finding.location?.offset ?? finding.range?.from) - shift;
+  return problems.find((problem) => problem.range.offset === at);
+}
+
+function yamlSyntax(format, text, finding) {
+  if (format === "yaml") {
+    const hit = yamlHit(yamlProblems(text), finding, 0);
+    return hit ? { fixes: hit.fixes.map(fromCore), related: (hit.related ?? []).map((range) => ({ from: range.offset, to: range.offset + range.length })) } : null;
+  }
+  const at = finding.location?.offset ?? finding.range?.from;
+  const region = markdownYamlRegions(text).find((entry) => at >= entry.from && at <= entry.to);
+  if (!region) return null;
+  const slice = text.slice(region.from, region.to);
+  const hit = yamlHit(analyzeYamlSyntax(slice, { rootKind: "any" }), finding, region.from);
+  if (!hit) return null;
+  const shift = (offset) => offset + region.from;
+  return {
+    fixes: hit.fixes.map(fromCore).map((entry) => ({ ...entry, edits: entry.edits.map((edit) => ({ ...edit, from: shift(edit.from), to: shift(edit.to) })), ...(entry.caret !== undefined ? { caret: shift(entry.caret) } : {}) })),
+    related: (hit.related ?? []).map((range) => ({ from: shift(range.offset), to: shift(range.offset + range.length) })),
+  };
+}
+
+// ---- Markdown ---------------------------------------------------------------------------------------------------------------------
+
+/** The end of the last non-blank line inside [from, to). */
+function lastContentEnd(text, from, to) {
+  let end = Math.min(to, text.length);
+  while (end > from && /\s/.test(text[end - 1])) end--;
+  return end;
+}
+
+/** Where a front matter that was never closed should end: before the first blank line or the first line that is not YAML-shaped. */
+function frontMatterEnd(text) {
+  const YAMLISH = /^(\s*[A-Za-z_][\w.-]*\s*:|\s*-\s|\s+\S|\s*#(?!\s)|\s*#\s*$|\s*#\s.*$)/;
+  let at = nextLine(text, 0);
+  let seen = false;
+  while (at < text.length) {
+    const end = lineEnd(text, at);
+    const content = text.slice(at, end);
+    if (content.trim() === "" || (!YAMLISH.test(content) && seen)) return at;
+    if (/^#{1,6}\s/.test(content) && !/^#\s.*:\s/.test(content)) return at;
+    seen = true;
+    at = nextLine(text, at);
+  }
+  return text.length;
+}
+
+/** Remove the whole lines that [from, to) touches. */
+const removeLines = (text, from, to) => ({ from: lineStart(text, from), to: nextLine(text, Math.max(from, to - 1)), insert: "" });
+
+const markdownRules = {
+  "markdown/front-matter-unterminated": (text) => {
+    const at = frontMatterEnd(text);
+    const prefix = at > 0 && text[at - 1] !== "\n" ? "\n" : "";
+    return [fix("insert-front-matter-end", "Insert ---", [{ from: at, to: at, insert: `${prefix}---\n` }], { safe: true })];
+  },
+  "markdown/comment-unterminated": (text, finding) => {
+    const from = finding.location.offset;
+    const end = lastContentEnd(text, from, from + finding.location.length);
+    return [fix("insert-comment-end", "Insert -->", [{ from: end, to: end, insert: " -->" }], { safe: true, caret: end + 4 })];
+  },
+  "markdown/fence-unterminated": (text, finding) => {
+    const from = finding.location.offset;
+    const opening = text.slice(lineStart(text, from), lineEnd(text, from));
+    const marker = /^\s*(`{3,}|~{3,})/.exec(opening)?.[1] ?? "```";
+    const end = lastContentEnd(text, from, from + finding.location.length);
+    const at = nextLine(text, end > from ? end - 1 : from);
+    const prefix = at === text.length && !text.endsWith("\n") ? "\n" : "";
+    return [fix("insert-closing-fence", "Insert closing fence", [{ from: at, to: at, insert: `${prefix}${marker}\n` }], { safe: true })];
+  },
+  "markdown/options-unknown-key": (text, finding) => {
+    const key = /option "(.*)"\.$/.exec(finding.message)?.[1];
+    const { offset, length } = finding.location;
+    const found = key ? new RegExp(`(^|[\\s:])(${key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")})(?==|\\s|-->|$)`).exec(text.slice(offset, offset + length)) : null;
+    if (!found) return [];
+    const from = offset + found.index + found[1].length;
+    return (finding.suggestions ?? []).map((entry) => fix(`rename-to:${entry.value}`, `Rename to ${entry.value}`, [{ from, to: from + key.length, insert: String(entry.value) }]));
+  },
+  "markdown/options-value": (text, finding) => {
+    if (!/^hidden takes/.test(finding.message)) return [];
+    const { offset, length } = finding.location;
+    const found = /\bhidden=("[^"]*"|\S+?)(?=\s|-->)/.exec(text.slice(offset, offset + length));
+    if (!found) return [];
+    const from = offset + found.index;
+    return ["true", "false"].map((value) => fix(`hidden-${value}`, `Use hidden=${value}`, [{ from, to: from + found[0].length, insert: `hidden=${value}` }]));
+  },
+  "markdown/options-duplicate": (text, finding) => {
+    const key = /^Option (\w+) is given twice/.exec(finding.message)?.[1];
+    if (!key) return [];
+    const { offset, length } = finding.location;
+    const body = text.slice(offset, offset + length);
+    const pattern = new RegExp(`\\s${key}=("[^"]*"|[^\\s>]+)`, "g");
+    const matches = [...body.matchAll(pattern)];
+    if (matches.length < 2) return [];
+    const second = matches[1];
+    return [fix("remove-duplicate-option", `Remove the second ${key}`, [{ from: offset + second.index, to: offset + second.index + second[0].length, insert: "" }])];
+  },
+  "markdown/chart-type": (text, finding) => {
+    const open = lineStart(text, finding.location.offset);
+    const line = text.slice(open, lineEnd(text, open));
+    const found = /^(\s*(?:`{3,}|~{3,})\s*chart)/.exec(line);
+    if (!found) return [];
+    const at = open + found[1].length;
+    return (finding.suggestions ?? []).map((entry) => fix(`chart-type:${entry.value}`, `Insert ${entry.value}`, [{ from: at, to: at, insert: ` ${entry.value}` }]));
+  },
+  "markdown/front-matter-slides": (text, finding) => {
+    const { offset, length } = finding.location;
+    return [fix("remove-slides-key", "Remove the slides key", [removeLines(text, offset, offset + length)])];
+  },
+  "markdown/no-slides": (text) => {
+    const empty = text.trim() === "";
+    return [fix("insert-title", "Insert # Title", [{ from: text.length, to: text.length, insert: empty ? "# Title\n" : `${text.endsWith("\n") ? "" : "\n"}\n# Title\n` }], { safe: true })];
+  },
+  "markdown/duplicate-title": (text, finding) => {
+    const open = lineStart(text, finding.location.offset);
+    return [
+      fix("start-new-slide", "Start a new slide here", [{ from: open, to: open, insert: "---\n\n" }]),
+      fix("remove-extra-heading", "Remove the extra heading", [removeLines(text, open, lineEnd(text, open))]),
+    ];
+  },
+  "markdown/duplicate-subtitle": (text, finding) => {
+    const open = lineStart(text, finding.location.offset);
+    return [fix("remove-extra-heading", "Remove the extra heading", [removeLines(text, open, lineEnd(text, open))])];
+  },
+  "markdown/empty-heading": (text, finding) => {
+    const open = lineStart(text, finding.location.offset);
+    return [fix("remove-empty-heading", "Remove the heading", [removeLines(text, open, lineEnd(text, open))])];
+  },
+  "markdown/numbered-list": (text, finding) => {
+    const { offset, length } = finding.location;
+    const scan = scanMarkdown(text);
+    const slide = scan.slides.find((entry) => offset >= entry.from && offset <= entry.to);
+    // A slide that has an opf-slide fence already gets the field written into it, not a second fence.
+    if (slide && scan.fences.some((fence) => fence.kind === "opf-slide" && fence.from >= slide.from && fence.to <= slide.to + 1)) return [];
+    const end = lastContentEnd(text, offset, offset + length);
+    const at = nextLine(text, end > offset ? end - 1 : offset);
+    const prefix = at === text.length && !text.endsWith("\n") ? "\n" : "";
+    return [fix("add-numbering", "Add `numbering`", [{ from: at, to: at, insert: `${prefix}\n\`\`\`opf-slide\nnumbering: arabic\n\`\`\`\n` }])];
+  },
+  "markdown/metric-block": (text, finding) => {
+    if (finding.message !== "A metric needs a value.") return [];
+    const open = lineStart(text, finding.location.offset);
+    const at = nextLine(text, open);
+    return [fix("insert-metric-value", "Insert value:", [{ from: at, to: at, insert: "value: 0\n" }])];
+  },
+};
+
+/** The quick fixes of a YAML or Markdown syntax finding, and the other places that belong to it: `{ fixes, related }` or null. */
+export function syntaxFixesFor(format, text, finding) {
+  if (!finding?.location || format === "json") return null;
+  const id = String(finding.ruleId ?? "");
+  try {
+    if (id.startsWith("yaml/") || (format === "md" && (id === "markdown/front-matter" || id === "markdown/opf-slide" || id === "markdown/opf-block"))) return yamlSyntax(format, text, finding);
+    const make = markdownRules[id];
+    if (make) {
+      const fixes = make(text, finding).filter((entry) => entry.edits.length);
+      return fixes.length ? { fixes, related: [] } : null;
+    }
+  } catch { /* A fix that cannot be worked out is not offered. */ }
+  return null;
+}
+
+/**
+ * Findings of a YAML or Markdown source with their quick fixes (`editFixes`) and related places (`related`) added, in the shape `normalizeFinding` and
+ * `buildProblems` read. Findings that have no fixes are returned as they are.
+ */
+export function withSyntaxFixes(format, text, findings) {
+  return findings.map((finding) => {
+    const made = syntaxFixesFor(format, text, finding);
+    if (!made) return finding;
+    return { ...finding, ...(made.fixes.length ? { editFixes: made.fixes } : {}), ...(made.related.length ? { related: made.related } : {}) };
+  });
+}

package/dist/source-fixes-text.js

@@ -0,0 +1,160 @@
+// Quick fixes for the findings of a YAML or Markdown source (artifacts/source-editor/VALIDATOR-HINTS.md, section 12): "Change to center", "Rename to
+// slides", "Remove property", "Add `id`". The same fixes source-fixes.js writes for JSON, as text edits found with core's `locate`, so each one is a
+// change of the text itself (one undoable change) that keeps the author's comments and layout. Pure functions: `{ id, title, safe, edits: [{ from, to, insert }] }`.
+import { Document } from "yaml";
+import { SLIDE_OPTION_KEYS, scanMarkdown } from "@openpresentation/opf/source";
+import { replacementValues, segmentsOf } from "./source-messages.js";
+import { locateText } from "./source-ranges.js";
+
+const yamlScalar = (value) => {
+  if (typeof value !== "string") return String(value);
+  try { return new Document(value).toString({ lineWidth: 0 }).trimEnd() || '""'; } catch { return JSON.stringify(value); }
+};
+const yamlKey = (key) => (/^[A-Za-z_$][A-Za-z0-9_.$+-]*(?::[A-Za-z0-9_.$+-]+)*$/.test(key) ? key : yamlScalar(key));
+const BARE = /^[A-Za-z0-9_-]+$/;
+
+/** Whether `segments` is an option of a slide's options comment in Markdown (`/slides/0/layout`), whose value is written as `key=value`. */
+const isSlideOption = (format, segments) => format === "md" && segments[0] === "slides" && segments.length === 3 && SLIDE_OPTION_KEYS.includes(segments[2]);
+
+/** How `value` is written in place of the token `old`: in the quoting style the author used. */
+function written(format, segments, old, value) {
+  if (isSlideOption(format, segments)) return typeof value === "string" && BARE.test(value) ? value : JSON.stringify(value);
+  if (old.startsWith('"')) return JSON.stringify(value);
+  if (old.startsWith("'")) return `'${String(value).replaceAll("'", "''")}'`;
+  return yamlScalar(value);
+}
+
+// Only YAML written as block text (and the front matter and fences of Markdown, which are block YAML) can have a whole entry removed or added by lines.
+const lineStart = (text, offset) => text.lastIndexOf("\n", offset - 1) + 1;
+const lineEnd = (text, offset) => { const at = text.indexOf("\n", offset); return at < 0 ? text.length : at; };
+
+/** Remove the entry at `segments` (its lines), when it starts its line and is not the first key after a list dash. */
+function removeEntry(format, text, segments) {
+  const entry = locateText(format, text, segments, "entry");
+  if (!entry?.exact) return null;
+  const start = lineStart(text, entry.from);
+  if (text.slice(start, entry.from).trim() !== "") return null;
+  const end = lineEnd(text, Math.max(entry.from, entry.to - 1));
+  return [{ from: start, to: Math.min(text.length, end + 1), insert: "" }];
+}
+
+/** Add `key: value` to the mapping at `segments`, after its last line, indented like its first key. */
+function addProperty(format, text, segments, key, value) {
+  const parent = segments.length ? locateText(format, text, segments, "value") : null;
+  const first = parent?.exact ? locateText(format, text, segments, "open") : null;
+  let column = 0;
+  let at = text.length;
+  if (parent?.exact && first) {
+    if (/^[[{]/.test(text.slice(parent.from, parent.from + 1))) return null;
+    column = first.from - lineStart(text, first.from);
+    at = lineEnd(text, Math.max(parent.from, parent.to - 1));
+  } else if (segments.length) return null;
+  else if (text.trim() !== "") {
+    const root = locateText(format, text, [], "value");
+    if (!root) return null;
+    at = lineEnd(text, Math.max(root.from, root.to - 1));
+  }
+  const body = new Document({ [key]: value }).toString({ indent: 2, lineWidth: 0 }).trimEnd().split("\n").map((line) => `${" ".repeat(column)}${line}`).join("\n");
+  return [{ from: at, to: at, insert: text.trim() === "" ? `${body}\n` : `\n${body}` }];
+}
+
+/** Replace the value at `segments` by `make(old)`, when the text has it exactly. */
+function replaceValue(format, text, segments, make) {
+  const where = locateText(format, text, segments, "value");
+  if (!where?.exact || where.from === where.to) return null;
+  const insert = make(text.slice(where.from, where.to));
+  return insert === null ? null : [{ from: where.from, to: where.to, insert }];
+}
+
+/** A scalar as the one item of a flow list: quotes stay, a plain scalar that flow syntax would misread is quoted. */
+function inList(old, value) {
+  if (/^[|>&*!%@`]/.test(old) || /^[[{]/.test(old)) return null;
+  if (old.startsWith('"') || old.startsWith("'")) return `[${old}]`;
+  return /[,[\]{}#:]/.test(old) || typeof value !== "string" ? `[${JSON.stringify(value)}]` : `[${old}]`;
+}
+
+/** `slides: []` (or `slides:` with nothing) becomes a block list with one slide. */
+function addSlide(format, text) {
+  if (format !== "yaml") return null;
+  const key = locateText(format, text, ["slides"], "colon");
+  const value = locateText(format, text, ["slides"], "value");
+  if (!key?.exact) return null;
+  const empty = !value?.exact || text.slice(value.from, value.to).trim() === "" || /^\[\s*\]$/.test(text.slice(value.from, value.to));
+  if (!empty) return null;
+  const indent = " ".repeat(key.from - lineStart(text, key.from));
+  const end = value?.exact ? Math.max(value.to, key.to) : key.to;
+  return [{ from: key.to, to: end, insert: `\n${indent}  - title: Slide title` }];
+}
+
+/** The indentation of the first key of the block mapping at `segments` ("" for none), and where its last line ends. */
+function blockMapping(format, text, segments) {
+  // The root of a Markdown deck is its front matter, which ends where the closing `---` line starts.
+  if (format === "md" && segments.length === 0) {
+    const matter = scanMarkdown(text).frontMatter;
+    return matter?.closed ? { column: 0, end: matter.yamlTo } : null;
+  }
+  const value = segments.length ? locateText(format, text, segments, "value") : locateText(format, text, [], "value");
+  const open = locateText(format, text, segments, "open");
+  if (!value?.exact || !open?.exact || /^[[{]/.test(text[value.from] ?? "")) return null;
+  return { column: open.from - lineStart(text, open.from), end: nextLine(text, Math.max(value.from, value.to - 1)) };
+}
+const nextLine = (text, offset) => { const end = lineEnd(text, offset); return end < text.length ? end + 1 : end; };
+
+/** Move the entry at `segments` into the `extensions` mapping of its parent, creating it at the end of the parent when there is none. */
+function moveIntoExtensions(format, text, segments) {
+  if (segments.length === 0 || (format === "md" && segments[0] === "slides")) return null;
+  const entry = locateText(format, text, segments, "entry");
+  if (!entry?.exact) return null;
+  const start = lineStart(text, entry.from);
+  if (text.slice(start, entry.from).trim() !== "") return null;
+  const end = nextLine(text, Math.max(entry.from, entry.to - 1));
+  const parent = segments.slice(0, -1);
+  const base = entry.from - start;
+  const reindent = (column) => text.slice(start, end).replace(/\n$/, "").split("\n").map((line) => `${" ".repeat(column)}${line.slice(Math.min(base, line.length - line.trimStart().length))}`).join("\n");
+  const owner = blockMapping(format, text, parent);
+  if (!owner) return null;
+  const existing = blockMapping(format, text, [...parent, "extensions"]);
+  const prefix = (at) => (at === text.length && !text.endsWith("\n") ? "\n" : "");
+  const edits = [{ from: start, to: end, insert: "" }];
+  if (existing) edits.push({ from: existing.end, to: existing.end, insert: `${prefix(existing.end)}${reindent(existing.column)}\n` });
+  else if (locateText(format, text, [...parent, "extensions"], "key")?.exact) return null;
+  else edits.push({ from: owner.end, to: owner.end, insert: `${prefix(owner.end)}${" ".repeat(owner.column)}extensions:\n${reindent(owner.column + 2)}\n` });
+  return edits;
+}
+
+/**
+ * The quick fixes of a schema or reference finding in a YAML or Markdown text. `context` is the one source-messages.js takes plus `{ starter(segments,
+ * property) }` (the value `Add` inserts). Returns `[]` for what the text cannot express as a plain edit.
+ */
+export function textFixesForFinding(format, finding, text, context = {}) {
+  if (!finding.path && finding.validation?.keyword !== "required") return [];
+  const segments = segmentsOf(finding.path);
+  const keyword = finding.validation?.keyword;
+  const fixes = [];
+  const push = (id, title, edits) => { if (edits?.length) fixes.push({ id, title, edits, safe: false }); };
+  if (keyword === "enum" || finding.ruleId === "opf/unresolved-reference") {
+    const where = locateText(format, text, segments, "value");
+    if (!where?.exact) return [];
+    const old = text.slice(where.from, where.to);
+    for (const value of replacementValues(finding, context)) push(`change-to:${value}`, `Change to ${value}`, [{ from: where.from, to: where.to, insert: written(format, segments, old, value) }]);
+  } else if (keyword === "additionalProperties" && !isSlideOption(format, segments)) {
+    const key = locateText(format, text, segments, "key");
+    if (key?.exact) for (const value of replacementValues(finding, context)) push(`rename-to:${value}`, `Rename to ${value}`, [{ from: key.from, to: key.to, insert: yamlKey(value) }]);
+    if (segments.at(-1) !== "extensions" && context.keysOf?.(segments.slice(0, -1))?.includes("extensions")) push("move-to-extensions", "Move into extensions", moveIntoExtensions(format, text, segments));
+    push("remove-property", "Remove property", removeEntry(format, text, segments));
+  } else if (keyword === "type" && finding.validation.params?.type === "array") {
+    const value = context.valueAt?.(segments);
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") push("wrap-in-list", "Wrap in a list", replaceValue(format, text, segments, (old) => inList(old, value)));
+  } else if ((keyword === "type" && finding.validation.params?.type === "string") || ((keyword === "oneOf" || keyword === "anyOf") && (finding.validation.alternatives ?? []).some((entry) => String(entry).startsWith("string")))) {
+    const value = context.valueAt?.(segments);
+    if (typeof value === "number" || typeof value === "boolean") fixes.push({ id: "convert-to-string", title: "Convert to string", safe: true, edits: replaceValue(format, text, segments, () => JSON.stringify(String(value))) ?? [] });
+  } else if (keyword === "minItems" && finding.path === "/slides") {
+    push("add-slide", "Add a slide", addSlide(format, text));
+  } else if (keyword === "required") {
+    const property = finding.validation.params?.missingProperty;
+    const starter = property ? context.starter?.(segments, property) : undefined;
+    // In Markdown only the front matter is a mapping this can add to; a slide's fields are written as Markdown.
+    if (property && starter !== undefined && (format === "yaml" || segments[0] !== "slides")) push(`add:${property}`, `Add \`${property}\``, addProperty(format, text, segments, property, starter));
+  }
+  return fixes.filter((fix) => fix.edits.length);
+}