@quillmark/svelte 0.21.0 → 0.22.0

package/NOTICE

@@ -6,14 +6,13 @@ Copyright 2026 Nibs
 This package contains SVG glyph geometry derived from Lucide, carried in source
 rather than installed.
 
-`visual/icons/nodes.ts` holds nineteen verbatim from @lucide/svelte 1.28.0:
+`visual/icons/nodes.ts` holds eighteen verbatim from @lucide/svelte 1.28.0:
 chevron-right, arrow-right, chevron-down, chevron-up, bold, italic, underline,
-strikethrough, code, link, hash, info, plus, x, trash-2, minus, check, calendar
-and calendar-check.
+strikethrough, code, link, info, plus, x, trash-2, minus, check, calendar and
+calendar-check.
 
 `core/codec/table-view.ts` holds grip-horizontal, grip-vertical, align-left,
-align-center, align-right, align-start-horizontal, align-center-horizontal,
-align-end-horizontal and panel-top, derived from an earlier release of the same
+align-center, align-right and panel-top, derived from an earlier release of the same
 project.
 
 ISC License
@@ -34,8 +33,8 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
 --------------------------------------------------------------------------------
 
-Thirteen of those glyphs — arrow-right, chevron-down, chevron-right, chevron-up,
-code, hash, info, italic, link, minus, plus, trash-2 and x — are drawn exactly as
+Twelve of those glyphs — arrow-right, chevron-down, chevron-right, chevron-up,
+code, info, italic, link, minus, plus, trash-2 and x — are drawn exactly as
 the Feather project draws them and carry its license as well.
 
 The MIT License (MIT)

package/README.md

@@ -149,7 +149,7 @@ Hand it a different `doc` and the editor **re-keys itself**: every leaf remounts
 
 ### Wording
 
