@openpresentation/opf-editor 0.26.4 → 0.26.6

package/dist/source-details.js

@@ -0,0 +1,17 @@
+// The "Details" of a problem (artifacts/source-editor/VALIDATOR-HINTS.md, section 1): what the rule checks, why it matters, what to do and a small
+// example, from core's `explain(ruleId)`, behind a disclosure so the row itself stays one sentence and a hint. Pure data here; the pane draws it.
+import { explain } from "@openpresentation/opf/source";
+
+/**
+ * The details of a finding: `{ rule, summary, why, fix, example?, docs? }`, or null when core has nothing to say about the rule. A schema finding adds the
+ * keyword and the place in the schema it comes from.
+ */
+export function detailsFor(finding) {
+  const ruleId = finding?.ruleId;
+  if (!ruleId) return null;
+  let found;
+  try { found = explain(ruleId); } catch { found = undefined; }
+  if (!found) return null;
+  const schema = finding.validation?.keyword ? `The schema keyword is ${finding.validation.keyword}${finding.definition ? `; it is defined at ${finding.definition}` : ""}.` : "";
+  return { rule: found.id, summary: found.summary, why: found.rationale, fix: found.fix, ...(found.example ? { example: found.example } : {}), docs: finding.definition ?? found.docs, ...(schema ? { schema } : {}) };
+}

package/dist/source-diagnostics.js

