@quillmark/svelte 0.1.1 → 0.3.0

package/dist/core/codec/field.js

@@ -6,11 +6,11 @@
 //   (b) lower the tr to a `ChangeBundle` (or `overwrite` for a field not yet at
 //       content rest, which has nothing to splice),
 //   (c) commit via `doc.applyChange(addr, bundle)`,
-//   (d) fire `onChange` when the transaction COMMITTED, then `onCaretMove` with
+//   (d) fire `onChange` when the transaction committed, then `onCaretMove` with
 //       the new USV caret, which a bare selection move fires on its own.
 // On an `applyChange` throw the optimistic PM state stays and the failure reports
 // through `onError`: never a crash. Caret continuity across own-edits is the PM
-// `StepMap`; an EXTERNAL content change re-hydrates through `applyExternal`, gated
+// `StepMap`; an external content change re-hydrates through `applyExternal`, gated
 // by `reconcile`.
 import { baseKeymap, toggleMark } from 'prosemirror-commands';
 import { gapCursor } from 'prosemirror-gapcursor';
@@ -19,6 +19,7 @@ import { keymap } from 'prosemirror-keymap';
 import { EditorState, NodeSelection, Plugin, PluginKey, Selection, TextSelection } from 'prosemirror-state';
 import { Decoration, DecorationSet, EditorView } from 'prosemirror-view';
 import { reportError, errorMessage } from '../errors.js';
+import { tableClipboardPlugin } from './clipboard.js';
 import { decode } from './decode.js';
 import { usvToPM, pmToUsv, buildLineIndex } from './positions.js';
 import { lower, pmToContent, contentEdit } from './encode.js';
@@ -28,7 +29,7 @@ import { inputRulesPlugin } from './inputrules.js';
 import { bodyKeymap } from './keymap.js';
 import { blockSchema, inlineSchema } from './schema.js';
 import { DEFAULT_TABLE_STRINGS, tableNodeView } from './table-view.js';
-import { DEFAULT_SLASH_STRINGS, focusSlashItem, runSlashItem, slashItems, slashPlugin } from './slash.js';
+import { focusSlashItem, runSlashItem, slashPlugin } from './slash.js';
 const anchorKey = new PluginKey('quill-anchors');
 /** Plugin-held anchor positions (PM coords), mapped through every edit's `StepMap`
  * and mutated by an {@link AnchorEdit} meta (an insert/remove at a selection). */
