@openpresentation/opf-editor 0.26.3 → 0.26.4

package/dist/source-completions.js

@@ -2,16 +2,39 @@
 // ranked, and what accepting an item writes. Keys come from the schema (`describeField` of core), values from the schema's enums, booleans and the
 // catalogs, templates for objects and lists, snippets for slides and the like. Loaded lazily by the code editor with the schema and the catalogs.
 import { hasNextSnippetField, hasPrevSnippetField, pickedCompletion, snippet, startCompletion } from "@codemirror/autocomplete";
+import { isolateHistory } from "@codemirror/commands";
 import { EditorSelection } from "@codemirror/state";
 import { describeField } from "@openpresentation/opf/schema";
 import { listCatalogRecords } from "./catalogs.js";
 import { LAYOUT_INTENT_GROUPS, layoutRegionSummary } from "./layout-templates.js";
+import { Document, parse as parseYamlDocument } from "yaml";
+import { pathAt } from "@openpresentation/opf/source";
 import { contextAt, nextSignificant, nodeAt, skeleton, tokenAt } from "./source-json.js";
+import { scalarValue, yamlContextAt } from "./source-yaml.js";
+import { markdownContextAt, markdownOptions, markdownPlan, markdownHoverAt } from "./source-markdown.js";
 import { childDoc, docNode, docText, fieldDoc } from "./source-docs.js";
-import { snippetJson, snippetsFor } from "./source-snippets.js";
+import { snippetJson, snippetYaml, snippetsFor } from "./source-snippets.js";
 
 export { contextAt, tokenAt };
 
