@quillmark/svelte 0.5.0 → 0.6.0

package/dist/core/codec/inputrules.js

@@ -1,10 +1,10 @@
 // Input rules: the markdown-shorthand plugin the codec owns (`**`→strong, `*`→em,
 // `~~`→strike, `` ` ``→code, `# `→heading, `- `/`1. `→lists, `> `→blockquote,
-// `---`→divider).
-// Mark rules are hand-rolled (prosemirror-inputrules ships only node rules); the one
-// block rule with no guard of its own reuses `wrappingInputRule`, and the rest mirror
-// an upstream body around one. These produce transactions the codec already lowers:
-// they add no new lowering surface.
+// `---`→divider, a fence→code block).
+// 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
+// new lowering surface.
 //
 // A rule declines only where what it would mint is unrepresentable, or is a shape
 // another gesture owns — never on how a quill renders it. What a quill typesets is not
@@ -12,9 +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, wrappingInputRule } from 'prosemirror-inputrules';
-import { canJoin, findWrapping } from 'prosemirror-transform';
-import { Selection } from 'prosemirror-state';
+import { InputRule, inputRules } from 'prosemirror-inputrules';
+import { consuming, insertDivider, 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,69 +45,19 @@ function markInputRule(regexp, markType, delimLen) {
         return tr;
     });
 }
