@quillmark/svelte 0.2.0 → 0.3.0

package/dist/core/codec/inputrules.js

@@ -1,10 +1,11 @@
 // 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); block
-// rules reuse `wrappingInputRule` / `textblockTypeInputRule`. These produce
-// transactions the codec already lowers: they add no new lowering surface.
-import { InputRule, inputRules, textblockTypeInputRule, wrappingInputRule } from 'prosemirror-inputrules';
+// 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.
+import { InputRule, inputRules, wrappingInputRule } from 'prosemirror-inputrules';
 import { canJoin, findWrapping } from 'prosemirror-transform';
 import { Selection } from 'prosemirror-state';
 /**
@@ -12,8 +13,8 @@ import { Selection } from 'prosemirror-state';
  * before the caret, wrap capture group 1 in `markType` and drop the delimiters.
  * `delimLen` is the delimiter length (opening == closing for every rule here).
  * `match[0]` anatomy is `prefix? open captured close`: the em rule's
- * `(?:^|[^*])` guard consumes ONE non-delimiter prefix char into the match, so
- * positions are derived from the KNOWN delimiter/capture lengths, never from
+ * `(?:^|[^*])` guard consumes one non-delimiter prefix char into the match, so
+ * positions are derived from the known delimiter/capture lengths, never from
  * `indexOf` (which both deletes that prefix char and mis-anchors when it
  * happens to equal the captured text). `[start, end)` spans `match[0]` minus
  * the just-typed text (not yet inserted when the rule fires), so the trailing
@@ -48,9 +49,14 @@ function markInputRule(regexp, markType, delimLen) {
  * body paragraphs (`usaf_memo`'s `render-body`), where a heading resolves to
  * nothing. This is the wrap-side route into that shape; the `# ` rule guards the
  * other, in {@link markdownInputRules}.
+ *
+ * `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, getAttrs, joinPredicate) {
+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.
@@ -75,10 +81,28 @@ function listWrappingRule(regexp, listType, paragraph, getAttrs, joinPredicate)
         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;
+}
 /** 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.
     if (m.strong)
         rules.push(markInputRule(/\*\*([^*]+)\*\*$/, m.strong, 2));
@@ -95,7 +119,6 @@ export function markdownInputRules(schema) {
         // declines (null) and stays literal text, rather than minting the unrenderable
         // `list_item > heading` {@link listWrappingRule} normalizes away on the wrap side.
         const heading = schema.nodes.heading;
-        const item = schema.nodes.list_item;
         rules.push(new InputRule(/^(#{1,6})\s$/, (state, match, start, end) => {
             const $start = state.doc.resolve(start);
             for (let d = $start.depth; d > 0; d--) {
@@ -110,18 +133,34 @@ export function markdownInputRules(schema) {
                 .setBlockType(start, start, heading, { level: match[1].length });
         }));
     }
-    if (schema.nodes.code_block) {
-        rules.push(textblockTypeInputRule(/^```$/, schema.nodes.code_block));
+    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
+        // 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;
-        const item = schema.nodes.list_item;
         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 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) {
@@ -148,14 +187,13 @@ export function markdownInputRules(schema) {
             return tr;
         }));
     }
-    // `- ` / `1. ` at the start of a block, here or nested inside an item. These are
-    // the one pair of shorthands the slash menu ALSO carries: a list opens an item the
-    // caret then lives in, which is what that menu is the set of (`slash.ts`).
+    // `- ` / `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));
+        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, (match) => ({ start: +match[1] }), (match, node) => node.childCount + node.attrs.start === +match[1]));
+        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]));
     }
     if (schema.nodes.blockquote) {
         rules.push(wrappingInputRule(/^\s*>\s$/, schema.nodes.blockquote));

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

@@ -23,14 +23,18 @@ export declare function islandEntryFromNode(attrs: IslandNodeAttrs): ContentIsla
  *  rather than at each reader. */
 export declare function tablePropsOfNode(node: PMNode): TableProps | undefined;
 /**
- * The next island id for a field: the positional `isl-{n}` sequence continued past
- * the highest one the field already holds. A minted id is this tier's to produce
- * and it is part of the document's canonical bytes (CODEC §Islands), so it is a
- * counter over the projection in hand — never a UUID, never a clock reading, and
- * never a re-numbering of the ids already there, which are identities.
+ * A minter over one document: the positional `isl-{n}` sequence continued past the
+ * highest id the field already holds, handing out consecutive ids, so a caller placing
+ * several islands at once keeps one minter for the lot. A minted id is this tier's to
+ * produce and it is part of the document's canonical bytes (CODEC §Islands), so it is a
+ * counter over the projection in hand — never a UUID, never a clock reading, and never a
+ * re-numbering of the ids already there, which are identities.
  *
- * Reads the PM doc rather than the stored content because that is what the caller
- * (an insert command) holds and what the commit will project: an id minted against
+ * Reads the PM doc rather than the stored content because that is what the caller (an
+ * insert command, a paste) holds and what the commit will project: an id minted against
  * a stale content could collide with one the same transaction places.
  */
