@panphora/clayjs 1.15.2 → 1.17.0

package/src/page/history-intent.js

@@ -0,0 +1,78 @@
+// Typing joins one undo item the way it does in other editors: Mod-z removes the last
+// word typed, not the last letter. Only the editor's own input path marks a
+// transaction; a command or a programmatic dispatch stays one undo item by itself.
+import { state } from "../vendor/prosemirror.vendor.js";
+import { STEP } from "./blocks.js";
+
+export const HISTORY_INTENT = "page-history-intent";
+export const GROUP_MS = 500;
+
+const blockIdAt = (doc, pos) => {
+  const $pos = doc.resolve(pos);
+  return $pos.depth ? $pos.node(1).attrs.id : null;
+};
+
+const markKey = (st) => (st.storedMarks ?? st.selection.$from.marks()).map((m) => `${m.type.name}:${JSON.stringify(m.attrs)}`).sort().join(",");
+
+export function typingIntent(st, from, to, text) {
+  return { kind: "insert", blockId: blockIdAt(st.doc, from), from, end: from + text.length, replaced: from !== to, text, marks: markKey(st), at: Date.now() };
+}
+
+export function continuesGroup(prev, next) {
+  if (!prev || !next || prev.kind !== next.kind) return false;
+  if (next.kind === "compose") return prev.id === next.id;
+  if (prev.blockId !== next.blockId || next.at - prev.at > GROUP_MS) return false;
+  if (next.kind === "insert") return !next.replaced && next.from === prev.end && next.marks === prev.marks && !(/\s$/.test(prev.text) && /^\S/.test(next.text));
+  return next.direction === prev.direction && (next.direction < 0 ? next.to === prev.from : next.from === prev.from);
+}
+
+const DELETES = { deleteContentBackward: -1, deleteContentForward: 1 };
+const pendingDeletes = new WeakMap();
+const PENDING_MS = 1000;
+export const DERIVED = "page-derived";
+
+// A native deletion arrives as a DOM change with no handler, sometimes after a delayed flush
+// (Android waits 20 ms), so the beforeinput that announced it is held with the document it saw
+// and claimed by the next document change, whatever that change turns out to be.
+export function takePendingDelete(view) {
+  const mark = pendingDeletes.get(view) ?? null;
+  pendingDeletes.delete(view);
+  return mark;
+}
+
+export function deletionIntent(tr, mark) {
+  if (!mark || tr.before !== mark.doc || Date.now() - mark.at > PENDING_MS || tr.getMeta(STEP) || tr.steps.length !== 1) return null;
+  const step = tr.steps[0];
+  if (step.slice?.size !== 0 || step.from === step.to) return null;
+  const $from = tr.before.resolve(step.from), $to = tr.before.resolve(step.to);
+  if (!$from.parent.isTextblock || !$from.sameParent($to)) return null;
+  return { kind: "delete", blockId: $from.depth ? $from.node(1).attrs.id : null, direction: mark.direction, from: step.from, to: step.to, at: mark.at };
+}
+
+export function intentOf(transactions, view = null) {
+  const pending = view ? takePendingDelete(view) : null;
+  const primary = transactions.filter((t) => !t.getMeta(DERIVED));
+  if (primary.length !== 1) return null;
+  const tr = primary[0];
+  const composition = tr.getMeta("composition");
+  if (composition != null) return { kind: "compose", id: composition, at: Date.now() };
+  return tr.getMeta(HISTORY_INTENT) ?? deletionIntent(tr, pending);
+}
+
+export function historyIntentPlugin() {
+  return new state.Plugin({
+    props: {
+      handleTextInput(view, from, to, text, deflt) {
+        view.dispatch(deflt().setMeta(HISTORY_INTENT, typingIntent(view.state, from, to, text)));
+        return true;
+      },
+      handleDOMEvents: {
+        beforeinput(view, event) {
+          const direction = DELETES[event.inputType];
+          if (direction) pendingDeletes.set(view, { direction, at: Date.now(), doc: view.state.doc });
+          return false;
+        },
+      },
+    },
+  });
+}

package/src/page/inline.js

@@ -12,37 +12,43 @@
 // "@" and the node's JSON. No mark key starts with "@", so a U+FFFC typed as
 // text stays text. Private-use characters typed as text need nothing here:
 // encodeForMerge (replay.js) gives each one a code of its own.
