@openpresentation/opf-editor 0.26.5 → 0.26.6

package/dist/source-check.js

@@ -0,0 +1,90 @@
+// The source pane's text checks as plain functions of their input (no DOM, no editor session), so the main thread and the Web Worker
+// (`./source-worker.js`) run exactly the same code and give the same answer. `readSource` is what the pane has always done with a text
+// (parse it, collect the syntax findings); `checkSource` adds the validation the editor session would run on the deck it reads, so a worker
+// can hand both back and the session need not repeat it on the main thread. Everything returned is structured-cloneable data.
+import { fromYaml } from "@openpresentation/opf/yaml";
+import { fromMarkdown, toMarkdown } from "@openpresentation/opf/markdown";
+import { checkFormat } from "./checks.js";
+import { normalizeFinding } from "./source-findings.js";
+import { analyzeSyntax, findDuplicateKeys } from "./source-syntax.js";
+import { withSyntaxFixes } from "./source-fixes-syntax.js";
+
+/**
+ * Read the text of one format: `{ deck, findings, notes? }` on success, `{ syntax: true, findings }` when it cannot be read. `findings` carry the
+ * syntax errors (`kind: "syntax"`) or the OPF findings of the parsed deck; `notes` are the reader's warnings that come with a deck.
+ */
+export function readSource(format, text, catalogs) {
+  if (format === "json") {
+    const problems = analyzeSyntax(text);
+    if (problems.length) return { syntax: true, findings: problems.map((problem) => normalizeFinding(problem, "syntax")) };
+    const deck = JSON.parse(text);
+    const duplicates = findDuplicateKeys(text);
+    if (duplicates.length) return { syntax: true, findings: duplicates };
+    return { deck, findings: [] };
+  }
+  const result = format === "yaml" ? fromYaml(text, { catalogs }) : fromMarkdown(text, { catalogs });
+  // The reader's own findings: errors stop the document being read; its warnings (a numbered list that became bullets) come with the deck.
+  const readerFindings = result.findings.filter((finding) => !finding.ruleId?.startsWith("opf/"));
+  const errors = readerFindings.filter((finding) => finding.severity === "error");
+  const syntax = (list) => withSyntaxFixes(format, text, list).map((finding) => normalizeFinding(finding, "syntax"));
+  if (errors.length) return { syntax: true, findings: syntax(errors) };
+  return { deck: result.presentation, findings: result.findings.map((finding) => normalizeFinding(finding, "schema")), notes: syntax(readerFindings) };
+}
+
+/**
+ * `readSource` plus, when a deck was read, `validation`: the report the editor session computes for that deck (`checkFormat`, with the same
+ * catalogs). `validate: false` skips it (the main thread's own path, where the session validates the patch itself).
+ */
+export function checkSource({ format, text, catalogs, validate = true }) {
+  const read = readSource(format, text, catalogs);
+  if (validate && read.deck) {
+    read.validation = checkFormat(read.deck, { catalogs });
+    // What the Markdown writer cannot hold for this deck: the pane lists it after every applied edit, and writing a big deck back is not cheap.
+    if (format === "md") read.markdownNotes = markdownNotesOf(read.deck);
+  }
+  return read;
+}
+
+/** The notes about what Markdown cannot hold, as findings, from the report of `toMarkdown`. */
+export function markdownNotes(report) {
+  const notes = report.embedded.map((part) => normalizeFinding({ path: part.path, message: `Markdown has no syntax for this, so it is kept as YAML in a fenced block (${part.reason}).`, severity: "warning" }, "format"));
+  for (const entry of report.loss) {
+    const at = entry.indexOf(": ");
+    notes.push(normalizeFinding({ path: at > 0 ? entry.slice(0, at) : "", message: `Left out of the Markdown: ${at > 0 ? entry.slice(at + 2) : entry}.`, severity: "warning" }, "format"));
+  }
+  return notes;
+}
+
+/** The Markdown notes of `deck`; none when it cannot be written as Markdown. */
+export function markdownNotesOf(deck) {
+  try { return markdownNotes(toMarkdown(deck).report); } catch { return []; }
+}
+
+/** The syntax problems of a JSON text as findings (the pane's quick pass, 150 ms after the last key). */
+export function checkSyntaxOnly(text) {
+  return analyzeSyntax(text).map((problem) => normalizeFinding(problem, "syntax"));
+}
+
+/**
+ * The worker's side of the protocol, free of any worker API so it can be tested in Node. `handle(message)` returns the reply for one message
+ * (or null for a message with no reply). Messages: `{ id, type: "catalogs", catalogs }`, `{ id, type: "check", format, text }` and
+ * `{ id, type: "syntax", text }`; replies: `{ id, ok: true, result }` or `{ id, ok: false, error }`.
+ */
+export function createCheckService() {
+  let catalogs;
+  return {
+    handle(message) {
+      const id = message?.id;
+      try {
+        switch (message?.type) {
+          case "catalogs": catalogs = message.catalogs; return { id, ok: true, result: null };
+          case "check": return { id, ok: true, result: checkSource({ format: message.format, text: message.text, catalogs }) };
+          case "syntax": return { id, ok: true, result: checkSyntaxOnly(message.text) };
+          default: return { id, ok: false, error: `Unknown message type ${String(message?.type)}.` };
+        }
+      } catch (error) {
+        return { id, ok: false, error: error instanceof Error ? error.message : String(error) };
+      }
+    },
+  };
+}

