@quillmark/svelte 0.5.1 → 0.7.0

package/README.md

@@ -60,6 +60,12 @@ const session = await new Engine().open(quill, doc);
 
 Opening a document that names a **different** quill is the same sequence, in order: resolve the new ref, `engine.open(quill, next)`, swap the props, then free the replaced handles that were yours to free. `<VisualEditor>` re-keys itself on the new `doc` (see below); `<Preview>` swaps by remount (`{#key session}`).
 
+## What a document is trusted to be
+
+**A `Document` may be one its reader did not write** — an import, a shared file, a row from a multi-tenant store — and two properties hold over one regardless. Markdown becomes typed nodes and then DOM, never a markup string: this package has no `{@html}`, no `innerHTML` and no `eval`, so a document's text cannot become tags. And a link renders as one only for `http`, `https`, `mailto`, `tel`, `ftp`, or a value naming no scheme at all; every other scheme draws as an inert span, on the editable surface and in the tips card that paints `$ext.editor.tips` outside any `contenteditable`. That gate is the render's rather than the model's, so a refused href stays on the mark and round-trips: opening a document never edits it.
+
+What stays yours is the text edge and the ref. The markdown is the host's at both ends, and `doc.quillRef` is the **document's** own — a stored file names the quill that opens it, so the ref → `Quill` mapping above is what bounds which templates it can reach.
+
 ## Preview
 
 `createPreview` supplies the layer the session omits: viewport, DOM, DPR, click mapping. It is a pure view: it never calls `session.apply`; you drive the edit and hand it the resulting `ChangeSet`.

package/THEMING.md

@@ -24,7 +24,7 @@ Nothing to import and nothing to set. The package pulls its own stylesheet, and
 
 **Placing and sizing**: each surface carries a stable root class (`.qm-editor`, `.qm-preview`), so you can place it from your own stylesheet without a wrapper. Each also takes a `class` prop that merges onto the same element, which is the better handle when you have one to give.
 
-**Taking the column back**: your CSS is unlayered and ours is not (below), so `padding: 0` or a `background` of your own on `.qm-editor` wins outright. Nothing is locked.
+**Taking the column back**: our selectors compute at specificity zero (below), so `padding: 0` or a `background` of your own on `.qm-editor` wins outright. Nothing is locked.
 
 ## Make it yours
 
@@ -43,7 +43,7 @@ The whole contract is **nine CSS custom properties**. They are dials, not a pale
 
 `--qm-bg` and `--qm-fg` are the two a themed host sets before any brand decision. Their defaults are a self-consistent neutral for a bare mounting site, not a guess at your page.
 
-`--qm-bg` is the **card**, not the column behind it: the plane a document is written on, which is also the sheet the preview paints. Everything else is a step off it, and the column the cards sit in is a step down, so a mounted editor draws its own ground and the cards read as islands on it. Give it the tone you want a card to be — white, in most light themes — and let the column fall out. If you want the column to meet your page instead, set a `background` of your own on `.qm-editor`; your CSS is unlayered and wins.
+`--qm-bg` is the **card**, not the column behind it: the plane a document is written on, which is also the sheet the preview paints. Everything else is a step off it, and the column the cards sit in is a step down, so a mounted editor draws its own ground and the cards read as islands on it. Give it the tone you want a card to be — white, in most light themes — and let the column fall out. If you want the column to meet your page instead, set a `background` of your own on `.qm-editor`; any rule of yours wins.
 
 The poles take a colour, not `transparent` or `inherit`: the raised surfaces, the borders and the muted inks are each a `color-mix` against `--qm-bg`, so a transparent pole makes every one of them translucent instead of letting your page through. Hand over the value your page is painted with and the derivation steps off it.
 
@@ -65,15 +65,12 @@ Give a length dial a length: `--qm-space: 4` is a valid custom property and an i
 
 ### Your CSS beats ours
 
-The surfaces' own rules live in the `qm` cascade layer, so **unlayered CSS of yours beats them outright**, at any specificity and without `!important`. Nothing to declare; this is the case most apps are in.
+The rules behind every class the surfaces promise you — `.qm-editor`, `.qm-preview`, `.qm-pane` — are wrapped in `:where()` and sit in no cascade layer, as are the derivation and the shared control recipes under them. So **each computes at specificity zero**, and two things follow:
 
