Enter continues a block quote, as it already continues a list (#700)

[PathGao]

What this is

Enter on a block quote writes the next line's >, and Enter on a quote with
nothing after the marker takes it away. Closes #700, reported by @17Archangel,
who asked for the behaviour lists already have — "回车两次再取消掉".

It also changes one thing about lists, deliberately: see Scope.

Mechanism

utils/listSyntax.ts has always spelled the list-marker prefix
[ \t]*(?:>[ \t]*)*, so > was understood — as the thing a list item can be
nested inside. listEnter asked parseListItem and nothing else, and that
pattern needs a -, * or 1. to match at all. > quoted is a line with a
prefix and no marker, so it parsed as no block, and Enter fell through to
Monaco's own.

The module answers for both blocks now and is named for it (blockEnter), with
QUOTE_MARKER factored out beside the fragments the prefix already used.

Where the caret joins the block

The interesting decision is not "does a quote continue" but "from which
column". Measuring to where the marker's TEXT starts — the obvious rule, and
the one the list branch used — answers two opposite things for one gesture:

"> text"    caret just after the `>`   ->  inside a two-character marker
">text"     caret just after the `>`   ->  head of the content

Same pixel, same keystroke, and the user cannot see which spelling they are in
without counting spaces. So the boundary is the end of the marker's
characters instead, and both answer "continue". That is CodeMirror's rule,
reached for the same reason — @codemirror/lang-markdown's commands.ts
declines only when inner.to - inner.spaceAfter.length > pos, subtracting
exactly that whitespace.

The separator, once instead of twice

A caret parked inside the separator splits it. The half after the caret rides
down with the text, because that is what a line break does, so a new marker
carrying a whole separator lands one space more than was typed — and another on
every Enter after that, which is what the reporter would have hit first:

"- item", caret between `-` and its space, Enter five times
  before   "-  item" -> "-   item" -> "-    item" -> ...
  after    "- item"  -> "- item"   -> "- item"

markerUpTo rations the separator to the half already behind the caret, so the
two halves add back up to what was there. The marker's characters are never
rationed: an ordered marker still counts up (9. -> 10.) and a task box still
comes back unchecked.

Alternatives considered

Suppressing continuation inside fenced code. Built and then removed. - item
inside a ```diff block is prose-shaped text in somebody's code and
continuing it is wrong, and utils/pasteContext.ts already answers "is the
caret in code" for Ctrl+V, so the guard was four lines. It costs
monaco.editor.tokenize() over every line above the caret: 5.5 ms at 500
lines, 27 ms at 2 000, 275 ms at 20 000 (Monarch's own markdown grammar,
realistic prose). Ctrl+V has paid that since it shipped because a paste is one
keystroke in a while; Enter is every second keystroke of a paragraph. Nothing
public in Monaco is cheaper — ITextModel.getLineTokens is internal, and the
encoded tokens it holds have lost the type strings this needs (a bare fence's
body encodes as Other, indistinguishable from prose), while this app's own
semantic layer arrives a tick late inside Monaco's sparse store. CodeMirror
does bail on FencedCode, cheaply, because it has a Lezer tree to resolve
against; we do not. So lists and quotes are both still continued inside a fence,
as lists always have been, and listEditing.ts says so with the numbers.

Declining >text, as VS Code's Markdown All in One does
(/^> /.test(textBeforeCursor)). It sidesteps the caret problem above rather
than answering it, and it cannot be copied here: comrak renders >text as a
quote — semantic_spans returns quote.marker for it, exactly as for
> text — so Enter would be disagreeing with the preview drawn beside it.

Normalising the separator. CodeMirror collapses it to one space, Markdown
All in One writes a hard-coded > . Neither preserves a hand-aligned list
either, and this app does (- item continues as - ), so > quoted
keeps its spacing for the same reason.

Trimming the whitespace behind the caret, which CodeMirror does before
breaking (while (from > line.from && /\s/...) from--). It would make the
abandoned line byte-identical whichever side of the separator Enter is pressed,
and render.hardbreaks means trailing spaces carry no meaning here, so nothing
would break. Left out anyway: the line it cleans is one nobody can see the
difference in, and Enter quietly deleting characters to the left of the caret is
more than this key was asked to do.

Scope

Lists change too. The boundary and the separator rule are one implementation
for both blocks, so -| item now continues instead of dropping out of the
list, and - [x]| task continues from after the box. That is the same defect
one marker over; fixing it only for quotes would leave quotes one column more
forgiving than lists with nothing to point at for why.

Not touched: Tab and Shift+Tab, which read the same lines through
parseListItem and have their own reasons to; the fence blind spot above; and
the empty-quote ladder, which stays at one Enter per block rather than
CodeMirror's and Markdown All in One's two empty > lines — the reporter asked
for the list's two-Enter exit and this app's lists give it.

Tests

scripts/listContinuation.test.ts: 968 -> 969 node tests, all green, plus
npm run check (815 files, 0 errors), npm run test:vitest (398), npm audit
(0), cargo test.

The pure function is CALLED, once per shape: every quote depth and spelling,
the caret at each column across the marker of a quote, a bullet, an ordered
item and a task item, and the split-doubling case as a before/after pair. The
two Editor.svelte handlers are lifted out and run against the stub editor as
before, so the edits asserted are the real ones.

Reverting each half with the tests left in place: the quote branch -> 5 red;
the boundary -> the caret and doubling tests red; both restored -> green.

Verification

npm audit, npm run check, npm test, npm run test:vitest,
cd src-tauri && cargo test — all pass locally.

Driven by hand in a release build on macOS 15 (Apple silicon): every case above,
plus Enter held down on a quote and on a list to watch the separator stay one
space wide.

Not verified: Windows and Linux — the reporter is on Windows 10 — and that
Monaco delivers Enter to this handler at runtime, which no test here can
establish. What is pinned instead is the when clause the app declares.