@quillmark/svelte 0.20.1 → 0.22.0

package/dist/core/codec/encode.js

@@ -122,7 +122,12 @@ function scanBlock(acc, node, nodePos, containers, instance) {
             const start = ordered ? node.attrs.start : 1;
             let itemPos = contentStart;
             node.forEach((item, _off, index) => {
-                const container = withInstance({ container: 'list_item', attrs: { ordered, start, ordinal: index } }, instance);
+                const checked = item.attrs.checked;
+                const attrs = { ordered, start, ordinal: index };
+                const container = withInstance({
+                    container: 'list_item',
+                    attrs: checked === null ? attrs : { ...attrs, checked }
+                }, instance);
                 scanBlocks(acc, item, itemPos + 1, [...containers, container]);
                 itemPos += item.nodeSize;
             });

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

@@ -14,20 +14,20 @@ export interface CreateFieldOpts {
     quill: Quill;
     addr: Addr;
     container: HTMLElement;
-    /** Constrained single-textblock schema (a field declaring `inline`). */
+    /** Constrained single-textblock schema (a one-line field). */
     inline?: boolean;
-    /** A mark-free schema (a `plaintext` field): literal text, no formatting and no
+    /** A mark-free schema (a `text` field): literal text, no formatting and no
      *  anchors, in paragraphs and hard breaks or, with `inline`, one textblock. */
     plaintext?: boolean;
     /** The id of the note the caller draws inside `container` for a held leaf →
      *  `aria-describedby` while it holds. */
     heldNoteId?: string;
     /**
-     * Fired when the leaf holds or releases, and at mount when it mounts held. A leaf
-     * declaring `inline`, or a `plaintext` one, is held over a value its schema cannot
+     * Fired when the leaf holds or releases, and at mount when it mounts held. A one-line
+     * leaf, or a `text` one, is held over a value its schema cannot
      * hold (`fitsLeaf`, upstream's `isInline` and `isPlain`): the decode would join lines
      * and drop containers and islands for the first commit to store. Any leaf is held
-     * over an element or a task item, which no node holds. A held leaf draws
+     * over an element, which no node holds. A held leaf draws
      * its content on the block schema, read-only, and commits nothing. Judged of the value
      * each mount and re-hydrate reads, so {@link FieldController.applyExternal} is what
      * re-evaluates it.
@@ -79,6 +79,9 @@ export interface CreateFieldOpts {
      * emptied it holds an empty answer, which prints empty. Absent, the placeholder
      * returns whenever the leaf is empty. */
     placeholderUntilEdit?: boolean;
+    /** An edit leaving the leaf empty removes the field: an optional cell (`t?`), whose
+     * unanswered `none` is what the empty leaf draws and an empty answer would hide. */
+    emptyUnsets?: boolean;
     onFocus?(addr: Addr): void;
     /** Fired with the new USV caret after an edit or a selection move. */
     onCaretMove?(addr: Addr, pos: number): void;
@@ -88,8 +91,8 @@ export interface CreateFieldOpts {
      * move, so a host driving a recompile off it recompiles on every arrow key.
      *
      * Fires for every commit regardless of which branch it took (`applyChange`, the
-     * first-edit `overwrite`, the fallback `overwrite`, a `plaintext` leaf's typed
-     * write) and for an anchor mutation,
+     * first-edit `overwrite`, the fallback `overwrite`, a `text` leaf's typed write)
+     * and for an anchor mutation,
      * which changes no text. A commit that failed outright (`commit-lost`) does not
      * fire it: nothing landed.
      */
@@ -168,6 +171,8 @@ export interface LeafViews {
 /** The canonical empty `Content`: one empty `para` line. The empty a prose
  * leaf (or an array's prose element) seeds from. */
 export declare function emptyContent(): Content;
+/** Whether `rt` is the empty leaf: {@link emptyContent}, nothing typed and no shape left. */
+export declare function isEmptyContent(rt: Content): boolean;
 /** The naming attributes for the `contenteditable`, shared by every prose leaf
  * (`ProseValue` takes it too, so an addressed leaf and a by-value one name their
  * regions by one rule). `aria-labelledby` supersedes `aria-label`: a leaf carrying
@@ -193,15 +198,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`), the markdown paste
+ * (`markdown-paste.ts`) and the task item's checkbox (`tasks.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.
+ * Every mark-shaped plugin reads the schema rather than a flag: over either mark-free
+ * 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

@@ -5,8 +5,8 @@
 //   (a) apply optimistically to the view,
 //   (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)`, or a `plaintext` leaf's whole
-//       text through the typed writer,
+//   (c) commit via `doc.applyChange(addr, bundle)`, or a `text` leaf's whole text
+//       through the typed writer,
 //   (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
@@ -27,12 +27,16 @@ 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 { nestingPlugin } from './nesting.js';
 import { tablePastePlugin } from './table-paste.js';
+import { tableCopyPlugin } from './table-copy.js';
+import { taskPlugin } from './tasks.js';
 import { DEFAULT_TABLE_STRINGS, tableNodeView } from './table-view.js';
 import { DEFAULT_SLASH_STRINGS, focusSlashItem, runSlashItem, slashPlugin } from './slash.js';
 const anchorKey = new PluginKey('quill-anchors');
@@ -74,8 +78,8 @@ function anchorPlugin(seed) {
  * 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,
- * `plaintext` is literal text, and reading one as the other silently eats every
- * `*` the author typed. */
+ * `text` is literal text, and reading one as the other silently eats every `*` the
+ * author typed. */
 function readLeaf(reader, addr) {
     return reader.getContent(addr) ?? emptyContent();
 }
@@ -84,14 +88,18 @@ function readLeaf(reader, addr) {
 export function emptyContent() {
     return { text: '', lines: [{ containers: [], kind: 'para' }], marks: [], islands: [] };
 }
+/** Whether `rt` is the empty leaf: {@link emptyContent}, nothing typed and no shape left. */
+export function isEmptyContent(rt) {
+    return contentEqual(rt, 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`;
  * a default-only richtext field before its first edit) has nothing to splice, and an
  * authored string nothing to lose: content-only marks do not survive markdown, so a
- * string carries no anchors to pay. A body always rests as `Content`. A `plaintext`
- * leaf never asks: it commits through the writer ({@link createField}). */
+ * string carries no anchors to pay. A body always rests as `Content`. A `text` leaf
+ * never asks: it commits through the writer ({@link createField}). */
 function opsCommittable(doc, addr) {
     const stored = doc.getStored(addr);
     return stored !== null && typeof stored === 'object';
@@ -161,7 +169,7 @@ export function createField(opts) {
     const slash = block ? opts.onSlash : undefined;
     // Judged of the value being mounted rather than read off a diagnostic: a routed set
     // can predate the value it arrives with, and `validation::not_plain` stands in for
-    // `not_inline` on a `plaintext(inline)` field.
+    // `not_single_line` on a one-line `text` field.
     const holds = (rt) => !fitsLeaf(rt, { inline, plaintext, islands: true });
     let held = holds(reconciler.last);
     const named = proseAttributes(opts) ?? {};
@@ -209,6 +217,9 @@ export function createField(opts) {
         dispatchTransaction: (tr) => {
             const oldRt = reconciler.last;
             const next = view.state.apply(tr);
+            // A filtered transaction (`nesting.ts`) leaves the state as it was.
+            if (next === view.state)
+                return;
             // An edit takes a held default: the commit below writes the whole leaf, so the
             // mark goes in the same update that draws the edit.
             if (!held && (tr.docChanged || tr.getMeta(anchorKey)))
@@ -281,6 +292,8 @@ 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, newRt) {
+        if (opts.emptyUnsets && heldAnchors().length === 0 && isEmptyContent(newRt))
+            return commitUnset();
         if (plaintext)
             return commitPlain(newRt.text);
         // The text splice, computed once per keystroke: the gate below, both overwrite
@@ -334,8 +347,8 @@ export function createField(opts) {
         }
     }
     /**
-     * A `plaintext` leaf's commit: its whole text through the typed writer, which rests
-     * the field as that literal string (CODEC §Inline mode). A content object is the
+     * A `text` leaf's commit: its whole text through the typed writer, which rests the
+     * field as that literal string (CODEC §Inline mode). A content object is the
      * other rest form, and `toMarkdown` emits one as markdown: a break spelled as a
      * backslash, a `*` and a trailing space escaped, a blank line doubled, so the value
      * reads back changed. The leaf carries no anchors, so the op path has none to keep.
@@ -347,7 +360,7 @@ export function createField(opts) {
         try {
             const name = addr.field;
             if (name === undefined)
-                throw new Error('a plaintext leaf names a field');
+                throw new Error('a text leaf names a field');
             (addr.card === undefined ? writer : writer.card(addr.card)).set(name, text);
             reconciler.commit(readLeaf(reader, addr));
             return true;
@@ -362,6 +375,23 @@ export function createField(opts) {
             return false;
         }
     }
+    /** An emptied optional leaf's commit: the field removed, back to unanswered. */
+    function commitUnset() {
+        try {
+            doc.removeField(addr);
+            reconciler.commit(readLeaf(reader, addr));
+            return true;
+        }
+        catch (e) {
+            reportError(opts.onError, {
+                code: 'commit-lost',
+                severity: 'error',
+                message: `the field could not be removed; the stored value is stale while the editor keeps the edit: ${errorMessage(e)}`,
+                cause: e
+            });
+            return false;
+        }
+    }
     /** The anchors the plugin currently holds (PM coords); `[]` before the first apply. */
     const heldAnchors = () => anchorKey.getState(view.state) ?? [];
     /** The plugin's anchor positions as USV, against `index` — which `dispatchTransaction`
@@ -436,7 +466,7 @@ export function createField(opts) {
             return readLeaf(reader, addr);
         },
         insertAnchor(id, pos) {
-            // A plaintext field carries no marks (§Inline mode), and a held one commits nothing.
+            // A text field carries no marks (§Inline mode), and a held one commits nothing.
             if (plaintext || held)
                 return;
             if (heldAnchors().some((a) => a.id === id))
@@ -504,28 +534,32 @@ 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`), the markdown paste
+ * (`markdown-paste.ts`) and the task item's checkbox (`tasks.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.
+ * Every mark-shaped plugin reads the schema rather than a flag: over either mark-free
+ * 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))
-        list.push(gapCursor(), pastAtomPlugin(), islandPastePlugin(), tablePastePlugin(), markdownPastePlugin());
+        list.push(gapCursor(), pastAtomPlugin(), islandPastePlugin(), tablePastePlugin(), tableCopyPlugin(), markdownPastePlugin(), taskPlugin(), nestingPlugin());
     if (schema === plainSchema)
         list.push(plainClipboardPlugin());
     if (opts.placeholder)
@@ -553,8 +587,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 +606,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);
@@ -630,9 +670,9 @@ function ghostPlugin(opts) {
 /**
  * The field's keymap: history, mark toggles, and the body's structural keys; Enter
  * suppressed inline. The toggles are bound per mark type the schema declares, so a
- * plaintext leaf leaves Mod-b/i/u to the browser.
+ * `text` leaf leaves Mod-b/i/u to the browser.
  *
- * 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. A one-line or `text`
  * 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

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

@@ -1,6 +1,6 @@
 export { rangeAnchor } from './anchor.js';
 export type { RangeAnchor } from './anchor.js';
-export { createField, emptyContent, heldAttributes, proseAttributes, proseLeafPlugins } from './field.js';
+export { createField, emptyContent, heldAttributes, isEmptyContent, proseAttributes, proseLeafPlugins } from './field.js';
 export type { CreateFieldOpts, FieldController, LeafViews } from './field.js';
 export { DEFAULT_TABLE_STRINGS } from './table-view.js';
 export type { TableChromeStrings } from './table-view.js';

package/dist/core/codec/index.js

@@ -13,7 +13,7 @@ import './prose.css';
 // selection (`visual/FormatPopover.svelte`), so it is reached off-barrel.
 export { rangeAnchor } from './anchor.js';
 // The prose leaf.
-export { createField, emptyContent, heldAttributes, proseAttributes, proseLeafPlugins } from './field.js';
+export { createField, emptyContent, heldAttributes, isEmptyContent, proseAttributes, proseLeafPlugins } from './field.js';
 // The table island's chrome vocabulary: the visual tier's `strings` set extends it,
 // so the island's wording is overridden beside every other key.
 export { DEFAULT_TABLE_STRINGS } from './table-view.js';
@@ -37,7 +37,7 @@ export { pmToContent, contentEdit, lower } from './encode.js';
 export { usvToPM, pmToUsv, buildLineIndex } from './positions.js';
 // Reconciliation gate.
 export { createReconciler, contentEqual, valueEqual } from './reconcile.js';
-// Input rules (`createField` mounts them unless `noInputRules`/`plaintext`).
+// Input rules (`createField` mounts them unless `noInputRules`, or over a mark-free schema).
 export { inputRulesPlugin } from './inputrules.js';
 // The body leaf's structural keys: `createField` binds the composed chains
 // (`bodyKeymap`); the suite drives both it and the list link directly.

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,16 +48,17 @@ 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) {
     const rules = [];
     const m = schema.marks;
     // Inline marks. Non-greedy capture between matching delimiters. Built only where the
-    // schema has the mark: the inline schema omits them, and a plaintext one declares none
+    // schema has the mark: the inline schema omits them, and a `text` one declares none
     // at all.
     if (m.strong)
         rules.push(markInputRule(/\*\*([^*]+)\*\*$/, m.strong, 2));
@@ -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

@@ -1,7 +1,7 @@
 import type { Schema } from 'prosemirror-model';
 import type { Command } from 'prosemirror-state';
 /**
- * The list bindings for a block-schema leaf: `{}` for the inline/plaintext
+ * The list bindings for a block-schema leaf: `{}` for the one-line and plain
  * schemas, which declare no list nodes.
  *
  * `Tab` / `Shift-Tab` hold the list link of the body's Tab chain. Surfaces that own
@@ -13,11 +13,12 @@ import type { Command } from 'prosemirror-state';
  * shell structural keymap (VISUAL_EDITOR §Settled and open).
  *
  * `Enter` is a chain in precedence order: the escape-above gesture, then
- * `splitListItem`, then `liftListItem`. The middle link carries two behaviors of
+ * `splitListItem` (`splitTaskItem`, which leaves a task item's new half an open task),
+ * 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