@quillmark/svelte 0.24.0 → 0.25.0

package/THEMING.md

@@ -175,7 +175,7 @@ An app that mounts an editor beside a preview over one session needs a screen to
 | `.qm-switch`    | The band that says which track is showing, and nothing at the widths where both are. Its controls read as even halves and stand at the touch floor (`--qmh-tap`, 44px); depth past that is yours. |
 | `.qm-frame`     | The mounting site: an edge, a corner, and the clip that holds a surface to them. What is inside it is the surface's own.                                                                          |
 
-The narrow shape is one mount at a time, not two of them stacked: half a narrow viewport is under the width either surface reads at. The track you are not showing is `display: none`, so it leaves the tab order, hit-testing and the accessibility tree together: you need no `inert` on it, and no breakpoint in your JS, since the only state you hold is which of the two you last asked for. Keep both mounted: the hidden pane keeps its pixels, its caret and its scroll, and comes back to them — it rasters nothing at a box it has none of, and repaints only where it returns to a box of another width. A preview scroll asked for while it was hidden is held and run on the way back, so it opens at the caret rather than several edits behind it. A click that lands in the hidden pane is the one thing the shape adds to your wiring, so send the caret and reveal the track together, or the hit goes somewhere the reader cannot see.
+The narrow shape is one mount at a time, not two of them stacked: half a narrow viewport is under the width either surface reads at. The track you are not showing is `display: none`, so it leaves the tab order, hit-testing and the accessibility tree together: you need no `inert` on it, and no breakpoint in your JS, since the only state you hold is which of the two you last asked for. Keep both mounted: the hidden pane keeps its pixels, its caret and its scroll, and comes back to them — it rasters nothing at a box it has none of, and repaints only where it returns to a box that draws its pages at another scale. A preview scroll asked for while it was hidden is held and run on the way back, so it opens at the caret rather than several edits behind it. A click that lands in the hidden pane is the one thing the shape adds to your wiring, so send the caret and reveal the track together, or the hit goes somewhere the reader cannot see.
 
 The shape is shared; the look of a band is not. Your wordmark, your nav and the depth of your head are the most app-specific things on the screen, and a preset that drew them would hand every tool built on this the same face, so they read `--qmh-*` like everything else and you write the rules. `.qm-split`'s gap is a default rather than a fact about splitting: close it to `0` and carry a hairline on one pane if you want the two mounts to meet instead of stand apart.
 

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