+/** The context of the caret in a text of `format` ("json", "yaml" or "md"), or null: what the list offers, and the token it replaces. */
+export function contextFor(format, text, position, explicit) {
+  if (format === "yaml") {
+    const context = yamlContextAt(text, position, { explicit });
+    // A blank document starts with a deck.
+    return context && context.mode === "key" && context.path.length === 0 && text.trim() === "" ? { ...context, blank: true } : context;
+  }
+  if (format === "md") return markdownContextAt(text, position, { explicit });
+  return contextAt(text, position, { explicit });
+}
+
+/** The token being typed at `position` in a text of `format`, or null. */
+export function tokenFor(format, text, position) {
+  if (format === "json") return tokenAt(text, position, false);
+  const context = contextFor(format, text, position, false);
+  return context?.token ?? null;
+}
+
 // A quoted token keeps its list for any text between the quotes; a bare word for word characters only.
 const QUOTED_TEXT = /^[^"\\\n\r]*$/;
 const WORD_TEXT = /^[A-Za-z0-9_.-]*$/;
@@ -99,17 +122,21 @@ function keyOptions(context, text, caret, explicit) {
     const free = info.children.filter((child) => !context.existing.has(child.key));
     const withAdvanced = advancedShown(free, typed, explicit);
     const shown = free.filter((child) => !child.advanced || (withAdvanced && child.key.toLowerCase().startsWith(typed)));
+    // A blank document starts with a deck: its snippet comes first.
+    if (context.blank) for (const entry of snippetsFor("value", [])) options.push(snippetOption(entry, 99));
     shown.forEach((child, index) => options.push({
       label: child.key,
       type: "property",
       detail: child.required ? `${child.typeLabel} · required` : child.typeLabel,
-      boost: boostAt(index),
+      boost: boostAt(index + (context.blank ? 1 : 0)),
       opfRequired: child.required,
       opfDoc: child.description ?? "",
       opf: { kind: "key", key: child.key },
       info: () => docNode(describeChild(context, child)),
     }));
     for (const entry of snippetsFor("key", context.path)) options.push(snippetOption(entry, boostAt(options.length)));
+    // A key right after a list dash is also the start of the item: the item snippets (a slide, a reference) fit there.
+    if (context.itemStart) for (const entry of snippetsFor("item", context.path)) options.push(snippetOption(entry, boostAt(options.length)));
     return { options, advanced: withAdvanced };
   }
   return { options, advanced: false };
@@ -130,7 +157,7 @@ function snippetOption(entry, boost) {
 }
 
 function literalOption(label, literal, extra) {
-  return { label, type: extra.type ?? "enum", boost: extra.boost, detail: extra.detail, opfDoc: extra.doc ?? "", opf: { kind: "literal", literal }, info: extra.info };
+  return { label, type: extra.type ?? "enum", boost: extra.boost, detail: extra.detail, opfDoc: extra.doc ?? "", opf: { kind: "literal", literal, value: extra.value }, info: extra.info };
 }
 
 function catalogOptions(kind, context, catalogs) {
@@ -150,7 +177,7 @@ function catalogOptions(kind, context, catalogs) {
     const notes = [regions && `Regions: ${regions}`, SOURCE_LABELS[record.origin === "document" ? "document" : "registered"]].filter(Boolean);
     const model = { title: record.id, type: KIND_LABELS[kind], description: record.description ?? undefined, notes: [record.label !== record.id ? record.label : "", ...notes].filter(Boolean) };
     return literalOption(record.id, JSON.stringify(record.id), {
-      type: "catalog", boost: intent || record.origin === "document" ? boostAt(index) : 0, detail: record.label !== record.id ? record.label : SOURCE_LABELS[record.origin === "document" ? "document" : "registered"],
+      value: record.id, type: "catalog", boost: intent || record.origin === "document" ? boostAt(index) : 0, detail: record.label !== record.id ? record.label : SOURCE_LABELS[record.origin === "document" ? "document" : "registered"],
       doc: [brief(record.description), regions].filter(Boolean).join(" "), info: () => docNode(model),
     });
   });
@@ -165,11 +192,11 @@ function valueOptions(context, catalogs) {
   else if (info.enum?.length) {
     // In the order VS Code lists them: by label.
     info.enum.forEach((entry) => options.push(literalOption(String(entry.value), JSON.stringify(entry.value), {
-      doc: entry.description ?? "", info: entry.description ? () => docNode({ title: String(entry.value), type: "value", description: entry.description }) : undefined,
+      value: entry.value, doc: entry.description ?? "", info: entry.description ? () => docNode({ title: String(entry.value), type: "value", description: entry.description }) : undefined,
     })));
   } else if (info.types.includes("boolean")) {
-    for (const value of ["true", "false"]) options.push(literalOption(value, value, { type: "boolean" }));
-  } else if (variant && !info.freeText && (variant.type === "object" || variant.type === "array")) {
+    for (const value of ["true", "false"]) options.push(literalOption(value, value, { type: "boolean", value: value === "true" }));
+  } else if (variant && !info.freeText && (variant.type === "object" || variant.type === "array") && context.format !== "yaml") {
     // An object or a list goes in as a template: `{}` with its required members, or `[]`.
     const label = variant.type === "object" ? "{}" : "[]";
     options.push({ label, type: "keyword", detail: variant.type === "object" ? "object" : "list", boost: 99, opfDoc: info.description ?? "", opf: { kind: "template" }, info: () => docNode(fieldDoc(info, context.key ?? label)) });
@@ -178,17 +205,49 @@ function valueOptions(context, catalogs) {
   return { options };
 }
 
+// A word of a key, a value or an id: what the list stays valid for while the author types within the same token.
+const YAML_KEY_TEXT = /^[A-Za-z0-9_.+-]*$/;
+const YAML_VALUE_TEXT = /^[A-Za-z0-9_.:+-]*$/;
+
+// In a YAML list the dash may start a mapping (a slide) or hold a scalar (an id, a line of text): the schema of the item tells.
+function settleYamlContext(context, text) {
+  if (context.mode === "key" && context.seq) {
+    let info;
+    try { info = describeField(context.path, context.document); } catch { info = null; }
+    const primary = info?.known ? info.variants[info.primary] : undefined;
+    if (!info?.known || !primary) return null;
+    if (primary.type !== "object") {
+      // The item is a scalar, not the mapping the line reader pictured: the schema reads the document with an empty string there.
+      let parent = context.document;
+      for (const step of context.path.slice(0, -1)) parent = parent?.[step];
+      if (parent && typeof parent === "object") parent[context.path.at(-1)] = "";
+      return { ...context, mode: "item", key: undefined, itemStart: false };
+    }
+  }
+  return context;
+}
+
 /**
- * The completion result at `position` for CodeMirror, or null. `catalogs` are the host's.
+ * The completion result at `position` for CodeMirror, or null. `catalogs` are the host's; `format` is "json" (the default), "yaml" or "md".
  */
-export function completionResult(state, position, { explicit, catalogs }) {
+export function completionResult(state, position, { explicit, catalogs, format = "json" }) {
   const text = state.doc.toString();
-  const context = contextAt(text, position, { explicit });
+  let context = contextFor(format, text, position, explicit);
   if (!context) return null;
+  if (context.format === "md") return markdownResult(context, text, position, { explicit, catalogs });
+  if (context.format === "yaml") {
+    context = settleYamlContext(context, text);
+    if (!context) return null;
+  }
   const { options, advanced } = context.mode === "key" ? keyOptions(context, text, position, explicit) : valueOptions(context, catalogs);
   if (!options.length) return null;
+  return listResult(context, options, advanced, { position, explicit });
+}
+
+function listResult(context, options, advanced, { position, explicit }) {
   const { token } = context;
   const quoted = token.quoted;
+  const plainText = context.format !== "yaml" ? WORD_TEXT : context.mode === "value" || context.mode === "item" ? YAML_VALUE_TEXT : YAML_KEY_TEXT;
   // The result stays valid while the author types within the same token and the set of keys it shows does not change (advanced keys come and go
   // with the prefix).
   const sameSet = context.mode !== "key" ? () => true : (typed) => advancedShown(options.length ? infoChildren(context) : [], typed.toLowerCase(), explicit) === Boolean(advanced);
@@ -198,7 +257,20 @@ export function completionResult(state, position, { explicit, catalogs }) {
     to: Math.max(token.from, Math.min(position, token.to)),
     filter: true,
     options,
-    validFor: (typed) => (quoted ? QUOTED_TEXT : WORD_TEXT).test(typed) && sameSet(typed),
+    validFor: (typed) => (quoted ? QUOTED_TEXT : plainText).test(typed) && sameSet(typed),
+  };
+}
+
+function markdownResult(context, text, position, { explicit, catalogs }) {
+  const built = markdownOptions(context, { catalogs, explicit, text, position, makers: { snippetOption, literalOption, boostAt, docNode, valueOptions, listCatalogRecords } });
+  if (!built?.options.length) return null;
+  const { token } = context;
+  return {
+    from: token.from,
+    to: Math.max(token.from, Math.min(position, token.to)),
+    filter: true,
+    options: built.options,
+    validFor: (typed) => (token.quoted ? QUOTED_TEXT : built.validFor ?? YAML_VALUE_TEXT).test(typed),
   };
 }
 function infoChildren(context) {
@@ -208,8 +280,64 @@ function infoChildren(context) {
 // ---- accepting -------------------------------------------------------------------------------------------------------------------------
 const snippetRuns = new WeakMap();
 
-/** What accepting `completion` writes: `{ start, end, template, fields, chain, choices }` for the context of the caret. */
+// A YAML value as text: a plain scalar when it reads back as the same value, else quoted (the `yaml` library knows the cases: `true`, `1`, `a: b`).
+function 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 escapeTemplate = (text) => text.replace(/[\\{}]/g, (character) => `\\${character}`);
+
+/** What accepting a key writes in YAML: `key: ` for a scalar, `key:` and a new line for a mapping or a list. */
+function yamlKeyPlan(context, key, text, end) {
+  const written = yamlKey(key);
+  if (/^[ \t]*:/.test(text.slice(end))) return { template: escapeTemplate(written), fields: 0, chain: false };
+  let info;
+  try { info = describeField([...context.path, key], context.document); } catch { info = null; }
+  const kind = info?.known ? variantKind(info) : "string";
+  if (context.flow || kind === "choice" || kind === "boolean" || !["array", "object"].includes(kind)) {
+    return { template: `${escapeTemplate(written)}: `, fields: 0, chain: kind === "choice" || kind === "boolean" };
+  }
+  // A mapping or a list goes on the next line, one level in; after a dash the line's content starts two columns in, so the new lines do too.
+  const dash = " ".repeat(Math.max(0, context.column - context.indent));
+  const unit = "  ";
+  const lead = `\n${dash}${unit}`;
+  if (kind === "array") return { template: `${escapeTemplate(written)}:${lead}- \${0}`, fields: 1, chain: false };
+  const variant = primaryVariant(info);
+  const required = variant?.requiredChildren?.length ? variant.requiredChildren : info.requiredChildren;
+  if (!required.length) return { template: `${escapeTemplate(written)}:${lead}\${0}`, fields: 1, chain: false };
+  const lines = required.map((name, index) => `${yamlKey(name)}: \${${index + 1}}`);
+  return { template: `${escapeTemplate(written)}:${lead}${lines.join(lead)}\${0}`, fields: required.length + 1, chain: false };
+}
+
+/** What accepting `completion` writes in YAML: `{ start, end, template, fields, chain, choices }`. */
+function planYaml(context, completion, text, end) {
+  const kind = completion.opf?.kind;
+  if (kind === "key") return yamlKeyPlan(context, completion.opf.key, text, end);
+  if (kind === "literal") {
+    const value = completion.opf.value;
+    const prefix = context.needsSpace ? " " : "";
+    if (context.token.quoted) {
+      const inner = typeof value === "string" ? value.replace(/\\/g, "\\\\").replace(/"/g, '\\"') : String(value);
+      return { template: escapeTemplate(inner), fields: 0, chain: false, inner: true };
+    }
+    return { template: `${prefix}${escapeTemplate(yamlScalar(value))}`, fields: 0, chain: false };
+  }
+  if (kind === "snippet") {
+    const mode = context.itemStart ? "item" : context.blank ? "value" : context.mode;
+    const entry = snippetsFor(mode, context.path).find((candidate) => candidate.prefix === completion.opf.prefix);
+    if (!entry) return null;
+    const dash = " ".repeat(Math.max(0, context.column - context.indent));
+    const rendered = snippetYaml(entry, { dash: context.seq ? dash.length : 0, blank: context.blank });
+    return { template: rendered.text, fields: rendered.fields.length, chain: false, choices: rendered.fields };
+  }
+  return null;
+}
+
+/** What accepting `completion` writes: `{ template, fields, chain, choices }` for the context of the caret. */
 export function planCompletion(context, completion, text, end) {
+  if (context.format === "yaml") return planYaml(context, completion, text, end);
+  if (context.format === "md") return markdownPlan(context, completion, text, end);
   const next = nextSignificant(text, end);
   const needsComma = next !== "" && !",}]".includes(next);
   const kind = completion.opf?.kind;
@@ -242,11 +370,11 @@ export function planCompletion(context, completion, text, end) {
 }
 
 /** Accept `completion`: write its text over the token under the caret (quotes included) and, if it has tab stops, start the snippet. */
-export function applyCompletion(view, completion, fallbackFrom, fallbackTo, say) {
+export function applyCompletion(view, completion, fallbackFrom, fallbackTo, say, format = "json") {
   const { state } = view;
   const text = state.doc.toString();
   const main = state.selection.main;
-  const context = contextAt(text, main.head, { explicit: true });
+  const context = contextFor(format, text, main.head, true);
   const token = context?.token;
   const start = token ? token.start : fallbackFrom, end = token ? token.end : fallbackTo;
   const plan = context ? planCompletion(context, completion, text, end) : null;
@@ -254,10 +382,10 @@ export function applyCompletion(view, completion, fallbackFrom, fallbackTo, say)
     view.dispatch({ changes: { from: fallbackFrom, to: fallbackTo, insert: completion.label }, selection: { anchor: fallbackFrom + completion.label.length }, annotations: [pickedCompletion.of(completion)], userEvent: "input.complete" });
     return;
   }
-  if (state.selection.ranges.length > 1) { applyAtEveryCursor(view, completion, plan); return; }
+  if (state.selection.ranges.length > 1) { applyAtEveryCursor(view, completion, plan, format); return; }
   // A string between quotes that are already there keeps them: only what is inside is replaced. In the stop of a snippet the caret stays inside
   // the quotes, so Tab goes on to the next stop; elsewhere it ends after the closing quote.
-  if (completion.opf?.kind === "literal" && token?.quoted && token.closed && completion.opf.literal.startsWith('"')) {
+  if (format === "json" && completion.opf?.kind === "literal" && token?.quoted && token.closed && completion.opf.literal.startsWith('"')) {
     const inner = completion.opf.literal.slice(1, -1);
     const inSnippet = snippetRuns.has(view) && (hasNextSnippetField(state) || hasPrevSnippetField(state));
     const next = nextSignificant(text, token.end);
@@ -267,29 +395,39 @@ export function applyCompletion(view, completion, fallbackFrom, fallbackTo, say)
     view.dispatch({ changes, selection: { anchor: caret }, annotations: [pickedCompletion.of(completion)], userEvent: "input.complete", scrollIntoView: true });
     return;
   }
+  // YAML and Markdown values inside quotes: only the inside changes, and the caret ends after the closing quote.
+  if (plan.inner && token) {
+    const insert = plan.template.replace(/\\([{}\\])/g, "$1");
+    const caret = token.closed ? token.end + insert.length - (token.to - token.from) : token.from + insert.length;
+    view.dispatch({ changes: { from: token.from, to: token.to, insert }, selection: { anchor: caret }, annotations: [pickedCompletion.of(completion)], userEvent: "input.complete", scrollIntoView: true });
+    return;
+  }
+  const from = plan.replaceFrom ?? start, to = plan.replaceTo ?? end;
   if (plan.fields > 0 || plan.template.includes("${")) {
-    snippet(plan.template)(view, completion, start, end);
+    snippet(plan.template)(view, completion, from, to);
     if (plan.choices) snippetRuns.set(view, { fields: plan.choices, index: -1 });
     else snippetRuns.delete(view);
     if (plan.choices) snippetStep(view, true, { start: true, say });
   } else {
     const insert = plan.template.replace(/\\([{}\\])/g, "$1");
-    view.dispatch({ changes: { from: start, to: end, insert }, selection: { anchor: start + insert.length }, annotations: [pickedCompletion.of(completion)], userEvent: "input.complete", scrollIntoView: true });
+    view.dispatch({ changes: { from, to, insert }, selection: { anchor: from + insert.length }, annotations: [pickedCompletion.of(completion)], userEvent: "input.complete", scrollIntoView: true });
     snippetRuns.delete(view);
   }
+  // Accepting is one undo step: what is typed next starts another.
+  view.dispatch({ annotations: isolateHistory.of("full") });
   // A key whose value is one of a closed set opens that list at once.
   if (plan.chain) startCompletion(view);
 }
 
 // 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) {
+function applyAtEveryCursor(view, completion, plan, format) {
   const { state } = view;
   const text = state.doc.toString();
   const plain = plainOf(plan.template);
   const changes = [], carets = [];
   let shift = 0;
   for (const range of [...state.selection.ranges].sort((a, b) => a.from - b.from)) {
-    const context = contextAt(text, range.head, { explicit: true });
+    const context = contextFor(format, text, range.head, true);
     const token = context?.token ?? { start: range.from, end: range.to };
     changes.push({ from: token.start, to: token.end, insert: plain.text });
     carets.push(token.start + shift + plain.first);
@@ -327,21 +465,49 @@ export const describeOption = (completion) => completion.opfDoc ?? "";
 export { docText };
 
 // ---- hover -----------------------------------------------------------------------------------------------------------------------------
+// The key or value under a position of a YAML text, from core's `pathAt` (which reads text with errors as far as it can): the same shape
+// as source-json.js's `nodeAt`, with the whole document read for the schema (hover waits 300 ms, so the cost does not matter).
+function yamlNodeAt(text, position) {
+  const found = pathAt(text, "yaml", position);
+  if (!found?.range || (found.part !== "key" && found.part !== "value")) return null;
+  const { offset, length } = found.range;
+  const source = text.slice(offset, offset + length);
+  const base = { path: found.path, from: offset, to: offset + length };
+  let document = {};
+  try { document = parseYamlDocument(text) ?? {}; } catch { document = {}; }
+  if (found.part === "key") return { ...base, kind: "key", value: source, document };
+  const collection = /^[[{]/.test(source);
+  return { ...base, kind: "value", value: collection ? undefined : scalarValue(source), nodeType: collection ? (source[0] === "[" ? "array" : "object") : "scalar", document };
+}
+
 /**
  * What the schema and the catalogs say about the key or the value under `position`: `{ from, to, model }` (offsets of the token; `model` is a
- * source-docs.js card), or null over free text, punctuation and whitespace.
+ * source-docs.js card), or null over free text, punctuation and whitespace. `format` is "json", "yaml" or "md".
  */
-export function hoverModelAt(state, position, { catalogs }) {
-  const found = nodeAt(state.doc.toString(), position);
-  if (!found) return null;
+export function hoverModelAt(state, position, { catalogs, format = "json" }) {
+  const text = state.doc.toString();
+  if (format === "md") return markdownHoverAt(text, position, { catalogs, describeFound });
+  let found, document;
+  if (format === "yaml") {
+    found = yamlNodeAt(text, position);
+    document = found?.document;
+  } else {
+    found = nodeAt(text, position);
+    document = found ? skeleton(found.root, found.path, false) : undefined;
+  }
+  return found ? describeFound(found, document, catalogs) : null;
+}
+
+/** The card for a found node `{ kind, path, from, to, value, nodeType }` of a document (shared by the three formats). */
+export function describeFound(found, document, catalogs) {
   let info;
-  try { info = describeField(found.path, skeleton(found.root, found.path, false)); } catch { return null; }
+  try { info = describeField(found.path, document); } catch { return null; }
   if (!info.known) return null;
   const name = String(found.path.at(-1));
   if (found.kind === "key") return { from: found.from, to: found.to, model: fieldDoc(info, name) };
   if (typeof found.value === "string" && info.catalogKind) {
     let record;
-    try { record = listCatalogRecords(skeleton(found.root, found.path, false), info.catalogKind, { catalogs }).find((entry) => entry.id === found.value); } catch { record = undefined; }
+    try { record = listCatalogRecords(document, info.catalogKind, { catalogs }).find((entry) => entry.id === found.value); } catch { record = undefined; }
     if (!record) return { from: found.from, to: found.to, model: { title: found.value, type: `${KIND_LABELS[info.catalogKind]} id`, description: `No ${KIND_LABELS[info.catalogKind]} named ${found.value} is available here.` } };
     const regions = info.catalogKind === "layouts" ? layoutRegionSummary(record.record) : "";
     return { from: found.from, to: found.to, model: { title: record.id, type: KIND_LABELS[info.catalogKind], description: record.description, notes: [record.label !== record.id ? record.label : "", regions && `Regions: ${regions}`, SOURCE_LABELS[record.origin === "document" ? "document" : "registered"]].filter(Boolean) } };

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;
+});