-If your app uses cascade layers of its own, layer order decides it, and layer order is first-declaration order across the document — which makes it the bundler's, not yours. Name our layer first in one statement of your own, anywhere in your CSS, and it stops mattering:
+- **Any rule of yours wins**, at any specificity and without `!important`. A bare `.qm-editor { … }` does it; so does a bare `input`.
+- **No layer of yours can reach them**, because unlayered rules outrank every layer. A reset in a layer — Tailwind v4's preflight in `@layer base` is the common one — cannot strip the controls however your bundler orders the sheets. There is no layer statement to write and no sheet order to get right.
 
-```css
-@layer qm, app;
-```
-
-Declared before our sheet it fixes the order outright; declared after, `qm` is already first and `app` appends behind it. Either way your layer lands after ours and wins. `qm` is the contract; the sub-layers under it (`qm.scale`, `qm.chrome`) are ours to re-cut.
+One thing still outranks us: an **unlayered** blanket reset of your own (`* { padding: 0 }` in no layer) ties at specificity zero and wins on source order. Put it in a layer, where Tailwind, Bootstrap and Open Props already put theirs, and it stops reaching us.
 
 ### The surface follows your colour scheme
 
@@ -176,22 +173,21 @@ 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 repaints itself when it comes back. 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 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 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.
 
-It is **unlayered**, so your own rules beat it by ordinary precedence, exactly as they beat the surfaces. It is also opt-in and side-effect free until imported: nothing that styles your document arrives with a component.
+It is **unlayered** and at ordinary specificity, so your own rules beat it by ordinary precedence. It is also opt-in and side-effect free until imported: nothing that styles your document arrives with a component.
 
-One rule in it earns its place regardless of whether you take the rest, and you want it if you draw a focus ring of your own:
+One rule in it earns its place regardless of whether you take the rest, and you want it if you draw a focus ring of your own — cut the mounted surfaces out of the blanket:
 
 ```css
-[data-qm-root] :focus-visible {
-	outline: revert-layer;
-	outline-offset: revert-layer;
+:focus-visible:not(:where([data-qm-root], [data-qm-root] *)) {
+	outline: 2px solid; /* your ring, on your page */
 }
 ```
 
-A blanket `:focus-visible` of yours is unlayered, so it beats `@layer qm.chrome`, including on the controls that already draw a ring. `revert-layer` hands those back to ours and leaves yours everywhere else.
+A blanket `:focus-visible` of yours outranks ours, including on the controls that already draw one, so a ring written for the controls that draw none repaints the ones that do. The cut-out leaves yours everywhere else, and `:not(:where(…))` contributes no specificity, so your rule ranks exactly as it would without it.
 
 ## What is deliberately not public
 