@@ -1,4 +1,4 @@
-import type { Attrs, Node as PMNode, Schema } from 'prosemirror-model';
+import type { Attrs, Schema } from 'prosemirror-model';
 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`. */
@@ -17,19 +17,36 @@ export declare function insertDivider(): Command;
  *  content holds, where a list wrapping one mints an item whose only content is an
  *  item. */
 export declare function wrapInQuote(): Command;
-/** `- ` / `1. `. `joinBefore` is the shorthand's ordinal test: `2. ` continues the list
- *  above where `7. ` opens one. */
-export declare function wrapInList(ordered: boolean, attrs?: Attrs | null, joinBefore?: (node: PMNode) => boolean): Command;
+/** `- ` / `1. `. Beside a list of its kind the line joins it, whatever `N` is typed: a
+ *  number comes from position. Elsewhere `N. ` is the number the new list counts from,
+ *  and at the head of an item the shorthand is the item's (§`listAtItem`), `N` reading
+ *  the same way; a marker the item already shows is taken as typed and changes nothing. */
+export declare function wrapInList(ordered: boolean, attrs?: Attrs | null): Command;
+/**
+ * `a. `, `(1) `, `(a) `: the markers a nested level draws, typed at the head of a nested
+ * item's first line, where the item already is the thing typed. Taken as typed and
+ * changing nothing, as `N. ` on an item of a numbered list is: the marker comes from the
+ * item's position and the quill's style for its depth, never from the text. Anywhere
+ * else these stay text, being no markdown list marker.
+ */
+export declare function takeNestedMarker(): Command;
 /**
  * A list pick, at whatever caret the writer has. `atHead` is the shorthand's guard,
  * where a prefix firing mid-sentence would eat a dash; a pick is a gesture at the caret.
  *
  * At the end of a non-empty block it opens a fresh empty item below it, Enter then `- `
  * as one gesture. Anywhere else it wraps the whole block, the smaller surprise: a writer
- * who meant to split presses Enter first. It passes no `joinBefore`, so it continues
- * whatever list is above.
+ * who meant to split presses Enter first. In an item's first block it is the shorthand's
+ * item gesture (§`listAtItem`), offered only where that changes something.
  */
 export declare function pickList(ordered: boolean): Command;
+/**
+ * The bullet pick where it puts a line under an item one level deeper than the caret
+ * stood, and nowhere else: the pick a subparagraph names. Outside every item the bullet
+ * it would mint stands at the first level, and on a list's first item the bullet pick
+ * retypes the list instead.
+ */
+export declare function pickSubList(): Command;
 /**
  * Run `command` in place of the text at `[from, to)`: one transaction carrying the
  * delete and the command's own steps. One rather than two because two would be two

package/dist/core/codec/blocks.js

@@ -1,8 +1,10 @@
 import { Selection } from 'prosemirror-state';
 import { chainCommands, splitBlock } from 'prosemirror-commands';
+import { sinkListItem } from 'prosemirror-schema-list';
 import { canJoin, findWrapping } from 'prosemirror-transform';
 import { withinNesting } from './nesting.js';
 import { takesLineBreak } from './schema.js';
+import { joinLists } from './touching.js';
 /** The head of a textblock: where a shorthand fires, and where a pick lands once its
  *  run is consumed. */
 function atHead(state) {
@@ -15,12 +17,9 @@ function fits($from, type) {
     return $from.node(-1).canReplaceWith($from.index(-1), $from.indexAfter(-1), type);
 }
 /**
- * The head of an item that already exists: 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. A
+ * The first block of an item that already exists: where a list gesture retypes the
+ * item's list rather than wrapping the block, which would mint an item whose only
+ * content is another item, a level with nothing on it. Tab is the indent gesture. A
  * later block of the item is not this case: wrapping a continuation paragraph is how a
  * sub-list opens under text.
  */
@@ -58,23 +57,23 @@ function spaceBreaks(tr, $from, type) {
         at += child.nodeSize;
     });
 }
-/** `wrappingInputRule`'s body: wrap the block range at `pos`, then join a preceding
- *  sibling of the same type — the one boundary the wrap itself opens (`lists.ts`
- *  §cleanup: command-local, never a global pass). False where no wrap fits, or where
- *  the one that does nests past `MAX_NESTING_DEPTH` (`nesting.ts`). */
-function wrapAt(tr, pos, type, attrs, joinBefore) {
+/** `wrappingInputRule`'s body: wrap the block range at `pos`, then join a sibling of
+ *  the same type — the boundaries the wrap itself opens (`lists.ts` §cleanup:
+ *  command-local, never a global pass). A list joins on both sides (`touching.ts`), a
+ *  quote the one above. False where no wrap fits, or where the one that does nests past
+ *  `MAX_NESTING_DEPTH` (`nesting.ts`). */
+function wrapAt(tr, pos, type, attrs) {
     const range = tr.doc.resolve(pos).blockRange();
     const wrapping = range && findWrapping(range, type, attrs);
     if (!range || !wrapping)
         return false;
     tr.wrap(range, wrapping);
-    const before = tr.doc.resolve(pos - 1).nodeBefore;
-    if (before &&
-        before.type === type &&
-        canJoin(tr.doc, pos - 1) &&
-        (!joinBefore || joinBefore(before))) {
-        tr.join(pos - 1);
-    }
+    const wrapped = tr.doc.nodeAt(range.start);
+    if (wrapped)
+        joinLists(tr, range.start + wrapped.nodeSize);
+    const before = tr.doc.resolve(range.start).nodeBefore;
+    if (before && before.type === type && canJoin(tr.doc, range.start))
+        tr.join(range.start);
     return withinNesting(tr.doc);
 }
 /** `# `: the heading `level` deep. `list_item` is `block+`, so one inside an item is a
