@openpresentation/opf-editor 0.26.4 → 0.26.5

package/dist/source-fixes-syntax.js

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

package/dist/source-fixes-text.js

@@ -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") {

package/dist/source-markdown.js

@@ -10,6 +10,7 @@ import { fromMarkdown } from "@openpresentation/opf/markdown";
 import { yamlContextAt } from "./source-yaml.js";
 import { snippetMarkdown, snippetsForMarkdown } from "./source-snippets.js";
 import { fieldDoc } from "./source-docs.js";
+import { regionNames } from "./source-references.js";
 
 const OPTION_KEY = /^[A-Za-z][A-Za-z0-9_-]*$/;
 const BARE = /^[A-Za-z0-9_-]+$/;
@@ -270,6 +271,12 @@ function bodyContext(text, position, where, explicit) {
     const start = position - span[2].length;
     return { format: "md", region: "span", token: { quoted: false, closed: false, start, end, from: start, to: end }, existing: used, document: {}, path: [], explicit, opened: span[2] === "" };
   }
+  // `{{` in a line of text: the variables of the document.
+  const variable = /\{\{([A-Za-z0-9._-]*)$/.exec(before);
+  if (variable) {
+    const start = position - variable[1].length;
+    return { format: "md", region: "variable", token: { quoted: false, closed: false, start, end: position, from: start, to: position }, document: {}, path: [] };
+  }
   if (!/^[A-Za-z][A-Za-z-]*$|^$/.test(before)) return null;
   if (before === "" && !explicit) return null;
   // Typing prose is not interrupted: a list opens by itself from the third letter on.
@@ -289,20 +296,8 @@ function bodyContext(text, position, where, explicit) {
 // ---- the options -------------------------------------------------------------------------------------------------------------------
 const kindOption = (label, type, detail, doc, boost, kind, extra = {}) => ({ label, type, detail, boost, opfDoc: doc, opf: { kind, ...extra } });
 
-function regionNames(record) {
-  const names = [];
-  const walk = (regions) => {
-    for (const region of Array.isArray(regions) ? regions : []) {
-      if (typeof region?.name === "string" && region.name !== "title" && region.name !== "subtitle") names.push(region.name);
-      if (region?.regions) walk(region.regions);
-    }
-  };
-  walk(record?.regions);
-  return names;
-}
-
 /** The completion options of a Markdown context: `{ options, validFor? }`, or null. `makers` are the option builders of the completion engine. */
-export function markdownOptions(context, { catalogs, text, explicit, makers }) {
+export function markdownOptions(context, { catalogs, text, explicit, makers, scope }) {
   const { literalOption, boostAt, docNode } = makers;
   const options = [];
   if (context.region === "comment-start") {
@@ -310,7 +305,7 @@ export function markdownOptions(context, { catalogs, text, explicit, makers }) {
     options.push(kindOption("block:", "keyword", "options", "Options of the next block: id, type, as, region.", boostAt(1), "comment", { word: "block:" }));
     return { options, validFor: /^[a-z]*$/ };
   }
-  if (context.region === "options") return optionsOptions(context, { catalogs, makers });
+  if (context.region === "options") return optionsOptions(context, { catalogs, makers, scope });
   if (context.region === "fence-info") {
     if (context.mode === "kind") {
       let order = 0;
@@ -368,7 +363,7 @@ export function markdownOptions(context, { catalogs, text, explicit, makers }) {
   return null;
 }
 
-function optionsOptions(context, { catalogs, makers }) {
+function optionsOptions(context, { catalogs, makers, scope }) {
   const { literalOption, boostAt, docNode } = makers;
   const options = [];
   if (context.mode === "key") {
@@ -399,7 +394,7 @@ function optionsOptions(context, { catalogs, makers }) {
   }
   if (!SLIDE_OPTION_KEYS.includes(key)) return null;
   const pseudo = { format: "md", mode: "value", path: ["slides", context.slide, key], document: context.document, key, token: context.token };
-  const built = makers.valueOptions(pseudo, catalogs);
+  const built = makers.valueOptions(pseudo, catalogs, scope);
   options.push(...built.options);
   return { options, validFor: /^[A-Za-z0-9_:+-]*$/ };
 }