@quillmark/svelte 0.20.0 → 0.21.0

package/THEMING.md

@@ -56,7 +56,7 @@ The poles take a colour, not `transparent` or `inherit`: the raised surfaces, th
 | `--qm-bg`        | `#fff` / `#272729`                     | Base surface: a card, and the preview's sheet. Fields, the popover and the column behind the cards each step off it.                                           |
 | `--qm-fg`        | `#1c1c1c` / `#d7dadc`                  | Base ink. Body text, labels, and borders step off it.                                                                                                          |
 | `--qm-accent`    | `#71717a` / `#a1a1aa`                  | Focus rings, active marks, the preview's active field box. The surface spends no hue of its own, so this is the one it wears.                                  |
-| `--qm-danger`    | `#9e1518` / `#f9786c`                  | Error diagnostics, the required marker, the delete glyph.                                                                                                      |
+| `--qm-danger`    | `#9e1518` / `#f9786c`                  | Error diagnostics and the delete glyph.                                                                                                                        |
 | `--qm-font`      | `ui-sans-serif, system-ui, sans-serif` | The editor surface's font family. Controls and buttons take it too, in place of the UA face.                                                                   |
 | `--qm-font-mono` | `ui-monospace, monospace`              | The monospace face: the JSON array control, the tips card.                                                                                                     |
 | `--qm-font-size` | `0.875rem`                             | Chrome text: every control's size, the anchor the ramp derives up (title) and down (label/meta) from, and the anchor a document body sits one small step over. |

package/dist/core/codec/atoms.js

@@ -1,5 +1,7 @@
 // The block-atom link of the body's Backspace/Delete chains: a delete against an
-// island or a divider selects it, and the press after that deletes it.
+// island or a divider selects it, and the press after that deletes it. A table is the
+// exception, having cells a caret can enter: the press steps into it instead, so a
+// delete against one edits nothing (§`againstAtom`).
 //
 // This is the neighbour half of the rule the leaf already holds for a key typed over a
 // selection (CODEC §"The table island"): a selection is the subject of the next
@@ -12,6 +14,7 @@
 // first item lifts the item, and that stays the item's answer whatever sits above the
 // list.
 import { NodeSelection, TextSelection } from 'prosemirror-state';
+import { tableAt } from './table-view.js';
 /** The caret, when it sits at a textblock edge with an empty selection: the only place
  *  a delete is about a neighbour rather than about a character. `null` everywhere else,
  *  which is where the key keeps its ordinary meaning. */
@@ -44,20 +47,32 @@ function cutAt($pos, side) {
     }
     return null;
 }