-The package ships English and a seam to replace it. `strings` is keyed and **partial**: set what you have translations for, and the rest stay the package's. Several keys are **accessible names** rather than decoration (the card controls, the add trigger, the required marker), so an untranslated surface reads the wrong language to a screen reader. `DEFAULT_VISUAL_STRINGS` is the English, exported so you can compose against it. `<Preview>` takes its own three-key `strings` for the states it shows when there is nothing to paint.
+The package ships English and a seam to replace it. `strings` is keyed and **partial**: set what you have translations for, and the rest stay the package's. Several keys are **accessible names** rather than decoration (the card controls, the add trigger), so an untranslated surface reads the wrong language to a screen reader. `DEFAULT_VISUAL_STRINGS` is the English, exported so you can compose against it. `<Preview>` takes its own three-key `strings` for the states it shows when there is nothing to paint.
 
 ```svelte
 <VisualEditor

package/dist/core/address.d.ts

@@ -50,10 +50,15 @@ export interface Landing {
  * - `{card: i}` → `"cards.<kind>[i].body"`
  * - `{card: i, field}` → `"cards.<kind>[i].<field>"`
  *
+ * `steps` descend from the field to a leaf inside it, the inverse of
+ * {@link nestedAddrForFieldPath}: `{field: 'contact'}` with `['email']` is
+ * `"main.contact.email"`, `{field: 'keywords'}` with `[0]` is `"main.keywords[0]"`. A body
+ * holds no cells, so a field-less address with steps is `undefined`.
+ *
  * `cards[i]` stands in for an unknown or blank kind. The index is the addr's own: no
  * per-kind counting, since `DocPath` addresses cards by document-array index.
  */
-export declare function fieldPathForAddr(addr: Addr, kinds: readonly string[]): DocPath | undefined;
+export declare function fieldPathForAddr(addr: Addr, kinds: readonly string[], steps?: readonly PathStep[]): DocPath | undefined;
 /**
  * A card's own path (`cards.<kind>[i]`), not a leaf's: what a structure op names,
  * where the change is the card rather than anything inside it. `undefined` for an

package/dist/core/address.js

@@ -15,15 +15,24 @@ import { core } from './lifecycle.js';
  * - `{card: i}` → `"cards.<kind>[i].body"`
  * - `{card: i, field}` → `"cards.<kind>[i].<field>"`
  *
+ * `steps` descend from the field to a leaf inside it, the inverse of
+ * {@link nestedAddrForFieldPath}: `{field: 'contact'}` with `['email']` is
+ * `"main.contact.email"`, `{field: 'keywords'}` with `[0]` is `"main.keywords[0]"`. A body
+ * holds no cells, so a field-less address with steps is `undefined`.
+ *
  * `cards[i]` stands in for an unknown or blank kind. The index is the addr's own: no
  * per-kind counting, since `DocPath` addresses cards by document-array index.
  */
-export function fieldPathForAddr(addr, kinds) {
+export function fieldPathForAddr(addr, kinds, steps = []) {
     const head = cardHead(addr.card, kinds);
     if (!head)
         return undefined;
-    const tail = addr.field != null ? { seg: 'field', name: addr.field } : { seg: 'body' };
-    return core().formatDocPath([head, tail]);
+    if (addr.field == null)
+        return steps.length ? undefined : core().formatDocPath([head, { seg: 'body' }]);
+    const segs = [head, { seg: 'field', name: addr.field }];
+    for (const step of steps)
+        segs.push(typeof step === 'number' ? { seg: 'index', index: step } : { seg: 'field', name: step });
+    return core().formatDocPath(segs);
 }
 /**
  * A card's own path (`cards.<kind>[i]`), not a leaf's: what a structure op names,

package/dist/core/bloom.d.ts

@@ -1,8 +1,13 @@
 /**
- * Bloom over `host`'s content: an inset child, so the wash neither tints the host's
- * own background nor fades the text under it. `host` must be positioned.
+ * Run one wash over `host`, a `.qm-wash` box, resolving the dwell off its root so the
+ * number is single-sourced in CSS (`core/rungs.ts`).
  *
- * One wash node per host, reused while it lives: two quick landings on the same leaf
+ * One property, both motion preferences: `--_qm-bloom-dwell` already shortens under
+ * `prefers-reduced-motion` in the derivation, so what is left to `matchMedia` here is
+ * the shape: a hold and a cut carry no ramps, which is a frame list rather than a
+ * number and the one half CSS cannot hand over.
+ *
+ * A run in flight on the same host is cancelled first: two quick landings on one leaf
  * must not stack two alphas over it.
  */
-export declare function bloomInside(host: HTMLElement): void;
+export declare function bloom(host: HTMLElement): void;

package/dist/core/bloom.js

@@ -6,9 +6,11 @@
 // fixed by `--_qm-accent-wash`, so interpolating 0→1→0 keeps the scale in CSS where
 // `color-mix` resolves, instead of in keyframe values a script would have to
 // pre-resolve and re-resolve on a theme change.
+//
+// The wash is the host's `::after` (`.qm-wash`, controls.css), drawn from mount: this
+// module plays it and adds nothing to the tree.
 import { rungStyle } from './rungs.js';
-const BLOOM_CLASS = 'qm-bloom';
-const WASH = 'var(--_qm-accent-wash)';
+const WASH = '::after';
 /** The dwell used when the derivation is out of reach (an unstyled root, or jsdom,
  *  where `getComputedStyle` reports custom properties as empty). A fallback is the
  *  absence of the scale, not a copy of it. */
@@ -25,61 +27,28 @@ const FRAMES = [
 ];
 const FRAMES_REDUCED = [{ opacity: 1 }, { opacity: 1 }];
 /**
- * Run one wash on `el`, resolving the dwell off its root so the number is
- * single-sourced in CSS (`core/rungs.ts`).
+ * Run one wash over `host`, a `.qm-wash` box, resolving the dwell off its root so the
+ * number is single-sourced in CSS (`core/rungs.ts`).
  *
  * One property, both motion preferences: `--_qm-bloom-dwell` already shortens under
  * `prefers-reduced-motion` in the derivation, so what is left to `matchMedia` here is
  * the shape: a hold and a cut carry no ramps, which is a frame list rather than a
  * number and the one half CSS cannot hand over.
- */
-function bloom(el) {
-    if (typeof el.animate !== 'function')
-        return undefined;
-    const reduced = typeof matchMedia === 'function' && matchMedia('(prefers-reduced-motion: reduce)').matches;
-    const raw = rungStyle(el).getPropertyValue('--_qm-bloom-dwell').trim();
-    const n = Number.parseFloat(raw);
-    const duration = !Number.isFinite(n) ? FALLBACK_MS : raw.endsWith('ms') ? n : n * 1000;
-    return el.animate(reduced ? FRAMES_REDUCED : FRAMES, { duration });
-}
-/**
- * Bloom over `host`'s content: an inset child, so the wash neither tints the host's
- * own background nor fades the text under it. `host` must be positioned.
  *
- * One wash node per host, reused while it lives: two quick landings on the same leaf
+ * A run in flight on the same host is cancelled first: two quick landings on one leaf
  * must not stack two alphas over it.
  */
-export function bloomInside(host) {
-    let el = host.querySelector(`:scope > .${BLOOM_CLASS}`);
-    if (el) {
-        // Drop the in-flight run's handlers before cancelling: its `oncancel` would
-        // otherwise remove the node the new run is about to animate.
-        for (const a of el.getAnimations()) {
-            a.onfinish = null;
-            a.oncancel = null;
-            a.cancel();
-        }
-    }
-    else {
-        el = document.createElement('div');
-        el.className = BLOOM_CLASS;
-        Object.assign(el.style, {
-            position: 'absolute',
-            inset: '0',
-            pointerEvents: 'none',
-            borderRadius: 'inherit',
-            background: WASH,
-            opacity: '0'
-        });
-        host.appendChild(el);
-    }
-    const node = el;
-    const anim = bloom(node);
-    if (!anim) {
-        node.remove();
+export function bloom(host) {
+    if (typeof host.animate !== 'function')
         return;
+    for (const a of host.getAnimations({ subtree: true })) {
+        const effect = a.effect;
+        if (effect?.target === host && effect.pseudoElement === WASH)
+            a.cancel();
     }
-    const drop = () => node.remove();
-    anim.onfinish = drop;
-    anim.oncancel = drop;
+    const reduced = typeof matchMedia === 'function' && matchMedia('(prefers-reduced-motion: reduce)').matches;
+    const raw = rungStyle(host).getPropertyValue('--_qm-bloom-dwell').trim();
+    const n = Number.parseFloat(raw);
+    const duration = !Number.isFinite(n) ? FALLBACK_MS : raw.endsWith('ms') ? n : n * 1000;
+    host.animate(reduced ? FRAMES_REDUCED : FRAMES, { duration, pseudoElement: WASH });
 }

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

@@ -1,7 +1,7 @@
 import { type Command } from 'prosemirror-state';
 import type { Schema } from 'prosemirror-model';
 /**
- * The block-atom bindings for a block-schema leaf: `{}` for the inline/plaintext
+ * The block-atom bindings for a block-schema leaf: `{}` for the one-line and plain
  * schemas, which hold no block to be against.
  *
  * Both keys are the same command on opposite sides, because what a delete against an

package/dist/core/codec/atoms.js

@@ -77,7 +77,7 @@ function againstAtom(side) {
     };
 }
 /**
- * The block-atom bindings for a block-schema leaf: `{}` for the inline/plaintext
+ * The block-atom bindings for a block-schema leaf: `{}` for the one-line and plain
  * schemas, which hold no block to be against.
  *
  * Both keys are the same command on opposite sides, because what a delete against an

package/dist/core/codec/blocks.js

@@ -1,6 +1,7 @@
 import { Selection } from 'prosemirror-state';
 import { chainCommands, splitBlock } from 'prosemirror-commands';
 import { canJoin, findWrapping } from 'prosemirror-transform';
+import { withinNesting } from './nesting.js';
 import { takesLineBreak } from './schema.js';
 /** The head of a textblock: where a shorthand fires, and where a pick lands once its
  *  run is consumed. */
@@ -59,7 +60,8 @@ function spaceBreaks(tr, $from, type) {
 }
 /** `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). */