+// A mark this schema has no type for keeps its token or named descriptor
+// instead of throwing (format-codec.js): the unit's key is written back exactly
+// as it was read. A mark of this schema with no compact code of its own is
+// written as a named descriptor too, x[name, attrs], so a new mark never takes a
+// letter an older writer already reads.
 import { model } from "../vendor/prosemirror.vendor.js";
+import { descriptors, entriesOf, isOpaque, keyOf, opaqueMark } from "./format-codec.js";
+import { nativeAttrs } from "./format-native.js";
 
 export const ATOM = "";
 export const CODES = { strong: "b", em: "i", strike: "s", code: "c", link: "a" };
+const NATIVE = new Set(["underline", "text_color", "highlight"]);
 const NAMES = Object.fromEntries(Object.entries(CODES).map(([name, code]) => [code, name]));
 
 export function markKey(marks) {
   let key = "";
+  const named = [];
   for (const mark of marks) {
+    if (isOpaque(mark)) {
+      key += keyOf(mark.attrs.entries);
+      continue;
+    }
     const code = CODES[mark.type.name];
-    if (!code) throw new TypeError(`page: the mark ${mark.type.name} has no key code`);
+    if (!code) {
+      // A mark with no compact letter travels as a named descriptor, after the codes
+      // and in the codec's order: one of the four formats only with attrs it writes,
+      // any other (a mention, a date) with its own attrs.
+      const native = nativeAttrs(mark.type.name, mark.attrs);
+      if (!native && NATIVE.has(mark.type.name)) throw new TypeError(`page: the mark ${mark.type.name} has no key code`);
+      named.push({ name: mark.type.name, attrs: native ?? mark.attrs });
+      continue;
+    }
     key += code;
     const names = Object.keys(mark.type.attrs);
     if (names.length) key += JSON.stringify(names.map((name) => mark.attrs[name]));
   }
-  return key;
-}
-
-// The end of the JSON array that starts at s[i].
-function arrayEnd(s, i) {
-  let depth = 0, str = false;
-  for (; i < s.length; i++) {
-    const ch = s[i];
-    if (str) {
-      if (ch === "\\") i++;
-      else if (ch === '"') str = false;
-    } else if (ch === '"') str = true;
-    else if (ch === "[") depth++;
-    else if (ch === "]" && --depth === 0) return i + 1;
-  }
-  throw new SyntaxError(`page: unterminated attrs in mark key ${s}`);
+  return named.length ? key + keyOf(named) : key;
 }
 
 const parsed = new WeakMap();
