edytor 1.0.0-rc.2 → 1.0.0

package/dist/session/composition.svelte.js

@@ -4,7 +4,7 @@ import { attemptOf, intentSnapshot, kindOf, untargeted } from './attempt.js';
 import { insertionMarks } from './editing/text.js';
 /** How long the tail owns late signals of an engine that sends no next occurrence (compared at use). */
 const TAIL_MS = 500;
-const now = () => (typeof performance === 'undefined' ? Date.now() : performance.now());
+const now = () => performance.now();
 const isAppleWebKit = () => typeof navigator !== 'undefined' &&
     /AppleWebKit/i.test(navigator.userAgent) &&
     !/(Chrome|Chromium|Edg|OPR|SamsungBrowser)/i.test(navigator.userAgent);
@@ -55,9 +55,8 @@ export class Composition {
     #tail = null;
     #caret = null;
     #waiting = [];
-    /** Where the host's block sits (its and its ancestors' ids and types), and their siblings: the re-placement check compares them. */
-    #where = '';
-    #order = [];
+    /** Where the host's block sits (`#place`): the re-placement check compares it. */
+    #where = [];
     /** After a re-placing commit, until the IME ends: the text it committed (resumed over), or `lost` (dropped). */
     #resume = null;
     /** Phantom structural keys the tail swallowed (a test oracle). */
@@ -68,8 +67,6 @@ export class Composition {
     get live() {
         return this.phase === 'live';
     }
-    /** `node` lies inside the element a live session owns (the pinned element). */
-    owns = (node) => this.host !== null && this.edytor.pin.owns(node);
     /** Run `fn` once the live session has ended (after its writes), or now when none is live. */
     ended = (fn) => {
         if (this.live)
@@ -98,7 +95,7 @@ export class Composition {
         this.#resume = null;
         if (resume && resume !== 'lost')
             selection.select(resume);
-        const { startText, endText, yStart, yEnd } = selection.state;
+        const { startText, endText, yStart, yEnd } = selection.textRange();
         this.phase = 'live';
         this.#tail = this.#caret = this.#region = null;
         this.#own.clear();
@@ -117,8 +114,11 @@ export class Composition {
                     ? 'block'
                     : 'blocks'
                 : false;
+        // With no target, the caret the browser parked for the IME.
+        const parked = targetless && dom?.anchorNode;
+        const point = parked ? this.edytor.ports.surface.pointAt(parked, dom.anchorOffset) : null;
         const at = targetless
-            ? this.#parkedAt(dom)
+            ? point && { text: point.text, from: point.offset, to: point.offset }
             : shown === 'blocks' || shown === 'atom'
                 ? this.#rangeless()
                 : startText && {
@@ -130,7 +130,6 @@ export class Composition {
             this.#pin(at.text, at.from, at.to);
         this.host = at?.text ?? null;
         this.#where = this.#place();
-        this.#order = this.#siblings();
     };
     /** A composition update: the model holds `value` (mechanical, in the capture group). */
     update = (value, attempt) => {
@@ -187,7 +186,7 @@ export class Composition {
     restructured = (change) => {
         if (!this.live || !(change.removed.size || change.moved.size || change.meta.size))
             return;
-        if (this.#place() === this.#where && !this.#reordered())
+        if (!this.#replaced())
             return;
         const shown = this.edytor.pin.imeBuffer() ?? this.preview;
         const at = this.#kept();
@@ -243,12 +242,10 @@ export class Composition {
         }
         const tail = this.tail();
         this.occurred();
-        const { state, selectedBlocks, selectedInlineBlock } = this.edytor.selection;
+        // A caret: a block or atom selection is no collapsed projection.
         const phantom = tail &&
             (event.key === 'Enter' || (event.key === 'Backspace' && isAppleWebKit())) &&
-            state.isCollapsed &&
-            !selectedBlocks.size &&
-            !selectedInlineBlock.size;
+            this.edytor.selection.projection.isCollapsed;
         if (!phantom)
             return false;
         this.swallows++;
@@ -299,10 +296,10 @@ export class Composition {
      */
     #rangeless() {
         const { edytor } = this;
-        const { selectedBlocks, state } = edytor.selection;
+        const { selectedBlocks, projection } = edytor.selection;
         const exit = selectedBlocks.size
             ? selectedBlocksExit(edytor)
-            : state.startText && { text: state.startText, offset: state.yStart };
+            : edytor.selection.textAt(projection.start);
         const at = this.#open() ? this.#at() : exit;
         if (!at)
             return null;
@@ -312,41 +309,38 @@ export class Composition {
         edytor.ports.surface.park(at.text, at.offset);
         return { text: at.text, from: at.offset, to: at.offset };
     }
-    /** The text and offset of the caret the browser parked for a session with no target. */
-    #parkedAt(dom) {
-        const node = dom?.anchorNode;
-        const at = node ? this.edytor.ports.surface.pointAt(node, dom.anchorOffset) : null;
-        return at && { text: at.text, from: at.offset, to: at.offset };
-    }
-    /** The host's block and its ancestors (none once it is not visible). */
-    #chain() {
-        const { facade } = this.edytor;
-        const id = this.host?.parent.id;
-        return id && facade.isVisibleBlock(id) ? [id, ...facade.ancestorsOf(id)] : [];
-    }
-    /** The chain with its types. */
+    /**
+     * Where the host's block sits: it and its ancestors (none once it is not
+     * visible), each with its type and its parent's child ids.
+     */
     #place() {
         const { facade } = this.edytor;
-        return this.#chain()
-            .map((id) => `${id}:${facade.blockTypeOf(id)}`)
-            .join('/');
-    }
-    /** Each chain member with its parent's child ids. */
-    #siblings() {
-        const { facade } = this.edytor;
-        return this.#chain().map((id) => ({ id, kids: facade.childrenIds(facade.parentOf(id)) }));
+        const id = this.host?.parent.id;
+        const chain = id && facade.isVisibleBlock(id) ? [id, ...facade.ancestorsOf(id)] : [];
+        return chain.map((id) => ({
+            id,
+            type: facade.blockTypeOf(id),
+            kids: facade.childrenIds(facade.parentOf(id))
+        }));
     }
-    /** A chain member moved among the siblings it had and still has (a same-parent move). */
-    #reordered() {
-        const [before, after] = [this.#order, (this.#order = this.#siblings())];
+    /**
+     * The host's block was re-placed since the last look: a chain member is
+     * another block or kind, or moved among the siblings it had and still
+     * has (a same-parent move).
+     */
+    #replaced() {
+        const [before, after] = [this.#where, (this.#where = this.#place())];
         const rank = (id, kids, other) => {
             const kept = new Set(other);
             return kids.filter((kid) => kept.has(kid)).indexOf(id);
         };
-        return before.some(({ id, kids }, i) => {
-            const now = after[i]?.kids ?? [];
-            return rank(id, kids, now) !== rank(id, now, kids);
-        });
+        return (before.length !== after.length ||
+            before.some(({ id, type, kids }, i) => {
+                const now = after[i];
+                return (now.id !== id ||
+                    now.type !== type ||
+                    rank(id, kids, now.kids) !== rank(id, now.kids, kids));
+            }));
     }
     /** The preview's position while it is live and whole in one visible block (not deleted with it). */
     #kept() {
@@ -379,17 +373,15 @@ export class Composition {
         const end = this.#region && facade.resolveAnchor(this.#region.end);
         if (!start || !end || !this.#own.size)
             return [];
-        const spans = start.blockId === end.blockId
-            ? [{ blockId: start.blockId, from: start.offset, to: end.offset }]
-            : [
-                { blockId: start.blockId, from: start.offset, to: facade.displayLength(start.blockId) },
-                { blockId: end.blockId, from: 0, to: end.offset }
-            ];
         const units = [];
-        for (const { blockId, from, to } of spans)
-            for (let offset = from; offset < to; offset++)
+        for (const { blockId, offset: from } of start.blockId === end.blockId
+            ? [start]
+            : [start, end]) {
+            const to = blockId === end.blockId ? end.offset : facade.displayLength(blockId);
+            for (let offset = blockId === start.blockId ? from : 0; offset < to; offset++)
                 if (this.#own.has(this.#unit(blockId, offset)))
                     units.push({ blockId, offset });
+        }
         return units;
     }
     /** Delete the preview's live units through the facade's text delete, one run each, last first; foreign units stay. */
@@ -451,15 +443,12 @@ export class Composition {
         const um = this.edytor.undoManager;
         if (!um || this.#item)
             return write();
-        const record = ({ stackItem }) => (this.#item ??= stackItem);
-        um.on('stack-item-added', record);
-        um.on('stack-item-updated', record);
+        const off = um.observe(({ stackItem }) => (this.#item ??= stackItem));
         try {
             return write();
         }
         finally {
-            um.off('stack-item-added', record);
-            um.off('stack-item-updated', record);
+            off();
         }
     }
     /** The one ending: `value` replaces the preview (a commit shown to hooks), '' deletes it. */
@@ -471,7 +460,7 @@ export class Composition {
         const { edytor } = this;
         const { dispatcher, selection } = edytor;
         // A command that moved the caret out of the region keeps it there.
-        const { startText: moved, yStart: movedAt } = selection.state;
+        const { startText: moved, yStart: movedAt } = selection.textRange();
         const keep = this.#interrupted && moved && !this.covers(moved, movedAt);
         this.#tail = this.host;
         this.#ended = now();
@@ -482,13 +471,15 @@ export class Composition {
             this.#hold();
             if (at && value) {
                 const text = at.text;
-                const payload = { value, start: at.offset, end: at.offset, marks: this.marks };
-                dispatcher.run('insertFromComposition', () => dispatcher.dispatch('insertText', payload, { block: text.parent, text }, (p) => {
+                const args = [text.parent.id, text.segStart + at.offset, value, this.marks];
+                const prepare = (a) => edytor.facade.prepare.insertText(...a);
+                // The preview goes first, in the command: the insertion is prepared over what it leaves.
+                dispatcher.run('insertFromComposition', () => dispatcher.dispatch('insertText', args, { block: text.parent, text }, (a) => {
                     this.#erase();
-                    text.insertAt(p.start, p.value, p.marks ?? this.marks);
+                    dispatcher.write(prepare(a));
                     if (selection.pending)
                         selection.stage(undefined);
-                }));
+                }, prepare));
             }
             // A refused commit, or a cancel: the preview goes.
             if (!value || dispatcher.last?.status === 'refused')
@@ -498,7 +489,7 @@ export class Composition {
             if (text)
                 this.#caret = { text, offset: Math.min(at.offset + typed, text.length) };
         }
-        const { startText, yStart } = selection.state;
+        const { startText, yStart } = selection.textRange();
         const caret = keep && startText ? { text: startText, offset: yStart } : this.#caret;
         this.#release();
         if (caret)
@@ -512,8 +503,7 @@ export class Composition {
         this.host = null;
         // No host, no re-placement baseline: a stale one would end the next session
         // when its start target's replacement commits (`#rangeless`).
-        this.#where = '';
-        this.#order = [];
+        this.#where = [];
         this.#region = this.#merged = null;
         this.#own.clear();
         this.edytor.pin.release();

package/dist/session/editing/text.d.ts

@@ -42,3 +42,9 @@ export declare const marksForInsertion: (text: Text, offset: number, { replaced,
  * is replaced: typing, a soft break, a plain paste, an IME's first preview.
  */
 export declare const insertionMarks: (edytor: Edytor, snapshot: Attempt) => Marks;
+/**
+ * The marks of text a view inserts at offset `offset` of block `id` with
+ * none named (`edytor.insertText(id, offset, text)`): the caret's pending
+ * marks when it sits there, else the neighbours' (`marksForInsertion`).
+ */
+export declare const insertionMarksAt: (edytor: Edytor, id: string, offset: number) => Marks;

package/dist/session/editing/text.js

@@ -9,9 +9,10 @@ const commonMarks = (parts) => {
 };
 /** The side the selection admitted for a caret at `text`/`offset`, if it sits there. */
 export const admittedSide = (text, offset) => {
-    const state = text.edytor.selection.state;
-    return state.isCollapsed && state.startText === text && state.yStart === offset
-        ? state.edge
+    const { selection } = text.edytor;
+    const { startText, yStart } = selection.textRange();
+    return selection.projection.isCollapsed && startText === text && yStart === offset
+        ? selection.edge
         : undefined;
 };
 export const marksForInsertion = (text, offset, { replaced, side = admittedSide(text, offset), pending } = {}) => {
@@ -51,3 +52,16 @@ export const insertionMarks = (edytor, snapshot) => {
         pending: edytor.selection.pending
     });
 };
+/**
+ * The marks of text a view inserts at offset `offset` of block `id` with
+ * none named (`edytor.insertText(id, offset, text)`): the caret's pending
+ * marks when it sits there, else the neighbours' (`marksForInsertion`).
+ */
+export const insertionMarksAt = (edytor, id, offset) => {
+    const at = edytor.idToBlock.get(id)?.textAtOffset(offset);
+    if (!at)
+        return {};
+    const { caret, pending } = edytor.selection;
+    const here = caret?.block.id === id && caret.offset === offset;
+    return marksForInsertion(at.text, at.offset, { pending: here ? pending : undefined });
+};

package/dist/session/handles.d.ts

@@ -15,8 +15,9 @@
 import { Block } from '../block/block.svelte.js';
 import { InlineBlock } from '../block/inlineBlock.svelte.js';
 import { Text } from '../text/text.svelte.js';
-import type { ContentItem, DocChange } from '../crdt/index.js';
+import type { ContentItem, Destination, DocChange } from '../crdt/index.js';
 import type { Edytor } from '../edytor.svelte.js';
+import type { JSONText } from '../utils/json.js';
 export type TextRunItem = {
     text: string;
     marks?: Record<string, unknown>;
@@ -36,6 +37,14 @@ export type ContentPart = {
 };
 /** Segments and atoms, alternating, starting and ending with a segment. */
 export declare const contentParts: (items: readonly ContentItem[]) => ContentPart[];
+/**
+ * A text segment's items as `JSONText` runs (`text.value`): empty items
+ * dropped, adjacent runs with the same marks joined, each run's marks a
+ * copy (none when it has no mark).
+ */
+export declare const segmentJSON: (items: readonly TextRunItem[]) => JSONText[];
+/** The destination right after `block` among its siblings (`after: false`, right before it). */
+export declare const siblingSlot: (block: Block, after?: boolean) => Destination;
 export declare class Handles {
     #private;
     private edytor;

package/dist/session/handles.js

@@ -38,7 +38,35 @@ export const contentParts = (items) => {
     close();
     return parts;
 };
+/**
+ * A text segment's items as `JSONText` runs (`text.value`): empty items
+ * dropped, adjacent runs with the same marks joined, each run's marks a
+ * copy (none when it has no mark).
+ */
+export const segmentJSON = (items) => {
+    const out = [];
+    for (const { text, marks = {} } of items) {
+        if (!text)
+            continue;
+        const keys = Object.keys(marks);
+        const last = out.at(-1);
+        const held = last?.marks ?? {};
+        if (last && Object.keys(held).length === keys.length && keys.every((k) => held[k] === marks[k]))
+            last.text += text;
+        else
+            out.push(keys.length ? { text, marks: { ...marks } } : { text });
+    }
+    return out;
+};
 const ROOT = contentParts([]);
+/** The destination right after `block` among its siblings (`after: false`, right before it). */
+export const siblingSlot = (block, after = true) => {
+    const parent = block.parent;
+    return {
+        parent: !parent || parent.isRoot ? null : parent.id,
+        index: block.index + Number(after)
+    };
+};
 export class Handles {
     edytor;
     root;

package/dist/session/history.d.ts

@@ -53,8 +53,4 @@ export declare class History {
      * `refused`, `noop` on an empty stack, else `applied`.
      */
     replay: (command: "undo" | "redo") => "refused" | "noop" | "applied";
-    /** Replay the top undo item; answers whether one was replayed. */
-    undo: () => boolean;
-    /** Replay the top redo item; answers whether one was replayed. */
-    redo: () => boolean;
 }

package/dist/session/history.js

@@ -1,4 +1,4 @@
-import { project, textSelection } from './selection.js';
+import { project, sameEnds, textSelection } from './selection.js';
 const KEY = 'edytor:selection';
 /** A stack item's last dispatched write was an insertion (`wrote`): typing may continue it. */
 const INSERTING = 'edytor:inserting';
@@ -50,12 +50,10 @@ export class History {
             this.#open = { entry, gesture: this.edytor.intentSerial };
         };
         doc.on('beforeTransaction', begin);
-        um.on('stack-item-added', record);
-        um.on('stack-item-updated', record);
+        const off = um.observe(record);
         this.#off = () => {
             doc.off('beforeTransaction', begin);
-            um.off('stack-item-added', record);
-            um.off('stack-item-updated', record);
+            off();
         };
     };
     unbind = () => {
@@ -78,12 +76,16 @@ export class History {
      * moves) restores the one the user had.
      */
     began = (value) => {
-        const { undoManager: um, transaction: key } = this.edytor;
-        const item = um?.undoStack.at(-1);
-        const entry = item && entries(item).get(key);
+        const { entry } = this.#top();
         if (entry)
             entry.before = value;
     };
+    /** The top undo item and this view's entry on it. */
+    #top() {
+        const { undoManager: um, transaction: key } = this.edytor;
+        const item = um?.undoStack.at(-1);
+        return { item, entry: item && entries(item).get(key) };
+    }
     /** The dispatcher wrote in this transaction: an insertion (`inserts`) or not. */
     wrote = (insertion) => {
         this.#inserting = (this.#inserting ?? true) && insertion;
@@ -97,16 +99,12 @@ export class History {
      * follows.
      */
     continues = (value) => {
-        const { undoManager: um, transaction: key, facade } = this.edytor;
-        const item = um?.undoStack.at(-1);
-        if (item?.meta.get(INSERTING) !== true)
-            return false;
-        const after = item?.meta.get(KEY)?.get(key)?.after;
-        if (after?.kind !== 'text' || value.kind !== 'text')
+        const { item, entry } = this.#top();
+        const after = entry?.after;
+        if (item?.meta.get(INSERTING) !== true || after?.kind !== 'text' || value.kind !== 'text')
             return false;
-        const [a, b] = [project(after, facade), project(value, facade)];
-        const at = (p, q) => p !== null && q !== null && p.block === q.block && p.offset === q.offset;
-        return at(a.start, b.start) && at(a.end, b.end);
+        const a = project(after, this.edytor.facade);
+        return !!a.start && sameEnds(a, project(value, this.edytor.facade));
     };
     /**
      * Replay the top undo (redo) item, under the dispatcher's admission (a
@@ -114,10 +112,6 @@ export class History {
      * `refused`, `noop` on an empty stack, else `applied`.
      */
     replay = (command) => !this.edytor.dispatcher.permits() ? 'refused' : this.#run(command) ? 'applied' : 'noop';
-    /** Replay the top undo item; answers whether one was replayed. */
-    undo = () => this.replay('undo') === 'applied';
-    /** Replay the top redo item; answers whether one was replayed. */
-    redo = () => this.replay('redo') === 'applied';
     #run(command) {
         const { undoManager: um, transaction: key, selection, facade } = this.edytor;
         this.#open = null;

package/dist/session/inputRules.js

@@ -18,111 +18,102 @@ const matchAtEnd = (find, subject) => {
 export const inputRulesHook = (edytor, rules) => {
     /** A rule's replacement, or the typed text after it declined, is running: no rule runs on its writes. */
     let running = false;
-    /** The typed text lands as typed, the caret after it. */
-    const typeAsIs = (text, payload, at) => {
-        text.insertText(payload);
-        edytor.dispatcher.caret(text, at + payload.value.length);
-    };
     return (change) => {
+        const { dispatcher, facade, selection } = edytor;
         if (running || change.operation !== 'insertText' || !rules.length)
             return;
         // Typed text only: a paste or a drop (a URL pasted at the caret) completes no rule.
-        if (edytor.dispatcher.command?.startsWith('insertFrom'))
+        if (dispatcher.command?.startsWith('insertFrom'))
             return;
         const { payload, block, prevent, text } = change;
-        const caret = edytor.selection.caret;
-        const { startText, yStart } = edytor.selection.state;
+        const [, offset, value] = payload;
+        const { startText, yStart } = selection.textRange();
         // Only text typed at the caret: an insertion elsewhere completes no rule.
-        if (!caret || !startText || text !== startText || caret.block.id !== block.id)
+        if (!selection.caret || !text || text !== startText)
             return;
-        if ((payload.start ?? yStart) !== yStart || (payload.end ?? yStart) !== yStart)
+        if (offset !== text.segStart + yStart)
             return;
-        if (!payload.value || inCodeLines(edytor, block))
+        if (!value || inCodeLines(edytor, block))
             return;
-        const before = startText.stringContent.slice(0, yStart);
-        const subject = before + payload.value;
-        // The first rule that matches, with the typed text inside its match.
-        const first = rules.findIndex((rule) => {
+        const before = text.stringContent.slice(0, yStart);
+        const subject = before + value;
+        // The rules that match, with the typed text inside their match.
+        const matches = rules.flatMap((rule) => {
             const match = matchAtEnd(rule.find, subject);
-            return !!match && match.index <= before.length;
+            return match && match.index <= before.length ? [{ rule, match }] : [];
         });
-        if (first === -1)
+        if (!matches.length)
             return;
+        /** The typed text lands as typed, the caret after it. */
+        const typeAsIs = () => {
+            edytor.insertText(...payload);
+            dispatcher.caret(text, yStart + value.length);
+        };
+        /**
+         * Run `rule` over `match`: whether it wrote, or `null` when it declined
+         * (the next rule is asked).
+         */
+        const apply = (rule, match) => {
+            /** The match's start in the segment; the match in the block, `from` to the caret. */
+            const start = match.index;
+            const from = text.segStart + start;
+            const to = text.segStart + yStart;
+            let removed = null;
+            /** Remove the match in the same plan as `then`'s first operation: `ctx.remove`. */
+            const remove = (then) => {
+                const last = dispatcher.last;
+                if (to > from) {
+                    const removal = facade.prepare.deleteText(block.id, from, to - from);
+                    const run = dispatcher.lead(removal, () => then?.());
+                    // Nothing took the lead: the matched text goes on its own, unless `then` declined.
+                    if (!run.taken && run.out !== false && text.index !== -1)
+                        edytor.deleteText(block.id, from, to - from);
+                }
+                else
+                    dispatcher.alone(() => then?.());
+                removed = dispatcher.last !== last && dispatcher.last?.status === 'applied';
+                return removed;
+            };
+            const ctx = {
+                edytor,
+                block,
+                from,
+                to,
+                typed: value,
+                caret: (offset) => void dispatcher.caret({ block, offset }),
+                remove
+            };
+            const last = dispatcher.last;
+            // Whatever the rule writes is a step of its own, even when no removal leads it.
+            const out = dispatcher.alone(() => rule.replace(match, ctx));
+            if (typeof out === 'string') {
+                const written = remove(() => dispatcher.alone(() => edytor.insertText(block.id, from, out)));
+                if (written)
+                    dispatcher.caret({ block, offset: from + out.length });
+                return written;
+            }
+            if (out === false || out === null)
+                return removed;
+            if (removed !== null)
+                return removed;
+            // Written without `remove`: what its own commands did decides.
+            if (dispatcher.last !== last)
+                return dispatcher.last?.status === 'applied';
+            return out === true ? true : null;
+        };
         prevent(() => {
             running = true;
             try {
-                for (const rule of rules.slice(first)) {
-                    const match = matchAtEnd(rule.find, subject);
-                    if (!match || match.index > before.length)
-                        continue;
-                    const written = apply(rule, match, startText, block, yStart, caret.offset, payload);
-                    if (written !== null) {
-                        if (!written)
-                            typeAsIs(startText, payload, yStart);
-                        return;
-                    }
+                for (const { rule, match } of matches) {
+                    const written = apply(rule, match);
+                    if (written !== null)
+                        return written || typeAsIs();
                 }
-                typeAsIs(startText, payload, yStart);
+                typeAsIs();
             }
             finally {
                 running = false;
             }
         });
     };
-    /**
-     * Run `rule` over `match`: whether it wrote, or `null` when it declined
-     * (the next rule is asked).
-     */
-    function apply(rule, match, text, block, yStart, caretOffset, payload) {
-        const { dispatcher, facade } = edytor;
-        /** The match's start in the segment, and in the block. */
-        const start = match.index;
-        const from = caretOffset - (yStart - start);
-        const to = caretOffset;
-        let removed = null;
-        /** Remove the match in the same plan as `then`'s first operation: `ctx.remove`. */
-        const removeMatch = (then) => {
-            const last = dispatcher.last;
-            if (to > from) {
-                const removal = facade.prepare.deleteText(block.id, from, to - from);
-                const run = dispatcher.lead(removal, () => then?.());
-                // Nothing took the lead: the matched text goes on its own, unless `then` declined.
-                if (!run.taken && run.out !== false && text.index !== -1)
-                    block.deleteContentAtRange({
-                        start: [text.index, start],
-                        end: [text.index, yStart]
-                    });
-            }
-            else
-                dispatcher.alone(() => then?.());
-            removed = dispatcher.last !== last && dispatcher.last?.status === 'applied';
-            return removed;
-        };
-        const ctx = {
-            edytor,
-            block,
-            from,
-            to,
-            typed: payload.value,
-            caret: (offset) => void dispatcher.caret({ block, offset }),
-            remove: removeMatch
-        };
-        const last = dispatcher.last;
-        // Whatever the rule writes is a step of its own, even when no removal leads it.
-        const out = dispatcher.alone(() => rule.replace(match, ctx));
-        if (typeof out === 'string') {
-            const written = removeMatch(() => dispatcher.alone(() => text.insertText({ value: out, start, end: start })));
-            if (written)
-                dispatcher.caret({ block, offset: from + out.length });
-            return written;
-        }
-        if (out === false || out === null)
-            return removed ?? null;
-        if (removed !== null)
-            return removed;
-        // Written without `remove`: what its own commands did decides.
-        if (dispatcher.last !== last)
-            return dispatcher.last?.status === 'applied';
-        return out === true ? true : null;
-    }
 };

package/dist/session/keymap.d.ts

@@ -23,6 +23,7 @@ export type Modifiers = {
 /** A chord: a key, after up to three modifiers in any order (matched case-insensitively). */
 export type HotKeyCombination = Key | `${Modifiers}+${Key}`;
 export declare class Keymap {
+    #private;
     private edytor;
     /** chord → bindings in precedence order. */
     private table;
@@ -30,12 +31,6 @@ export declare class Keymap {
     offered: string | null;
     get isMac(): boolean;
     constructor(edytor: Edytor, consumer?: EdytorOptions['hotkeys'], plugins?: InitializedPlugin[]);
-    /**
-     * A keyboard event's chord: `mod` is Cmd on Apple and Ctrl elsewhere; on
-     * Apple bare Ctrl stays `ctrl` (the Emacs rows); a reverse tab is Shift+Tab;
-     * the space bar is `space`.
-     */
-    chordOf: (event: KeyboardEvent, key?: string) => string;
     /** Offer a keydown to its bindings (the produced key first, then the layout key). */
     handle: (event: KeyboardEvent) => boolean;
     /** Run `chord`'s bindings in precedence order until one claims it. */