package/dist/source-checker.js

@@ -0,0 +1,130 @@
+// The client side of the source worker (`./source-worker.js`): it owns the worker, numbers the requests, keeps the worker's catalogs in step with the
+// pane's, and falls back to the pane's own inline path for good, once, when anything about the worker goes wrong (it cannot start, a script URL is
+// blocked or missing, a message cannot be cloned, the worker throws or stops answering). It never loses an edit: a failed request rejects with
+// `error.workerFailed === true`, and the pane then does the same work inline.
+
+const DEFAULT_TIMEOUT = 15000;
+
+/** A failure of the worker as an error the caller can tell from an exception of the checked text. */
+function failure(cause) {
+  const error = new Error(cause instanceof Error ? cause.message : String(cause ?? "The source worker failed."));
+  error.workerFailed = true;
+  error.cause = cause;
+  return error;
+}
+
+/** The worker the `worker` option stands for: a function is called, an object with `postMessage` is used as given, `true` starts the package's own. */
+function makeWorker(option) {
+  if (typeof option === "function") return option();
+  if (option && typeof option === "object" && typeof option.postMessage === "function") return option;
+  if (option === true) {
+    if (typeof Worker !== "function") throw new Error("Web Workers are not available here.");
+    return new Worker(new URL("./source-worker.js", import.meta.url), { type: "module" });
+  }
+  throw new TypeError("The worker option is true, a Worker, or a function that returns one.");
+}
+
+/**
+ * @param {{ worker: boolean | object | (() => object), onError?: (error: unknown) => void, timeout?: number }} options
+ */
+export function createSourceChecker(options = {}) {
+  const timeout = options.timeout ?? DEFAULT_TIMEOUT;
+  let worker = null;
+  let failed = false;
+  let disposed = false;
+  let nextId = 0;
+  let sentCatalogs;
+  let catalogsSent = false;
+  const pending = new Map();
+  const latest = { check: 0, syntax: 0 };
+  const counts = { worker: 0 };
+
+  function fail(cause) {
+    if (failed || disposed) return;
+    failed = true;
+    const error = failure(cause);
+    for (const entry of pending.values()) { clearTimeout(entry.timer); entry.reject(error); }
+    pending.clear();
+    try { worker?.terminate?.(); } catch { /* Already gone. */ }
+    worker = null;
+    try { options.onError?.(cause instanceof Error ? cause : error); } catch { /* A host callback must not break the fallback. */ }
+  }
+
+  function reply(event) {
+    const data = event?.data;
+    const entry = pending.get(data?.id);
+    if (!entry) return;
+    pending.delete(data.id);
+    clearTimeout(entry.timer);
+    if (data.ok === false) { entry.reject(failure(data.error)); fail(new Error(String(data.error))); return; }
+    if (data.skipped || (entry.kind && latest[entry.kind] !== data.id)) { entry.resolve(null); return; }
+    if (entry.kind) counts.worker++;
+    entry.resolve(data.result);
+  }
+
+  function start() {
+    if (worker) return worker;
+    worker = makeWorker(options.worker);
+    if (!worker || typeof worker.postMessage !== "function") throw new TypeError("The worker option did not give a Worker.");
+    worker.onmessage = reply;
+    worker.onerror = (event) => { event?.preventDefault?.(); fail(new Error(event?.message || "The source worker failed to start.")); };
+    worker.onmessageerror = () => fail(new Error("The source worker sent a message that could not be read."));
+    return worker;
+  }
+
+  function post(message, kind) {
+    if (failed || disposed) return Promise.reject(failure("The source worker is not available."));
+    let target;
+    try { target = start(); } catch (error) { fail(error); return Promise.reject(failure(error)); }
+    const id = ++nextId;
+    if (kind) latest[kind] = id;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => fail(new Error("The source worker did not answer in time.")), timeout);
+      pending.set(id, { resolve, reject, timer, kind });
+      try { target.postMessage({ id, ...message }); } catch (error) { fail(error); }
+    });
+  }
+
+  /** Send the catalogs when they are not the ones the worker already has (by identity), ahead of the request that needs them. */
+  function syncCatalogs(catalogs) {
+    if (catalogsSent && sentCatalogs === catalogs) return;
+    sentCatalogs = catalogs;
+    catalogsSent = true;
+    post({ type: "catalogs", catalogs }).catch(() => { /* `fail` already ran; the request after it rejects too. */ });
+  }
+
+  return {
+    /** Whether the worker can still be used (it may not have been started yet). */
+    get available() { return !failed && !disposed; },
+    /** Whether the worker is running now. */
+    get running() { return worker !== null && !failed && !disposed; },
+    /** The catalogs object the worker's next check will use (the last one sent). */
+    get catalogs() { return catalogsSent ? sentCatalogs : undefined; },
+    /** How many checks the worker answered. */
+    get answered() { return counts.worker; },
+    /**
+     * Check `text` as `format` in the worker, with `catalogs`. Resolves with the `checkSource` result, or with null when a newer check replaced this
+     * one. Rejects with `error.workerFailed` when the worker is not usable (and never again starts it).
+     */
+    check(format, text, catalogs) {
+      if (failed || disposed) return Promise.reject(failure("The source worker is not available."));
+      try { start(); syncCatalogs(catalogs); } catch (error) { fail(error); return Promise.reject(failure(error)); }
+      return post({ type: "check", format, text }, "check");
+    },
+    /** The syntax findings of a JSON text (null when a newer request replaced this one). */
+    syntax(text) {
+      if (failed || disposed) return Promise.reject(failure("The source worker is not available."));
+      try { start(); } catch (error) { fail(error); return Promise.reject(failure(error)); }
+      return post({ type: "syntax", text }, "syntax");
+    },
+    /** Stop the worker and answer nothing more. */
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      for (const entry of pending.values()) { clearTimeout(entry.timer); entry.resolve(null); }
+      pending.clear();
+      try { worker?.terminate?.(); } catch { /* Already gone. */ }
+      worker = null;
+    },
+  };
+}