+export declare function islandMinter(doc: PMNode): () => string;
+/** The next island id for a field: one draw from {@link islandMinter}, which is what a
+ *  command placing exactly one island wants. */
 export declare function mintIslandId(doc: PMNode): string;

package/dist/core/codec/islands.js

@@ -4,7 +4,7 @@ export const ISLAND_SLOT = '';
 // The four island node attributes carry the content entry verbatim: `id` is the
 // stable identity (rebases like an anchor), `islandType` the discriminator, `props`
 // the opaque payload the codec preserves byte-for-byte across a round-trip, and
-// `loss` how faithfully markdown can carry it. `loss` is AUTHORED, not derived:
+// `loss` how faithfully markdown can carry it. `loss` is authored, not derived:
 // `applyChange` stores the class an island op gives it and re-derives nothing, so
 // an entry that did not carry its own would promote a degraded table to lossless
 // on the first cell edit. The default is the class an unknown one reads as, so a
@@ -58,17 +58,18 @@ export function tablePropsOfNode(node) {
     return isTableIsland(entry) ? entry.props : undefined;
 }
 /**
- * The next island id for a field: the positional `isl-{n}` sequence continued past
- * the highest one the field already holds. A minted id is this tier's to produce
- * and it is part of the document's canonical bytes (CODEC §Islands), so it is a
- * counter over the projection in hand — never a UUID, never a clock reading, and
- * never a re-numbering of the ids already there, which are identities.
+ * A minter over one document: the positional `isl-{n}` sequence continued past the
+ * highest id the field already holds, handing out consecutive ids, so a caller placing
+ * several islands at once keeps one minter for the lot. A minted id is this tier's to
+ * produce and it is part of the document's canonical bytes (CODEC §Islands), so it is a
+ * counter over the projection in hand — never a UUID, never a clock reading, and never a
+ * re-numbering of the ids already there, which are identities.
  *
- * Reads the PM doc rather than the stored content because that is what the caller
- * (an insert command) holds and what the commit will project: an id minted against
+ * Reads the PM doc rather than the stored content because that is what the caller (an
+ * insert command, a paste) holds and what the commit will project: an id minted against
  * a stale content could collide with one the same transaction places.
  */