@@ -138,10 +137,96 @@ export function wrapInQuote() {
         return true;
     };
 }
-/** `- ` / `1. `. `joinBefore` is the shorthand's ordinal test: `2. ` continues the list
- *  above where `7. ` opens one. */
-export function wrapInList(ordered, attrs = null, joinBefore) {
-    return (state, dispatch) => atHead(state) && wrapBlock(state, dispatch, ordered, attrs, joinBefore);
+/** `- ` / `1. `. Beside a list of its kind the line joins it, whatever `N` is typed: a
+ *  number comes from position. Elsewhere `N. ` is the number the new list counts from,
+ *  and at the head of an item the shorthand is the item's (§`listAtItem`), `N` reading
+ *  the same way; a marker the item already shows is taken as typed and changes nothing. */
+export function wrapInList(ordered, attrs = null) {
+    return (state, dispatch) => {
+        if (!atHead(state))
+            return false;
+        const { $from } = state.selection;
+        if (openingAnItem($from, state.schema.nodes.list_item))
+            return listAtItem(ordered, attrs?.start ?? null, true)(state, dispatch);
+        return wrapBlock(state, dispatch, ordered, attrs);
+    };
+}
+/**
+ * `a. `, `(1) `, `(a) `: the markers a nested level draws, typed at the head of a nested
+ * item's first line, where the item already is the thing typed. Taken as typed and
+ * changing nothing, as `N. ` on an item of a numbered list is: the marker comes from the
+ * item's position and the quill's style for its depth, never from the text. Anywhere
+ * else these stay text, being no markdown list marker.
+ */
+export function takeNestedMarker() {
+    return (state, dispatch) => {
+        const item = state.schema.nodes.list_item;
+        const { $from } = state.selection;
+        if (!atHead(state) || !openingAnItem($from, item) || $from.depth < 3)
+            return false;
+        if ($from.node(-3).type !== item)
+            return false;
+        dispatch?.(state.tr);
+        return true;
+    };
+}
+/**
+ * A list gesture in an item's first block. On a list's first item it retypes the list,
+ * every item with it: a list is one kind, and that item is where a writer changes it.
+ * `number` is the shorthand's `N`, the list's `start`, the one door back to 1 for a list
+ * that arrived counting from elsewhere. On a later item, a list of the other kind is a
+ * sub-list: the item sinks under the one above, as Tab sinks it, into a list of that
+ * kind — `- ` in a new numbered paragraph is its first lettered subparagraph, never the
+ * whole memo turned to bullets. A sub-list already standing there of that kind takes the
+ * item as its next.
+ *
+ * A gesture that changes nothing — the kind the item's list already is, and on a first
+ * item the number it already counts from — goes unoffered as a pick. As a shorthand
+ * (`take`) it is claimed and changes nothing, so the run is consumed: a writer typing
+ * `2. Second` into the second item meant the number the item already shows, and an item
+ * reading `2. 2. Second` is the one outcome no writer typed for. Backspace on the press
+ * after gives the text back.
+ */
+function listAtItem(ordered, number, take = false) {
+    return (state, dispatch) => {
+        const { $from } = state.selection;
+        const type = state.schema.nodes[ordered ? 'ordered_list' : 'bullet_list'];
+        const item = state.schema.nodes.list_item;
+        if (!type || !item || $from.depth < 2)
+            return false;
+        const list = $from.node(-2);
+        const unchanged = () => {
+            if (take)
+                dispatch?.(state.tr);
+            return take;
+        };
+        if ($from.index(-2) === 0) {
+            const start = number ?? (list.type === type ? list.attrs.start : 1);
+            if (list.type === type && (!ordered || start === list.attrs.start))
+                return unchanged();
+            dispatch?.(state.tr.setNodeMarkup($from.before(-2), type, ordered ? { start } : null));
+            return true;
+        }
+        if (list.type === type)
+            return unchanged();
+        let sunk;
+        if (!sinkListItem(item)(state, (tr) => (sunk = tr)) || !sunk)
+            return false;
+        const tr = sunk;
+        const $at = tr.doc.resolve(tr.mapping.map($from.pos));
+        const nested = $at.node(-2);
+        if (nested.childCount === 1 && nested.type !== type) {
+            const at = $at.before(-2);
+            tr.setNodeMarkup(at, type, ordered ? { start: number ?? 1 } : null);
+            const before = tr.doc.resolve(at).nodeBefore;
+            if (before?.type === type && canJoin(tr.doc, at))
+                tr.join(at);
+        }
+        if (!withinNesting(tr.doc))
+            return false;
+        dispatch?.(tr.scrollIntoView());
+        return true;
+    };
 }
 /**
  * A list pick, at whatever caret the writer has. `atHead` is the shorthand's guard,
@@ -149,8 +234,8 @@ export function wrapInList(ordered, attrs = null, joinBefore) {
  *
  * At the end of a non-empty block it opens a fresh empty item below it, Enter then `- `
  * as one gesture. Anywhere else it wraps the whole block, the smaller surprise: a writer
- * who meant to split presses Enter first. It passes no `joinBefore`, so it continues
- * whatever list is above.
+ * who meant to split presses Enter first. In an item's first block it is the shorthand's
+ * item gesture (§`listAtItem`), offered only where that changes something.
  */
 export function pickList(ordered) {
     return (state, dispatch) => {
@@ -172,14 +257,47 @@ export function pickList(ordered) {
         return true;
     };
 }
+/** How many items the caret stands in. */
+function itemDepth($pos, item) {
+    let n = 0;
+    for (let depth = $pos.depth; depth > 0; depth--)
+        if ($pos.node(depth).type === item)
+            n++;
+    return n;
+}
+/**
+ * The bullet pick where it puts a line under an item one level deeper than the caret
+ * stood, and nowhere else: the pick a subparagraph names. Outside every item the bullet
+ * it would mint stands at the first level, and on a list's first item the bullet pick
+ * retypes the list instead.
+ */
+export function pickSubList() {
+    const pick = pickList(false);
+    return (state, dispatch) => {
+        const item = state.schema.nodes.list_item;
+        const depth = item ? itemDepth(state.selection.$from, item) : 0;
+        if (!depth)
+            return false;
+        let picked;
+        if (!pick(state, (tr) => (picked = tr)) || !picked)
+            return false;
+        if (itemDepth(picked.selection.$from, item) <= depth)
+            return false;
+        dispatch?.(picked);
+        return true;
+    };
+}
 /** Wrap the caret's whole block in a list, wherever in the block the caret sits: the
- *  wrap opens at the block's head, so it joins the list above as the shorthand's does. */
-function wrapBlock(state, dispatch, ordered, attrs, joinBefore) {
+ *  wrap opens at the block's head, so it joins the lists beside it as the shorthand's
+ *  does. */
+function wrapBlock(state, dispatch, ordered, attrs) {
     const { paragraph, list_item: item } = state.schema.nodes;
     const list = state.schema.nodes[ordered ? 'ordered_list' : 'bullet_list'];
     const { $from } = state.selection;
-    if (!list || !paragraph || openingAnItem($from, item))
+    if (!list || !paragraph)
         return false;
+    if (openingAnItem($from, item))
+        return listAtItem(ordered, null)(state, dispatch);
     const pos = $from.start();
     const tr = state.tr;
     // A paragraph item wherever this fires: `# ` inside the item is the gesture that
@@ -187,7 +305,7 @@ function wrapBlock(state, dispatch, ordered, attrs, joinBefore) {
     // that shape. Positions survive the retype — same content, same size.
     if ($from.parent.type !== paragraph)
         tr.setBlockType(pos, pos, paragraph);
-    if (!wrapAt(tr, pos, list, attrs, joinBefore))
+    if (!wrapAt(tr, pos, list, attrs))
         return false;
     dispatch?.(tr);
     return true;
@@ -224,18 +342,18 @@ function atBodyStart($from) {
  * Enter at the very start of a body whose first block takes no caret above it → an
  * empty paragraph there, the caret staying with the text it pushed down.
  *
- * A code block, a quote and a list are the blocks `prosemirror-gapcursor` declines
- * to sit beside, and nothing else mints a block above one: three keystrokes on an
- * empty body (` ``` `, `> `, `- `) put one first, and a document carrying one there
- * can never be given a title. The argument is `paragraphAboveList`'s, about the
- * block rather than about lists, so this link comes first and that one holds the
- * position it alone reaches, a list under an island or a rule.
+ * A code block and a quote are blocks `prosemirror-gapcursor` declines to sit beside,
+ * and nothing else mints a block above one: two keystrokes on an empty body (` ``` `,
+ * `> `) put one first, and a document carrying one there could never be given a title.
  *
  * Declines wherever the first block is a plain textblock, whose Enter-split already
- * leaves a paragraph above, and on an empty one, which the links after it answer.
+ * leaves a paragraph above, and on an empty one, which the links after it answer. An
+ * item's first line of prose declines too: Enter at its head is the list's new first
+ * item, as at every item, and the empty item's own Enter lifts it out to the paragraph a
+ * title takes. A fence opening that item is the fence case and takes the paragraph.
  */
 const paragraphAtBodyStart = (state, dispatch) => {
-    const paragraph = state.schema.nodes.paragraph;
+    const { paragraph, list_item: item } = state.schema.nodes;
     const { $from, empty } = state.selection;
     if (!paragraph || !empty || !atBodyStart($from))
         return false;
@@ -243,6 +361,8 @@ const paragraphAtBodyStart = (state, dispatch) => {
         return false;
     if ($from.depth === 1 && $from.parent.isTextblock && !$from.parent.type.spec.code)
         return false;
+    if (item && $from.depth >= 2 && $from.node(-1).type === item && !$from.parent.type.spec.code)
+        return false;
     dispatch?.(state.tr.insert(0, paragraph.create()).scrollIntoView());
     return true;
 };
@@ -310,7 +430,8 @@ const splitAcrossBlocks = (state, dispatch) => {
  * are the whole of what holds them, and the key is whichever link answers a construct
  * with nothing in it. An empty fence is not that case — the doc spares it, and it
  * carries no text to lose. Declines with nothing after it too: a line with no next
- * line is Backspace's.
+ * line is Backspace's. The line was the one thing between two lists of a kind, they
+ * are one list after it.
  */
 const takeEmptyLine = (state, dispatch) => {
     const { $from, empty } = state.selection;
@@ -321,7 +442,11 @@ const takeEmptyLine = (state, dispatch) => {
         return false;
     if (!Selection.findFrom(state.doc.resolve($from.after()), 1))
         return false;
-    dispatch?.(state.tr.delete($from.before(), $from.after()).scrollIntoView());
+    if (dispatch) {
+        const tr = state.tr.delete($from.before(), $from.after());
+        joinLists(tr, $from.before());
+        dispatch(tr.scrollIntoView());
+    }
     return true;
 };
 /**

package/dist/core/codec/code.js

@@ -75,14 +75,9 @@ const indentInCode = (state, dispatch) => {
 /**
  * Shift-Tab in a code block: remove one indent level from every covered line.
  *
- * Declines when no covered line carries an indent, so the key is not swallowed: it
- * falls through to the list link and, outside a list, on out of the leaf — the
- * body's keyboard exit from inside a code block (VISUAL_EDITOR §Chrome). Inside
- * a `list_item > code_block` the list link claims it and lifts the item out
- * (`tests/codec/code-keys.test.ts`), so a fence in an item has no keyboard exit in
- * either direction — Tab is a code block's whole point and takes the key
- * unconditionally. What a body's keyboard exit should be settles in the shell keymap
- * (VISUAL_EDITOR §Settled and open), not here.
+ * Declines when no covered line carries an indent, so the key falls through to the
+ * list link: inside a `list_item > code_block` it lifts the item out
+ * (`tests/codec/code-keys.test.ts`), and outside a list the body holds it (`keymap.ts`).
  */
 const outdentInCode = (state, dispatch) => {
     const block = codeBlockAt(state);

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

@@ -200,7 +200,8 @@ export declare function createField(opts: CreateFieldOpts): FieldController;
 /**
  * The prose-leaf plugin stack (VISUAL_EDITOR §Surface): shared by
  * {@link createField} and the by-value editor (`ProseValue`), so the two
- * never fork the keymap/plugin ordering. History first, then any leaf-specific
+ * never fork the keymap/plugin ordering. History first, with the plugin that starts an
+ * undo step at each block-moving edit (`undo.ts`), 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 and the
@@ -208,7 +209,8 @@ export declare function createField(opts: CreateFieldOpts): FieldController;
  * 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`).
+ * (`markdown-paste.ts`) and the task item's checkbox (`tasks.ts`). A one-line leaf's
+ * paste joins its lines (`line-paste.ts`).
  *
  * 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

package/dist/core/codec/field.js

@@ -31,10 +31,13 @@ import { contentEqual, createReconciler } from './reconcile.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 { blockSchema, isBlockSchema, isInlineSchema, leafSchema, plainSchema } from './schema.js';
 import { linkPastePlugin } from './link-paste.js';
+import { linePastePlugin } from './line-paste.js';
+import { listPastePlugin } from './list-paste.js';
 import { markdownPastePlugin } from './markdown-paste.js';
 import { nestingPlugin } from './nesting.js';
+import { undoStepPlugin } from './undo.js';
 import { tablePastePlugin } from './table-paste.js';
 import { tableCopyPlugin } from './table-copy.js';
 import { taskPlugin } from './tasks.js';
@@ -533,7 +536,8 @@ export function createField(opts) {
 /**
  * The prose-leaf plugin stack (VISUAL_EDITOR §Surface): shared by
  * {@link createField} and the by-value editor (`ProseValue`), so the two
- * never fork the keymap/plugin ordering. History first, then any leaf-specific
+ * never fork the keymap/plugin ordering. History first, with the plugin that starts an
+ * undo step at each block-moving edit (`undo.ts`), 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 and the
@@ -541,7 +545,8 @@ export function createField(opts) {
  * 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`).
+ * (`markdown-paste.ts`) and the task item's checkbox (`tasks.ts`). A one-line leaf's
+ * paste joins its lines (`line-paste.ts`).
  *
  * 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
@@ -551,6 +556,7 @@ export function createField(opts) {
 export function proseLeafPlugins(schema, opts) {
     const list = [
         history(),
+        undoStepPlugin(),
         ...(opts.cap ? [capPlugin(opts.cap)] : []),
         ...(opts.afterHistory ?? []),
         linebreakPlugin(schema)
@@ -566,9 +572,11 @@ export function proseLeafPlugins(schema, opts) {
     // 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(), tableCopyPlugin(), markdownPastePlugin(), taskPlugin(), nestingPlugin());
+        list.push(gapCursor(), pastAtomPlugin(), islandPastePlugin(), tablePastePlugin(), tableCopyPlugin(), markdownPastePlugin(), listPastePlugin(), taskPlugin(), nestingPlugin());
     if (schema === plainSchema)
         list.push(plainClipboardPlugin());
+    if (isInlineSchema(schema))
+        list.push(linePastePlugin());
     if (opts.placeholder)
         list.push(ghostPlugin(opts));
     return list;

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

@@ -3,6 +3,7 @@ export type { RangeAnchor } from './anchor.js';
 export { createField, emptyContent, heldAttributes, isEmptyContent, proseAttributes, proseLeafPlugins } from './field.js';
 export type { CreateFieldOpts, FieldController, LeafViews } from './field.js';
 export { capCount } from './cap.js';
+export { joinLines, pastedLines } from './line-paste.js';
 export type { TextCap } from './cap.js';
 export { DEFAULT_TABLE_STRINGS } from './table-view.js';
 export type { TableChromeStrings } from './table-view.js';
@@ -20,3 +21,4 @@ export type { Reconciler } from './reconcile.js';
 export { inputRulesPlugin } from './inputrules.js';
 export { bodyKeymap } from './keymap.js';
 export { listKeymap } from './lists.js';
+export { toggleList } from './list-toggle.js';

package/dist/core/codec/index.js

@@ -15,6 +15,7 @@ export { rangeAnchor } from './anchor.js';
 // The prose leaf.
 export { createField, emptyContent, heldAttributes, isEmptyContent, proseAttributes, proseLeafPlugins } from './field.js';
 export { capCount } from './cap.js';
+export { joinLines, pastedLines } from './line-paste.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';
@@ -44,3 +45,6 @@ export { inputRulesPlugin } from './inputrules.js';
 // (`bodyKeymap`); the suite drives both it and the list link directly.
 export { bodyKeymap } from './keymap.js';
 export { listKeymap } from './lists.js';
+// The list toggle the keymap binds to Mod-Shift-7/8, and the selection toolbar's list
+// buttons run (`visual/FormatPopover.svelte`).
+export { toggleList } from './list-toggle.js';

package/dist/core/codec/inputrules.js

@@ -1,6 +1,7 @@
-// Input rules: the markdown-shorthand plugin the codec owns (`**`→strong, `*`→em,
-// `~~`→strike, `` ` ``→code, `# `→heading, `- `/`1. `→lists, `> `→blockquote,
-// `---`→divider), and the fence, which fires on Enter rather than as typed.
+// Input rules: the markdown-shorthand plugin the codec owns (`**`/`__`→strong,
+// `*`/`_`→em, `~~`→strike, `` ` ``→code, `# `→heading, `- `/`1. `/`1) `→lists,
+// `> `→blockquote, `---`→divider, a typed URL→link), 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
@@ -10,11 +11,14 @@
 // another gesture owns — never on how a quill renders it. What a quill typesets is not
 // knowable here (a quill this build has not seen is the open-sets case, CODEC §"Open
 // 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.
+// a document opens carrying a shape the editor refuses to make. So one rule answers
+// otherwise: `- ` / `1. ` at the head of an existing item retypes the item's list, where
+// a wrap would nest and Tab owns the nesting. A marker the item already shows, and `a. `,
+// `(1) `, `(a) ` in a nested item, are taken as typed and change nothing.
 import { InputRule, inputRules, undoInputRule } from 'prosemirror-inputrules';
 import { keymap } from 'prosemirror-keymap';
-import { consuming, insertDivider, toCodeBlock, toHeading, wrapInList, wrapInQuote } from './blocks.js';
+import { rendersHref } from './urls.js';
+import { consuming, insertDivider, takeNestedMarker, toCodeBlock, toHeading, wrapInList, wrapInQuote } from './blocks.js';
 /**
  * A mark input rule: when `regexp` (ending in the closing delimiter) matches
  * before the caret, wrap capture group 1 in `markType` and drop the delimiters.
@@ -46,6 +50,25 @@ function markInputRule(regexp, markType, delimLen) {
         return tr;
     });
 }
+/** A typed URL, closed by the space after it: a scheme `rendersHref` follows, or a bare
+ *  `www.`, less the punctuation around it. */
+const TYPED_URL = /(?:^|[\s(["'])((?:[a-z][a-z0-9+.-]*:\/\/|www\.)[^\s.]\S*?)([.,;:!?)\]'"]*)\s$/i;
+/** The link a typed URL takes, as a paste over a selection does (`link-paste.ts`): the
+ *  URL's own text, with a bare `www.` read as `https://`. The space that closed it is
+ *  typed after the link. Declined over a span already linked or set as code. */
+function autolinkRule(link, code) {
+    return new InputRule(TYPED_URL, (state, match, start, end) => {
+        const [whole, url, trail] = match;
+        const from = start + whole.length - 1 - trail.length - url.length;
+        const to = from + url.length;
+        const href = /^www\./i.test(url) ? `https://${url}` : url;
+        if (!rendersHref(href) || state.doc.rangeHasMark(from, to, link))
+            return null;
+        if (code && state.doc.rangeHasMark(from, to, code))
+            return null;
+        return state.tr.addMark(from, to, link.create({ href })).insertText(whole.slice(-1), end);
+    });
+}
 /** 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 caret it places is scrolled to
@@ -59,23 +82,30 @@ export function markdownInputRules(schema) {
     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 `text` one declares none
-    // at all.
+    // at all. An underscore pair opens only past a word, so `snake_case_name` stays text.
     if (m.strong)
         rules.push(markInputRule(/\*\*([^*]+)\*\*$/, m.strong, 2));
+    if (m.strong)
+        rules.push(markInputRule(/(?:^|[^\w])__([^_]+)__$/, m.strong, 2));
     if (m.em)
         rules.push(markInputRule(/(?:^|[^*])\*([^*]+)\*$/, m.em, 1));
+    if (m.em)
+        rules.push(markInputRule(/(?:^|[^\w])_([^_]+)_$/, m.em, 1));
     if (m.strike)
         rules.push(markInputRule(/~~([^~]+)~~$/, m.strike, 2));
     if (m.code)
         rules.push(markInputRule(/`([^`]+)`$/, m.code, 1));
+    if (m.link)
+        rules.push(autolinkRule(m.link, m.code));
     // 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(/^---$/, 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.
+    // `- ` / `1. ` / `1) ` at the start of a block, here or nested inside an item; at the
+    // start of an item's own first block the command retypes the item's list instead.
     rules.push(blockRule(/^\s*([-+*])\s$/, () => wrapInList(false)));
-    rules.push(blockRule(/^(\d+)\.\s$/, (match) => wrapInList(true, { start: +match[1] }, (node) => node.childCount + node.attrs.start === +match[1])));
+    rules.push(blockRule(/^(\d+)[.)]\s$/, (match) => wrapInList(true, { start: +match[1] })));
+    rules.push(blockRule(/^(?:[a-z]\.|\((?:\d+|[a-z])\))\s$/, takeNestedMarker));
     rules.push(blockRule(/^\s*>\s$/, wrapInQuote));
     return rules;
 }

package/dist/core/codec/keymap.js

@@ -4,6 +4,7 @@ import { blockKeymap } from './blocks.js';
 import { breakKeymap } from './breaks.js';
 import { codeKeymap } from './code.js';
 import { listKeymap } from './lists.js';
+import { listMoveKeymap } from './list-move.js';
 import { slashKeymap } from './slash.js';
 /** One chain per key, the maps taken in precedence order: on a key several bind, an
  * earlier map's command runs first and the next runs only if it declines. A key one
@@ -17,6 +18,23 @@ function chainKeymaps(...maps) {
     }
     return out;
 }
+/** The last link of a document body: Tab and Shift-Tab held wherever no surface took
+ *  them, and Escape giving the focus up, so the browser's next Tab leaves from the body.
+ *  `{}` over `plainSchema`, a form field whose Tab is field navigation. */
+function exitKeymap(schema) {
+    if (!schema.nodes.list_item)
+        return {};
+    return {
+        Tab: () => true,
+        'Shift-Tab': () => true,
+        Escape: (_state, _dispatch, view) => {
+            if (!view)
+                return false;
+            view.dom.blur();
+            return true;
+        }
+    };
+}
 /** A multi-block leaf's structural keys, each link binding only what its schema
  * declares: over `plainSchema`, which holds neither lists nor code blocks nor islands,
  * the block link and the break link alone. The argument list is the precedence order
@@ -29,5 +47,5 @@ function chainKeymaps(...maps) {
  * no visible reason. */
 export function bodyKeymap(schema, slash) {
     const links = slash ? [slashKeymap()] : [];
-    return chainKeymaps(...links, blockKeymap(schema), codeKeymap(schema), breakKeymap(schema), listKeymap(schema), atomKeymap(schema));
+    return chainKeymaps(...links, blockKeymap(schema), codeKeymap(schema), breakKeymap(schema), listKeymap(schema), listMoveKeymap(schema), atomKeymap(schema), exitKeymap(schema));
 }

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

@@ -0,0 +1,7 @@
+import { Fragment, Slice, type Node as PMNode, type Schema } from 'prosemirror-model';
+import { Plugin } from 'prosemirror-state';
+/** The lines a slice holds that hold anything, in order. */
+export declare function pastedLines(slice: Slice): PMNode[];
+/** `lines` as the content of one line, a space between each two. */
+export declare function joinLines(lines: readonly PMNode[], schema: Schema): Fragment;
+export declare function linePastePlugin(): Plugin;