@@ -62,8 +63,8 @@ function anchorPlugin(seed) {
  *
  * Bound rather than verbatim, because the storage form is not the leaf's business
  * and the verbatim read cannot answer it alone. A field the editor committed rests
- * as `Content`; a field a markdown parse left rests as the authored STRING, and
- * what that string MEANS is the declared type's to say: `richtext` is markdown,
+ * as `Content`; a field a markdown parse left rests as the authored string, and
+ * what that string means is the declared type's to say: `richtext` is markdown,
  * `plaintext` is literal text, and reading one as the other silently eats every
  * `*` the author typed. */
 function readLeaf(reader, addr) {
@@ -77,9 +78,9 @@ export function emptyContent() {
 /** Whether ops may commit here: the stored value is a `Content` object, so
  * `applyChange` splices exactly the content the leaf read and PM is showing.
  *
- * The two other rest forms both take `overwrite` instead. An UNSET field (`undefined`;
+ * The two other rest forms both take `overwrite` instead. An unset field (`undefined`;
  * a default-only richtext field before its first edit) has nothing to splice.
- * An AUTHORED STRING is the trap: `applyChange` reads it as markdown whatever the
+ * An authored string is the trap: `applyChange` reads it as markdown whatever the
  * declared type is, so on a `plaintext` field its pre-image is not the content the
  * leaf read and a delta computed against that content lands at the wrong offsets.
  * Installing over it costs nothing either way, since content-only marks do not
@@ -119,15 +120,14 @@ export function createField(opts) {
     // The ghost's live cell: the placeholder plugin reads it per pass, so moving it
     // is an assignment plus a re-render rather than a rebuilt plugin stack.
     let placeholderText = opts.placeholder;
-    // The views nested INSIDE this leaf: one per table cell (`table-view.ts`). The
+    // The views nested inside this leaf: one per table cell (`table-view.ts`). The
     // leaf holds the set because chrome asks the leaf, not the island, which view
     // holds the caret: the format popover raises over a cell exactly as over the
     // body, and only the leaf knows both.
     const nested = new Set();
-    // The menu's offers, derived from the wording per read: the chrome names an item
-    // and the codec runs it, so a locale swap changes the labels and not the picks.
-    const menuItems = () => slashItems(opts.slashStrings?.() ?? DEFAULT_SLASH_STRINGS);
-    const slash = !inline && opts.onSlash ? { items: menuItems, onState: opts.onSlash } : undefined;
+    // The menu's report channel, and the whole of what a leaf holds of it: the
+    // vocabulary is the codec's own constant (`slash.ts`), not a wording to derive.
+    const slash = inline ? undefined : opts.onSlash;
     const state = buildState(reconciler.last);
     index = buildLineIndex(state.doc);
     view = new EditorView(container, {
@@ -154,7 +154,7 @@ export function createField(opts) {
             const next = view.state.apply(tr);
             view.updateState(next); // (a) optimistic
             index = buildLineIndex(next.doc);
-            // Commit a content edit OR an anchor mutation. An anchor insert/remove is
+            // Commit a content edit or an anchor mutation. An anchor insert/remove is
             // zero-width, so `docChanged` is false: the `anchorKey` meta is what
             // routes it through the same commit path (the diff emits the anchor op).
             if (tr.docChanged || tr.getMeta(anchorKey)) {
@@ -203,7 +203,7 @@ export function createField(opts) {
     // Returns whether anything landed: the caller's change signal, which must not
     // be a property of which branch the commit took.
     function commitEdit(oldRt, newDoc) {
-        // The projection and its text splice, each computed ONCE per keystroke: the gate
+        // The projection and its text splice, each computed once per keystroke: the gate
         // below, both overwrite fallbacks, and `lower` all read this one `edit`.
         const edit = contentEdit(oldRt, pmToContent(newDoc));
         try {
@@ -226,7 +226,7 @@ export function createField(opts) {
             return true;
         }
         catch (e) {
-            // Bound the damage: an op path the gates missed leaves the store STALE
+            // Bound the damage: an op path the gates missed leaves the store stale
             // while PM keeps the edit; and because the reconciler then re-diffs
             // from that stale content, every later edit re-throws and the field
             // silently stops persisting. Install the full projection instead
@@ -256,7 +256,7 @@ export function createField(opts) {
     }
     /** The anchors the plugin currently holds (PM coords); `[]` before the first apply. */
     const heldAnchors = () => anchorKey.getState(view.state) ?? [];
-    /** Anchor positions in the CURRENT (new) doc, as USV. */
+    /** Anchor positions in the current (new) doc, as USV. */
     function readAnchorsUsv(newDoc) {
         return heldAnchors().map((a) => ({ id: a.id, pos: pmToUsv(index, a.pos) }));
     }
@@ -326,13 +326,13 @@ export function createField(opts) {
             })
                 .map((a) => a.id);
         },
-        slashFocus(id) {
+        slashFocus(name) {
             if (slash)
-                focusSlashItem(view, id, slash.items());
+                focusSlashItem(view, name);
         },
-        slashPick(id) {
+        slashPick(name) {
             if (slash)
-                runSlashItem(view, id);
+                runSlashItem(view, name);
         },
         selectionRange() {
             const { from, to } = view.state.selection;
@@ -365,13 +365,13 @@ export function createField(opts) {
  * leaf-specific plugins (`afterHistory`: the addressed leaf passes its
  * anchor-position plugin; a by-value array element passes none), the
  * markdown-shorthand input rules, then the field keymap over the base keymap, and
- * last the two that answer to a caret or a selection BESIDE a block: the gap cursor
+ * last the two that answer to a caret or a selection beside a block: the gap cursor
  * and {@link pastAtomPlugin}.
  *
  * A `plaintext` field carries no marks (decode strips them, the keymap suppresses
  * Mod-b/i/u), so it also skips the input rules: `inlineSchema` still declares the
- * mark types, so a `**bold**` rule would apply a strong mark AND eat the literal
- * delimiters. The inline schema has no block nodes, so those rules are the ONLY
+ * mark types, so a `**bold**` rule would apply a strong mark and eat the literal
+ * delimiters. The inline schema has no block nodes, so those rules are the only
  * ones it would add: skip all.
  */
 export function proseLeafPlugins(schema, opts) {
@@ -380,21 +380,22 @@ export function proseLeafPlugins(schema, opts) {
         list.push(slashPlugin(opts.slash));
     if (!opts.noInputRules && !opts.plaintext)
         list.push(inputRulesPlugin(schema));
-    list.push(keymap(editorKeymap(schema, opts.inline, opts.plaintext, opts.slash?.items)));
+    list.push(keymap(editorKeymap(schema, opts.inline, opts.plaintext, !!opts.slash)));
     list.push(keymap(baseKeymap));
-    // Both answer to a selection over an ATOM, which only a block leaf holds: an
-    // inline leaf is one textblock with no island and no gap to put a cursor in.
+    // All three answer to something only a block leaf holds: an inline leaf is one
+    // textblock with no island, no gap to put a cursor in, and nowhere for a pasted
+    // table to land.
     if (!opts.inline)
-        list.push(gapCursor(), pastAtomPlugin());
+        list.push(gapCursor(), pastAtomPlugin(), tableClipboardPlugin(schema));
     if (opts.placeholder)
         list.push(placeholderPlugin(opts.placeholder));
     return list;
 }
 /**
- * A printable key over a selected atom writes PAST it. A selection is the subject
+ * A printable key over a selected atom writes past it. A selection is the subject
  * of the next command, never a thing armed for
  * replacement: Backspace deletes it, Mod-C copies it, and a character lands beside
- * it. A BLOCK island takes a new paragraph after it, an INLINE one the caret after
+ * it. A block island takes a new paragraph after it, an inline one the caret after
  * the image in the same line: one rule, both node types.
  *
  * PM routes text input over a non-`TextSelection` through `handleTextInput` before
@@ -461,13 +462,13 @@ function placeholderPlugin(read) {
  * The field's keymap: history, mark toggles, and the body's structural keys; Enter
  * suppressed inline.
  *
- * Tab forks on the leaf's ROLE, not on the caret's position. An inline/plaintext
+ * Tab forks on the leaf's role, not on the caret's position. An inline/plaintext
  * leaf is a form field: Tab stays unbound, so field navigation is open for a shell
  * keymap (VISUAL_EDITOR §Settled and open). A block-schema body is a document: Tab
  * is structural, a chain each nested surface prepends to (`keymap.ts`). One key
  * never means two things within one surface.
  */
-function editorKeymap(schema, inline, plaintext, slashItems) {
+function editorKeymap(schema, inline, plaintext, slash) {
     const map = {
         'Mod-z': undo,
         'Mod-y': redo,
@@ -487,7 +488,7 @@ function editorKeymap(schema, inline, plaintext, slashItems) {
     }
     else {
         // Each binding falls through to `baseKeymap` when no link claims the key.
-        Object.assign(map, bodyKeymap(schema, slashItems));
+        Object.assign(map, bodyKeymap(schema, slash));
     }
     return map;
 }

package/dist/core/codec/index.js

@@ -1,9 +1,9 @@
 // The codec barrel: the bidirectional bridge between one content field (`Content`)
-// and one ProseMirror document (CODEC). Decode (content → PM), lower (PM tr → a
+// and one ProseMirror document (CODEC.md). Decode (content → PM), lower (PM tr → a
 // `ChangeBundle` for `applyChange`), the USV↔PM position map, and the `createField`
 // prose leaf. Consumed by the VisualEditor and the codec test suite.
 // ProseMirror's structural base styles and the gap cursor's, then the retint of the
-// hues they mint. Imported HERE because `createField` is what mounts a view: a
+// hues they mint. Imported here because `createField` is what mounts a view: a
 // consumer reaching the codec directly gets them with it, and the order is what makes
 // the retint win.
 import 'prosemirror-view/style/prosemirror.css';
@@ -24,12 +24,9 @@ export { DEFAULT_SLASH_STRINGS } from './slash.js';
 export { blockSchema, inlineSchema } from './schema.js';
 // Decode / encode / positions (tests + VisualEditor).
 //
-// THE BARREL CARRIES WHAT HAS AN OFF-BARREL CALLER, and nothing else. The mark
-// algebra, the island bridge, the schema predicate, the `diff*` helpers,
-// `scanDoc`, `codePoints`: every one of them is reached by RELATIVE import
-// within `codec/`, so none of them is here. An export nothing imports is surface
-// that still has to stay honest; a symbol earns its line when a caller outside
-// this folder wants it.
+// The barrel carries what has an off-barrel caller, and nothing else. A symbol
+// reached only by relative import within `codec/` stays off it: an export nothing
+// imports is surface that still has to stay honest.
 export { decode, renderContent, usvLength } from './decode.js';
 export { pmToContent, contentEdit, lower } from './encode.js';
 export { usvToPM, pmToUsv, buildLineIndex } from './positions.js';

package/dist/core/codec/inputrules.js

@@ -1,10 +1,11 @@
 // Input rules: the markdown-shorthand plugin the codec owns (`**`→strong, `*`→em,
 // `~~`→strike, `` ` ``→code, `# `→heading, `- `/`1. `→lists, `> `→blockquote,
 // `---`→divider).
-// Mark rules are hand-rolled (prosemirror-inputrules ships only node rules); block
-// rules reuse `wrappingInputRule` / `textblockTypeInputRule`. These produce
-// transactions the codec already lowers: they add no new lowering surface.
-import { InputRule, inputRules, textblockTypeInputRule, wrappingInputRule } from 'prosemirror-inputrules';
+// Mark rules are hand-rolled (prosemirror-inputrules ships only node rules); the one
+// block rule with no guard of its own reuses `wrappingInputRule`, and the rest mirror
+// an upstream body around one. These produce transactions the codec already lowers:
+// they add no new lowering surface.
+import { InputRule, inputRules, wrappingInputRule } from 'prosemirror-inputrules';
 import { canJoin, findWrapping } from 'prosemirror-transform';
 import { Selection } from 'prosemirror-state';
 /**
@@ -12,8 +13,8 @@ import { Selection } from 'prosemirror-state';
  * before the caret, wrap capture group 1 in `markType` and drop the delimiters.
  * `delimLen` is the delimiter length (opening == closing for every rule here).
  * `match[0]` anatomy is `prefix? open captured close`: the em rule's
- * `(?:^|[^*])` guard consumes ONE non-delimiter prefix char into the match, so
- * positions are derived from the KNOWN delimiter/capture lengths, never from
+ * `(?:^|[^*])` guard consumes one non-delimiter prefix char into the match, so
+ * positions are derived from the known delimiter/capture lengths, never from
  * `indexOf` (which both deletes that prefix char and mis-anchors when it
  * happens to equal the captured text). `[start, end)` spans `match[0]` minus
  * the just-typed text (not yet inserted when the rule fires), so the trailing
@@ -48,9 +49,14 @@ function markInputRule(regexp, markType, delimLen) {
  * body paragraphs (`usaf_memo`'s `render-body`), where a heading resolves to
  * nothing. This is the wrap-side route into that shape; the `# ` rule guards the
  * other, in {@link markdownInputRules}.
+ *
+ * `item` is the second guard, and it is about the gesture rather than the shape: the
+ * rule declines at the start of an item's own first block ({@link openingAnItem}).
  */
-function listWrappingRule(regexp, listType, paragraph, getAttrs, joinPredicate) {
+function listWrappingRule(regexp, listType, paragraph, item, getAttrs, joinPredicate) {
     return new InputRule(regexp, (state, match, start, end) => {
+        if (openingAnItem(state.doc.resolve(start), item))
+            return null;
         const attrs = getAttrs ? getAttrs(match) : null;
         const tr = state.tr.delete(start, end);
         // Positions survive the retype: same content, same size.
@@ -75,10 +81,28 @@ function listWrappingRule(regexp, listType, paragraph, getAttrs, joinPredicate)
         return tr;
     });
 }
+/**
+ * Whether `$start` is the head of an item that already exists: offset 0 of a
+ * `list_item`'s first block, which is where a list shorthand is the text an author
+ * typed rather than a shorthand at all.
+ *
+ * Firing there wraps the item's own paragraph in a fresh list, minting an item whose
+ * only content is another item — a level with nothing on it. Tab is the indent gesture
+ * and lands the shape a nesting is supposed to have, under the previous sibling, so
+ * what the rule adds here is a second door onto a worse answer. A later block of the
+ * item is not this case: wrapping a continuation paragraph is how a sub-list opens
+ * under text.
+ */
+function openingAnItem($start, item) {
+    if (!item || $start.depth < 2 || $start.parentOffset !== 0)
+        return false;
+    return $start.node(-1).type === item && $start.index(-1) === 0;
+}
 /** The full markdown-shorthand rule set for a block schema. */
 export function markdownInputRules(schema) {
     const rules = [];
     const m = schema.marks;
+    const item = schema.nodes.list_item;
     // Inline marks. Non-greedy capture between matching delimiters.
     if (m.strong)
         rules.push(markInputRule(/\*\*([^*]+)\*\*$/, m.strong, 2));
@@ -95,7 +119,6 @@ export function markdownInputRules(schema) {
         // declines (null) and stays literal text, rather than minting the unrenderable
         // `list_item > heading` {@link listWrappingRule} normalizes away on the wrap side.
         const heading = schema.nodes.heading;
-        const item = schema.nodes.list_item;
         rules.push(new InputRule(/^(#{1,6})\s$/, (state, match, start, end) => {
             const $start = state.doc.resolve(start);
             for (let d = $start.depth; d > 0; d--) {
@@ -110,18 +133,34 @@ export function markdownInputRules(schema) {
                 .setBlockType(start, start, heading, { level: match[1].length });
         }));
     }
-    if (schema.nodes.code_block) {
-        rules.push(textblockTypeInputRule(/^```$/, schema.nodes.code_block));
+    if (schema.nodes.code_block && schema.nodes.paragraph) {
+        // `textblockTypeInputRule`'s body plus the exit the `---` rule mints below, for a
+        // sharper version of its reason: a code block is the one block a GAP CURSOR will
+        // not sit beside either (`closedBefore`/`closedAfter` both fail on a textblock), so
+        // a fence at the end of a body leaves the caret with no way forward at all.
+        const code = schema.nodes.code_block;
+        const paragraph = schema.nodes.paragraph;
+        rules.push(new InputRule(/^```$/, (state, _match, start, end) => {
+            const $start = state.doc.resolve(start);
+            if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), code)) {
+                return null;
+            }
+            const tr = state.tr.delete(start, end).setBlockType(start, start, code);
+            const at = tr.doc.resolve(start).after();
+            if (!tr.doc.nodeAt(at))
+                tr.insert(at, paragraph.create());
+            // The caret stays in the fence, not in the exit it minted.
+            return tr;
+        }));
     }
     if (schema.nodes.horizontal_rule && schema.nodes.paragraph) {
-        // A divider is a whole block, so this rule REPLACES its textblock rather than
+        // A divider is a whole block, so this rule replaces its textblock rather than
         // retyping one: `horizontal_rule` holds no content to retype into.
         const rule = schema.nodes.horizontal_rule;
         const paragraph = schema.nodes.paragraph;
-        const item = schema.nodes.list_item;
         rules.push(new InputRule(/^---$/, (state, _match, start, end) => {
             const $start = state.doc.resolve(start);
-            // The block ENTIRELY, not a prefix of one. `[start, end)` is the match minus
+            // The block entirely, not a prefix of one. `[start, end)` is the match minus
             // the just-typed `-`, so the block holds `--` when this fires; anything else
             // in it is a paragraph being edited, which a replace would eat.
             if ($start.parentOffset !== 0 || $start.parent.content.size !== end - start) {
@@ -148,14 +187,13 @@ export function markdownInputRules(schema) {
             return tr;
         }));
     }
-    // `- ` / `1. ` at the start of a block, here or nested inside an item. These are
-    // the one pair of shorthands the slash menu ALSO carries: a list opens an item the
-    // caret then lives in, which is what that menu is the set of (`slash.ts`).
+    // `- ` / `1. ` at the start of a block, here or nested inside an item — but not at
+    // the start of an item's own first block, where {@link openingAnItem} declines.
     if (schema.nodes.bullet_list && schema.nodes.paragraph) {
-        rules.push(listWrappingRule(/^\s*([-+*])\s$/, schema.nodes.bullet_list, schema.nodes.paragraph));
+        rules.push(listWrappingRule(/^\s*([-+*])\s$/, schema.nodes.bullet_list, schema.nodes.paragraph, item));
     }
     if (schema.nodes.ordered_list && schema.nodes.paragraph) {
-        rules.push(listWrappingRule(/^(\d+)\.\s$/, schema.nodes.ordered_list, schema.nodes.paragraph, (match) => ({ start: +match[1] }), (match, node) => node.childCount + node.attrs.start === +match[1]));
+        rules.push(listWrappingRule(/^(\d+)\.\s$/, schema.nodes.ordered_list, schema.nodes.paragraph, item, (match) => ({ start: +match[1] }), (match, node) => node.childCount + node.attrs.start === +match[1]));
     }
     if (schema.nodes.blockquote) {
         rules.push(wrappingInputRule(/^\s*>\s$/, schema.nodes.blockquote));

package/dist/core/codec/islands.d.ts

@@ -23,14 +23,18 @@ export declare function islandEntryFromNode(attrs: IslandNodeAttrs): ContentIsla
  *  rather than at each reader. */
 export declare function tablePropsOfNode(node: PMNode): TableProps | undefined;
 /**
- * The next island id for a field: the positional `isl-{n}` sequence continued past
- * the highest one the field already holds. A minted id is this tier's to produce
- * and it is part of the document's canonical bytes (CODEC §Islands), so it is a
- * counter over the projection in hand — never a UUID, never a clock reading, and
- * never a re-numbering of the ids already there, which are identities.
+ * A minter over one document: the positional `isl-{n}` sequence continued past the
+ * highest id the field already holds, handing out consecutive ids, so a caller placing
+ * several islands at once keeps one minter for the lot. A minted id is this tier's to
+ * produce and it is part of the document's canonical bytes (CODEC §Islands), so it is a
+ * counter over the projection in hand — never a UUID, never a clock reading, and never a
+ * re-numbering of the ids already there, which are identities.
  *
- * Reads the PM doc rather than the stored content because that is what the caller
- * (an insert command) holds and what the commit will project: an id minted against
+ * Reads the PM doc rather than the stored content because that is what the caller (an
+ * insert command, a paste) holds and what the commit will project: an id minted against
  * a stale content could collide with one the same transaction places.
  */
+export declare function islandMinter(doc: PMNode): () => string;
+/** The next island id for a field: one draw from {@link islandMinter}, which is what a
+ *  command placing exactly one island wants. */
 export declare function mintIslandId(doc: PMNode): string;

package/dist/core/codec/islands.js

@@ -4,7 +4,7 @@ export const ISLAND_SLOT = '';
 // The four island node attributes carry the content entry verbatim: `id` is the
 // stable identity (rebases like an anchor), `islandType` the discriminator, `props`
 // the opaque payload the codec preserves byte-for-byte across a round-trip, and
-// `loss` how faithfully markdown can carry it. `loss` is AUTHORED, not derived:
+// `loss` how faithfully markdown can carry it. `loss` is authored, not derived:
 // `applyChange` stores the class an island op gives it and re-derives nothing, so
 // an entry that did not carry its own would promote a degraded table to lossless
 // on the first cell edit. The default is the class an unknown one reads as, so a
@@ -58,17 +58,18 @@ export function tablePropsOfNode(node) {
     return isTableIsland(entry) ? entry.props : undefined;
 }
 /**
- * The next island id for a field: the positional `isl-{n}` sequence continued past
- * the highest one the field already holds. A minted id is this tier's to produce
- * and it is part of the document's canonical bytes (CODEC §Islands), so it is a
- * counter over the projection in hand — never a UUID, never a clock reading, and
- * never a re-numbering of the ids already there, which are identities.
+ * A minter over one document: the positional `isl-{n}` sequence continued past the
+ * highest id the field already holds, handing out consecutive ids, so a caller placing
+ * several islands at once keeps one minter for the lot. A minted id is this tier's to
+ * produce and it is part of the document's canonical bytes (CODEC §Islands), so it is a
+ * counter over the projection in hand — never a UUID, never a clock reading, and never a
+ * re-numbering of the ids already there, which are identities.
  *
- * Reads the PM doc rather than the stored content because that is what the caller
- * (an insert command) holds and what the commit will project: an id minted against
+ * Reads the PM doc rather than the stored content because that is what the caller (an
+ * insert command, a paste) holds and what the commit will project: an id minted against
  * a stale content could collide with one the same transaction places.
  */
-export function mintIslandId(doc) {
+export function islandMinter(doc) {
     let next = 0;
     doc.descendants((node) => {
         if (node.type.name !== 'island_block' && node.type.name !== 'island_inline')
@@ -78,5 +79,10 @@ export function mintIslandId(doc) {
             next = Math.max(next, Number(m[1]) + 1);
         return false;
     });
-    return `isl-${next}`;
+    return () => `isl-${next++}`;
+}
+/** The next island id for a field: one draw from {@link islandMinter}, which is what a
+ *  command placing exactly one island wants. */
+export function mintIslandId(doc) {
+    return islandMinter(doc)();
 }

package/dist/core/codec/keymap.d.ts

@@ -1,13 +1,12 @@
 import type { Schema } from 'prosemirror-model';
 import type { Command } from 'prosemirror-state';
-import { type SlashItem } from './slash.js';
 /** The block-schema body's structural keys: `{}` for the inline/plaintext schemas,
- * whose leaves declare neither lists nor code blocks. The argument list IS the
+ * whose leaves declare neither lists nor code blocks. The argument list is the
  * precedence order VISUAL_EDITOR §Chrome states, so a new link is one more argument
  * at its place in that order rather than a nesting to read inside out.
  *
  * The slash menu is innermost of the three, and it is conditional rather than
- * schema-gated: the keys exist only where a menu can be DRAWN (`slashItems` present),
- * because Enter and Escape claimed by a surface nobody can see is a body that
- * swallows two keys for no visible reason. */
-export declare function bodyKeymap(schema: Schema, slashItems?: () => SlashItem[]): Record<string, Command>;
+ * schema-gated: the keys exist only where a menu can be drawn (`slash`), because Enter
+ * and Escape claimed by a surface nobody can see is a body that swallows two keys for
+ * no visible reason. */
+export declare function bodyKeymap(schema: Schema, slash?: boolean): Record<string, Command>;

package/dist/core/codec/keymap.js

@@ -1,4 +1,5 @@
 import { chainCommands } from 'prosemirror-commands';
+import { atomKeymap } from './atoms.js';
 import { codeKeymap } from './code.js';
 import { listKeymap } from './lists.js';
 import { slashKeymap } from './slash.js';
@@ -15,15 +16,15 @@ function chainKeymaps(...maps) {
     return out;
 }
 /** The block-schema body's structural keys: `{}` for the inline/plaintext schemas,
- * whose leaves declare neither lists nor code blocks. The argument list IS the
+ * whose leaves declare neither lists nor code blocks. The argument list is the
  * precedence order VISUAL_EDITOR §Chrome states, so a new link is one more argument
  * at its place in that order rather than a nesting to read inside out.
  *
  * The slash menu is innermost of the three, and it is conditional rather than
- * schema-gated: the keys exist only where a menu can be DRAWN (`slashItems` present),
- * because Enter and Escape claimed by a surface nobody can see is a body that
- * swallows two keys for no visible reason. */
-export function bodyKeymap(schema, slashItems) {
-    const links = slashItems ? [slashKeymap(slashItems)] : [];
-    return chainKeymaps(...links, codeKeymap(schema), listKeymap(schema));
+ * schema-gated: the keys exist only where a menu can be drawn (`slash`), because Enter
+ * and Escape claimed by a surface nobody can see is a body that swallows two keys for
+ * no visible reason. */
+export function bodyKeymap(schema, slash) {
+    const links = slash ? [slashKeymap()] : [];
+    return chainKeymaps(...links, codeKeymap(schema), listKeymap(schema), atomKeymap(schema));
 }

package/dist/core/codec/lists.d.ts

@@ -8,14 +8,14 @@ import type { Command } from 'prosemirror-state';
  * Tab more locally under the same rule (`prose/canon/VISUAL_EDITOR.md` §Chrome)
  * prepend a link ahead of these in `keymap.ts`: a `code_block` takes literal
  * indentation (`code.ts`), an island takes cell traversal once added. Outside all
- * of them every link returns false and the key is NOT swallowed: Tab keeps its
+ * of them every link returns false and the key is not swallowed: Tab keeps its
  * default meaning, which is the body's only keyboard exit and the open seam for a
  * shell structural keymap (VISUAL_EDITOR §Settled and open).
  *
- * `Enter` is a chain in precedence order: the paragraph-above gesture, then
+ * `Enter` is a chain in precedence order: the escape-above gesture, then
  * `splitListItem`, then `liftListItem`. The middle link carries two behaviors of
  * its own: it splits a non-empty item, and on an empty item it either splits the
- * WRAPPING item (a nested empty item, so Enter lifts exactly one level) or bails
+ * wrapping item (a nested empty item, so Enter lifts exactly one level) or bails
  * so the third link lifts a top-level empty item out to a paragraph. `Backspace`
  * forks on the item's index: the first item lifts, any later one merges.
  */

package/dist/core/codec/lists.js

@@ -1,7 +1,7 @@
 import { liftListItem, sinkListItem, splitListItem } from 'prosemirror-schema-list';
 import { chainCommands, joinTextblockBackward } from 'prosemirror-commands';
 /** The caret's enclosing `list_item` when it sits at the very start of that item's
- * FIRST block: the position both structural keys branch on. `null` otherwise
+ * first block: the position both structural keys branch on. `null` otherwise
  * (mid-text, a non-first block of a multi-paragraph item, a non-empty selection),
  * which is where the key keeps its ordinary meaning. */
 function atItemStart(state, itemType) {
@@ -21,13 +21,30 @@ function atItemStart(state, itemType) {
     };
 }
 /**
- * Enter at the very start of a top-level list's first item → an empty paragraph
- * above the list, caret staying with the text it pushed down.
+ * Whether a caret already fits immediately above the list at `pos`. The node ending
+ * there answers for its last child, so a quote counts through its final paragraph;
+ * an atom (an island, a rule) does not, and neither does a list opening its parent.
+ * Those are the shapes `prosemirror-gapcursor` declines too, its `closedBefore`
+ * asking this question from the other side.
+ */
+function writableAbove(doc, pos) {
+    let before = doc.resolve(pos).nodeBefore;
+    while (before && !before.isTextblock && !before.isAtom)
+        before = before.lastChild;
+    return !!before?.isTextblock;
+}
+/**
+ * Enter at the very start of a top-level list's first item, where nothing above the
+ * list takes a caret → an empty paragraph above it, caret staying with the text it
+ * pushed down. A list that opens a document, or one under an island or a rule, has
+ * nowhere above to write and nothing else that opens one. Where a caret already
+ * fits above, the key is the conventional split instead, at every item alike: an
+ * escape a writer reaches by pressing Up needs no key of its own.
  *
- * Only where the list itself is not inside an item: in a NESTED list this pushes
- * an empty paragraph into the parent item (`list_item` is `block+`, so the shape
- * is representable and wrong), where the conventional split (an empty item above)
- * is what the next link does. An empty first item falls through to that same
+ * Also only where the list itself is not inside an item: in a nested list this
+ * pushes an empty paragraph into the parent item (`list_item` is `block+`, so the
+ * shape is representable and wrong), where the conventional split (an empty item
+ * above) is what the next link does. An empty first item falls through to that same
  * link, which exits the list instead.
  */
 function paragraphAboveList(itemType, paragraph) {
@@ -37,13 +54,15 @@ function paragraphAboveList(itemType, paragraph) {
             return false;
         if (state.selection.$from.parent.content.size === 0)
             return false;
+        if (writableAbove(state.doc, at.listPos))
+            return false;
         if (dispatch)
             dispatch(state.tr.insert(at.listPos, paragraph.create()).scrollIntoView());
         return true;
     };
 }
 /**
- * Backspace at the start of a list's FIRST item → lift it: one level out for a
+ * Backspace at the start of a list's first item → lift it: one level out for a
  * nested item, out of the list entirely (to a paragraph) at the top.
  */
 function liftAtListStart(itemType) {
@@ -55,10 +74,10 @@ function liftAtListStart(itemType) {
     };
 }
 /**
- * Backspace at the start of any LATER item → join its text into the previous
+ * Backspace at the start of any later item → join its text into the previous
  * item's last block, so the two items become one line.
  *
- * Not the base keymap's `joinBackward`, which merges the BLOCK and leaves
+ * Not the base keymap's `joinBackward`, which merges the block and leaves
  * `list_item(paragraph, paragraph)`: the item's marker gone while its text stays
  * on its own line, which the reference quill typesets as an unnumbered
  * continuation paragraph.
@@ -79,14 +98,14 @@ function mergeIntoPreviousItem(itemType) {
  * Tab more locally under the same rule (`prose/canon/VISUAL_EDITOR.md` §Chrome)
  * prepend a link ahead of these in `keymap.ts`: a `code_block` takes literal
  * indentation (`code.ts`), an island takes cell traversal once added. Outside all
- * of them every link returns false and the key is NOT swallowed: Tab keeps its
+ * of them every link returns false and the key is not swallowed: Tab keeps its
  * default meaning, which is the body's only keyboard exit and the open seam for a
  * shell structural keymap (VISUAL_EDITOR §Settled and open).
  *
- * `Enter` is a chain in precedence order: the paragraph-above gesture, then
+ * `Enter` is a chain in precedence order: the escape-above gesture, then
  * `splitListItem`, then `liftListItem`. The middle link carries two behaviors of
  * its own: it splits a non-empty item, and on an empty item it either splits the
- * WRAPPING item (a nested empty item, so Enter lifts exactly one level) or bails
+ * wrapping item (a nested empty item, so Enter lifts exactly one level) or bails
  * so the third link lifts a top-level empty item out to a paragraph. `Backspace`
  * forks on the item's index: the first item lifts, any later one merges.
  */

package/dist/core/codec/marks.d.ts

@@ -18,7 +18,7 @@ export declare function descriptorOf(m: ContentMark): Record<string, unknown>;
 /**
  * A stable grouping key for the mark diff: marks sharing a key union into one
  * coverage set. Formatting keys on its type; a link keys on type+url and an
- * unknown on type+attrs, because `applyChange`'s `remove` matches type AND attrs
+ * unknown on type+attrs, because `applyChange`'s `remove` matches type and attrs
  * (verified), so different urls / attrs are independent mark families.
  */
 export declare function markKey(descriptor: Record<string, unknown>): string;

package/dist/core/codec/marks.js

@@ -49,7 +49,7 @@ export function descriptorOf(m) {
 /**
  * A stable grouping key for the mark diff: marks sharing a key union into one
  * coverage set. Formatting keys on its type; a link keys on type+url and an
- * unknown on type+attrs, because `applyChange`'s `remove` matches type AND attrs
+ * unknown on type+attrs, because `applyChange`'s `remove` matches type and attrs
  * (verified), so different urls / attrs are independent mark families.
  */
 export function markKey(descriptor) {