-export function mintIslandId(doc) {
+export function islandMinter(doc) {
     let next = 0;
     doc.descendants((node) => {
         if (node.type.name !== 'island_block' && node.type.name !== 'island_inline')
@@ -78,5 +79,10 @@ export function mintIslandId(doc) {
             next = Math.max(next, Number(m[1]) + 1);
         return false;
     });
-    return `isl-${next}`;
+    return () => `isl-${next++}`;
+}
+/** The next island id for a field: one draw from {@link islandMinter}, which is what a
+ *  command placing exactly one island wants. */
+export function mintIslandId(doc) {
+    return islandMinter(doc)();
 }

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

@@ -1,13 +1,12 @@
 import type { Schema } from 'prosemirror-model';
 import type { Command } from 'prosemirror-state';
-import { type SlashItem } from './slash.js';
 /** The block-schema body's structural keys: `{}` for the inline/plaintext schemas,
- * whose leaves declare neither lists nor code blocks. The argument list IS the
+ * whose leaves declare neither lists nor code blocks. The argument list is the
  * precedence order VISUAL_EDITOR §Chrome states, so a new link is one more argument
  * at its place in that order rather than a nesting to read inside out.
  *
  * The slash menu is innermost of the three, and it is conditional rather than
- * schema-gated: the keys exist only where a menu can be DRAWN (`slashItems` present),
- * because Enter and Escape claimed by a surface nobody can see is a body that
- * swallows two keys for no visible reason. */
-export declare function bodyKeymap(schema: Schema, slashItems?: () => SlashItem[]): Record<string, Command>;
+ * schema-gated: the keys exist only where a menu can be drawn (`slash`), because Enter
+ * and Escape claimed by a surface nobody can see is a body that swallows two keys for
+ * no visible reason. */
+export declare function bodyKeymap(schema: Schema, slash?: boolean): Record<string, Command>;

package/dist/core/codec/keymap.js

@@ -1,4 +1,5 @@
 import { chainCommands } from 'prosemirror-commands';
+import { atomKeymap } from './atoms.js';
 import { codeKeymap } from './code.js';
 import { listKeymap } from './lists.js';
 import { slashKeymap } from './slash.js';
@@ -15,15 +16,15 @@ function chainKeymaps(...maps) {
     return out;
 }
 /** The block-schema body's structural keys: `{}` for the inline/plaintext schemas,
- * whose leaves declare neither lists nor code blocks. The argument list IS the
+ * whose leaves declare neither lists nor code blocks. The argument list is the
  * precedence order VISUAL_EDITOR §Chrome states, so a new link is one more argument
  * at its place in that order rather than a nesting to read inside out.
  *
  * The slash menu is innermost of the three, and it is conditional rather than
- * schema-gated: the keys exist only where a menu can be DRAWN (`slashItems` present),
- * because Enter and Escape claimed by a surface nobody can see is a body that
- * swallows two keys for no visible reason. */
-export function bodyKeymap(schema, slashItems) {
-    const links = slashItems ? [slashKeymap(slashItems)] : [];
-    return chainKeymaps(...links, codeKeymap(schema), listKeymap(schema));
+ * schema-gated: the keys exist only where a menu can be drawn (`slash`), because Enter
+ * and Escape claimed by a surface nobody can see is a body that swallows two keys for
+ * no visible reason. */
+export function bodyKeymap(schema, slash) {
+    const links = slash ? [slashKeymap()] : [];
+    return chainKeymaps(...links, codeKeymap(schema), listKeymap(schema), atomKeymap(schema));
 }

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

@@ -8,14 +8,14 @@ import type { Command } from 'prosemirror-state';
  * Tab more locally under the same rule (`prose/canon/VISUAL_EDITOR.md` §Chrome)
  * prepend a link ahead of these in `keymap.ts`: a `code_block` takes literal
  * indentation (`code.ts`), an island takes cell traversal once added. Outside all
- * of them every link returns false and the key is NOT swallowed: Tab keeps its
+ * of them every link returns false and the key is not swallowed: Tab keeps its
  * default meaning, which is the body's only keyboard exit and the open seam for a
  * shell structural keymap (VISUAL_EDITOR §Settled and open).
  *
- * `Enter` is a chain in precedence order: the paragraph-above gesture, then
+ * `Enter` is a chain in precedence order: the escape-above gesture, then
  * `splitListItem`, then `liftListItem`. The middle link carries two behaviors of
  * its own: it splits a non-empty item, and on an empty item it either splits the
- * WRAPPING item (a nested empty item, so Enter lifts exactly one level) or bails
+ * wrapping item (a nested empty item, so Enter lifts exactly one level) or bails
  * so the third link lifts a top-level empty item out to a paragraph. `Backspace`
  * forks on the item's index: the first item lifts, any later one merges.
  */

package/dist/core/codec/lists.js

@@ -1,7 +1,7 @@
 import { liftListItem, sinkListItem, splitListItem } from 'prosemirror-schema-list';
 import { chainCommands, joinTextblockBackward } from 'prosemirror-commands';
 /** The caret's enclosing `list_item` when it sits at the very start of that item's
- * FIRST block: the position both structural keys branch on. `null` otherwise
+ * first block: the position both structural keys branch on. `null` otherwise
  * (mid-text, a non-first block of a multi-paragraph item, a non-empty selection),
  * which is where the key keeps its ordinary meaning. */
 function atItemStart(state, itemType) {
@@ -21,13 +21,30 @@ function atItemStart(state, itemType) {
     };
 }
 /**
- * Enter at the very start of a top-level list's first item → an empty paragraph
- * above the list, caret staying with the text it pushed down.
+ * Whether a caret already fits immediately above the list at `pos`. The node ending
+ * there answers for its last child, so a quote counts through its final paragraph;
+ * an atom (an island, a rule) does not, and neither does a list opening its parent.
+ * Those are the shapes `prosemirror-gapcursor` declines too, its `closedBefore`
+ * asking this question from the other side.
+ */
+function writableAbove(doc, pos) {
+    let before = doc.resolve(pos).nodeBefore;
+    while (before && !before.isTextblock && !before.isAtom)
+        before = before.lastChild;
+    return !!before?.isTextblock;
+}
+/**
+ * Enter at the very start of a top-level list's first item, where nothing above the
+ * list takes a caret → an empty paragraph above it, caret staying with the text it
+ * pushed down. A list that opens a document, or one under an island or a rule, has
+ * nowhere above to write and nothing else that opens one. Where a caret already
+ * fits above, the key is the conventional split instead, at every item alike: an
+ * escape a writer reaches by pressing Up needs no key of its own.
  *
- * Only where the list itself is not inside an item: in a NESTED list this pushes
- * an empty paragraph into the parent item (`list_item` is `block+`, so the shape
- * is representable and wrong), where the conventional split (an empty item above)
- * is what the next link does. An empty first item falls through to that same
+ * Also only where the list itself is not inside an item: in a nested list this
+ * pushes an empty paragraph into the parent item (`list_item` is `block+`, so the
+ * shape is representable and wrong), where the conventional split (an empty item
+ * above) is what the next link does. An empty first item falls through to that same
  * link, which exits the list instead.
  */
 function paragraphAboveList(itemType, paragraph) {
@@ -37,13 +54,15 @@ function paragraphAboveList(itemType, paragraph) {
             return false;
         if (state.selection.$from.parent.content.size === 0)
             return false;
+        if (writableAbove(state.doc, at.listPos))
+            return false;
         if (dispatch)
             dispatch(state.tr.insert(at.listPos, paragraph.create()).scrollIntoView());
         return true;
     };
 }
 /**
- * Backspace at the start of a list's FIRST item → lift it: one level out for a
+ * Backspace at the start of a list's first item → lift it: one level out for a
  * nested item, out of the list entirely (to a paragraph) at the top.
  */
 function liftAtListStart(itemType) {
@@ -55,10 +74,10 @@ function liftAtListStart(itemType) {
     };
 }
 /**
- * Backspace at the start of any LATER item → join its text into the previous
+ * Backspace at the start of any later item → join its text into the previous
  * item's last block, so the two items become one line.
  *
- * Not the base keymap's `joinBackward`, which merges the BLOCK and leaves
+ * Not the base keymap's `joinBackward`, which merges the block and leaves
  * `list_item(paragraph, paragraph)`: the item's marker gone while its text stays
  * on its own line, which the reference quill typesets as an unnumbered
  * continuation paragraph.
@@ -79,14 +98,14 @@ function mergeIntoPreviousItem(itemType) {
  * Tab more locally under the same rule (`prose/canon/VISUAL_EDITOR.md` §Chrome)
  * prepend a link ahead of these in `keymap.ts`: a `code_block` takes literal
  * indentation (`code.ts`), an island takes cell traversal once added. Outside all
- * of them every link returns false and the key is NOT swallowed: Tab keeps its
+ * of them every link returns false and the key is not swallowed: Tab keeps its
  * default meaning, which is the body's only keyboard exit and the open seam for a
  * shell structural keymap (VISUAL_EDITOR §Settled and open).
  *
- * `Enter` is a chain in precedence order: the paragraph-above gesture, then
+ * `Enter` is a chain in precedence order: the escape-above gesture, then
  * `splitListItem`, then `liftListItem`. The middle link carries two behaviors of
  * its own: it splits a non-empty item, and on an empty item it either splits the
- * WRAPPING item (a nested empty item, so Enter lifts exactly one level) or bails
+ * wrapping item (a nested empty item, so Enter lifts exactly one level) or bails
  * so the third link lifts a top-level empty item out to a paragraph. `Backspace`
  * forks on the item's index: the first item lifts, any later one merges.
  */

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

@@ -18,7 +18,7 @@ export declare function descriptorOf(m: ContentMark): Record<string, unknown>;
 /**
  * A stable grouping key for the mark diff: marks sharing a key union into one
  * coverage set. Formatting keys on its type; a link keys on type+url and an
- * unknown on type+attrs, because `applyChange`'s `remove` matches type AND attrs
+ * unknown on type+attrs, because `applyChange`'s `remove` matches type and attrs
  * (verified), so different urls / attrs are independent mark families.
  */
 export declare function markKey(descriptor: Record<string, unknown>): string;

package/dist/core/codec/marks.js

@@ -49,7 +49,7 @@ export function descriptorOf(m) {
 /**
  * A stable grouping key for the mark diff: marks sharing a key union into one
  * coverage set. Formatting keys on its type; a link keys on type+url and an
- * unknown on type+attrs, because `applyChange`'s `remove` matches type AND attrs
+ * unknown on type+attrs, because `applyChange`'s `remove` matches type and attrs
  * (verified), so different urls / attrs are independent mark families.
  */
 export function markKey(descriptor) {

package/dist/core/codec/positions.js

@@ -51,7 +51,7 @@ export function usvToPM(index, usvPos) {
     const usv = clamp(usvPos, 0, index.usvEnd);
     if (usv >= index.usvEnd)
         return index.usvEnd === 0 ? index.firstContentStart : index.pmEndContent;
-    // The runs TILE the USV space from 0 (every text the walk appends pushes its run
+    // The runs tile the USV space from 0 (every text the walk appends pushes its run
     // first), so below `usvEnd` the run at or before `usv` is the run that owns it.
     const run = index.runs[lastRunAtOrBefore(index.runs, usv, usvStartOf)];
     if (run.kind === 'text')