package/dist/source-completions.js

@@ -11,7 +11,7 @@ import { Document, parse as parseYamlDocument, parseDocument } from "yaml";
 import { pathAt, scanMarkdown } from "@openpresentation/opf/source";
 import { findNodeAtLocation, getNodeValue } from "jsonc-parser";
 import { contextAt, nextSignificant, nodeAt, skeleton, tokenAt } from "./source-json.js";
-import { PROMOTED_REGIONS, beatsOf, columnSourceFor, factsOf, jsonDeckParts, layoutKeys, referenceSiteAt, regionNames, slidePath, valueAt, variableNames, yamlDeckParts } from "./source-references.js";
+import { PROMOTED_REGIONS, beatsOf, builtinVariables, columnSourceFor, factsOf, jsonDeckParts, layoutKeys, referenceSiteAt, regionNames, slidePath, valueAt, variableNames, yamlDeckParts } from "./source-references.js";
 import { beginUndoGroup, finishUndoGroup, takeUndoGroup } from "./source-undo-groups.js";
 import { scalarValue, yamlContextAt } from "./source-yaml.js";
 import { markdownContextAt, markdownOptions, markdownPlan, markdownHoverAt } from "./source-markdown.js";
@@ -290,11 +290,20 @@ function referenceOptions(site, context, catalogs, scope) {
   return options;
 }
 