-/**
- * `wrappingInputRule` (whose body this mirrors), plus one normalization: a
- * `heading` being wrapped becomes a `paragraph` first.
- *
- * `list_item` is `block+`, so `list_item > heading` is *representable*, and `# `
- * inside the item is the gesture that mints it ({@link markdownInputRules}). A wrap
- * keeping the heading would be a second door onto that shape, so `- ` / `1. ` mint a
- * paragraph item wherever they fire.
- *
- * `item` is the second guard, and it is about the gesture rather than the shape: the
- * rule declines at the start of an item's own first block ({@link openingAnItem}).
- */
-function listWrappingRule(regexp, listType, paragraph, item, getAttrs, joinPredicate) {
-    return new InputRule(regexp, (state, match, start, end) => {
-        if (openingAnItem(state.doc.resolve(start), item))
-            return null;
-        const attrs = getAttrs ? getAttrs(match) : null;
-        const tr = state.tr.delete(start, end);
-        // Positions survive the retype: same content, same size.
-        if (tr.doc.resolve(start).parent.type !== paragraph) {
-            tr.setBlockType(start, start, paragraph);
-        }
-        const $start = tr.doc.resolve(start);
-        const range = $start.blockRange();
-        const wrapping = range && findWrapping(range, listType, attrs);
-        if (!range || !wrapping)
-            return null;
-        tr.wrap(range, wrapping);
-        // Join a preceding list of the same type: the one boundary this rule
-        // itself opens (`lists.ts` §cleanup: command-local, never a global pass).
-        const before = tr.doc.resolve(start - 1).nodeBefore;
-        if (before &&
-            before.type === listType &&
-            canJoin(tr.doc, start - 1) &&
-            (!joinPredicate || joinPredicate(match, before))) {
-            tr.join(start - 1);
-        }
-        return tr;
-    });
-}
-/**
- * Whether `$start` is the head of an item that already exists: offset 0 of a
- * `list_item`'s first block, which is 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, so
- * what the rule adds here is a second door onto a worse answer. A later block of the
- * item is not this case: wrapping a continuation paragraph is how a sub-list opens
- * under text.
- */
-function openingAnItem($start, item) {
-    if (!item || $start.depth < 2 || $start.parentOffset !== 0)
-        return false;
-    return $start.node(-1).type === item && $start.index(-1) === 0;
+/** 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. */
+function blockRule(regexp, command) {
+    return new InputRule(regexp, (state, match, start, end) => consuming(state, start, end, command(match))?.tr ?? null);
 }
 /** The full markdown-shorthand rule set for a block schema. */
 export function markdownInputRules(schema) {
     const rules = [];
     const m = schema.marks;
-    const item = schema.nodes.list_item;
-    // Inline marks. Non-greedy capture between matching delimiters.
+    // 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
+    // at all.
     if (m.strong)
         rules.push(markInputRule(/\*\*([^*]+)\*\*$/, m.strong, 2));
     if (m.em)
@@ -117,85 +66,16 @@ export function markdownInputRules(schema) {
         rules.push(markInputRule(/~~([^~]+)~~$/, m.strike, 2));
     if (m.code)
         rules.push(markInputRule(/`([^`]+)`$/, m.code, 1));
-    // Block shorthands (only where the schema has the node; the inline schema
-    // omits them, so this stays a no-op there).
-    if (schema.nodes.heading) {
-        // `textblockTypeInputRule`'s body. It fires inside a list item like anywhere else:
-        // `list_item > heading` is a shape the content holds and `importMarkdown` produces
-        // from `- # title`, so a rule that declined there would refuse to author what a
-        // document can arrive carrying.
-        const heading = schema.nodes.heading;
-        rules.push(new InputRule(/^(#{1,6})\s$/, (state, match, start, end) => {
-            const $start = state.doc.resolve(start);
-            if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), heading)) {
-                return null;
-            }
-            return state.tr
-                .delete(start, end)
-                .setBlockType(start, start, heading, { level: match[1].length });
-        }));
-    }
-    if (schema.nodes.code_block && schema.nodes.paragraph) {
-        // `textblockTypeInputRule`'s body plus the exit the `---` rule mints below, for a
-        // sharper version of its reason: a code block is the one block a GAP CURSOR will
-        // not sit beside either (`closedBefore`/`closedAfter` both fail on a textblock), so
-        // a fence at the end of a body leaves the caret with no way forward at all.
-        const code = schema.nodes.code_block;
-        const paragraph = schema.nodes.paragraph;
-        rules.push(new InputRule(/^```$/, (state, _match, start, end) => {
-            const $start = state.doc.resolve(start);
-            if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), code)) {
-                return null;
-            }
-            const tr = state.tr.delete(start, end).setBlockType(start, start, code);
-            const at = tr.doc.resolve(start).after();
-            if (!tr.doc.nodeAt(at))
-                tr.insert(at, paragraph.create());
-            // The caret stays in the fence, not in the exit it minted.
-            return tr;
-        }));
-    }
-    if (schema.nodes.horizontal_rule && schema.nodes.paragraph) {
-        // A divider is a whole block, so this rule replaces its textblock rather than
-        // retyping one: `horizontal_rule` holds no content to retype into.
-        const rule = schema.nodes.horizontal_rule;
-        const paragraph = schema.nodes.paragraph;
-        rules.push(new InputRule(/^---$/, (state, _match, start, end) => {
-            const $start = state.doc.resolve(start);
-            // The block entirely, not a prefix of one. `[start, end)` is the match minus
-            // the just-typed `-`, so the block holds `--` when this fires; anything else
-            // in it is a paragraph being edited, which a replace would eat.
-            if ($start.parentOffset !== 0 || $start.parent.content.size !== end - start) {
-                return null;
-            }
-            if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), rule)) {
-                return null;
-            }
-            const from = $start.before();
-            const tr = state.tr.replaceWith(from, $start.after(), rule.create());
-            // A divider at the end of a body leaves nowhere to type; the paragraph after
-            // it is the exit, and it is where the caret lands (`slash.ts` §insertBlock
-            // opens the same block for the same reason).
-            const at = from + 1;
-            if (!tr.doc.nodeAt(at))
-                tr.insert(at, paragraph.create());
-            tr.setSelection(Selection.near(tr.doc.resolve(at), 1));
-            return tr;
-        }));
-    }
+    // 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 {@link openingAnItem} declines.
-    if (schema.nodes.bullet_list && schema.nodes.paragraph) {
-        rules.push(listWrappingRule(/^\s*([-+*])\s$/, schema.nodes.bullet_list, schema.nodes.paragraph, item));
-    }
-    if (schema.nodes.ordered_list && schema.nodes.paragraph) {
-        rules.push(listWrappingRule(/^(\d+)\.\s$/, schema.nodes.ordered_list, schema.nodes.paragraph, item, (match) => ({ start: +match[1] }), (match, node) => node.childCount + node.attrs.start === +match[1]));
-    }
-    // No item guard: a quote wrapping an item's own first block is a container the
-    // content holds, where a list wrapping one is an item whose only content is an item.
-    if (schema.nodes.blockquote) {
-        rules.push(wrappingInputRule(/^\s*>\s$/, schema.nodes.blockquote));
-    }
+    // the start of an item's own first block, where the command declines.
+    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(/^\s*>\s$/, wrapInQuote));
     return rules;
 }
 /** The input-rules plugin the field mounts by default (opt-out via createField). */

package/dist/core/codec/prose.css

@@ -432,11 +432,11 @@ li.ProseMirror-selectednode::after {
    which is drawn through a drag the pointer has travelled off — answering which line.
 
    Opacity rather than absence, so every control keeps its box and is hit-tested wherever
-   it sits. A grip's reach is the pointer's — no Tab arrives at one, the cell traversal
-   claiming the key first (`table-view.ts` §`step`) — so it is out of the tab order, and
-   the focus rung there draws the focus the view takes itself. The two bars are in it, the
-   Tab that declines off the last cell landing on them, and the same rung is what draws
-   one a keyboard has reached. */
+   it sits. A grip's reach is the pointer's alone and it holds no focus, so it carries no
+   focus rung: what a keyboard draws a line with is the cell the selection runs through
+   (`table-view.ts` §`cellKeys`), and the wash and the selected grip's tint are what say
+   so. The two bars are in the tab order, the Tab that declines off the last cell landing
+   on them, so the rung there draws one a keyboard has reached. */
 :is(.qm-table-grip, .qm-table-add) {
 	opacity: 0;
 	transition: opacity var(--_qm-duration-fast) var(--_qm-ease-reverse);
@@ -447,32 +447,21 @@ li.ProseMirror-selectednode::after {
 :where(.qm-table-island:hover) :is(.qm-table-grip, .qm-table-add) {
 	opacity: var(--_qm-opacity-muted);
 }
-:is(.qm-table-grip, .qm-table-add):is(:hover, :focus-visible),
-.qm-table-grip:is([aria-pressed='true'], .qm-table-lifted) {
+.qm-table-add:is(:hover, :focus-visible),
+.qm-table-grip:is(:hover, [aria-pressed='true'], .qm-table-lifted) {
 	opacity: 1;
 }
 
-/* The ring, on the chrome and nowhere else in this file. A prose leaf's focus indicator
-   is its caret and a cell's is too, so the outline is dropped there; a control that comes
-   up out of nothing has the reveal, and a ring under a keyboard is what says the focus is
-   there rather than on the paper behind it. Declared here rather than reached for as
-   `.qm-focus-ring`: that recipe is the visual tier's stylesheet, and the island is inside
-   the leaf, which is the codec's.
-
-   A selected grip takes none. Focus and selection arrive together there — the grip takes
-   the focus because the selection's keys bind on it — and the tint plus the wash already
-   say where the next command lands. A ring on top is a second box around the loudest
-   thing on the island, drawn on the press that made the selection: a pointer gesture
-   answering with a keyboard's indicator. Stated as `none` rather than left unset, because
-   what fills the gap is the browser's own ring, which is the same box in a colour the
-   surface does not own. */
-:is(.qm-table-grip, .qm-table-add):focus-visible {
+/* The ring, on the two add bars and nowhere else in this file. A prose leaf's focus
+   indicator is its caret and a cell's is too, so the outline is dropped there; a control
+   that comes up out of nothing has the reveal, and a ring under a keyboard is what says
+   the focus is there rather than on the paper behind it. Declared here rather than
+   reached for as `.qm-focus-ring`: that recipe is the visual tier's stylesheet, and the
+   island is inside the leaf, which is the codec's. */
+.qm-table-add:focus-visible {
 	outline: var(--_qm-ring);
 	outline-offset: var(--_qm-ring-offset);
 }
-.qm-table-grip[aria-pressed='true']:focus-visible {
-	outline: none;
-}
 
 /* A drag in flight. The lifted line reads as picked up by tone, never a shadow:
    elevation is a surface rung here, which says the same thing at both poles. The drop

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

@@ -1,4 +1,12 @@
 import { Schema } from 'prosemirror-model';
+/**
+ * Whether a link carrying `href` renders as one. A value with no scheme is relative
+ * to the embedding page and has none to refuse.
+ *
+ * A refused href is unchanged: it stays on the mark and round-trips, so a document
+ * survives an editor that declines to make it clickable.
+ */
+export declare function rendersHref(href: string): boolean;
 /** The full field schema: every block kind, container, mark, and island. */
 export declare const blockSchema: Schema<string, string>;
 /** The constrained inline schema: one paragraph, no block splitting, no

package/dist/core/codec/schema.js

@@ -10,6 +10,33 @@
 // not marks here (decorations).
 import { Schema } from 'prosemirror-model';
 import { islandBlockSpec, islandInlineSpec } from './islands.js';
+// ── The href gate ───────────────────────────────────────────────────────────
+// An `href` is an attribute value and not markup, so the markdown → typed node → DOM
+// path that keeps a document's text from becoming tags never reaches it: what the
+// mark carries is what `toDOM` emits, and `renderContent` paints marks outside a
+// `contenteditable` (the tips card), where a click is a plain one.
+//
+// An allowlist, because the set a document can spell is open: naming the dangerous
+// schemes instead loses to the first one this has not heard of. It holds what the
+// surface has a caller for; a scheme reaching it later is a line.
+const RENDERED_SCHEMES = new Set(['http', 'https', 'mailto', 'tel', 'ftp']);
+/** A scheme and its colon: a letter, then letters, digits, `+`, `-` or `.` (RFC 3986). */
+const SCHEME = /^([a-z][a-z0-9+.-]*):/i;
+/** Dropped before the scheme is read, so a tab spliced into `javascript:` is tested
+ *  as what it navigates to. Wider than the URL parser's own tab/newline rule: no
+ *  scheme carries a control character, and the strip decides without rewriting. */
+const IGNORED = /[\u0000-\u0020]/g;
+/**
+ * Whether a link carrying `href` renders as one. A value with no scheme is relative
+ * to the embedding page and has none to refuse.
+ *
+ * A refused href is unchanged: it stays on the mark and round-trips, so a document
+ * survives an editor that declines to make it clickable.
+ */
+export function rendersHref(href) {
+    const scheme = SCHEME.exec(href.replace(IGNORED, ''));
+    return scheme === null || RENDERED_SCHEMES.has(scheme[1].toLowerCase());
+}
 // ── Marks (the block and inline schemas share them; plaintext declares none) ─
 const marks = {
     // Order matters: it fixes mark-set sort order and parse precedence. `link`
@@ -26,7 +53,12 @@ const marks = {
         parseDOM: [
             { tag: 'a[href]', getAttrs: (el) => ({ href: el.getAttribute('href') }) }
         ],
-        toDOM: (mark) => ['a', { href: mark.attrs.href }, 0]
+        // A refused href draws as a bare span: the text stands, unstyled and
+        // unclickable, and the mark keeps its value for encode.
+        toDOM: (mark) => {
+            const href = mark.attrs.href;
+            return rendersHref(href) ? ['a', { href }, 0] : ['span', 0];
+        }
     },
     // The open-set escape hatch: an inert mark that renders as a bare span and
     // re-emits its stored `type`/`attrs` on encode. `excludes: ''` lets marks of

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

@@ -1,4 +1,4 @@
-import { Plugin, type Command } from 'prosemirror-state';
+import { EditorState, Plugin, type Command } from 'prosemirror-state';
 import type { EditorView } from 'prosemirror-view';
 import { type RangeAnchor } from './anchor.js';
 /** The menu as the chrome sees it: the command names the query matched, the keyboard's
@@ -25,18 +25,21 @@ export interface SlashStrings {
  *  chrome's wording follows, and the visual `strings` set extends both. */
 export declare const DEFAULT_SLASH_STRINGS: SlashStrings;
 /**
- * The vocabulary, in menu order: the names `SLASH_COMMANDS` is keyed by, read off the
- * table itself so an offer and its pick cannot disagree.
+ * The vocabulary a caret can run, in menu order: the names `SLASH_COMMANDS` is keyed
+ * by, each asked whether it would fire here. A row that declines when picked is worse
+ * than an absent one, and asking the command rather than restating its guards is what
+ * keeps the menu from drifting off what the shorthand does. So the offers narrow as the
+ * caret moves: the island alone mid-paragraph, no list at an item's head.
  *
- * The set is what no shorthand reaches. A list is `- ` / `1. `, a heading `# `, a quote
- * `> `, a rule `---`, a code block a fence: a shorthand fires where the caret already
- * is, and a second door onto the same construct is a second thing to keep true. A table
- * has no prefix a rule can fire on (a pipe row is not one), so it is the menu's alone.
+ * `state` is the state a pick leaves behind — the run already consumed — since that is
+ * the caret every command answers for (`blocks.ts`).
  */
-export declare function slashItems(): string[];
-/** The query filter: a case-insensitive prefix of the name, which is how a command line
- *  completes. An empty query offers everything, and the vocabulary's order survives, so
- *  the menu never reorders under a keystroke. */
+export declare function slashItems(state: EditorState): string[];
+/** The query filter: a case-insensitive prefix of the name or of any of its words, which
+ *  is how a command line completes and how a two-word name stays reachable by the noun a
+ *  writer has — `/list` offers both lists. A prefix and not a substring: `note` is inside
+ *  `footnote` and completes nothing. An empty query offers everything, and the
+ *  vocabulary's order survives, so the menu never reorders under a keystroke. */
 export declare function filterItems(items: string[], query: string): string[];
 /** The live trigger: where the `/` sits, what has been typed after it, and which
  *  offer the keyboard is on. */
@@ -67,11 +70,10 @@ export declare function slashKeymap(): Record<string, Command>;
  *  highlight has one lane rather than a hover painting a second one. */
 export declare function focusSlashItem(view: EditorView, name: string): void;
 /**
- * Run a command: one transaction that deletes the trigger run and applies the
- * command's own edit. One rather than two because two would be two commits, two undo
- * steps and two recompiles for one gesture; the command is built against the
- * post-delete state and its steps are replayed onto the same transaction, which is
- * exactly what they were computed for.
+ * Run a command: one transaction that deletes the trigger run and applies the command's
+ * own edit (`blocks.ts` §`consuming`). A command that declines consumes nothing. The
+ * menu never picks one, offering only what would run; `slashPick` is a public seam and
+ * can.
  */
 export declare function runSlashItem(view: EditorView, name: string): void;
 export {};