@@ -123,7 +123,7 @@ export function fixesAtCaret(state, source) {
  * `getSource()` is the original text; `applyFix(fix, problem)` performs a fix (the editor's edits or the pane's own action); `say(message)` is
  * the live region. Returns `{ extension, draw(view, problems), problems(view) }`.
  */
-export function createDiagnostics({ getSource, applyFix, say }) {
+export function createDiagnostics({ getSource, applyFix, say, km }) {
   let announced = null;
   const stepProblem = (forward) => (view) => {
     const source = getSource(), map = textInputMap(source), list = currentProblems(view.state, source);
@@ -165,7 +165,8 @@ export function createDiagnostics({ getSource, applyFix, say }) {
     { key: "Escape", run: whenOpen((view) => view.dispatch({ effects: closeFixes.of(null) })) },
     { key: "Tab", run: whenOpen((view) => view.dispatch({ effects: closeFixes.of(null) })) },
   ]));
-  const plain = keymap.of([
+  // F8, Shift+F8 and the quick fix key are declared in source-keymap.js; the menu's own keys above are modal and not listed.
+  const plain = keymap.of(km ? [...km.bind("problem.next", stepProblem(true)), ...km.bind("problem.previous", stepProblem(false)), ...km.bind("problem.quickFix", openMenu)] : [
     { key: "F8", run: stepProblem(true), shift: stepProblem(false) },
     { key: "Mod-.", run: openMenu },
   ]);

package/dist/source-editing.js

@@ -227,39 +227,59 @@ export const markdownWrapSelection = EditorView.inputHandler.of((view, _from, _t
 // ---- Folding in Markdown -----------------------------------------------------------------------------------------------------------
 const SEPARATOR = /^-{3,}[ \t]*$/;
 
+const FRONT_END = /^(---|\.\.\.)\s*$/;
+const foldIndexes = new WeakMap();
+
 /**
- * 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.
+ * Every foldable range of a Markdown text, by the number of the line it starts on, from one pass over the lines (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 last line before the next `---`). A `---` inside a
+ * fence or the front matter is not a separator. A fence that is also the first line of a slide folds as the fence.
  */
-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;
+export function markdownFoldIndex(doc) {
+  const cached = foldIndexes.get(doc);
+  if (cached) return cached;
+  const index = new Map();
+  const range = (line, endLine) => ({ from: doc.line(line).to, to: doc.line(endLine).to });
+  let front = false, fence = null, previous = null, slide = null, frontEnd = 0;
+  const closeSlide = () => { if (slide && slide.last > slide.start) index.set(slide.start, range(slide.start, slide.last)); slide = null; };
+  for (let number = 1; number <= doc.lines; number++) {
+    const text = doc.line(number).text;
+    // What this line is, from the state before it (as markdownLineKind): the opening line of the front matter is body.
+    let kind = "body";
+    if (front) kind = FRONT_END.test(text) ? "body" : "front";
+    else if (fence) kind = new RegExp(`^ {0,3}${fence.char}{${fence.length},}\\s*$`).test(text) ? "body" : fence.yaml ? "yaml-fence" : "fence";
+    const blank = text.trim() === "";
+    if (kind === "body" && !blank) {
+      if (SEPARATOR.test(text)) closeSlide();
+      else {
+        const startsSlide = !previous || ((SEPARATOR.test(previous.text) || /^\.\.\.\s*$/.test(previous.text)) && previous.kind === "body");
+        if (!slide && startsSlide) slide = { start: number, last: number };
+      }
+    }
+    if (slide && !blank && !(kind === "body" && SEPARATOR.test(text))) slide.last = number;
+    if (!blank) previous = { text, kind };
+    // The state after this line.
+    if (number === 1 && /^---\s*$/.test(text)) {
+      front = true;
+      for (let at = 2; at <= doc.lines; at++) if (FRONT_END.test(doc.line(at).text)) { frontEnd = at; break; }
+      if (frontEnd > 2) index.set(1, range(1, frontEnd - 1));
+    } else if (front) {
+      if (FRONT_END.test(text)) front = false;
+    } else if (fence) {
+      if (new RegExp(`^ {0,3}${fence.char}{${fence.length},}\\s*$`).test(text)) {
+        if (number > fence.start + 1) index.set(fence.start, range(fence.start, number - 1));
+        fence = null;
+      }
+    } else {
+      const open = /^( {0,3})(`{3,}|~{3,})(.*)$/.exec(text);
+      if (open && !(open[2][0] === "`" && open[3].includes("`"))) fence = { char: open[2][0], length: open[2].length, yaml: /^\s*opf-(?:slide|block)\b/.test(open[3]), start: number };
+    }
   }
-  while (end > line.number && doc.line(end).text.trim() === "") end--;
-  return end > line.number ? { from: line.to, to: doc.line(end).to } : null;
-});
+  // A fence never closed folds to the end of the text.
+  if (fence && fence.start < doc.lines) index.set(fence.start, range(fence.start, doc.lines));
+  closeSlide();
+  foldIndexes.set(doc, index);
+  return index;
+}
+
+export const markdownFolding = foldService.of((state, lineStart) => markdownFoldIndex(state.doc).get(state.doc.lineAt(lineStart).number) ?? null);

package/dist/source-fixes-syntax.js

@@ -0,0 +1,334 @@
+// 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 { parseDocument } from "yaml";
+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 escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const isBlankLine = (text, start) => text.slice(start, lineEnd(text, start)).trim() === "";
+/** A name as the finding message writes it (a JSON string without its quotes). */
+const unquote = (value) => { try { return JSON.parse(`"${value}"`); } catch { return value; } };
+
+/**
+ * The lines of the top-level entry `key` of the YAML in text[from, to) (the key through its value, whole lines), as an edit; null when the key is
+ * not a block entry at the start of a line (a flow mapping, an entry the reader cannot place). The comments above and below stay.
+ */
+function yamlEntryEdit(text, from, to, key) {
+  const slice = text.slice(from, to);
+  let document;
+  try { document = parseDocument(slice, { strict: false, uniqueKeys: false }); } catch { return null; }
+  const pairs = document.contents?.items;
+  if (!Array.isArray(pairs) || document.contents.flow) return null;
+  const pair = pairs.find((entry) => String(entry.key?.value ?? entry.key) === key);
+  const keyRange = pair?.key?.range;
+  if (!keyRange) return null;
+  const start = lineStart(slice, keyRange[0]);
+  if (slice.slice(start, keyRange[0]).trim() !== "") return null;
+  const valueEnd = Math.max(keyRange[1], pair.value?.range?.[1] ?? 0);
+  const end = nextLine(slice, Math.max(keyRange[1], valueEnd - 1));
+  // The last line of a body has no line break of its own (the closing fence's follows it): the one before it goes instead.
+  const lead = end >= slice.length && !slice.endsWith("\n") && start > 0 ? (slice.slice(Math.max(0, start - 2), start) === "\r\n" ? 2 : 1) : 0;
+  return { from: from + start - lead, to: from + end, insert: "" };
+}
+
+/** True when the YAML text[from, to) has only blank and comment lines once `edit` is applied. */
+function emptyAfter(text, from, to, edit) {
+  const rest = text.slice(from, edit.from) + text.slice(edit.to, to);
+  return rest.split(/\r?\n/).every((line) => line.trim() === "" || line.trim().startsWith("#"));
+}
+
+/** The span of `key` (a flag, `key=bare` or `key="quoted"`) in an info line or an options comment text[from, to), with the space before it, or null. */
+function attributeSpan(text, from, to, key) {
+  const found = new RegExp(`[ \t]+${escapeRegExp(key)}(?:=(?:"(?:[^"\\\\]|\\\\.)*"|[^\\s,"]+))?(?=[\\s,]|-->|$)`).exec(text.slice(from, to));
+  return found ? { from: from + found.index, to: from + found.index + found[0].length } : null;
+}
+
+/** An attribute the fence does not take (`Unknown chart attribute "foo".`) is dropped from its info line; a known one with a bad value is left to the author. */
+function unknownAttribute(text, finding, kind, known) {
+  const quoted = new RegExp(`^Unknown ${kind} attribute ("(?:[^"\\\\]|\\\\.)*")\\.$`).exec(finding.message)?.[1];
+  const key = quoted ? unquote(quoted.slice(1, -1)) : "";
+  if (!key || known.includes(key)) return [];
+  const open = lineStart(text, finding.location.offset);
+  const span = attributeSpan(text, open, lineEnd(text, open), key);
+  return span ? [fix(`remove-attribute:${key}`, `Remove ${key}`, [{ ...span, 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) => {
+    const { offset, length } = finding.location;
+    const body = text.slice(offset, offset + length);
+    if (/^hidden takes/.test(finding.message)) {
+      const found = /\bhidden=("[^"]*"|\S+?)(?=\s|-->)/.exec(body);
+      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}` }]));
+    }
+    if (/^as takes/.test(finding.message)) {
+      const found = /\bas=("[^"]*"|\S+?)(?=\s|-->)/.exec(body);
+      if (!found) return [];
+      const from = offset + found.index;
+      return ["bullets", "video"].map((value) => fix(`as-${value}`, `Use as=${value}`, [{ from, to: from + found[0].length, insert: `as=${value}` }]));
+    }
+    // A key written as a flag (`layout`) where it needs a value: the safest repair is to drop it, not to guess the value.
+    const key = /^Option (\w+) needs a value/.exec(finding.message)?.[1];
+    const span = key ? attributeSpan(text, offset, offset + length, key) : null;
+    return span ? [fix(`remove-option:${key}`, `Remove ${key}`, [{ ...span, insert: "" }])] : [];
+  },
+  "markdown/options-syntax": (text, finding) => {
+    const { offset, length } = finding.location;
+    const body = text.slice(offset, offset + length);
+    const open = /^Unterminated quoted value for ([A-Za-z][\w-]*)\./.exec(finding.message)?.[1];
+    if (open) {
+      // The quote is closed after the last character before `-->`.
+      const quote = new RegExp(`(?:^|[\\s:,])${escapeRegExp(open)}="`).exec(body);
+      if (!quote) return [];
+      const valueStart = quote.index + quote[0].length;
+      const arrow = body.indexOf("-->", valueStart);
+      if (arrow < 0) return [];
+      let end = arrow;
+      while (end > valueStart && /\s/.test(body[end - 1])) end--;
+      return [fix("insert-closing-quote", "Insert closing quote", [{ from: offset + end, to: offset + end, insert: '"' }])];
+    }
+    const missing = /^Missing value for ([A-Za-z][\w-]*)\./.exec(finding.message)?.[1];
+    if (missing) {
+      const found = new RegExp(`[ \t]+${escapeRegExp(missing)}=(?=[\\s,]|-->|$)`).exec(body);
+      return found ? [fix(`remove-option:${missing}`, `Remove ${missing}=`, [{ from: offset + found.index, to: offset + found.index + found[0].length, insert: "" }])] : [];
+    }
+    return [];
+  },
+  "markdown/options-trailing": (text, finding) => {
+    const { offset, length } = finding.location;
+    const body = text.slice(offset, offset + length);
+    const arrow = body.indexOf("-->");
+    if (arrow < 0) return [];
+    const gap = /^[ \t]*/.exec(body.slice(arrow + 3))[0];
+    if (body.slice(arrow + 3 + gap.length).trim() === "") return [];
+    return [fix("move-text-down", "Move the text to its own line", [{ from: offset + arrow + 3, to: offset + arrow + 3 + gap.length, insert: /\r\n/.test(text) ? "\r\n" : "\n" }])];
+  },
+  "markdown/options-orphan": (text, finding) => {
+    const { offset, length } = finding.location;
+    return [fix("remove-options-comment", "Remove the options comment", [removeLines(text, offset, offset + length)])];
+  },
+  "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/empty-quote": (text, finding) => {
+    const { offset, length } = finding.location;
+    const edit = removeLines(text, offset, offset + length);
+    // The blank line after the quote goes too when the line before is blank as well, so no double gap is left.
+    if (edit.from > 0 && isBlankLine(text, lineStart(text, edit.from - 1)) && edit.to < text.length && isBlankLine(text, edit.to)) edit.to = nextLine(text, edit.to);
+    return [fix("remove-empty-quote", "Remove the empty quote", [edit])];
+  },
+  "markdown/slide-property-conflict": (text, finding) => {
+    const key = unquote(/property "(.*)" is set twice/.exec(finding.message)?.[1] ?? "");
+    const slide = Number(/^\/slides\/(\d+)\//.exec(finding.path ?? "")?.[1]);
+    if (!key || !Number.isInteger(slide)) return [];
+    for (const fence of scanMarkdown(text).fences) {
+      if (fence.kind !== "opf-slide" || fence.slide !== slide) continue;
+      const edit = yamlEntryEdit(text, fence.bodyFrom, fence.bodyTo, key);
+      if (!edit) continue;
+      if (!emptyAfter(text, fence.bodyFrom, fence.bodyTo, edit)) return [fix(`remove-from-fence:${key}`, `Remove ${key} from the fence`, [edit])];
+      // The fence held nothing else: it goes with its blank line above.
+      let from = lineStart(text, fence.from);
+      const to = nextLine(text, fence.to);
+      if (from > 0 && isBlankLine(text, lineStart(text, from - 1)) && (to >= text.length || isBlankLine(text, to))) from = lineStart(text, from - 1);
+      return [fix(`remove-from-fence:${key}`, `Remove ${key} from the fence`, [{ from, to, insert: "" }])];
+    }
+    return [];
+  },
+  "markdown/chart-attributes": (text, finding) => unknownAttribute(text, finding, "chart", ["alt"]),
+  "markdown/timeline-attributes": (text, finding) => unknownAttribute(text, finding, "timeline", ["name", "description"]),
+  "markdown/metric-block": (text, finding) => {
+    const open = lineStart(text, finding.location.offset);
+    if (finding.message === "A metric needs a value.") {
+      const at = nextLine(text, open);
+      return [fix("insert-metric-value", "Insert value:", [{ from: at, to: at, insert: "value: 0\n" }])];
+    }
+    // The offending line itself is the finding's range: a key given twice, or a key with nothing after the colon.
+    const { offset, length } = finding.location;
+    const twice = /^Metric key (\w+) is given twice\./.exec(finding.message)?.[1];
+    if (twice) return [fix("remove-duplicate-metric-key", `Remove the second ${twice}`, [removeLines(text, offset, offset + length)])];
+    const empty = /^Metric key (\w+) has no value\./.exec(finding.message)?.[1];
+    return empty && empty !== "value" ? [fix(`remove-metric-key:${empty}`, `Remove ${empty}:`, [removeLines(text, offset, offset + length)])] : [];
+  },
+};
+
+/** 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

@@ -2,7 +2,7 @@
 // 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 } from "@openpresentation/opf/source";
+import { SLIDE_OPTION_KEYS, scanMarkdown } from "@openpresentation/opf/source";
 import { replacementValues, segmentsOf } from "./source-messages.js";
 import { locateText } from "./source-ranges.js";
 
@@ -58,6 +58,70 @@ function addProperty(format, text, segments, key, value) {
   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.
@@ -76,12 +140,21 @@ export function textFixesForFinding(format, finding, text, context = {}) {
   } 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;
+  return fixes.filter((fix) => fix.edits.length);
 }

package/dist/source-fixes.js

@@ -72,6 +72,27 @@ export function wrapInList(text, segments) {
   return [{ from: offset, to: offset, insert: "[" }, { from: offset + length, to: offset + length, insert: "]" }];
 }
 
+/** One edit that turns `before` into `after` (the span between their common start and common end), for a change several `modify` calls make together. */
+export function diffEdit(before, after) {
+  let start = 0;
+  while (start < before.length && start < after.length && before[start] === after[start]) start++;
+  let end = 0;
+  while (end < before.length - start && end < after.length - start && before[before.length - 1 - end] === after[after.length - 1 - end]) end++;
+  return [{ from: start, to: before.length - end, insert: after.slice(start, after.length - end) }];
+}
+/** Move the property whose value is at `segments` into the `extensions` object of its parent (created when there is none). */
+export function moveIntoExtensions(text, segments, unit = "  ") {
+  const found = nodeAt(text, segments);
+  if (!found || segments.length === 0) return null;
+  const parent = segments.slice(0, -1), name = segments.at(-1);
+  let value;
+  try { value = JSON.parse(text.slice(found.node.offset, found.node.offset + found.node.length)); } catch { return null; }
+  const options = { formattingOptions: formatting(unit, text) };
+  const removed = applySourceEdits(text, asEdits(modify(text, toPath(segments), undefined, options)));
+  const added = applySourceEdits(removed, asEdits(modify(removed, [...toPath(parent), "extensions", name], value, options)));
+  return added === text ? null : diffEdit(text, added);
+}
+
 /**
  * The quick fixes of a schema or reference finding in a JSON text that parses. `context` is the one source-messages.js takes plus
  * `{ unit, starter(segments, property) }` (the value `Add` inserts).
@@ -88,14 +109,17 @@ export function fixesForFinding(finding, text, context = {}) {
   } else if (keyword === "additionalProperties") {
     const name = finding.validation.params?.additionalProperty ?? segments.at(-1);
     for (const value of replacementValues(finding, context)) push(`rename-to:${value}`, `Rename to ${value}`, renameKey(text, segments, value));
+    if (name !== "extensions" && context.keysOf?.(segments.slice(0, -1))?.includes("extensions")) push("move-to-extensions", "Move into extensions", moveIntoExtensions(text, segments, unit));
     push("remove-property", "Remove property", removeAt(text, segments, unit));
-    void name;
   } else if (keyword === "required") {
     const property = finding.validation.params?.missingProperty;
     const starter = context.starter?.(segments, property);
     if (property && starter !== undefined) push(`add:${property}`, `Add \`${property}\``, addProperty(text, segments, property, starter, unit));
   } else if (keyword === "type" && finding.validation.params?.type === "array") {
     push("wrap-in-list", "Wrap in a list", wrapInList(text, segments));
+  } 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") push("convert-to-string", "Convert to string", changeValue(text, segments, String(value)), { safe: true });
   } else if (keyword === "minItems" && finding.path === "/slides") {
     push("add-slide", "Add a slide", addItem(text, segments, { title: "Slide title" }, unit));
   } else if (finding.ruleId === "opf/duplicate-key") {