+ *  §cleanup: command-local, never a global pass). False where no wrap fits, or where
+ *  the one that does nests past `MAX_NESTING_DEPTH` (`nesting.ts`). */
 function wrapAt(tr, pos, type, attrs, joinBefore) {
     const range = tr.doc.resolve(pos).blockRange();
     const wrapping = range && findWrapping(range, type, attrs);
@@ -73,7 +75,7 @@ function wrapAt(tr, pos, type, attrs, joinBefore) {
         (!joinBefore || joinBefore(before))) {
         tr.join(pos - 1);
     }
-    return true;
+    return withinNesting(tr.doc);
 }
 /** `# `: the heading `level` deep. `list_item` is `block+`, so one inside an item is a
  *  shape the content holds and `importMarkdown` produces from `- # title`. */

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

@@ -1,7 +1,7 @@
 import type { Schema } from 'prosemirror-model';
 import { type Command } from 'prosemirror-state';
 /**
- * The `code_block` link of the body's key chains: `{}` for the inline/plaintext
+ * The `code_block` link of the body's key chains: `{}` for the one-line and plain
  * schemas, which declare no code node.
  *
  * `Enter` is upstream's `newlineInCode`, and it is load-bearing rather than

package/dist/core/codec/code.js

@@ -182,7 +182,7 @@ const belowFinalFence = (state, dispatch) => {
     return true;
 };
 /**
- * The `code_block` link of the body's key chains: `{}` for the inline/plaintext
+ * The `code_block` link of the body's key chains: `{}` for the one-line and plain
  * schemas, which declare no code node.
  *
  * `Enter` is upstream's `newlineInCode`, and it is load-bearing rather than

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

@@ -18,10 +18,10 @@ export declare function renderContent(rt: Content, schema: Schema): Node;
 /** Decode a `Content` to a PM document under `schema`. */
 export declare function decode(rt: Content, schema: Schema): PMNode;
 /** Whether `rt` decodes under an inline schema with nothing but whitespace dropped:
- *  upstream's `inline` rule, or one plain line and the empty one a trailing `\n`
- *  opens. That newline is the one a YAML `|` scalar keeps in a `plaintext` value,
- *  which upstream refuses (`trailingNewline`) and the inline decode drops. Marks are
- *  the schema's own business (`plaintextSchema` declares none). */
+ *  upstream's one-line rule, or one plain line and the empty one a trailing `\n`
+ *  opens. That newline is the one a YAML `|` scalar keeps in a `text` value, which
+ *  upstream ignores and the inline decode drops. Marks are the schema's own business
+ *  (`plaintextSchema` declares none). */
 export declare function fitsInline(rt: Content): boolean;
 /** Whether `rt` decodes under `plainSchema` losing nothing but its marks, which the
  *  next commit heals (CODEC §Inline mode): upstream's `isPlain`, asked of the content
@@ -29,7 +29,7 @@ export declare function fitsInline(rt: Content): boolean;
 export declare function fitsPlain(rt: Content): boolean;
 /** Whether a leaf so declared edits `rt` losing nothing: {@link fitsInline} narrowed
  *  and {@link fitsPlain} plain, past which the decode drops what the first commit would
- *  store; on the block schema anything but an element or a task item ({@link editable}),
+ *  store; on the block schema anything but an element ({@link editable}),
  *  and an island where the leaf mounts no island view (`islands`), which draws as its
  *  placeholder tag, an atom a keystroke deletes unseen. What a leaf held over the rest
  *  reads. */