@@ -201,4 +197,4 @@ The derived surface scale (surface / border / ink rungs, the blur radius, the po
 
 ## Requirements
 
-`@layer`, `color-mix()`, `light-dark()` and relative colour syntax (`oklab(from …)`): Baseline since 2022, 2023, 2024 and 2024 respectively — the last is what lets a plane step by the card's own lightness. `@property` is the one feature the surface does not require: where it is missing, an invalid length dial collapses the surface rather than falling back.
+`:where()`, `color-mix()`, `light-dark()` and relative colour syntax (`oklab(from …)`): Baseline since 2021, 2023, 2024 and 2024 respectively — the last is what lets a plane step by the card's own lightness. `@property` is the one feature the surface does not require: where it is missing, an invalid length dial collapses the surface rather than falling back.

package/dist/core/address.d.ts

@@ -63,14 +63,28 @@ export declare function cardPath(index: number, kinds: readonly string[]): DocPa
 /**
  * The inverse: a canonical `DocPath` back to the `Addr` the document verbs take, or
  * `undefined` for a path that names no single commit address — a nested or
- * array-element path (`main.keywords[0]`, which {@link elementAddrForFieldPath}
- * takes instead), a field-rooted one, or a malformed one. A bare card and a `.body`
- * terminal both land on the field-less `{card: i}` the body leaf answers to.
+ * array-element path (`main.keywords[0]`, which {@link elementAddrForFieldPath} and
+ * {@link nearestAddrForFieldPath} take instead), a field-rooted one, or a malformed
+ * one. A bare card and a `.body` terminal both land on the field-less `{card: i}`
+ * the body leaf answers to.
  *
  * Needs no `kinds`: the path carries the absolute index, and the kind in it is
  * decoration the `Addr` has no room for.
  */
 export declare function addrForFieldPath(path: DocPath): Addr | undefined;
+/**
+ * The nearest ancestor a commit address can name: {@link addrForFieldPath} where the
+ * path has one, else the root and its first field. `main.contact.email` and
+ * `main.keywords[0]` land on their field, any deeper nesting on the top-level field
+ * it hangs off. `undefined` where those two segments name nothing — a field-rooted
+ * (config-space) or malformed path.
+ *
+ * An `Addr` reaches a root and one field, so two segments is the whole search: a
+ * deeper prefix is unaddressable by arity alone. Addressability being `Addr`'s reach
+ * rather than the grammar's is what makes the truncation a consumer's to make
+ * (VISUAL_EDITOR §Diagnostics).
+ */
+export declare function nearestAddrForFieldPath(path: DocPath): Addr | undefined;
 /**
  * An array element's address, split: `main.keywords[0]` lands here, and anything
  * {@link addrForFieldPath} can name — or whose trailing segment is not an index —

package/dist/core/address.js

@@ -37,9 +37,10 @@ export function cardPath(index, kinds) {
 /**
  * The inverse: a canonical `DocPath` back to the `Addr` the document verbs take, or
  * `undefined` for a path that names no single commit address — a nested or
- * array-element path (`main.keywords[0]`, which {@link elementAddrForFieldPath}
- * takes instead), a field-rooted one, or a malformed one. A bare card and a `.body`
- * terminal both land on the field-less `{card: i}` the body leaf answers to.
+ * array-element path (`main.keywords[0]`, which {@link elementAddrForFieldPath} and
+ * {@link nearestAddrForFieldPath} take instead), a field-rooted one, or a malformed
+ * one. A bare card and a `.body` terminal both land on the field-less `{card: i}`
+ * the body leaf answers to.
  *
  * Needs no `kinds`: the path carries the absolute index, and the kind in it is
  * decoration the `Addr` has no room for.
@@ -48,6 +49,22 @@ export function addrForFieldPath(path) {
     const segs = segsOf(path);
     return segs && addrForSegs(segs);
 }
+/**
+ * The nearest ancestor a commit address can name: {@link addrForFieldPath} where the
+ * path has one, else the root and its first field. `main.contact.email` and
+ * `main.keywords[0]` land on their field, any deeper nesting on the top-level field
+ * it hangs off. `undefined` where those two segments name nothing — a field-rooted
+ * (config-space) or malformed path.
+ *
+ * An `Addr` reaches a root and one field, so two segments is the whole search: a
+ * deeper prefix is unaddressable by arity alone. Addressability being `Addr`'s reach
+ * rather than the grammar's is what makes the truncation a consumer's to make
+ * (VISUAL_EDITOR §Diagnostics).
+ */
+export function nearestAddrForFieldPath(path) {
+    const segs = segsOf(path);
+    return segs && addrForSegs(segs.slice(0, 2));
+}
 /**
  * An array element's address, split: `main.keywords[0]` lands here, and anything
  * {@link addrForFieldPath} can name — or whose trailing segment is not an index —

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

@@ -0,0 +1,37 @@
+import type { Attrs, Node as PMNode } 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`. */
+export declare function toHeading(level: number): Command;
+/** A fence. The exit paragraph after it is the one a block island mints for the same
+ *  reason, sharpened: a code block is the one block a gap cursor will not sit beside
+ *  either, so a fence at the end of a body leaves the caret nowhere to go. The caret
+ *  stays in the fence, not in the exit it minted. */
+export declare function toCodeBlock(): Command;
+/** `---`. A divider is a whole block, so this replaces its textblock rather than
+ *  retyping one: `horizontal_rule` holds no content to retype into, and an empty block
+ *  is the whole of what it may replace — anything else in one is a paragraph being
+ *  edited, which a replace would eat. */
+export declare function insertDivider(): Command;
+/** `> `. No item guard: what this wraps an item's first block in is a container the
+ *  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. A pick passes none and continues whatever list is
+ *  above it. */
+export declare function wrapInList(ordered: boolean, attrs?: Attrs | null, joinBefore?: (node: PMNode) => boolean): 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
+ * commits, two undo steps and two recompiles for one gesture; the command is built
+ * against the state the delete leaves, which is exactly what its steps were computed
+ * for.
+ *
+ * `null` is a command that declined, and nothing is consumed: the shorthand stays the
+ * text it was typed as.
+ */
+export declare function consuming(state: EditorState, from: number, to: number, command: Command): {
+    tr: Transaction;
+    produced: Transaction;
+} | null;

package/dist/core/codec/blocks.js

@@ -0,0 +1,163 @@
+import { Selection } from 'prosemirror-state';
+import { canJoin, findWrapping } from 'prosemirror-transform';
+/** The head of a textblock: where a shorthand fires, and where a pick lands once its
+ *  run is consumed. */
+function atHead(state) {
+    const { $from, empty } = state.selection;
+    return empty && $from.parent.isTextblock && $from.parentOffset === 0;
+}
+/** Whether the caret's parent holds `type` in its block's place. `setBlockType` and
+ *  `replaceWith` both mint the shape without asking. */
+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
+ * later block of the item is not this case: wrapping a continuation paragraph is how a
+ * sub-list opens under text.
+ */
+function openingAnItem($from, item) {
+    if (!item || $from.depth < 2)
+        return false;
+    return $from.node(-1).type === item && $from.index(-1) === 0;
+}
+function retype(name, attrs) {
+    return (state, dispatch) => {
+        const type = state.schema.nodes[name];
+        const { $from } = state.selection;
+        if (!type || !atHead(state) || !fits($from, type))
+            return false;
+        dispatch?.(state.tr.setBlockType($from.pos, $from.pos, type, attrs));
+        return true;
+    };
+}
+/** `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). */
+function wrapAt(tr, pos, type, attrs, joinBefore) {
+    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);
+    }
+    return true;
+}
+/** `# `: the heading `level` deep. `list_item` is `block+`, so one inside an item is a
+ *  shape the content holds and `importMarkdown` produces from `- # title`. */
+export function toHeading(level) {
+    return retype('heading', { level });
+}
+/** A fence. The exit paragraph after it is the one a block island mints for the same
+ *  reason, sharpened: a code block is the one block a gap cursor will not sit beside
+ *  either, so a fence at the end of a body leaves the caret nowhere to go. The caret
+ *  stays in the fence, not in the exit it minted. */
+export function toCodeBlock() {
+    return (state, dispatch) => {
+        const { code_block: code, paragraph } = state.schema.nodes;
+        const { $from } = state.selection;
+        if (!code || !paragraph || !atHead(state) || !fits($from, code))
+            return false;
+        const tr = state.tr.setBlockType($from.pos, $from.pos, code);
+        const at = tr.doc.resolve($from.pos).after();
+        if (!tr.doc.nodeAt(at))
+            tr.insert(at, paragraph.create());
+        dispatch?.(tr);
+        return true;
+    };
+}
+/** `---`. A divider is a whole block, so this replaces its textblock rather than
+ *  retyping one: `horizontal_rule` holds no content to retype into, and an empty block
+ *  is the whole of what it may replace — anything else in one is a paragraph being
+ *  edited, which a replace would eat. */
+export function insertDivider() {
+    return (state, dispatch) => {
+        const { horizontal_rule: rule, paragraph } = state.schema.nodes;
+        const { $from } = state.selection;
+        if (!rule || !paragraph || !atHead(state) || !fits($from, rule))
+            return false;
+        if ($from.parent.content.size !== 0)
+            return false;
+        const from = $from.before();
+        const tr = state.tr.replaceWith(from, $from.after(), rule.create());
+        const at = from + 1;
+        if (!tr.doc.nodeAt(at))
+            tr.insert(at, paragraph.create());
+        tr.setSelection(Selection.near(tr.doc.resolve(at), 1));
+        dispatch?.(tr);
+        return true;
+    };
+}
+/** `> `. No item guard: what this wraps an item's first block in is a container the
+ *  content holds, where a list wrapping one mints an item whose only content is an
+ *  item. */
+export function wrapInQuote() {
+    return (state, dispatch) => {
+        const quote = state.schema.nodes.blockquote;
+        const { $from } = state.selection;
+        if (!quote || !atHead(state))
+            return false;
+        const tr = state.tr;
+        if (!wrapAt(tr, $from.pos, quote, null))
+            return false;
+        dispatch?.(tr);
+        return true;
+    };
+}
+/** `- ` / `1. `. `joinBefore` is the shorthand's ordinal test: `2. ` continues the list
+ *  above where `7. ` opens one. A pick passes none and continues whatever list is
+ *  above it. */
+export function wrapInList(ordered, attrs = null, joinBefore) {
+    return (state, dispatch) => {
+        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 || !atHead(state) || openingAnItem($from, item))
+            return false;
+        const pos = $from.pos;
+        const tr = state.tr;
+        // A paragraph item wherever this fires: `# ` inside the item is the gesture that
+        // mints `list_item > heading`, and a wrap keeping the heading is a second door onto
+        // 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))
+            return false;
+        dispatch?.(tr);
+        return true;
+    };
+}
+/**
+ * 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
+ * commits, two undo steps and two recompiles for one gesture; the command is built
+ * against the state the delete leaves, which is exactly what its steps were computed
+ * for.
+ *
+ * `null` is a command that declined, and nothing is consumed: the shorthand stays the
+ * text it was typed as.
+ */
+export function consuming(state, from, to, command) {
+    const tr = state.tr.delete(from, to);
+    let produced;
+    command(state.apply(tr), (t) => {
+        produced = t;
+    });
+    if (!produced)
+        return null;
+    for (const step of produced.steps)
+        tr.step(step);
+    tr.setSelection(Selection.fromJSON(tr.doc, produced.selection.toJSON()));
+    return { tr, produced };
+}