-/** Select the block atom the caret is against, rather than deleting it. Declines when
- *  the neighbour is anything a caret can enter, so a paragraph, a heading, a quote and
- *  a list all keep the join the base keymap gives them. */
-function selectAtom(side) {
-    return (state, dispatch) => {
+/** The press against a block atom: select it, rather than deleting it, or step into a
+ *  mounted table, its last cell from below and its first from above. An empty line under
+ *  a table goes with the step, its Backspace having nothing of its own to edit. Declines
+ *  when the neighbour is anything else a caret can enter, so a paragraph, a heading, a
+ *  quote and a list all keep the join the base keymap gives them. */
+function againstAtom(side) {
+    return (state, dispatch, view) => {
         const $head = atEdge(state, side);
         const $cut = $head && cutAt($head, side);
-        if (!$cut)
+        if (!$head || !$cut)
             return false;
         const node = side < 0 ? $cut.nodeBefore : $cut.nodeAfter;
         if (!node || !node.isAtom || !node.isBlock || !NodeSelection.isSelectable(node))
             return false;
         const at = side < 0 ? $cut.pos - node.nodeSize : $cut.pos;
-        dispatch?.(state.tr.setSelection(NodeSelection.create(state.doc, at)).scrollIntoView());
+        const table = view && tableAt(view, at);
+        if (!table) {
+            dispatch?.(state.tr.setSelection(NodeSelection.create(state.doc, at)).scrollIntoView());
+            return true;
+        }
+        if (!dispatch)
+            return true;
+        const index = $head.index(-1);
+        if (side < 0 && $head.parent.content.size === 0 && $head.node(-1).canReplace(index, index + 1))
+            dispatch(state.tr.delete($head.before(), $head.after()));
+        table.enter(side);
         return true;
     };
 }
@@ -72,7 +87,7 @@ export function atomKeymap(schema) {
     if (!schema.nodes.island_block)
         return {};
     return {
-        Backspace: selectAtom(-1),
-        Delete: selectAtom(1)
+        Backspace: againstAtom(-1),
+        Delete: againstAtom(1)
     };
 }

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

@@ -3,11 +3,11 @@ import type { Command, EditorState, Transaction } from 'prosemirror-state';
 /** `# `: the heading `level` deep. `list_item` is `block+`, so one inside an item is a
  *  shape the content holds and `importMarkdown` produces from `- # title`. */
 export declare function toHeading(level: number): Command;
-/** A fence. The exit paragraph after it is the one a block island mints for the same
- *  reason, sharpened: a code block is the one block a gap cursor will not sit beside
- *  either, so a fence at the end of a body leaves the caret nowhere to go. The caret
- *  stays in the fence, not in the exit it minted. */
-export declare function toCodeBlock(): Command;
+/** A fence, carrying `attrs` (its `lang`). The exit paragraph after it is the one a
+ *  block island mints for the same reason, sharpened: a code block is the one block a
+ *  gap cursor will not sit beside either, so a fence at the end of a body leaves the
+ *  caret nowhere to go. The caret stays in the fence, not in the exit it minted. */
+export declare function toCodeBlock(attrs?: Attrs): Command;
 /** `---`. A divider is a whole block, so this replaces its textblock rather than
  *  retyping one: `horizontal_rule` holds no content to retype into, and an empty block
  *  is the whole of what it may replace — anything else in one is a paragraph being

package/dist/core/codec/blocks.js

@@ -80,17 +80,17 @@ function wrapAt(tr, pos, type, attrs, joinBefore) {
 export function toHeading(level) {
     return retype('heading', { level });
 }
-/** A fence. The exit paragraph after it is the one a block island mints for the same
- *  reason, sharpened: a code block is the one block a gap cursor will not sit beside
- *  either, so a fence at the end of a body leaves the caret nowhere to go. The caret
- *  stays in the fence, not in the exit it minted. */
-export function toCodeBlock() {
+/** A fence, carrying `attrs` (its `lang`). The exit paragraph after it is the one a
+ *  block island mints for the same reason, sharpened: a code block is the one block a
+ *  gap cursor will not sit beside either, so a fence at the end of a body leaves the
+ *  caret nowhere to go. The caret stays in the fence, not in the exit it minted. */
+export function toCodeBlock(attrs) {
     return (state, dispatch) => {
         const { code_block: code, paragraph } = state.schema.nodes;
         const { $from } = state.selection;
         if (!code || !paragraph || !atHead(state) || !fits($from, code))
             return false;
-        const tr = state.tr.setBlockType($from.pos, $from.pos, code);
+        const tr = state.tr.setBlockType($from.pos, $from.pos, code, attrs);
         const at = tr.doc.resolve($from.pos).after();
         if (!tr.doc.nodeAt(at))
             tr.insert(at, paragraph.create());
@@ -322,6 +322,22 @@ const takeEmptyLine = (state, dispatch) => {
     dispatch?.(state.tr.delete($from.before(), $from.after()).scrollIntoView());
     return true;
 };
+/**
+ * Backspace at a heading's head → a paragraph, where it stands, and the press after is
+ * the join. The first press takes off the block's own shape, which is the whole of what
+ * it edits: the base keymap's join would merge the heading's text into the block above
+ * and lose the heading with it, and at the body's start it does nothing at all.
+ */
+const unheading = (state, dispatch) => {
+    const paragraph = state.schema.nodes.paragraph;
+    const { $from } = state.selection;
+    if (!paragraph || !atHead(state) || $from.parent.type.name !== 'heading')
+        return false;
+    if (!fits($from, paragraph))
+        return false;
+    dispatch?.(state.tr.setBlockType($from.pos, $from.pos, paragraph).scrollIntoView());
+    return true;
+};
 /** The body-wide link of the leaf's key chains: `{}` for a schema with no paragraph
  *  to mint. Outermost of the structural links, being about the body, or about the
  *  caret's own line, rather than about the surface either stands in. */
@@ -330,6 +346,7 @@ export function blockKeymap(schema) {
         return {};
     return {
         Enter: chainCommands(paragraphAtBodyStart, paragraphFromEmptyFence, splitAcrossBlocks),
+        Backspace: unheading,
         Delete: takeEmptyLine
     };
 }

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

@@ -9,8 +9,8 @@ import { type Command } from 'prosemirror-state';
  * otherwise splits the item in two, each half holding a code block. `Shift-Enter` is
  * the same command because it is the same edit: the line break the key means
  * everywhere else (`breaks.ts`) is, inside a fence, the newline Enter already takes.
- * Every command here declines away from a code block — inside one for the four keys
- * about its text, against one for the two about its edge — so the list links keep the
- * keys elsewhere.
+ * Every command here declines away from a code block — inside one for the keys about
+ * its text and its last line, against one for the two about its edge — so the list
+ * links keep the keys elsewhere.
  */
 export declare function codeKeymap(schema: Schema): Record<string, Command>;

package/dist/core/codec/code.js

@@ -1,4 +1,4 @@
-import { TextSelection } from 'prosemirror-state';
+import { Selection, TextSelection } from 'prosemirror-state';
 import { newlineInCode } from 'prosemirror-commands';
 /** One indent level. */
 const UNIT = '  ';
@@ -107,7 +107,7 @@ const outdentInCode = (state, dispatch) => {
  * The textblock the caret's own block stands directly against on `side`: its sibling
  * under one parent, which is the only neighbour a press joins the text of. `null` at a
  * container's edge, where the base keymap moves the whole block in or out rather than
- * joining anything, and so retypes nothing.
+ * joining anything, and so changes nothing here.
  */
 function blockAgainst(state, side) {
     const { $from, empty } = state.selection;
@@ -122,22 +122,22 @@ function blockAgainst(state, side) {
     return { node, pos: side < 0 ? $edge.pos - node.nodeSize : $edge.pos };
 }
 /**
- * Backspace at a fence's head or Delete at its end, and the same two presses from the
- * block on the other side: retype the code block to a paragraph, and join nothing. The
- * press after that is an ordinary join between two prose blocks.
+ * Backspace or Delete at a fence's edge, from either side, edits only the block the caret
+ * is in.
  *
- * The join itself retypes one side's whole text as the other's kind on one keystroke —
- * a fence's lines as prose, or a typed line as code — which is the destruction
- * `atoms.ts` refuses for a neighbouring island, with nothing drawn first to say what is
- * about to go. This is `toCodeBlock`'s inverse in its place (`blocks.ts`), and it takes
- * no text with it: `linebreakReplacement` carries the fence's newlines across as breaks
- * (`schema.ts`). The caret stays in the block it was in.
+ * Inside the fence, a press at its head or its end retypes it to a paragraph and joins
+ * nothing: `toCodeBlock`'s inverse in its place (`blocks.ts`), taking no text with it,
+ * since `linebreakReplacement` carries the fence's newlines across as breaks
+ * (`schema.ts`). The press after that is an ordinary join between two prose blocks.
+ *
+ * From the prose block against it, the caret steps into the fence, to the end it faces,
+ * and the fence is left as it is: a join would retype one side's whole text as the
+ * other's kind, and a retype from outside edits a block the caret is not in. An empty
+ * line under a fence goes with the step, its Backspace having nothing of its own to edit.
  *
  * Declines where both sides are code and where neither is: those joins retype nothing.
- * An empty block on either side never reaches this at all: the block link takes the
- * empty line ahead of the chain (`blocks.ts`), and there is no text to retype.
  */
-function retypeAtProseEdge(side) {
+function atProseEdge(side) {
     return (state, dispatch) => {
         const paragraph = state.schema.nodes.paragraph;
         const edge = blockAgainst(state, side);
@@ -147,11 +147,40 @@ function retypeAtProseEdge(side) {
         const inside = !!$from.parent.type.spec.code;
         if (inside === !!edge.node.type.spec.code)
             return false;
-        const at = inside ? $from.pos : edge.pos + 1;
-        dispatch?.(state.tr.setBlockType(at, at, paragraph).scrollIntoView());
+        if (inside) {
+            dispatch?.(state.tr.setBlockType($from.pos, $from.pos, paragraph).scrollIntoView());
+            return true;
+        }
+        const tr = state.tr;
+        const index = $from.index(-1);
+        if (side < 0 && $from.parent.content.size === 0 && $from.node(-1).canReplace(index, index + 1))
+            tr.delete($from.before(), $from.after());
+        const into = side < 0 ? edge.pos + edge.node.nodeSize - 1 : edge.pos + 1;
+        dispatch?.(tr.setSelection(TextSelection.create(tr.doc, into)).scrollIntoView());
         return true;
     };
 }
+/** ↓ on the last line of a fence nothing follows → a paragraph after it, the caret
+ *  there: no block stands below to arrow to, and a gap cursor will not sit beside a
+ *  fence. */
+const belowFinalFence = (state, dispatch) => {
+    const paragraph = state.schema.nodes.paragraph;
+    const { $from, empty } = state.selection;
+    if (!paragraph || !empty || !$from.parent.type.spec.code)
+        return false;
+    if ($from.parent.textBetween($from.parentOffset, $from.parent.content.size).includes('\n'))
+        return false;
+    const $after = state.doc.resolve($from.after());
+    if (Selection.findFrom($after, 1))
+        return false;
+    if (!$after.parent.canReplaceWith($after.index(), $after.index(), paragraph))
+        return false;
+    if (dispatch) {
+        const tr = state.tr.insert($after.pos, paragraph.create());
+        dispatch(tr.setSelection(TextSelection.create(tr.doc, $after.pos + 1)).scrollIntoView());
+    }
+    return true;
+};
 /**
  * The `code_block` link of the body's key chains: `{}` for the inline/plaintext
  * schemas, which declare no code node.
@@ -161,9 +190,9 @@ function retypeAtProseEdge(side) {
  * otherwise splits the item in two, each half holding a code block. `Shift-Enter` is
  * the same command because it is the same edit: the line break the key means
  * everywhere else (`breaks.ts`) is, inside a fence, the newline Enter already takes.
- * Every command here declines away from a code block — inside one for the four keys
- * about its text, against one for the two about its edge — so the list links keep the
- * keys elsewhere.
+ * Every command here declines away from a code block — inside one for the keys about
+ * its text and its last line, against one for the two about its edge — so the list
+ * links keep the keys elsewhere.
  */
 export function codeKeymap(schema) {
     if (!schema.nodes.code_block)
@@ -173,7 +202,8 @@ export function codeKeymap(schema) {
         'Shift-Tab': outdentInCode,
         Enter: newlineInCode,
         'Shift-Enter': newlineInCode,
-        Backspace: retypeAtProseEdge(-1),
-        Delete: retypeAtProseEdge(1)
+        Backspace: atProseEdge(-1),
+        Delete: atProseEdge(1),
+        ArrowDown: belowFinalFence
     };
 }

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

@@ -193,15 +193,17 @@ export declare function createField(opts: CreateFieldOpts): FieldController;
  * never fork the keymap/plugin ordering. History first, then any leaf-specific
  * plugins (`afterHistory`: the addressed leaf passes its anchor-position plugin;
  * a by-value leaf passes none), then {@link linebreakPlugin}, which normalizes what
- * the rest of the stack leaves, then the markdown-shorthand input rules, the field
- * keymap over the base keymap, and last the ones that answer to a block leaf's own
- * shapes: the gap cursor, {@link pastAtomPlugin}, the island paste pass (`islands.ts`),
- * the table paste (`table-paste.ts`) and the markdown paste (`markdown-paste.ts`).
+ * the rest of the stack leaves, then the markdown-shorthand input rules and the
+ * Backspace that takes one back, the field keymap over the base keymap, the URL paste
+ * that links a selection (`link-paste.ts`), and last the ones that answer to a block
+ * leaf's own shapes: the gap cursor, {@link pastAtomPlugin}, the island paste pass
+ * (`islands.ts`), the table paste (`table-paste.ts`) and the markdown paste
+ * (`markdown-paste.ts`).
  *
  * Every mark-shaped plugin reads the schema rather than a flag: over either plaintext
- * schema the shorthand rules build nothing (each is guarded on its mark type) and the
- * toggles bind no key, so a `**bold**` keeps the delimiters its author typed without
- * a second rule saying so.
+ * schema the shorthand rules build nothing (each is guarded on its mark type), the
+ * toggles bind no key and a pasted URL stays text, so a `**bold**` keeps the delimiters
+ * its author typed without a second rule saying so.
  */
 export declare function proseLeafPlugins(schema: Schema, opts: {
     inline: boolean;

package/dist/core/codec/field.js

@@ -27,10 +27,11 @@ import { lower, pmToContent, scanContent, scanDoc, contentEdit } from './encode.
 import { islandPastePlugin } from './islands.js';
 import { anchorsFromContent } from './marks.js';
 import { contentEqual, createReconciler } from './reconcile.js';
-import { inputRulesPlugin } from './inputrules.js';
+import { inputRulesPlugin, undoRuleKeymap } from './inputrules.js';
 import { linebreakPlugin } from './breaks.js';
 import { bodyKeymap } from './keymap.js';
 import { blockSchema, isBlockSchema, leafSchema, plainSchema } from './schema.js';
+import { linkPastePlugin } from './link-paste.js';
 import { markdownPastePlugin } from './markdown-paste.js';
 import { tablePastePlugin } from './table-paste.js';
 import { DEFAULT_TABLE_STRINGS, tableNodeView } from './table-view.js';
@@ -504,24 +505,28 @@ export function createField(opts) {
  * never fork the keymap/plugin ordering. History first, then any leaf-specific
  * plugins (`afterHistory`: the addressed leaf passes its anchor-position plugin;
  * a by-value leaf passes none), then {@link linebreakPlugin}, which normalizes what
- * the rest of the stack leaves, then the markdown-shorthand input rules, the field
- * keymap over the base keymap, and last the ones that answer to a block leaf's own
- * shapes: the gap cursor, {@link pastAtomPlugin}, the island paste pass (`islands.ts`),
- * the table paste (`table-paste.ts`) and the markdown paste (`markdown-paste.ts`).
+ * the rest of the stack leaves, then the markdown-shorthand input rules and the
+ * Backspace that takes one back, the field keymap over the base keymap, the URL paste
+ * that links a selection (`link-paste.ts`), and last the ones that answer to a block
+ * leaf's own shapes: the gap cursor, {@link pastAtomPlugin}, the island paste pass
+ * (`islands.ts`), the table paste (`table-paste.ts`) and the markdown paste
+ * (`markdown-paste.ts`).
  *
  * Every mark-shaped plugin reads the schema rather than a flag: over either plaintext
- * schema the shorthand rules build nothing (each is guarded on its mark type) and the
- * toggles bind no key, so a `**bold**` keeps the delimiters its author typed without
- * a second rule saying so.
+ * schema the shorthand rules build nothing (each is guarded on its mark type), the
+ * toggles bind no key and a pasted URL stays text, so a `**bold**` keeps the delimiters
+ * its author typed without a second rule saying so.
  */
 export function proseLeafPlugins(schema, opts) {
     const list = [history(), ...(opts.afterHistory ?? []), linebreakPlugin(schema)];
     if (opts.slash)
         list.push(slashPlugin(opts.slash, opts.slashHint));
     if (!opts.noInputRules)
-        list.push(inputRulesPlugin(schema));
+        list.push(inputRulesPlugin(schema), undoRuleKeymap());
     list.push(keymap(editorKeymap(schema, opts.inline, !!opts.slash)));
     list.push(keymap(baseKeymap));
+    if (schema.marks.link)
+        list.push(linkPastePlugin(schema.marks.link));
     // Each answers to something only the block schema holds: any other leaf is
     // textblocks alone, with no island and no gap to put a cursor in.
     if (isBlockSchema(schema))
@@ -553,8 +558,10 @@ function plainClipboardPlugin() {
  * 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
- * the image in the same line: one rule, both node types.
+ * it. A block island takes the empty paragraph after it, or a new one where there is
+ * none; an inline one the caret after the image in the same line: one rule, both node
+ * types. Only a paragraph is reused, since an empty heading or fence would set the
+ * text in a shape the key never asked for.
  *
  * PM routes text input over a non-`TextSelection` through `handleTextInput` before
  * falling back to replacing the selection, so this one prop is the whole of it.
@@ -570,9 +577,13 @@ function pastAtomPlugin() {
                     return false;
                 const tr = view.state.tr;
                 const at = selection.to; // just past the node, in both coordinate senses
+                const after = tr.doc.resolve(at).nodeAfter;
                 if (selection.node.isInline) {
                     tr.setSelection(TextSelection.create(tr.doc, at)).insertText(text);
                 }
+                else if (after?.type === schema.nodes.paragraph && after.content.size === 0) {
+                    tr.setSelection(TextSelection.create(tr.doc, at + 1)).insertText(text);
+                }
                 else {
                     const para = schema.nodes.paragraph.create(null, schema.text(text));
                     tr.insert(at, para);

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

@@ -5,3 +5,7 @@ import type { Plugin } from 'prosemirror-state';
 export declare function markdownInputRules(schema: Schema): InputRule[];
 /** The input-rules plugin the field mounts by default (opt-out via createField). */
 export declare function inputRulesPlugin(schema: Schema): Plugin;
+/** Backspace on the press right after a rule fired takes the rule back and leaves the
+ *  text it consumed, the way a writer who meant the literal `# ` says so; and Enter fires
+ *  the fence. Mounted ahead of every other keymap: each declines on any other press. */
+export declare function undoRuleKeymap(): Plugin;

package/dist/core/codec/inputrules.js

@@ -1,6 +1,6 @@
 // Input rules: the markdown-shorthand plugin the codec owns (`**`→strong, `*`→em,
 // `~~`→strike, `` ` ``→code, `# `→heading, `- `/`1. `→lists, `> `→blockquote,
-// `---`→divider, a fence→code block).
+// `---`→divider), and the fence, which fires on Enter rather than as typed.
 // Mark rules are hand-rolled (prosemirror-inputrules ships only node rules); every
 // block rule is one regexp over a command in `blocks.ts`, which is the slash menu's
 // implementation too. These produce transactions the codec already lowers: they add no
@@ -12,7 +12,8 @@
 // sets"), and a construct that arrives through `importMarkdown` must stay authorable or
 // a document opens carrying a shape the editor refuses to make. So one guard survives:
 // `- ` / `1. ` at the head of an existing item, where Tab owns the nesting.
-import { InputRule, inputRules } from 'prosemirror-inputrules';
+import { InputRule, inputRules, undoInputRule } from 'prosemirror-inputrules';
+import { keymap } from 'prosemirror-keymap';
 import { consuming, insertDivider, toCodeBlock, toHeading, wrapInList, wrapInQuote } from './blocks.js';
 /**
  * A mark input rule: when `regexp` (ending in the closing delimiter) matches
@@ -47,9 +48,10 @@ function markInputRule(regexp, markType, delimLen) {
 }
 /** A block shorthand: the regexp that fires it, and the command it runs in the match's
  *  place. Every one is `^`-anchored, so the command's own head-of-a-textblock guard is
- *  the same position the regexp already stands at. */
+ *  the same position the regexp already stands at. The caret it places is scrolled to
+ *  here: `consuming` rebuilds the transaction, so a flag the command set is not on it. */
 function blockRule(regexp, command) {
-    return new InputRule(regexp, (state, match, start, end) => consuming(state, start, end, command(match))?.tr ?? null);
+    return new InputRule(regexp, (state, match, start, end) => consuming(state, start, end, command(match))?.tr.scrollIntoView() ?? null);
 }
 /** The full markdown-shorthand rule set for a block schema. */
 export function markdownInputRules(schema) {
@@ -69,7 +71,6 @@ export function markdownInputRules(schema) {
     // Block shorthands. Each command answers for the schema it is run against, so a
     // schema without the node declines rather than being guarded here.
     rules.push(blockRule(/^(#{1,6})\s$/, (match) => toHeading(match[1].length)));
-    rules.push(blockRule(/^```$/, toCodeBlock));
     rules.push(blockRule(/^---$/, insertDivider));
     // `- ` / `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 the command declines.
@@ -82,3 +83,40 @@ export function markdownInputRules(schema) {
 export function inputRulesPlugin(schema) {
     return inputRules({ rules: markdownInputRules(schema) });
 }
+/** A fence's opening line: three backticks, then the language, if one is typed. */
+const FENCE = /^```([^\s`]*)$/;
+/**
+ * Enter at the end of a paragraph that is a fence's opening line → a code block carrying
+ * the language typed after the backticks. The one shorthand Enter fires rather than its
+ * last character: on the third backtick the language is not typed yet. It records itself
+ * as the input-rules plugin's last rule, so the Backspace after takes it back like any
+ * other shorthand.
+ */
+const fenceOnEnter = (state, dispatch) => {
+    const { $from, empty } = state.selection;
+    const line = $from.parent;
+    if (!empty || line.type !== state.schema.nodes.paragraph)
+        return false;
+    if ($from.parentOffset !== line.content.size || line.childCount !== 1 || !line.firstChild.isText)
+        return false;
+    const match = FENCE.exec(line.textContent);
+    if (!match)
+        return false;
+    const done = consuming(state, $from.start(), $from.pos, toCodeBlock({ lang: match[1] || null }));
+    if (!done)
+        return false;
+    if (dispatch) {
+        const tr = done.tr.scrollIntoView();
+        const rules = state.plugins.find((plugin) => plugin.spec.isInputRules);
+        if (rules)
+            tr.setMeta(rules, { transform: tr, from: $from.pos, to: $from.pos, text: '' });
+        dispatch(tr);
+    }
+    return true;
+};
+/** Backspace on the press right after a rule fired takes the rule back and leaves the
+ *  text it consumed, the way a writer who meant the literal `# ` says so; and Enter fires
+ *  the fence. Mounted ahead of every other keymap: each declines on any other press. */
+export function undoRuleKeymap() {
+    return keymap({ Backspace: undoInputRule, Enter: fenceOnEnter });
+}

package/dist/core/codec/link-paste.d.ts

@@ -0,0 +1,11 @@
+import type { MarkType } from 'prosemirror-model';
+import { Plugin } from 'prosemirror-state';
+/**
+ * Links a selection within one block where the clipboard's text is one URL naming a
+ * scheme the mark renders. A selection crossing blocks, or held in one taking no link
+ * (a code block), keeps the default paste, and so does a URL nothing would follow.
+ *
+ * The ops are `setLink`'s pair (`visual/links.ts`), so the mark diff lowers the paste
+ * as one link exchanged for another.
+ */
+export declare function linkPastePlugin(link: MarkType): Plugin;

package/dist/core/codec/link-paste.js

@@ -0,0 +1,32 @@
+import { Plugin, TextSelection } from 'prosemirror-state';
+import { rendersHref } from './urls.js';
+/** One URL and nothing else: a scheme, then no whitespace. */
+const URL_ALONE = /^[a-z][a-z0-9+.-]*:\S+$/i;
+/**
+ * Links a selection within one block where the clipboard's text is one URL naming a
+ * scheme the mark renders. A selection crossing blocks, or held in one taking no link
+ * (a code block), keeps the default paste, and so does a URL nothing would follow.
+ *
+ * The ops are `setLink`'s pair (`visual/links.ts`), so the mark diff lowers the paste
+ * as one link exchanged for another.
+ */
+export function linkPastePlugin(link) {
+    return new Plugin({
+        props: {
+            handlePaste(view, event) {
+                const { selection } = view.state;
+                if (!(selection instanceof TextSelection) || selection.empty)
+                    return false;
+                const { $from, $to } = selection;
+                if (!$from.sameParent($to) || !$from.parent.type.allowsMarkType(link))
+                    return false;
+                const href = event.clipboardData?.getData('text/plain').trim() ?? '';
+                if (!URL_ALONE.test(href) || !rendersHref(href))
+                    return false;
+                const { from, to } = selection;
+                view.dispatch(view.state.tr.removeMark(from, to, link).addMark(from, to, link.create({ href })));
+                return true;
+            }
+        }
+    });
+}

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

@@ -16,8 +16,8 @@ import type { Command } from 'prosemirror-state';
  * `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
- * 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. `Delete` is
+ * so the third link lifts a top-level empty item out to a paragraph. `Backspace` lifts
+ * an item at its start, and joins a block onto the list it stands after. `Delete` is
  * that same chain at the seam below rather than a second table of cases beside it, so
  * the two keys cannot come to differ over a seam this link reaches. An empty line is
  * not one: the block link takes it ahead of this chain (`blocks.ts`), the caret's own