@quillmark/svelte 0.23.0 → 0.25.0

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/islands.d.ts

@@ -5,9 +5,12 @@ import type { ContentIsland, TableProps } from '@quillmark/wasm';
 export declare const ISLAND_SLOT = "\uFFFC";
 /** Whether an island of `type` is block markup: a `table` stands alone on its line. */
 export declare function isBlockIsland(type: ContentIsland['type']): boolean;
+/** Whether a leaf edits an island of `type`; one holding any other is held (`fitsLeaf`). */
+export declare function isEditedIsland(type: ContentIsland['type']): boolean;
 /** Block island node (a table): a `U+FFFC` slot alone on its `para` line. Atom, unselectable content. */
 export declare const islandBlockSpec: NodeSpec;
-/** Inline island node (an image): a `U+FFFC` slot inside a `para` line. */
+/** Inline island node (an image, a footnote, an equation): a `U+FFFC` slot inside a
+ *  `para` line. */
 export declare const islandInlineSpec: NodeSpec;
 /** A PM island node's attributes: the content entry, spelled the way a node spec
  *  spells it (`islandType`, because `type` on a PM node is the node type). `islandType`

package/dist/core/codec/islands.js

@@ -1,10 +1,11 @@
 // Islands: the `U+FFFC` slot + `ContentIsland` entry ↔ a PM leaf node. Every slot sits
 // in a `para` line; the island's type says which node it is, a `table` a block alone on
-// its line and an `image` inline. The node carries `id`, `islandType` and `props` verbatim.
+// its line and every other type inline. The node carries `id`, `islandType` and `props`
+// verbatim.
 //
 // A props-aware consumer reads the shape straight off the boundary:
-// `ContentIsland.props` is the typed union (`TableProps` for `table`,
-// `ImageProps` for `image`; DOCUMENT_MODEL §Stability seams), so the codec
+// `ContentIsland.props` is the typed union (`TableProps` for `table`, `ImageProps` for
+// `image`, …; DOCUMENT_MODEL §Stability seams), so the codec
 // reads it rather than hand-rolling a shape. `type` is a closed set, so a
 // discriminant check narrows it; `props` still crosses the DOM as opaque JSON,
 // which is what §`tablePropsOfNode` guards.
@@ -38,25 +39,35 @@ function islandDOM(node) {
     };
 }
 /** The island types the content model names, each with whether its markup is a block,
- *  which decides the node its slot decodes to. A `Record` over the boundary's own union,
- *  so a member added upstream is a missing key here rather than a silent refusal at the
- *  one door with no decode behind it. */
-const BLOCK_ISLAND = { table: true, image: false };
+ *  which decides the node its slot decodes to, and whether a leaf edits it. A `Record`
+ *  over the boundary's own union, so a member added upstream is a missing key here
+ *  rather than a silent refusal at the one door with no decode behind it. A footnote and
+ *  an equation are read, not edited (CODEC §Decode): a leaf holding one is held. */
+const ISLANDS = {
+    table: { block: true, edited: true },
+    image: { block: false, edited: true },
+    footnote: { block: false, edited: false },
+    math: { block: false, edited: false }
+};
 /** Whether an island of `type` is block markup: a `table` stands alone on its line. */
 export function isBlockIsland(type) {
-    return BLOCK_ISLAND[type];
+    return ISLANDS[type].block;
+}
+/** Whether a leaf edits an island of `type`; one holding any other is held (`fitsLeaf`). */
+export function isEditedIsland(type) {
+    return ISLANDS[type].edited;
 }
 /** An island node's attributes off that DOM, or `false` where the id is absent or the
- *  type is one the content vocabulary does not name — a name no read produces and no
- *  write takes, so the element's text arrives as text. A `props` that is not the JSON
- *  written above reads as `null`, and one of the wrong shape is `undefined` at its
- *  reader (§`tablePropsOfNode`): the entry survives as an island of its type rather
- *  than taking the paste down with it. */
+ *  type is one no leaf edits — a name the vocabulary does not hold, or a footnote or an
+ *  equation, which no gesture mints — so the element's text arrives as text. A `props`
+ *  that is not the JSON written above reads as `null`, and one of the wrong shape is
+ *  `undefined` at its reader (§`tablePropsOfNode`): the entry survives as an island of
+ *  its type rather than taking the paste down with it. */
 function islandAttrsFromDOM(el) {
     const id = el.getAttribute('data-qm-island-id');
     // Asserted off an untrusted attribute and checked against the set on the next line.
     const type = el.getAttribute('data-qm-island');
-    if (id == null || type == null || !Object.hasOwn(BLOCK_ISLAND, type))
+    if (id == null || type == null || !Object.hasOwn(ISLANDS, type) || !isEditedIsland(type))
         return false;
     const raw = el.getAttribute('data-qm-island-props');
     let props = null;
@@ -86,7 +97,8 @@ export const islandBlockSpec = {
     parseDOM: [{ tag: 'div[data-qm-island]', getAttrs: (el) => islandAttrsFromDOM(el) }],
     toDOM: (node) => ['div', islandDOM(node), `[${node.attrs.islandType || 'island'}]`]
 };
-/** Inline island node (an image): a `U+FFFC` slot inside a `para` line. */
+/** Inline island node (an image, a footnote, an equation): a `U+FFFC` slot inside a
+ *  `para` line. */
 export const islandInlineSpec = {
     group: 'inline',
     inline: true,
@@ -94,8 +106,23 @@ export const islandInlineSpec = {
     selectable: true,
     attrs: islandAttrs,
     parseDOM: [{ tag: 'span[data-qm-island]', getAttrs: (el) => islandAttrsFromDOM(el) }],
-    toDOM: (node) => ['span', islandDOM(node), `[${node.attrs.islandType || 'island'}]`]
+    toDOM: inlineIslandDOM
 };
+/** An inline island's DOM: a footnote its reference mark, whose number `prose.css` draws
+ *  in reading order and whose note is its title, an equation its TeX between the dollars
+ *  that write it, and an image its tag. */
+function inlineIslandDOM(node) {
+    const attrs = node.attrs;
+    const dom = islandDOM(node);
+    const props = attrs.props;
+    if (attrs.islandType === 'footnote')
+        return ['sup', typeof props?.text === 'string' ? { ...dom, title: props.text } : dom];
+    if (attrs.islandType === 'math' && typeof props?.tex === 'string') {
+        const fence = props.display ? '$$' : '$';
+        return ['span', dom, `${fence}${props.tex}${fence}`];
+    }
+    return ['span', dom, `[${attrs.islandType || 'island'}]`];
+}
 /** Build a content island entry from a PM island node's attrs (block or inline). The
  *  cast pairs a closed `type` with a `props` that crossed the DOM as opaque JSON. The
  *  store is lenient about a table's shape — it fills what it can and keeps the rest —

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;

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

@@ -0,0 +1,36 @@
+// A one-line leaf holds one paragraph, so a paste of several lines lands as that one line:
+// the lines joined by a space, as a browser's single-line input joins them, where the
+// schema would keep the first and drop the rest. An element of an array of them is the
+// exception the array asks for (`visual/ProseValue.svelte`): there each line is a row.
+import { Fragment, Slice } from 'prosemirror-model';
+import { Plugin } from 'prosemirror-state';
+/** The lines a slice holds that hold anything, in order. */
+export function pastedLines(slice) {
+    const lines = [];
+    slice.content.descendants((node) => {
+        if (node.isTextblock && node.content.size)
+            lines.push(node);
+        return !node.isTextblock;
+    });
+    return lines;
+}
+/** `lines` as the content of one line, a space between each two. */
+export function joinLines(lines, schema) {
+    const parts = [];
+    for (const line of lines) {
+        if (parts.length)
+            parts.push(schema.text(' '));
+        line.content.forEach((node) => parts.push(node));
+    }
+    return Fragment.from(parts);
+}
+export function linePastePlugin() {
+    return new Plugin({
+        props: {
+            transformPasted(slice, view) {
+                const lines = pastedLines(slice);
+                return lines.length > 1 ? new Slice(joinLines(lines, view.state.schema), 0, 0) : slice;
+            }
+        }
+    });
+}

package/dist/core/codec/list-move.d.ts

@@ -0,0 +1,6 @@
+import type { Schema } from 'prosemirror-model';
+import type { Command } from 'prosemirror-state';
+/** The items the selection stands in, in the innermost list holding all of them, moved
+ *  one place up (`-1`) or down (`1`). */
+export declare function moveItems(dir: -1 | 1): Command;
+export declare function listMoveKeymap(schema: Schema): Record<string, Command>;

package/dist/core/codec/list-move.js

@@ -0,0 +1,30 @@
+const isList = (node) => node.type.name === 'ordered_list' || node.type.name === 'bullet_list';
+/** The items the selection stands in, in the innermost list holding all of them, moved
+ *  one place up (`-1`) or down (`1`). */
+export function moveItems(dir) {
+    return (state, dispatch) => {
+        const { $from, $to } = state.selection;
+        const range = $from.blockRange($to, isList);
+        if (!range)
+            return false;
+        const index = dir < 0 ? range.startIndex - 1 : range.endIndex;
+        if (index < 0 || index >= range.parent.childCount)
+            return false;
+        if (!dispatch)
+            return true;
+        const sibling = range.parent.child(index);
+        const size = sibling.nodeSize;
+        const tr = state.tr;
+        if (dir < 0)
+            tr.delete(range.start - size, range.start).insert(range.end - size, sibling);
+        else
+            tr.delete(range.end, range.end + size).insert(range.start, sibling);
+        dispatch(tr.scrollIntoView());
+        return true;
+    };
+}
+export function listMoveKeymap(schema) {
+    if (!schema.nodes.list_item)
+        return {};
+    return { 'Alt-ArrowUp': moveItems(-1), 'Alt-ArrowDown': moveItems(1) };
+}

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

@@ -0,0 +1,2 @@
+import { Plugin } from 'prosemirror-state';
+export declare function listPastePlugin(): Plugin;

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

@@ -0,0 +1,142 @@
+// A pasted list takes the numbering of where it lands (CODEC §"Markdown at the edges").
+// An item's number is its position, so a paste counts where it stands: items pasted into
+// a list are that list's next items, of its kind and in its count, and items pasted on
+// the empty line a list was just left by are the same list's. A list pasted on a line of
+// its own keeps the `start` it was copied with, which a writer typed (`lists.ts` writes
+// none) — but a run of items copied from inside a list is copied counting from 1: their
+// numbers were positions in the list they came out of.
+//
+// A line's shape travels with its end, as a word processor's paragraph mark carries its
+// style: text copied from inside one line pastes as text, whatever block it was copied
+// out of, and paragraphs pasted into a numbered line are numbered lines.
+import { Fragment, Slice } from 'prosemirror-model';
+import { Plugin, Selection } from 'prosemirror-state';
+const isList = (node) => !!node && (node.type.name === 'ordered_list' || node.type.name === 'bullet_list');
+/** The one list a slice is, if it is one: whole, or open where a run of its items was
+ *  copied. */
+function soleList(slice) {
+    return slice.content.childCount === 1 && isList(slice.content.firstChild)
+        ? slice.content.firstChild
+        : null;
+}
+/** The textblock a slice is the inside of: text copied from within one line, the slice
+ *  open to that line at both ends down a chain of only children. */
+function lineInside(slice) {
+    if (slice.openStart === 0 || slice.openStart !== slice.openEnd)
+        return null;
+    let node = null;
+    for (let d = 0, content = slice.content; d < slice.openStart; d++, content = node.content) {
+        if (content.childCount !== 1)
+            return null;
+        node = content.firstChild;
+    }
+    return node.isTextblock ? node : null;
+}
+/** `content` with the node `depth` levels down its leading edge counting from 1. */
+function fromOne(content, depth) {
+    const first = content.firstChild;
+    const node = depth === 1
+        ? first.type.create({ ...first.attrs, start: 1 }, first.content, first.marks)
+        : first.copy(fromOne(first.content, depth - 1));
+    return content.replaceChild(0, node);
+}
+/** A new item beside `item`: a task's sibling is a task, and unchecked. */
+const itemAttrs = (item) => ({ checked: item.attrs.checked === null ? null : false });
+/** HTML a ProseMirror view wrote, which states how deep the copy was open at each end. */
+const PM_SLICE = /\sdata-pm-slice="\d+ \d+/;
+export function listPastePlugin() {
+    // Whether the paste in flight states its own open depths: a ProseMirror copy does, and
+    // a drag inside the view carries its slice whole. Any other source is parsed open as
+    // deep as it goes, so a whole item copied off a web page reads as the inside of one
+    // line, and only a slice that says so is taken for one. Read once, by the transform.
+    let exact = false;
+    return new Plugin({
+        props: {
+            handleDOMEvents: {
+                drop: (view) => {
+                    exact = !!view.dragging;
+                    return false;
+                }
+            },
+            transformPastedHTML(html) {
+                exact = PM_SLICE.test(html);
+                return html;
+            },
+            // A copy whose leading edge stands past an ordered list's first item is a run
+            // out of it, and goes out counting from 1; one from the first item keeps the
+            // list's `start`, however the selection ends. The copy is the selection's own
+            // slice, its leading edge the caret's ancestors from the top, so the list at
+            // depth `d` stands `d` levels down it.
+            transformCopied(slice, view) {
+                const { $from } = view.state.selection;
+                let content = slice.content;
+                for (let d = 1; d < $from.depth; d++) {
+                    const list = $from.node(d);
+                    if (list.type.name === 'ordered_list' && $from.index(d) > 0 && list.attrs.start !== 1)
+                        content = fromOne(content, d);
+                }
+                return content === slice.content
+                    ? slice
+                    : new Slice(content, slice.openStart, slice.openEnd);
+            },
+            // The caret's line keeps its shape under text from inside another line: no
+            // list, heading or fence comes along to wrap it. Into a line of an item, a list
+            // is its items, which join the list the caret is in where a whole list would
+            // nest under that line's item. Paragraphs into an item's first line are items
+            // beside it, as a word processor numbers each pasted paragraph; a later line of
+            // an item is unnumbered, and so are the paragraphs pasted into it.
+            transformPasted(slice, view) {
+                const line = exact && lineInside(slice);
+                exact = false;
+                if (line)
+                    return new Slice(line.content, 0, 0);
+                const { $from, $to } = view.state.selection;
+                if (!$from.sameParent($to) || !$from.parent.isTextblock || $from.depth < 2)
+                    return slice;
+                if ($from.parent.type.spec.code)
+                    return slice;
+                const item = $from.node(-1);
+                if (item.type.name !== 'list_item')
+                    return slice;
+                const list = soleList(slice);
+                if (list)
+                    return new Slice(list.content, Math.max(slice.openStart - 1, 0), Math.max(slice.openEnd - 1, 0));
+                const { content } = slice;
+                if ($from.index(-1) !== 0 || content.childCount < 2)
+                    return slice;
+                const items = [];
+                for (let i = 0; i < content.childCount; i++) {
+                    const block = content.child(i);
+                    if (block.type.name !== 'paragraph')
+                        return slice;
+                    items.push(item.type.create(itemAttrs(item), block));
+                }
+                return new Slice(Fragment.from(items), slice.openStart && slice.openStart + 1, slice.openEnd && slice.openEnd + 1);
+            },
+            // On the empty line right under a list of the same kind, the line Enter on an
+            // empty last item leaves, the items are that list's next ones.
+            handlePaste(view, _event, slice) {
+                const list = soleList(slice);
+                const { $from, empty } = view.state.selection;
+                if (!list || !empty || !$from.parent.isTextblock || $from.parent.content.size !== 0)
+                    return false;
+                if ($from.parent.type.spec.code)
+                    return false;
+                const above = view.state.doc.resolve($from.before()).nodeBefore;
+                if (!isList(above) || above.type !== list.type)
+                    return false;
+                const end = $from.before() - 1;
+                const tr = view.state.tr.delete($from.before(), $from.after()).insert(end, list.content);
+                try {
+                    tr.doc.check();
+                }
+                catch {
+                    return false;
+                }
+                tr.setSelection(Selection.near(tr.doc.resolve(end + list.content.size), -1));
+                view.dispatch(tr.scrollIntoView().setMeta('paste', true).setMeta('uiEvent', 'paste'));
+                return true;
+            }
+        }
+    });
+}

package/dist/core/codec/list-toggle.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from 'prosemirror-state';
+/** Number (`ordered`) or bullet every line of the selection, or, where every one already
+ *  carries the kind, take those markers off. Declines where the selection holds no line. */
+export declare function toggleList(ordered: boolean): Command;

package/dist/core/codec/list-toggle.js

@@ -0,0 +1,170 @@
+// The list toggle: every line of a selection numbered or bulleted as one gesture, or
+// every one's marker taken off. Mod-Shift-7 and Mod-Shift-8 bind it, the Docs chords
+// (`lists.ts`), and the selection toolbar offers it (`visual/FormatPopover.svelte`).
+//
+// A line is a textblock the selection touches; a fence is no line here, a list item
+// being no place for one to land unasked. A line carries a marker where it opens its
+// item. An item's later line, a continuation, goes with its item where the item's
+// opening line is selected too, and otherwise carries no marker of its own. Where every
+// line carries one of the kind, the toggle takes those markers off, and only those.
+// Otherwise each line becomes the kind: a run of plain lines is wrapped, one item a
+// line, and a run of continuation lines the same way where it stands, the first items
+// of a sub-list under their item, as `- ` or `1. ` at a continuation's head opens one
+// (`blocks.ts` §`openingAnItem`); a list of the other kind is retyped whole, a list
+// being one kind (`blocks.ts` §`listAtItem`); a line already in the kind stays. What it
+// wraps or retypes joins the lists of its kind it leaves touching (`touching.ts`), so
+// the lines of one selection count as one list.
+import { Fragment, NodeRange, Slice } from 'prosemirror-model';
+import { wrapRangeInList } from 'prosemirror-schema-list';
+import { ReplaceAroundStep } from 'prosemirror-transform';
+import { withinNesting } from './nesting.js';
+import { joinAll } from './touching.js';
+/** The textblocks `[from, to]` touches, by position, fences left out. A selection that
+ *  ends at the very head of a block has selected nothing in it. */
+function linesIn(doc, from, to) {
+    const lines = [];
+    doc.nodesBetween(from, to, (node, pos) => {
+        if (!node.isTextblock)
+            return true;
+        if (!node.type.spec.code && (from === to || pos + 1 < to))
+            lines.push(pos);
+        return false;
+    });
+    return lines;
+}
+function lineAt(doc, pos, itemType) {
+    const $at = doc.resolve(pos + 1);
+    let item = -1;
+    for (let depth = $at.depth - 1; depth > 0 && item < 0; depth--)
+        if ($at.node(depth).type === itemType)
+            item = depth;
+    let opens = item > 0;
+    for (let depth = item; opens && depth < $at.depth; depth++)
+        opens = $at.index(depth) === 0;
+    return { pos, $at, item, opens };
+}
+/** The selection's lines, each with whether its item's opening line is among them. */
+function linesOf(doc, from, to, itemType) {
+    const lines = linesIn(doc, from, to).map((pos) => lineAt(doc, pos, itemType));
+    const opened = new Set(lines.filter((l) => l.opens).map((l) => l.$at.before(l.item)));
+    return lines.map((line) => ({
+        ...line,
+        covered: line.item > 0 && !line.opens && opened.has(line.$at.before(line.item))
+    }));
+}
+/**
+ * `prosemirror-schema-list`'s `liftOutOfList`, over a transaction, which upstream does
+ * not export: the items of `range` out of their list, their blocks standing where the
+ * list stood, the list closed around them. In a sub-list the blocks land in the parent
+ * item, the continuation lines a marker coming off leaves (`lists.ts` §`markerOff`).
+ * Returns where the list's tail stands, `null` where the items were its last, and
+ * `false` where the parent cannot hold the items' blocks.
+ */
+function liftOut(tr, range) {
+    const list = range.parent;
+    for (let pos = range.end, i = range.endIndex - 1; i > range.startIndex; i--) {
+        pos -= list.child(i).nodeSize;
+        tr.delete(pos - 1, pos + 1);
+    }
+    const $start = tr.doc.resolve(range.start);
+    const item = $start.nodeAfter;
+    const atStart = range.startIndex === 0;
+    const atEnd = range.endIndex === list.childCount;
+    const start = $start.pos;
+    const end = start + item.nodeSize;
+    const shell = Fragment.from(list.copy(Fragment.empty));
+    const step = new ReplaceAroundStep(start - (atStart ? 1 : 0), end + (atEnd ? 1 : 0), start + 1, end - 1, new Slice((atStart ? Fragment.empty : shell).append(atEnd ? Fragment.empty : shell), atStart ? 0 : 1, atEnd ? 0 : 1), atStart ? 0 : 1);
+    if (tr.maybeStep(step).failed)
+        return false;
+    if (atEnd)
+        return null;
+    const $list = tr.doc.resolve(range.$from.before(range.depth));
+    return $list.posAtIndex($list.index() + (atStart ? 0 : 1) + item.childCount);
+}
+/** Take every marker the selection's lines carry off, the shallowest list first:
+ *  lifting an item brings its sub-lists up a level, where the next pass reaches them. A
+ *  list's tail counts from 1 again, a number that names its position in the list it now
+ *  is (`lists.ts` §`lineOut`). */
+function unlist(tr, type, itemType) {
+    for (;;) {
+        const { from, to } = tr.selection;
+        const marked = linesIn(tr.doc, from, to)
+            .map((pos) => lineAt(tr.doc, pos, itemType))
+            .filter((l) => l.opens && l.$at.node(l.item - 1).type === type);
+        if (!marked.length)
+            return true;
+        const depth = Math.min(...marked.map((l) => l.item - 1));
+        const listPos = marked.find((l) => l.item - 1 === depth).$at.before(depth);
+        const indices = marked
+            .filter((l) => l.item - 1 === depth && l.$at.before(depth) === listPos)
+            .map((l) => l.$at.index(depth));
+        const $list = tr.doc.resolve(listPos + 1);
+        const range = new NodeRange(tr.doc.resolve($list.posAtIndex(Math.min(...indices))), tr.doc.resolve($list.posAtIndex(Math.max(...indices) + 1)), depth);
+        const tail = liftOut(tr, range);
+        if (tail === false)
+            return false;
+        const rest = tail === null ? null : tr.doc.nodeAt(tail);
+        if (tail !== null && rest?.attrs.start != null && rest.attrs.start !== 1)
+            tr.setNodeMarkup(tail, null, { ...rest.attrs, start: 1 });
+    }
+}
+/** Make every line the kind, and join what that leaves touching. */
+function relist(tr, lines, type, paragraph) {
+    const changed = [];
+    const runs = [];
+    for (const line of lines) {
+        const { $at, item } = line;
+        if (line.covered)
+            continue;
+        if (line.opens) {
+            const pos = $at.before(item - 1);
+            if ($at.node(item - 1).type !== type && !changed.some((c) => c.pos === pos)) {
+                tr.setNodeMarkup(pos, type, type.name === 'ordered_list' ? { start: 1 } : null);
+                changed.push({ pos, step: tr.steps.length });
+            }
+            continue;
+        }
+        const end = line.pos + $at.parent.nodeSize;
+        const run = runs[runs.length - 1];
+        if (run && run.to === line.pos && run.depth === $at.depth - 1)
+            run.to = end;
+        else
+            runs.push({ from: line.pos, to: end, depth: $at.depth - 1 });
+    }
+    for (const run of runs.reverse()) {
+        tr.setBlockType(run.from, run.to, paragraph);
+        const range = new NodeRange(tr.doc.resolve(run.from), tr.doc.resolve(run.to), run.depth);
+        if (!wrapRangeInList(tr, range, type))
+            return false;
+        changed.push({ pos: run.from, step: tr.steps.length });
+    }
+    const seams = [];
+    for (const { pos, step } of changed) {
+        const at = tr.mapping.slice(step).map(pos);
+        const node = tr.doc.nodeAt(at);
+        if (node)
+            seams.push(at, at + node.nodeSize);
+    }
+    joinAll(tr, seams);
+    return withinNesting(tr.doc);
+}
+/** Number (`ordered`) or bullet every line of the selection, or, where every one already
+ *  carries the kind, take those markers off. Declines where the selection holds no line. */
+export function toggleList(ordered) {
+    return (state, dispatch) => {
+        const { list_item: item, paragraph } = state.schema.nodes;
+        const type = state.schema.nodes[ordered ? 'ordered_list' : 'bullet_list'];
+        if (!item || !paragraph || !type)
+            return false;
+        const { from, to } = state.selection;
+        const lines = linesOf(state.doc, from, to, item);
+        if (!lines.length)
+            return false;
+        const tr = state.tr;
+        const off = lines.every((l) => l.covered || (l.opens && l.$at.node(l.item - 1).type === type));
+        if (!(off ? unlist(tr, type, item) : relist(tr, lines, type, paragraph)))
+            return false;
+        dispatch?.(tr.scrollIntoView());
+        return true;
+    };
+}