package/dist/core/codec/decode.js

@@ -47,9 +47,9 @@ export function decode(rt, schema) {
         acc += usvLength(lineTexts[i]) + 1; // +1 for the `\n` boundary
     }
     // A mark-free schema (`plaintextSchema`) has nothing to apply them with, and a
-    // plaintext field that acquired one anyway — an older build's popover, a hand-
-    // written document — is exactly the content that must open and then heal on the
-    // next commit, not throw here.
+    // `text` field that acquired one anyway — an older build's popover, a hand-written
+    // document — is exactly the content that must open and then heal on the next
+    // commit, not throw here.
     const marks = hasMarks(schema) ? rt.marks.filter((m) => m.type !== 'anchor') : [];
     const cursor = { i: 0, rt };
     if (isInlineSchema(schema)) {
@@ -74,10 +74,10 @@ export function decode(rt, schema) {
     return schema.nodes.doc.create(null, blocks.length ? blocks : schema.nodes.paragraph.create());
 }
 /** Whether `rt` decodes under an inline schema with nothing but whitespace dropped:
- *  upstream's `inline` rule, or one plain line and the empty one a trailing `\n`
- *  opens. That newline is the one a YAML `|` scalar keeps in a `plaintext` value,
- *  which upstream refuses (`trailingNewline`) and the inline decode drops. Marks are
- *  the schema's own business (`plaintextSchema` declares none). */
+ *  upstream's one-line rule, or one plain line and the empty one a trailing `\n`
+ *  opens. That newline is the one a YAML `|` scalar keeps in a `text` value, which
+ *  upstream ignores and the inline decode drops. Marks are the schema's own business
+ *  (`plaintextSchema` declares none). */
 export function fitsInline(rt) {
     if (core().isInline(rt))
         return true;
@@ -96,7 +96,7 @@ export function fitsPlain(rt) {
 }
 /** Whether a leaf so declared edits `rt` losing nothing: {@link fitsInline} narrowed
  *  and {@link fitsPlain} plain, past which the decode drops what the first commit would
- *  store; on the block schema anything but an element or a task item ({@link editable}),
+ *  store; on the block schema anything but an element ({@link editable}),
  *  and an island where the leaf mounts no island view (`islands`), which draws as its
  *  placeholder tag, an atom a keystroke deletes unseen. What a leaf held over the rest
  *  reads. */
@@ -107,10 +107,10 @@ export function fitsLeaf(rt, leaf) {
         return fitsPlain(rt);
     return (leaf.islands || rt.islands.length === 0) && rt.lines.every(editable);
 }
-/** Whether every container on `line` is one the block schema edits: an element, and a
- *  task item's `checked`, decode to no node, so the first commit would drop them. */
+/** Whether every container on `line` is one the block schema edits: an element decodes
+ *  to no node, so the first commit would drop it. */
 function editable(line) {
-    return line.containers.every((c) => c.container === 'quote' || (c.container === 'list_item' && c.attrs.checked === undefined));
+    return line.containers.every((c) => c.container === 'quote' || c.container === 'list_item');
 }
 /** Inline decode: one paragraph, containers and islands stripped. */
 function decodeInline(rt, schema, lineTexts, starts, marks, cursor) {
@@ -184,7 +184,7 @@ function groupBlocks(schema, leaves, depth, marks, cursor) {
                 let l = k + 1;
                 while (l < run.length && ordinalAt(run[l], depth) === ord)
                     l++;
-                items.push(schema.nodes.list_item.create(null, groupBlocks(schema, run.slice(k, l), depth + 1, marks, cursor)));
+                items.push(schema.nodes.list_item.create({ checked: checkedAt(run[k], depth) }, groupBlocks(schema, run.slice(k, l), depth + 1, marks, cursor)));
                 k = l;
             }
             const listType = ordered ? schema.nodes.ordered_list : schema.nodes.bullet_list;
@@ -235,6 +235,12 @@ function ordinalAt(leaf, depth) {
     const c = atDepth(leaf, depth);
     return c?.container === 'list_item' ? c.attrs.ordinal : -1;
 }
+/** A task item's `checked` at `depth`, `null` on any other item: what the item's lines
+ * carry alike, so its first line answers for it. */
+function checkedAt(leaf, depth) {
+    const c = atDepth(leaf, depth);
+    return c?.container === 'list_item' ? (c.attrs.checked ?? null) : null;
+}
 /** A container's `instance`, absent meaning the zero a canonical read omits. It is what
  * tells one container from an adjacent sibling of identical shape, which contiguity
  * alone reads as one, so absent and `0` have to answer alike. */

package/dist/core/codec/encode.js

@@ -122,7 +122,12 @@ function scanBlock(acc, node, nodePos, containers, instance) {
             const start = ordered ? node.attrs.start : 1;
             let itemPos = contentStart;
             node.forEach((item, _off, index) => {
-                const container = withInstance({ container: 'list_item', attrs: { ordered, start, ordinal: index } }, instance);
+                const checked = item.attrs.checked;
+                const attrs = { ordered, start, ordinal: index };
+                const container = withInstance({
+                    container: 'list_item',
+                    attrs: checked === null ? attrs : { ...attrs, checked }
+                }, instance);
                 scanBlocks(acc, item, itemPos + 1, [...containers, container]);
                 itemPos += item.nodeSize;
             });

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

@@ -14,20 +14,20 @@ export interface CreateFieldOpts {
     quill: Quill;
     addr: Addr;
     container: HTMLElement;
-    /** Constrained single-textblock schema (a field declaring `inline`). */
+    /** Constrained single-textblock schema (a one-line field). */
     inline?: boolean;
-    /** A mark-free schema (a `plaintext` field): literal text, no formatting and no
+    /** A mark-free schema (a `text` field): literal text, no formatting and no
      *  anchors, in paragraphs and hard breaks or, with `inline`, one textblock. */
     plaintext?: boolean;
     /** The id of the note the caller draws inside `container` for a held leaf →
      *  `aria-describedby` while it holds. */
     heldNoteId?: string;
     /**
-     * Fired when the leaf holds or releases, and at mount when it mounts held. A leaf
-     * declaring `inline`, or a `plaintext` one, is held over a value its schema cannot
+     * Fired when the leaf holds or releases, and at mount when it mounts held. A one-line
+     * leaf, or a `text` one, is held over a value its schema cannot
      * hold (`fitsLeaf`, upstream's `isInline` and `isPlain`): the decode would join lines
      * and drop containers and islands for the first commit to store. Any leaf is held
-     * over an element or a task item, which no node holds. A held leaf draws
+     * over an element, which no node holds. A held leaf draws
      * its content on the block schema, read-only, and commits nothing. Judged of the value
      * each mount and re-hydrate reads, so {@link FieldController.applyExternal} is what
      * re-evaluates it.
@@ -79,6 +79,9 @@ export interface CreateFieldOpts {
      * emptied it holds an empty answer, which prints empty. Absent, the placeholder
      * returns whenever the leaf is empty. */
     placeholderUntilEdit?: boolean;
+    /** An edit leaving the leaf empty removes the field: an optional cell (`t?`), whose
+     * unanswered `none` is what the empty leaf draws and an empty answer would hide. */
+    emptyUnsets?: boolean;
     onFocus?(addr: Addr): void;
     /** Fired with the new USV caret after an edit or a selection move. */
     onCaretMove?(addr: Addr, pos: number): void;
@@ -88,8 +91,8 @@ export interface CreateFieldOpts {
      * move, so a host driving a recompile off it recompiles on every arrow key.
      *
      * Fires for every commit regardless of which branch it took (`applyChange`, the
-     * first-edit `overwrite`, the fallback `overwrite`, a `plaintext` leaf's typed
-     * write) and for an anchor mutation,
+     * first-edit `overwrite`, the fallback `overwrite`, a `text` leaf's typed write)
+     * and for an anchor mutation,
      * which changes no text. A commit that failed outright (`commit-lost`) does not
      * fire it: nothing landed.
      */
@@ -168,6 +171,8 @@ export interface LeafViews {
 /** The canonical empty `Content`: one empty `para` line. The empty a prose
  * leaf (or an array's prose element) seeds from. */
 export declare function emptyContent(): Content;
+/** Whether `rt` is the empty leaf: {@link emptyContent}, nothing typed and no shape left. */
+export declare function isEmptyContent(rt: Content): boolean;
 /** The naming attributes for the `contenteditable`, shared by every prose leaf
  * (`ProseValue` takes it too, so an addressed leaf and a by-value one name their
  * regions by one rule). `aria-labelledby` supersedes `aria-label`: a leaf carrying
@@ -197,10 +202,10 @@ export declare function createField(opts: CreateFieldOpts): FieldController;
  * Backspace that takes one back, the field keymap over the base keymap, the URL paste
  * that links a selection (`link-paste.ts`), and last the ones that answer to a block
  * leaf's own shapes: the gap cursor, {@link pastAtomPlugin}, the island paste pass
- * (`islands.ts`), the table paste (`table-paste.ts`) and the markdown paste
- * (`markdown-paste.ts`).
+ * (`islands.ts`), the table paste (`table-paste.ts`), the markdown paste
+ * (`markdown-paste.ts`) and the task item's checkbox (`tasks.ts`).
  *
- * Every mark-shaped plugin reads the schema rather than a flag: over either plaintext
+ * Every mark-shaped plugin reads the schema rather than a flag: over either mark-free
  * schema the shorthand rules build nothing (each is guarded on its mark type), the
  * toggles bind no key and a pasted URL stays text, so a `**bold**` keeps the delimiters
  * its author typed without a second rule saying so.

package/dist/core/codec/field.js

@@ -5,8 +5,8 @@
 //   (a) apply optimistically to the view,
 //   (b) lower the tr to a `ChangeBundle` (or `overwrite` for a field not yet at
 //       content rest, which has nothing to splice),
-//   (c) commit via `doc.applyChange(addr, bundle)`, or a `plaintext` leaf's whole
-//       text through the typed writer,
+//   (c) commit via `doc.applyChange(addr, bundle)`, or a `text` leaf's whole text
+//       through the typed writer,
 //   (d) fire `onChange` when the transaction committed, then `onCaretMove` with
 //       the new USV caret, which a bare selection move fires on its own.
 // On an `applyChange` throw the optimistic PM state stays and the failure reports
@@ -33,7 +33,10 @@ import { bodyKeymap } from './keymap.js';
 import { blockSchema, isBlockSchema, leafSchema, plainSchema } from './schema.js';
 import { linkPastePlugin } from './link-paste.js';
 import { markdownPastePlugin } from './markdown-paste.js';
+import { nestingPlugin } from './nesting.js';
 import { tablePastePlugin } from './table-paste.js';
+import { tableCopyPlugin } from './table-copy.js';
+import { taskPlugin } from './tasks.js';
 import { DEFAULT_TABLE_STRINGS, tableNodeView } from './table-view.js';
 import { DEFAULT_SLASH_STRINGS, focusSlashItem, runSlashItem, slashPlugin } from './slash.js';
 const anchorKey = new PluginKey('quill-anchors');
@@ -75,8 +78,8 @@ function anchorPlugin(seed) {
  * and the verbatim read cannot answer it alone. A field the editor committed rests
  * as `Content`; a field a markdown parse left rests as the authored string, and
  * what that string means is the declared type's to say: `richtext` is markdown,
- * `plaintext` is literal text, and reading one as the other silently eats every
- * `*` the author typed. */
+ * `text` is literal text, and reading one as the other silently eats every `*` the
+ * author typed. */
 function readLeaf(reader, addr) {
     return reader.getContent(addr) ?? emptyContent();
 }
@@ -85,14 +88,18 @@ function readLeaf(reader, addr) {
 export function emptyContent() {
     return { text: '', lines: [{ containers: [], kind: 'para' }], marks: [], islands: [] };
 }
+/** Whether `rt` is the empty leaf: {@link emptyContent}, nothing typed and no shape left. */
+export function isEmptyContent(rt) {
+    return contentEqual(rt, emptyContent());
+}
 /** Whether ops may commit here: the stored value is a `Content` object, so
  * `applyChange` splices exactly the content the leaf read and PM is showing.
  *
  * The two other rest forms both take `overwrite` instead. An unset field (`undefined`;
  * a default-only richtext field before its first edit) has nothing to splice, and an
  * authored string nothing to lose: content-only marks do not survive markdown, so a
- * string carries no anchors to pay. A body always rests as `Content`. A `plaintext`
- * leaf never asks: it commits through the writer ({@link createField}). */
+ * string carries no anchors to pay. A body always rests as `Content`. A `text` leaf
+ * never asks: it commits through the writer ({@link createField}). */
 function opsCommittable(doc, addr) {
     const stored = doc.getStored(addr);
     return stored !== null && typeof stored === 'object';
@@ -162,7 +169,7 @@ export function createField(opts) {
     const slash = block ? opts.onSlash : undefined;
     // Judged of the value being mounted rather than read off a diagnostic: a routed set
     // can predate the value it arrives with, and `validation::not_plain` stands in for
-    // `not_inline` on a `plaintext(inline)` field.
+    // `not_single_line` on a one-line `text` field.
     const holds = (rt) => !fitsLeaf(rt, { inline, plaintext, islands: true });
     let held = holds(reconciler.last);
     const named = proseAttributes(opts) ?? {};
@@ -210,6 +217,9 @@ export function createField(opts) {
         dispatchTransaction: (tr) => {
             const oldRt = reconciler.last;
             const next = view.state.apply(tr);
+            // A filtered transaction (`nesting.ts`) leaves the state as it was.
+            if (next === view.state)
+                return;
             // An edit takes a held default: the commit below writes the whole leaf, so the
             // mark goes in the same update that draws the edit.
             if (!held && (tr.docChanged || tr.getMeta(anchorKey)))
@@ -282,6 +292,8 @@ export function createField(opts) {
     // Returns whether anything landed: the caller's change signal, which must not
     // be a property of which branch the commit took.
     function commitEdit(oldRt, newRt) {
+        if (opts.emptyUnsets && heldAnchors().length === 0 && isEmptyContent(newRt))
+            return commitUnset();
         if (plaintext)
             return commitPlain(newRt.text);
         // The text splice, computed once per keystroke: the gate below, both overwrite
@@ -335,8 +347,8 @@ export function createField(opts) {
         }
     }
     /**
-     * A `plaintext` leaf's commit: its whole text through the typed writer, which rests
-     * the field as that literal string (CODEC §Inline mode). A content object is the
+     * A `text` leaf's commit: its whole text through the typed writer, which rests the
+     * field as that literal string (CODEC §Inline mode). A content object is the
      * other rest form, and `toMarkdown` emits one as markdown: a break spelled as a
      * backslash, a `*` and a trailing space escaped, a blank line doubled, so the value
      * reads back changed. The leaf carries no anchors, so the op path has none to keep.
@@ -348,7 +360,7 @@ export function createField(opts) {
         try {
             const name = addr.field;
             if (name === undefined)
-                throw new Error('a plaintext leaf names a field');
+                throw new Error('a text leaf names a field');
             (addr.card === undefined ? writer : writer.card(addr.card)).set(name, text);
             reconciler.commit(readLeaf(reader, addr));
             return true;
@@ -363,6 +375,23 @@ export function createField(opts) {
             return false;
         }
     }
+    /** An emptied optional leaf's commit: the field removed, back to unanswered. */
+    function commitUnset() {
+        try {
+            doc.removeField(addr);
+            reconciler.commit(readLeaf(reader, addr));
+            return true;
+        }
+        catch (e) {
+            reportError(opts.onError, {
+                code: 'commit-lost',
+                severity: 'error',
+                message: `the field could not be removed; the stored value is stale while the editor keeps the edit: ${errorMessage(e)}`,
+                cause: e
+            });
+            return false;
+        }
+    }
     /** The anchors the plugin currently holds (PM coords); `[]` before the first apply. */
     const heldAnchors = () => anchorKey.getState(view.state) ?? [];
     /** The plugin's anchor positions as USV, against `index` — which `dispatchTransaction`
@@ -437,7 +466,7 @@ export function createField(opts) {
             return readLeaf(reader, addr);
         },
         insertAnchor(id, pos) {
-            // A plaintext field carries no marks (§Inline mode), and a held one commits nothing.
+            // A text field carries no marks (§Inline mode), and a held one commits nothing.
             if (plaintext || held)
                 return;
             if (heldAnchors().some((a) => a.id === id))
@@ -509,10 +538,10 @@ export function createField(opts) {
  * Backspace that takes one back, the field keymap over the base keymap, the URL paste
  * that links a selection (`link-paste.ts`), and last the ones that answer to a block
  * leaf's own shapes: the gap cursor, {@link pastAtomPlugin}, the island paste pass
- * (`islands.ts`), the table paste (`table-paste.ts`) and the markdown paste
- * (`markdown-paste.ts`).
+ * (`islands.ts`), the table paste (`table-paste.ts`), the markdown paste
+ * (`markdown-paste.ts`) and the task item's checkbox (`tasks.ts`).
  *
- * Every mark-shaped plugin reads the schema rather than a flag: over either plaintext
+ * Every mark-shaped plugin reads the schema rather than a flag: over either mark-free
  * schema the shorthand rules build nothing (each is guarded on its mark type), the
  * toggles bind no key and a pasted URL stays text, so a `**bold**` keeps the delimiters
  * its author typed without a second rule saying so.
@@ -530,7 +559,7 @@ export function proseLeafPlugins(schema, opts) {
     // Each answers to something only the block schema holds: any other leaf is
     // textblocks alone, with no island and no gap to put a cursor in.
     if (isBlockSchema(schema))
-        list.push(gapCursor(), pastAtomPlugin(), islandPastePlugin(), tablePastePlugin(), markdownPastePlugin());
+        list.push(gapCursor(), pastAtomPlugin(), islandPastePlugin(), tablePastePlugin(), tableCopyPlugin(), markdownPastePlugin(), taskPlugin(), nestingPlugin());
     if (schema === plainSchema)
         list.push(plainClipboardPlugin());
     if (opts.placeholder)
@@ -641,9 +670,9 @@ function ghostPlugin(opts) {
 /**
  * The field's keymap: history, mark toggles, and the body's structural keys; Enter
  * suppressed inline. The toggles are bound per mark type the schema declares, so a
- * plaintext leaf leaves Mod-b/i/u to the browser.
+ * `text` leaf leaves Mod-b/i/u to the browser.
  *
- * Tab forks on the leaf's role, not on the caret's position. An inline/plaintext
+ * Tab forks on the leaf's role, not on the caret's position. A one-line or `text`
  * leaf is a form field: Tab stays unbound, so field navigation is open for a shell
  * keymap (VISUAL_EDITOR §Settled and open). A block-schema body is a document: Tab
  * is structural, a chain each nested surface prepends to (`keymap.ts`). One key

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

@@ -1,6 +1,6 @@
 export { rangeAnchor } from './anchor.js';
 export type { RangeAnchor } from './anchor.js';
-export { createField, emptyContent, heldAttributes, proseAttributes, proseLeafPlugins } from './field.js';
+export { createField, emptyContent, heldAttributes, isEmptyContent, proseAttributes, proseLeafPlugins } from './field.js';
 export type { CreateFieldOpts, FieldController, LeafViews } from './field.js';
 export { DEFAULT_TABLE_STRINGS } from './table-view.js';
 export type { TableChromeStrings } from './table-view.js';