-// `{{name}}` in a text: the variables the document declares, offered once `{{` is typed. `before` is the text of the value before the caret.
+// `{{name}}` in a text, offered once `{{` is typed: the variables the document declares first, then the built-in ones the engine resolves
+// (`deck.*`, `speaker.*`, `organization.*`, `slide.*`), grouped by prefix, each saying whether the document sets it. `before` is the text of the value
+// before the caret.
 const VARIABLE_OPEN = /\{\{([A-Za-z0-9._-]*)$/;
 function variableOptions(scope) {
+  const facts = scope.facts();
   const options = [];
-  variableNames(scope.facts()).forEach((variable, index) => options.push({ label: variable.id, type: "reference", detail: `${variable.type} variable`, boost: boostAt(index), opfDoc: `The variable ${variable.id}`, opf: { kind: "variable", name: variable.id } }));
+  variableNames(facts).forEach((variable) => options.push({ label: variable.id, type: "reference", detail: `${variable.type} variable`, boost: boostAt(options.length), opfDoc: `The variable ${variable.id}`, opf: { kind: "variable", name: variable.id } }));
+  for (const builtin of builtinVariables(facts)) {
+    options.push({
+      label: builtin.name, type: "reference", detail: builtin.detail, boost: boostAt(options.length), opfDoc: builtin.doc, opf: { kind: "variable", name: builtin.name, builtin: true },
+      info: () => docNode({ title: builtin.name, type: "built-in variable", description: builtin.doc, notes: [builtin.available ? "" : "Not set in this document"].filter(Boolean) }),
+    });
+  }
   return options;
 }
 
@@ -533,13 +542,7 @@ export function applyCompletion(view, completion, fallbackFrom, fallbackTo, say,
   const { state } = view;
   const text = state.doc.toString();
   const main = state.selection.main;
-  if (completion.opf?.kind === "variable") {
-    // `{{na|` becomes `{{name}}`: the name replaces what was typed after the braces and the closing braces are written unless they are there.
-    const to = text.startsWith("}}", fallbackTo) ? fallbackTo + 2 : fallbackTo;
-    const insert = `${completion.opf.name}}}`;
-    view.dispatch({ changes: { from: fallbackFrom, to, insert }, selection: { anchor: fallbackFrom + insert.length }, annotations: [pickedCompletion.of(completion), isolateHistory.of("full")], userEvent: "input.complete", scrollIntoView: true });
-    return;
-  }
+  if (completion.opf?.kind === "variable") { applyVariable(view, completion, fallbackFrom, fallbackTo); return; }
   // A value accepted right after the key that opened its list is one undo step with that key (R-CMP-14).
   const group = takeUndoGroup(view);
   const context = contextFor(format, text, main.head, true);
@@ -593,6 +596,39 @@ export function applyCompletion(view, completion, fallbackFrom, fallbackTo, say,
   finish(plan.chain);
 }
 
+/**
+ * `{{na|` becomes `{{name}}`: the name replaces what was typed after the braces and the closing braces are written unless they are there. With
+ * several cursors it does so at each of them, in one undo step. A cursor with no `{{` before it replaces as many characters as the main cursor's typed
+ * name when they are the same text (VS Code applies the item at every cursor the same way), and adds the braces all the same.
+ */
+function applyVariable(view, completion, fallbackFrom, fallbackTo) {
+  const { state } = view;
+  const text = state.doc.toString();
+  const insert = `${completion.opf.name}}}`;
+  const annotations = [pickedCompletion.of(completion), isolateHistory.of("full")];
+  if (state.selection.ranges.length <= 1) {
+    const to = text.startsWith("}}", fallbackTo) ? fallbackTo + 2 : fallbackTo;
+    view.dispatch({ changes: { from: fallbackFrom, to, insert }, selection: { anchor: fallbackFrom + insert.length }, annotations, userEvent: "input.complete", scrollIntoView: true });
+    return;
+  }
+  const typed = text.slice(fallbackFrom, fallbackTo);
+  const sorted = [...state.selection.ranges].sort((a, b) => a.from - b.from);
+  const changes = [], carets = [];
+  let shift = 0;
+  for (const range of sorted) {
+    const head = range.head;
+    const open = VARIABLE_OPEN.exec(text.slice(Math.max(0, head - 200), head));
+    const length = open ? open[1].length : text.slice(head - typed.length, head) === typed ? typed.length : 0;
+    const from = head - length;
+    const to = text.startsWith("}}", head) ? head + 2 : head;
+    changes.push({ from, to, insert });
+    carets.push(from + shift + insert.length);
+    shift += insert.length - (to - from);
+  }
+  const main = sorted.indexOf(state.selection.main);
+  view.dispatch({ changes, selection: EditorSelection.create(carets.map((position) => EditorSelection.cursor(position)), Math.max(0, main)), annotations, userEvent: "input.complete", scrollIntoView: true });
+}
+
 // With several cursors the item goes in at each of them as plain text (no tab stops), each over its own token.
 function applyAtEveryCursor(view, completion, plan, format) {
   const { state } = view;

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

@@ -3,6 +3,7 @@
 // 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;
@@ -79,6 +80,55 @@ function frontMatterEnd(text) {
 /** 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);
@@ -108,12 +158,59 @@ const markdownRules = {
     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}` }]));
+    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];
@@ -168,11 +265,44 @@ const markdownRules = {
     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) => {
-    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" }])];
+    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)])] : [];
   },
 };