package/dist/core/codec/field.js

@@ -19,7 +19,6 @@ import { keymap } from 'prosemirror-keymap';
 import { EditorState, NodeSelection, Plugin, PluginKey, Selection, TextSelection } from 'prosemirror-state';
 import { Decoration, DecorationSet, EditorView } from 'prosemirror-view';
 import { reportError, errorMessage } from '../errors.js';
-import { tableClipboardPlugin } from './clipboard.js';
 import { decode } from './decode.js';
 import { usvToPM, pmToUsv, buildLineIndex } from './positions.js';
 import { lower, pmToContent, contentEdit } from './encode.js';
@@ -162,7 +161,8 @@ export function createField(opts) {
                     // A focus event does not bubble, so the leaf's own `focus` handler
                     // never fires for a cell: without this the active address would not
                     // follow a caret clicked straight into a table.
-                    onCellFocus: () => opts.onFocus?.(addr)
+                    onCellFocus: () => opts.onFocus?.(addr),
+                    clearance
                 })
             },
         dispatchTransaction: (tr) => {
@@ -407,11 +407,10 @@ export function proseLeafPlugins(schema, opts) {
         list.push(inputRulesPlugin(schema));
     list.push(keymap(editorKeymap(schema, opts.inline, !!opts.slash)));
     list.push(keymap(baseKeymap));
-    // All three answer to something only a block leaf holds: an inline leaf is one
-    // textblock with no island, no gap to put a cursor in, and nowhere for a pasted
-    // table to land.
+    // Both answer to something only a block leaf holds: an inline leaf is one textblock
+    // with no island and no gap to put a cursor in.
     if (!opts.inline)
-        list.push(gapCursor(), pastAtomPlugin(), tableClipboardPlugin(schema));
+        list.push(gapCursor(), pastAtomPlugin());
     if (opts.placeholder)
         list.push(placeholderPlugin(opts.placeholder));
     return list;

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

@@ -9,7 +9,7 @@ export { DEFAULT_TABLE_STRINGS } from './table-view.js';
 export type { TableChromeStrings } from './table-view.js';
 export { DEFAULT_SLASH_STRINGS } from './slash.js';
 export type { SlashState, SlashStrings } from './slash.js';
-export { blockSchema, inlineSchema, plaintextSchema, hasMarks } from './schema.js';
+export { blockSchema, inlineSchema, plaintextSchema, hasMarks, rendersHref } from './schema.js';
 export { decode, renderContent, usvLength } from './decode.js';
 export { pmToContent, contentEdit, lower } from './encode.js';
 export type { ContentEdit } from './encode.js';

package/dist/core/codec/index.js

@@ -21,8 +21,9 @@ export { DEFAULT_TABLE_STRINGS } from './table-view.js';
 // the pixels (`visual/SlashMenu.svelte` is the only off-barrel caller).
 export { DEFAULT_SLASH_STRINGS } from './slash.js';
 // Schemas (the decode/encode target; the VisualEditor mounts them). `hasMarks` is
-// what a mark surface asks before offering itself over a leaf.
-export { blockSchema, inlineSchema, plaintextSchema, hasMarks } from './schema.js';
+// what a mark surface asks before offering itself over a leaf, and `rendersHref` the
+// link gate the prompt re-asks on submit (`visual/links.ts`).
+export { blockSchema, inlineSchema, plaintextSchema, hasMarks, rendersHref } from './schema.js';
 // Decode / encode / positions (tests + VisualEditor).
 //
 // The barrel carries what has an off-barrel caller, and nothing else. A symbol

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). */