@@ -54,19 +60,30 @@ export function marksOf(schema, key) {
   let marks = cache.get(key);
   if (marks) return marks;
   marks = [];
-  for (let i = 0; i < key.length;) {
-    const type = schema.marks[NAMES[key[i]]];
-    if (!type) throw new TypeError(`page: unknown mark code ${key[i]} in ${key}`);
-    i++;
-    let attrs = null;
-    if (key[i] === "[") {
-      const end = arrayEnd(key, i);
-      const values = JSON.parse(key.slice(i, end));
-      attrs = Object.fromEntries(Object.keys(type.attrs).map((name, j) => [name, values[j]]));
-      i = end;
+  const opaque = [];
+  for (const desc of descriptors(key)) {
+    // A named descriptor this schema does have a type for is that mark, not an opaque
+    // entry: one of the four formats only with attrs it writes, any other mark only
+    // with attributes its type declares. Anything else stays opaque, so nothing is lost.
+    if (desc.code === undefined) {
+      const native = nativeAttrs(desc.name, desc.attrs);
+      const type = schema.marks[desc.name];
+      if (native) marks = type.create(native).addToSet(marks);
+      else if (type && !NATIVE.has(desc.name) && Object.keys(desc.attrs ?? {}).every((field) => Object.hasOwn(type.attrs, field))) marks = type.create(desc.attrs).addToSet(marks);
+      else opaque.push(desc);
+      continue;
+    }
+    const name = NAMES[desc.code];
+    if (!name) {
+      opaque.push(desc);
+      continue;
     }
-    marks = type.create(attrs).addToSet(marks);
+    const coded = schema.marks[name];
+    if (!coded) throw new TypeError(`page: unknown mark code ${desc.code} in ${key}`);
+    const attrs = desc.attrs ? Object.fromEntries(Object.keys(coded.attrs).map((field, j) => [field, desc.attrs[j]])) : null;
+    marks = coded.create(attrs).addToSet(marks);
   }
+  if (opaque.length) marks = opaqueMark(entriesOf(opaque)).addToSet(marks);
   cache.set(key, marks);
   return marks;
 }

package/src/page/items.js

@@ -5,13 +5,15 @@
 import { state } from "../vendor/prosemirror.vendor.js";
 import { schema } from "./schema.js";
 import { isKey, keyBetween, newId } from "./model.js";
+import { isOpaque, opaqueMark } from "./format-codec.js";
 import { outline, subtreeRange } from "./blocks.js";
 import { asStep } from "./blocksel.js";
 import { pickFiles, hostPlace } from "./media.js";
 import { makeTable, insertTableNode } from "./table.js";
 import { pickCsv } from "./csv-import.js";
 import { makeBoard, insertBoardNode } from "./board.js";
-import { chartFromSlash, chartTables } from "./chart.js";
+import { chartTables } from "./chart-tables.js";
+import { viewFeatures } from "./view-hooks.js";
 
 const { TextSelection } = state;
 const N = schema.nodes;
@@ -26,6 +28,7 @@ export const BLOCK_TYPES = [
   { key: "check", label: "Checklist", description: "Tasks to tick off", icon: "☐", type: "list_item", attrs: { kind: "check" }, hint: "[]", aliases: ["todo", "to-do", "task", "check", "checkbox"] },
   { key: "toggle", label: "Toggle", description: "Hide details under a line", icon: "▸", type: "toggle", attrs: { open: true }, hint: ">", aliases: ["collapse", "details", "fold"] },
   { key: "callout", label: "Callout", description: "Make a note stand out", icon: "!", type: "callout", aliases: ["note", "aside", "info"] },
+  { key: "quote", label: "Quote", description: "Set text apart as a quotation", icon: "\u201c", type: "quote", hint: "\"", aliases: ["blockquote", "quotation", "cite"] },
   { key: "code", label: "Code", description: "Code with highlighting", icon: "</>", type: "code_block", hint: "```", aliases: ["pre", "snippet"] },
 ];
 
@@ -40,6 +43,10 @@ export const INSERT_ITEMS = [
 
 export const CHART_ITEM = { key: "chart", label: "Chart", description: "A bar or line chart from a table", icon: "📊", aliases: ["graph", "plot", "bar", "line"], insert: "chart" };
 
+// The chart module and its view part load together, before the block draws: a
+// document that never takes a chart never fetches either.
+export const loadChartPart = (view) => (viewFeatures.get(view)?.ensure("chart") ?? Promise.resolve()).catch(() => {}).then(() => import("./chart.js"));
+
 export const MENU_ITEMS = [...BLOCK_TYPES, ...INSERT_ITEMS];
 
 export const insertItemsFor = (st, items = MENU_ITEMS) => (chartTables(st.doc).length ? [...items, CHART_ITEM] : items);
@@ -67,8 +74,29 @@ export function retype(tr, index, item) {
   return tr.setBlockType(at + 1, at + node.nodeSize - 1, N[item.type], { ...keep, ...(item.attrs || {}) });
 }
 
+// A command this runtime cannot carry out on the content it was given: the
+// document and the clipboard keep what they hold.
+export const REFUSED = Object.freeze({ status: "refused", code: "unsupported-format" });
+
+const opaqueType = opaqueMark([]).type;
+const holdsOpaque = (node) => {
+  let found = false;
+  node.forEach((child) => { if (!found && child.marks.some(isOpaque)) found = true; });
+  return found;
+};
+
+// A block that is not a textblock cannot be turned into anything, and one this
+// runtime cannot rewrite, or whose opaque marks the target type would erase, is
+// refused rather than converted into something that lost them.
+export function canTurnInto(node, item) {
+  if (!node.isTextblock || node.type === N.opaque_block) return false;
+  return !holdsOpaque(node) || N[item.type].allowsMarkType(opaqueType);
+}
+
 export function turnInto(st, index, item) {
-  return st.doc.child(index).isTextblock ? retype(st.tr, index, item) : null;
+  const node = st.doc.child(index);
+  if (!node.isTextblock) return null;
+  return canTurnInto(node, item) ? retype(st.tr, index, item) : REFUSED;
 }
 
 // A new empty paragraph after the block at `index` and its subtree, at the
@@ -116,37 +144,62 @@ export function insertDivider(st, index, tr = st.tr) {
   return tr.setSelection(TextSelection.create(tr.doc, to + 2));
 }
 
+// The skipped letters between a query and a candidate it can be read out of,
+// or Infinity when it cannot. Only queries of 2 to 32 letters count, so a single
+// letter never drags in half the menu.
+function subsequenceCost(query, candidate) {
+  if (query.length < 2 || query.length > 32) return Infinity;
+  let at = -1;
+  let cost = 0;
+  for (const ch of query) {
+    const next = candidate.indexOf(ch, at + 1);
+    if (next < 0) return Infinity;
+    cost += next - at - 1;
+    at = next;
+  }
+  return cost;
+}
+
 // Exact name or alias first, then label prefix, word or alias prefix,
-// substring; equal ranks keep menu order. No fuzzy matching.
+// substring, description word, and last a fuzzy subsequence of the label, key
+// or aliases. Equal tiers keep the lower cost, then menu order.
 export function rankItems(items, query) {
   const q = query.trim().toLowerCase();
   if (!q) return items;
   const rank = (it) => {
     const label = it.label.toLowerCase();
     const names = [it.key, ...(it.aliases || []), ...(it.hint ? [it.hint] : [])].map((s) => s.toLowerCase());
-    if (label === q || names.includes(q)) return 0;
-    if (label.startsWith(q)) return 1;
-    if ([...label.split(/\s+/), ...names].some((s) => s.startsWith(q))) return 2;
-    if ([label, ...names].some((s) => s.includes(q))) return 3;
-    if (q.length >= 3 && it.description && it.description.toLowerCase().split(/[^a-z0-9]+/).some((w) => w.startsWith(q))) return 4;
-    return Infinity;
+    if (label === q || names.includes(q)) return [0, 0];
+    if (label.startsWith(q)) return [1, 0];
+    if ([...label.split(/\s+/), ...names].some((s) => s.startsWith(q))) return [2, 0];
+    if ([label, ...names].some((s) => s.includes(q))) return [3, 0];
+    if (q.length >= 3 && it.description && it.description.toLowerCase().split(/[^a-z0-9]+/).some((w) => w.startsWith(q))) return [4, 0];
+    const cost = Math.min(...[label, it.key, ...(it.aliases || [])].map((s) => subsequenceCost(q, s.toLowerCase())));
+    return cost === Infinity ? null : [5, cost];
   };
-  return items.map((it, order) => ({ it, order, rank: rank(it) })).filter((x) => x.rank !== Infinity).sort((a, b) => a.rank - b.rank || a.order - b.order).map((x) => x.it);
+  return items.map((it, order) => ({ it, order, rank: rank(it) })).filter((x) => x.rank).sort((a, b) => a.rank[0] - b.rank[0] || a.rank[1] - b.rank[1] || a.order - b.order).map((x) => x.it);
 }
 
 // What a pick does in the insert menu for the block at `index`. A divider and
 // the file pickers have their own placement; a block type retypes an empty line
-// and otherwise goes into a new block below the line's whole subtree.
+// and otherwise goes into a new block below the line's whole subtree. A block
+// type from a later format asks the format gate before it writes anything.
 export function runItem(view, item, index, remove = null) {
+  if (item.type !== "quote") return insertItem(view, item, index, remove);
+  return import("./format-native-commands.js").then(({ runFormat }) => runFormat(view, () => insertItem(view, item, index, remove)));
+}
+
+function insertItem(view, item, index, remove = null) {
   const st = view.state;
   if (item.insert === "image" || item.insert === "file") return pickFiles(view, item.insert === "image" ? "image/*" : "", hostPlace(st, index), remove);
   if (item.insert === "csv") return pickCsv(view, remove);
-  if (item.insert === "table") return insertTableNode(st, view.dispatch, makeTable(), remove);
-  if (item.insert === "board") return insertBoardNode(st, view.dispatch, makeBoard(), remove);
-  if (item.insert === "chart") return chartFromSlash(view, index, remove);
+  if (item.insert === "table") return insertTableNode(st, view.dispatch, makeTable(), remove, null, index);
+  if (item.insert === "board") return insertBoardNode(st, view.dispatch, makeBoard(), remove, index);
+  if (item.insert === "chart") return loadChartPart(view).then(({ chartFromSlash }) => chartFromSlash(view, index, remove));
   let tr = st.tr;
   if (remove) tr.delete(remove.from, remove.to);
   const node = tr.doc.child(index);
+  if (node.isTextblock && node.content.size === 0 && !canTurnInto(node, item)) return REFUSED;
   if (item.insert === "divider") tr = insertDivider(st, index, tr);
   else if (node.isTextblock && node.content.size === 0) tr = retype(tr, index, item);
   else {

package/src/page/link.js

@@ -79,6 +79,7 @@ class LinkPopover {
     this.edit.addEventListener("click", () => this.openEdit());
     this.remove.addEventListener("click", () => this.apply(""));
     this.input.addEventListener("keydown", (e) => {
+      if (e.isComposing || e.keyCode === 229) return;
       if (e.key === "Enter") { e.preventDefault(); this.apply(this.input.value); }
       else if (e.key === "Escape") { e.preventDefault(); this.close(); }
     });

package/src/page/markdown.js

@@ -8,6 +8,7 @@ import { retype, replaceWithDivider } from "./items.js";
 import { asStep } from "./blocksel.js";
 import { insertTableNode } from "./table.js";
 import { tableFromGrid } from "./table-paste.js";
+import { safeHref } from "./address.js";
 
 const { InputRule } = inputrules;
 const N = schema.nodes;
@@ -29,6 +30,87 @@ const dividerRule = new InputRule(/^---$/, (st, match, start, end) => {
   return asStep(replaceWithDivider(st.tr, $s.index(0)));
 });
 
+// Inline shortcuts typed around text: **bold** and __bold__ to strong, *italic*
+// and _italic_ to em, `code`, ~~strike~~, and [label](address) to a link. The
+// delimiters are deleted and the mark is added over the body, which stays where
+// it is, so the marks it already carries survive. Backspace right after puts the
+// delimiter characters back through the input rule's own undo.
+const OPENS = "\\s\\(\\[\\{'\u2018\u201C\u0022";
+const OPENS_ONE = new RegExp(`[${OPENS}]`);
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const bodyRe = (exclude) => `([^\\s${exclude}](?:[\\s\\S]*?[^\\s${exclude}])?)`;
+
+export const composing = (event, view) => !!event?.isComposing || event?.keyCode === 229 || !!view?.composing;
+
+const trailingBackslashes = (text) => {
+  let n = 0;
+  for (let i = text.length - 1; i >= 0 && text[i] === "\\"; i--) n++;
+  return n;
+};
+
+// An opening delimiter needs the start of a textblock or whitespace and opening
+// punctuation before it, and neither delimiter may be escaped.
+const opensAt = (st, at) => {
+  const $at = st.doc.resolve(at);
+  if (!$at.parent.inlineContent) return false;
+  if (trailingBackslashes($at.parent.textBetween(0, $at.parentOffset, null, "\uFFFC")) % 2) return false;
+  return $at.parentOffset === 0 || OPENS_ONE.test($at.parent.textBetween($at.parentOffset - 1, $at.parentOffset));
+};
+
+const inline = (st, match, start, end, markOf) => {
+  const mark = markOf(match);
+  if (!mark || !st.selection.empty) return null;
+  if (start < 0 || start > end || end > st.doc.content.size) return null;
+  const $start = st.doc.resolve(start), $end = st.doc.resolve(end);
+  if (!$start.sameParent($end) || !$start.parent.inlineContent) return null;
+  const [all, prefix, body, close] = match;
+  if (inlineCode(st, start, end)) return null;
+  const open = all.slice(prefix.length, all.length - body.length - close.length);
+  const from = start + prefix.length;
+  if (!opensAt(st, from)) return null;
+  if (trailingBackslashes(all.slice(0, all.length - close.length)) % 2) return null;
+  const pending = all.length - (end - start);
+  if (pending < 0) return null;
+  const tr = st.tr;
+  if (pending) tr.insertText(all.slice(-pending), end, end);
+  const bodyStart = from + open.length;
+  const bodyEnd = bodyStart + body.length;
+  tr.delete(bodyEnd, start + all.length);
+  tr.delete(from, bodyStart);
+  tr.addMark(from, from + body.length, mark);
+  tr.removeStoredMark(mark.type);
+  return asStep(tr);
+};
+
+const inlineRule = (re, markOf) => new InputRule(
+  re,
+  (st, match, start, end) => inline(st, match, start, end, markOf),
+  { inCodeMark: false },
+);
+
+const markRule = (open, close, type) => inlineRule(
+  new RegExp(`(^|[${OPENS}])${escapeRe(open)}${bodyRe(escapeRe(close))}(${escapeRe(close)})$`),
+  () => type.create(),
+);
+
+const linkRule = inlineRule(
+  new RegExp(`(^|[${OPENS}])\\[${bodyRe("\\[\\]")}(\\]\\([^()\\s]*\\))$`),
+  (match) => {
+    const href = safeHref(match[3].slice(2, -1));
+    return href ? schema.marks.link.create({ href }) : null;
+  },
+);
+
+const INLINE_RULES = [
+  markRule("**", "**", schema.marks.strong),
+  markRule("__", "__", schema.marks.strong),
+  markRule("*", "*", schema.marks.em),
+  markRule("_", "_", schema.marks.em),
+  markRule("`", "`", schema.marks.code),
+  markRule("~~", "~~", schema.marks.strike),
+  linkRule,
+];
+
 const LISTS = ["paragraph", "list_item"];
 
 export const MARKDOWN_RULES = [
@@ -39,9 +121,34 @@ export const MARKDOWN_RULES = [
   blockRule(/^>\s$/, { type: "toggle", attrs: { open: true } }),
   blockRule(/^```$/, { type: "code_block" }, ["paragraph"], true),
   dividerRule,
+  ...INLINE_RULES,
 ];
 
-export const markdownPlugin = () => inputrules.inputRules({ rules: MARKDOWN_RULES });
+// The shortest shortcut that quotes a line: `" ` typed at the start of a
+// paragraph. It writes a floor-1 block, so it asks the format gate first and
+// converts only when the gate answered applied; the transaction it dispatches is
+// the input-rule one, recorded on this plugin so Backspace puts the literal `" `
+// back and undo keeps the conversion whole. The typed space is never swallowed:
+// when the format cannot be written, the space is inserted as itself.
+function quoteShortcut(plugin, view, from, to, text) {
+  if (text !== " " || from !== to) return false;
+  const st = view.state;
+  const $from = st.doc.resolve(from);
+  const node = $from.parent;
+  if ($from.depth !== 1 || node.type !== N.paragraph || $from.parentOffset !== 1 || node.textContent !== '"') return false;
+  if (!view.editable || typeof view.runFormatCommand !== "function") return false;
+  const plain = () => { if (!view.isDestroyed) view.dispatch(st.tr.insertText(" ", from, to)); };
+  const at = $from.before(1);
+  import("./format-native-commands.js").then(({ quoteFromSpace }) => quoteFromSpace(plugin, view, { at, from, to }, plain), plain);
+  return true;
+}
+
+export const markdownPlugin = () => {
+  const plugin = inputrules.inputRules({ rules: MARKDOWN_RULES });
+  const rules = plugin.props.handleTextInput;
+  plugin.props.handleTextInput = (view, from, to, text) => quoteShortcut(plugin, view, from, to, text) || rules(view, from, to, text);
+  return plugin;
+};
 
 // "| Name | Owner |" then Enter at the end of a paragraph: the paragraph becomes
 // a table with those column names and one empty row, the caret in its first cell.
@@ -59,13 +166,15 @@ export function tableFromMarkdownRow(st, dispatch) {
   return insertTableNode(st, dispatch, table, { from: $from.start(), to: $from.end() });
 }
 
-export const markdownKeys = () => keymap.keymap({ Enter: tableFromMarkdownRow });
+export const markdownKeys = () => keymap.keymap({
+  Enter: (st, dispatch, view) => !composing(null, view) && tableFromMarkdownRow(st, dispatch),
+});
 
 export function backspaceToParagraph(st, dispatch) {
   const { $from, empty } = st.selection;
   if (!empty || $from.depth !== 1 || $from.parentOffset !== 0) return false;
   const n = $from.parent;
-  if (!(n.type === N.heading || n.type === N.callout || (n.type === N.code_block && n.content.size === 0))) return false;
+  if (!(n.type === N.heading || n.type === N.callout || n.type === N.quote || (n.type === N.code_block && n.content.size === 0))) return false;
   if (dispatch) dispatch(asStep(st.tr.setNodeMarkup($from.before(), N.paragraph, { id: n.attrs.id, pos: n.attrs.pos, parent: n.attrs.parent })));
   return true;
 }

package/src/page/media-views.js

@@ -0,0 +1,3 @@
+// The bookmark renderer a media plugin can reach, filled by the media view part
+// when it loads, per editor. An upload still tracks and settles with no renderer.
+export const mediaViews = new WeakMap();