edytor 1.0.0-rc.3 → 2.0.0

package/dist/events/onInput.js

@@ -1,24 +1,10 @@
 import { diffText } from '../utils/diffText.js';
 import { getDomSelectionSnapshot } from '../selection/domSelection.js';
-import { isInsideTrailingNewlineMarker } from '../selection/selection.utils.js';
-import { replaceSelectionWithCollapsedTarget } from '../selection/replaceSelection.js';
-import { isNativeInteractiveEvent, isNestedForeignEditableTarget } from './nativeInteractiveControl.js';
-import { getTextContentOffsetAtPoint } from './domTextOffset.js';
+import { domOffsetIn } from '../selection/selection.utils.js';
+import { isControlEvent } from './nativeInteractiveControl.js';
 import { runOccurrence } from './onBeforeInput.js';
 import { attemptOf, kindOf } from '../session/attempt.js';
 const ZERO_WIDTH_SPACE = '\u200B';
-const isNativeLineBreakTextInput = (event) => typeof InputEvent !== 'undefined' &&
-    event instanceof InputEvent &&
-    (event.inputType === 'insertText' || kindOf(event.inputType) === 'break');
-const isTextInsertionInput = (event) => typeof InputEvent !== 'undefined' &&
-    event instanceof InputEvent &&
-    event.inputType === 'insertText' &&
-    typeof event.data === 'string' &&
-    event.data.length > 0;
-const isNativeHistoryInput = (event) => typeof InputEvent !== 'undefined' &&
-    event instanceof InputEvent &&
-    kindOf(event.inputType) === 'history';
-const runInputHistoryCommand = (edytor, event) => event.inputType === 'historyUndo' ? edytor.historyUndo() : edytor.historyRedo();
 /**
  * What the browser shows for `text`: its element's text nodes in order (WebKit's
  * converted-space wrappers read as plain spaces), the empty filler and the
@@ -44,20 +30,6 @@ export const readDomText = (text) => {
     }
     return value;
 };
-const isLiveText = (text) => text.isInDocument;
-const getDomOffsetWithinText = (text, node, offset) => {
-    if (!text.node) {
-        return 0;
-    }
-    if (text.endsWithNewline && isInsideTrailingNewlineMarker(node)) {
-        return text.length;
-    }
-    // No model-length clamp here — the DOM caret is read BEFORE the
-    // reconcile writes the model, so a native insertion legitimately sits
-    // past the current `text.length` (the trailing-newline marker case is
-    // handled above; `setAtTextOffset` clamps the final write).
-    return getTextContentOffsetAtPoint(text.node, node, offset);
-};
 export const getCollapsedDomTextSelection = (edytor) => {
     const selection = getDomSelectionSnapshot(edytor.node);
     if (!selection?.anchorNode || !selection.isCollapsed) {
@@ -70,47 +42,22 @@ export const getCollapsedDomTextSelection = (edytor) => {
     if (!text?.node) {
         return null;
     }
-    return {
-        text,
-        offset: getDomOffsetWithinText(text, selection.anchorNode, selection.anchorOffset)
-    };
-};
-const getEventTextRepairTarget = (edytor, event) => {
-    const target = event.target instanceof Node ? event.target : null;
-    const text = edytor.selection.getTextOfNode(target);
-    if (!text?.node) {
-        return null;
-    }
-    return {
-        text,
-        offset: edytor.selection.state.startText === text ? edytor.selection.state.yStart : text.length
-    };
+    // No model rule here: the DOM caret is read BEFORE the reconcile writes
+    // the model, so a native insertion legitimately sits past `text.length`
+    // (`selectText` clamps the final write).
+    return { text, offset: domOffsetIn(text, selection.anchorNode, selection.anchorOffset) };
 };
 const getInputType = (event) => {
     const inputType = event.inputType;
     return typeof inputType === 'string' ? inputType : '';
 };
-const waitForSuppressedObservedMutationRepair = () => new Promise((resolve) => setTimeout(resolve, 20));
-/**
- * Where drift repair puts the caret: the command's caret, else the model
- * caret (a restore, or a line break), else the DOM caret; the event's text last.
- */
-const driftRepairTarget = (edytor, event, repair, caret) => {
-    const { startText, yStart } = edytor.selection.state;
-    const model = startText ? { text: startText, offset: yStart } : null;
-    const preferModel = repair || kindOf(getInputType(event)) === 'break';
-    return ((repair && caret) ||
-        (preferModel ? model : getCollapsedDomTextSelection(edytor)) ||
-        getEventTextRepairTarget(edytor, event));
-};
 const getNativeLineBreakInsertionIndexFromValue = (text, value) => {
     const change = diffText(text.stringContent, value);
     return change && !change.remove && /^[\r\n]+$/.test(change.insert) ? change.at : null;
 };
 export const handleNativeLineBreakTextValue = async (edytor, text, value) => {
-    if (!isLiveText(text)) {
+    if (!text.isInDocument)
         return false;
-    }
     const insertionIndex = getNativeLineBreakInsertionIndexFromValue(text, value);
     if (insertionIndex === null) {
         return false;
@@ -120,71 +67,10 @@ export const handleNativeLineBreakTextValue = async (edytor, text, value) => {
         ? 'insertLineBreak'
         : 'insertParagraph';
     text.refreshFromModel();
-    edytor.selection.setAtTextOffset(text, insertionIndex);
+    edytor.selection.selectText(text, insertionIndex);
     await runOccurrence(edytor, { inputType, cancelable: false });
     return true;
 };
-const handleNativeLineBreakTextInput = async (edytor, event) => {
-    if (!isNativeLineBreakTextInput(event)) {
-        return false;
-    }
-    const target = getCollapsedDomTextSelection(edytor) ?? getEventTextRepairTarget(edytor, event);
-    return target
-        ? handleNativeLineBreakTextValue(edytor, target.text, readDomText(target.text))
-        : false;
-};
-const getExpandedSelectionInputText = (edytor, event) => !edytor.readonly &&
-    !edytor.isComposing &&
-    isTextInsertionInput(event) &&
-    !edytor.selection.state.isCollapsed &&
-    edytor.selection.selectedBlocks.size === 0
-    ? event.data
-    : null;
-const replaceExpandedSelectionFromInputOnlyText = (edytor, value) => {
-    const target = replaceSelectionWithCollapsedTarget(edytor);
-    if (!target) {
-        return false;
-    }
-    edytor.selection.setAtTextOffset(target.text, target.offset);
-    target.text.insertText({
-        value,
-        start: target.offset,
-        end: target.offset
-    });
-    target.text.refreshFromModel();
-    edytor.selection.setAtTextOffset(target.text, target.offset + value.length);
-    return true;
-};
-/** Drift around a model-owned attempt: re-render its texts from the model and put the caret back. */
-const repairDrift = async (edytor, attempt, expect, event) => {
-    const repair = expect.mode !== 'refresh';
-    if (attempt.isStructuralKeyFallback && attempt.phase === 'open' && !repair) {
-        // The key's attempt has not run yet: its deadline performs it.
-        expect.input = false;
-        edytor.attempts.arm(attempt, 50);
-        return;
-    }
-    const serial = edytor.intentSerial;
-    if (expect.mode === 'discard') {
-        await waitForSuppressedObservedMutationRepair();
-    }
-    expect.input = false;
-    if (expect.mode !== 'discard')
-        edytor.attempts.arm(attempt, 0);
-    const target = driftRepairTarget(edytor, event, repair, expect.caret);
-    if (!target)
-        return;
-    const eventTarget = getEventTextRepairTarget(edytor, event);
-    if (eventTarget && eventTarget.text !== target.text && isLiveText(eventTarget.text)) {
-        eventTarget.text.refreshFromModel();
-    }
-    target.text.refreshFromModel();
-    // The attempt decided the caret; `select()` it — the projector displays it —
-    // unless a gesture came during the wait: the selection is then the user's.
-    if (edytor.intentSerial !== serial)
-        return;
-    edytor.selection.setAtTextOffset(target.text, Math.min(target.offset, target.text.length));
-};
 /**
  * An `input` no attempt expected (its engine sent no `beforeinput`): the
  * browser changed the text under its caret — a browser-owned attempt of its own.
@@ -201,45 +87,46 @@ const claimOf = (edytor, event) => {
     });
 };
 /**
- * An `input` event. Model-owned drift is repaired here; browser-made text is
- * never adopted here: the mutation queue is the only adopter, so
- * the `input` flushes it — a browser-owned attempt's change is adopted there,
- * once, through the dispatcher — then closes the attempt it belongs to.
+ * An `input` event. Browser-made text is never adopted here: the mutation
+ * queue is the only adopter (a native line break there runs as its
+ * occurrence), so the `input` flushes it — a browser-owned attempt's change
+ * is adopted there, once, through the dispatcher — then closes the attempt it
+ * belongs to. Drift around a model-owned attempt is the observer's to invert;
+ * a restoring attempt (a delete the browser could not be kept from) also
+ * re-renders the text the input landed in and shows its caret again, which
+ * the browser moved.
  */
 export async function onInput(event) {
     // The live session's own input; a late one of its tail is drift it expects.
     if (this.composition.input(event) === 'live')
         return;
+    const inputType = getInputType(event);
     // The attempt this `input` belongs to: the newest whose expectation it satisfies.
-    let attempt = this.attempts.inputOf(getInputType(event));
+    let attempt = this.attempts.inputOf(inputType);
     const expect = attempt?.expect;
-    if (attempt && expect?.kind === 'drift') {
-        return repairDrift(this, attempt, expect, event);
+    if (expect?.kind === 'drift') {
+        expect.input = false;
+        if (expect.mode !== 'restore')
+            return;
+        this.attempts.arm(attempt, 0);
+        const { selection } = this;
+        const at = expect.caret;
+        for (const text of [selection.getTextOfNode(event.target), at?.text])
+            if (text?.isInDocument)
+                text.refreshFromModel();
+        return selection.select(at ? selection.textValue(at.text, at.offset) : selection.value);
     }
     try {
-        if (isNativeInteractiveEvent(event) ||
-            (event && isNestedForeignEditableTarget(this.node, event.target))) {
+        if (isControlEvent(this.node, event))
             return;
-        }
-        if (isNativeHistoryInput(event)) {
-            // Same guard as the beforeinput channel — a history command
-            // mid-composition consumes capture groups while the IME still
-            // owns the DOM node (engines that deliver history via `input`
-            // only would otherwise bypass the beforeinput swallow).
+        // History an engine delivers by `input` only; mid-composition it would
+        // consume capture groups while the IME still owns the DOM node.
+        if (kindOf(inputType) === 'history') {
             if (!this.isComposing)
-                runInputHistoryCommand(this, event);
+                this[inputType]();
             return;
         }
         attempt ??= claimOf(this, event);
-        if (await handleNativeLineBreakTextInput(this, event)) {
-            return;
-        }
-        const expandedSelectionInputText = getExpandedSelectionInputText(this, event);
-        if (expandedSelectionInputText) {
-            if (replaceExpandedSelectionFromInputOnlyText(this, expandedSelectionInputText)) {
-                return;
-            }
-        }
         await this.surface.flush();
     }
     finally {

package/dist/events/onKeyDown.js

@@ -1,143 +1,76 @@
-import { isInsideTrailingNewlineMarker } from '../selection/selection.utils.js';
 import { isNativeInteractiveEvent, isNativeTextControl, isNativeTextControlEvent, ownsEvent } from './nativeInteractiveControl.js';
 import { replaceSelectedAtom } from '../session/bindings.js';
-import { admitKeyAttempt } from './onBeforeInput.js';
-import { targetless } from '../session/attempt.js';
-import { getDomSelection } from '../selection/domSelection.js';
+import { admitKeyAttempt, isTrailingSoftBreakBackward } from './onBeforeInput.js';
+import { INTENTS, intentSnapshot, keyIntentOf, targetless } from '../session/attempt.js';
+import { selectionIsInside } from './onFocus.js';
 const isEventFromEditor = (edytor, event) => {
-    if (!edytor.node) {
+    const { node, selection } = edytor;
+    if (!node)
         return true;
-    }
-    const activeElement = edytor.node.ownerDocument.activeElement;
-    const activeElementIsOutsideTextControl = activeElement instanceof HTMLElement &&
-        !edytor.node.contains(activeElement) &&
-        isNativeTextControl(activeElement);
-    if (activeElementIsOutsideTextControl) {
+    const active = node.ownerDocument.activeElement;
+    if (active instanceof HTMLElement && !node.contains(active) && isNativeTextControl(active))
         return false;
-    }
-    const hasEditorOwnedSelection = edytor.selection.selectedBlocks.size > 0 || edytor.selection.selectedInlineBlock.size > 0;
-    if (hasEditorOwnedSelection &&
-        (activeElement === edytor.node ||
-            activeElement === edytor.node.ownerDocument.body ||
-            (activeElement instanceof Node && edytor.node.contains(activeElement)))) {
+    // Focus on the host or inside it, or nowhere (the body): a selection of the
+    // editor's own (blocks, an atom; a text one under a command chord) takes the key.
+    const focused = active === node.ownerDocument.body || (active instanceof Node && node.contains(active));
+    if (focused &&
+        (selection.selectedBlocks.size > 0 ||
+            selection.selectedInlineBlock.size > 0 ||
+            ((event.metaKey || event.ctrlKey) && selection.textRange().startText?.node)))
         return true;
-    }
-    if (event.composedPath().includes(edytor.node)) {
+    if (event.composedPath().includes(node))
         return true;
-    }
-    if (event.target instanceof Node && edytor.node.contains(event.target)) {
+    if (event.target instanceof Node && node.contains(event.target))
         return true;
-    }
-    const hasModelTextSelection = Boolean(edytor.selection.state.startText?.node);
-    if ((event.metaKey || event.ctrlKey) &&
-        hasModelTextSelection &&
-        (activeElement === edytor.node ||
-            activeElement === edytor.node.ownerDocument.body ||
-            (activeElement instanceof Node && edytor.node.contains(activeElement)))) {
-        return true;
-    }
-    const selection = getDomSelection(edytor.node);
-    return Boolean(selection?.anchorNode &&
-        (edytor.node.contains(selection.anchorNode) ||
-            (selection.focusNode && edytor.node.contains(selection.focusNode))));
+    return selectionIsInside(node);
 };
 const hasCommandModifier = (event) => event.metaKey || event.ctrlKey || event.altKey;
 /** Backspace or Delete on a select or a button: the browser would delete around it in the host. */
 const shouldPreventNativeInteractiveDeletionKey = (event) => isNativeInteractiveEvent(event) &&
     !isNativeTextControlEvent(event) &&
     (event.key.toLowerCase() === 'backspace' || event.key.toLowerCase() === 'delete');
-const modifierKeys = new Set(['Alt', 'Control', 'Meta', 'Shift']);
-const shouldRefreshSelectionBeforeKeyDown = (edytor, event) => !modifierKeys.has(event.key) &&
+/** A command chord at a caret (a block or atom selection projects no caret). */
+const shouldRefreshSelectionBeforeKeyDown = (edytor, event) => !/^(Alt|Control|Meta|Shift)$/.test(event.key) &&
     hasCommandModifier(event) &&
-    edytor.selection.state.isCollapsed &&
-    edytor.selection.selectedBlocks.size === 0 &&
-    edytor.selection.selectedInlineBlock.size === 0 &&
+    edytor.selection.projection.isCollapsed &&
     !isNativeInteractiveEvent(event);
-const isPrintableReplacementKey = (event) => {
-    if (event.metaKey || event.ctrlKey || event.altKey || event.key === 'Dead') {
-        return false;
-    }
-    return event.key.length === 1;
-};
+/** A character key with no command modifier (a dead key's name is no character). */
+const isPrintableReplacementKey = (event) => !hasCommandModifier(event) && event.key.length === 1;
 /** The editing intent of an unmodified key (a character, Backspace, Delete, Enter), if it has one. */
-const keyIntent = (event) => {
-    if (event.isComposing || event.metaKey || event.ctrlKey || event.altKey)
-        return null;
-    if (event.key === 'Backspace')
-        return 'deleteContentBackward';
-    if (event.key === 'Delete')
-        return 'deleteContentForward';
-    if (event.key === 'Enter')
-        return event.shiftKey ? 'insertLineBreak' : 'insertParagraph';
-    return isPrintableReplacementKey(event) ? 'insertText' : null;
-};
-/** Copy, select all and the browser's find (the keymap does not run while readonly). */
-const isReadonlyAllowedShortcut = (event) => {
-    const key = event.key.toLowerCase();
-    const hasCopyModifier = event.metaKey || event.ctrlKey;
-    return hasCopyModifier && (key === 'c' || key === 'a' || key === 'f');
-};
-const isReadonlyNavigationKey = (event) => [
-    'arrowleft',
-    'arrowright',
-    'arrowup',
-    'arrowdown',
-    'home',
-    'end',
-    'pageup',
-    'pagedown',
-    'escape'
-].includes(event.key.toLowerCase());
-const shouldPreventReadonlyMutationKey = (event) => {
-    if (isNativeTextControlEvent(event)) {
-        return false;
-    }
-    if (isReadonlyAllowedShortcut(event) || isReadonlyNavigationKey(event)) {
-        return false;
-    }
-    const key = event.key.toLowerCase();
-    return (key.length === 1 || key === 'backspace' || key === 'delete' || key === 'enter' || key === 'tab');
-};
-const isBackspaceFromTrailingNewlineMarker = (edytor) => {
-    const { isCollapsed, startText, yStart } = edytor.selection.state;
-    if (!isCollapsed ||
-        !startText?.node ||
-        !startText.endsWithNewline ||
-        yStart !== startText.length) {
-        return false;
-    }
-    const selection = getDomSelection(startText.node);
-    const anchorNode = selection?.anchorNode;
-    return Boolean(anchorNode && isInsideTrailingNewlineMarker(anchorNode));
-};
+const keyIntent = (event) => event.isComposing || hasCommandModifier(event)
+    ? null
+    : (keyIntentOf(event.key, event.shiftKey) ??
+        (isPrintableReplacementKey(event) ? 'insertText' : null));
+/**
+ * A key that would edit a readonly view (a character, Backspace, Delete,
+ * Enter, Tab), outside a text control: never copy, select all or the
+ * browser's find (the keymap does not run while readonly).
+ */
+const shouldPreventReadonlyMutationKey = (event) => /^(.|backspace|delete|enter|tab)$/i.test(event.key) &&
+    !((event.metaKey || event.ctrlKey) && /^[acf]$/i.test(event.key)) &&
+    !isNativeTextControlEvent(event);
+/**
+ * The intent a keydown admits when its `beforeinput` may never come: Enter
+ * and Shift+Enter, and a Backspace or Delete over a range or at the edge of
+ * its block or text (or right after a trailing soft break, for Backspace,
+ * which the model deletes). With a
+ * command modifier, a word or line chord at the block's edge deletes the
+ * neighbour like a character (a unit delete, `runBeforeInputDeleteCommand`); WebKit announces no
+ * `beforeinput` for it at the document's first text.
+ */
 const getStructuralFallbackInputType = (edytor, event) => {
-    const key = event.key.toLowerCase();
+    const intent = keyIntentOf(event.key, event.shiftKey);
+    const dir = intent && INTENTS[intent].dir;
     const { isCollapsed, isAtStartOfBlock, isAtStartOfText, isAtEndOfBlock, isAtEndOfText } = edytor.selection.projection;
-    if (hasCommandModifier(event)) {
-        // A word or line chord at the block's edge deletes the neighbour like a
-        // character (`deleteCollapsedUnit`); WebKit announces no `beforeinput`
-        // for it at the document's first text (SW10-crdt-1).
-        if (!isCollapsed || event.shiftKey)
-            return null;
-        if (key === 'backspace' && isAtStartOfBlock)
-            return 'deleteContentBackward';
-        if (key === 'delete' && isAtEndOfBlock)
-            return 'deleteContentForward';
-        return null;
-    }
-    if (key === 'enter') {
-        return event.shiftKey ? 'insertLineBreak' : 'insertParagraph';
-    }
-    if (key === 'backspace') {
-        if (isBackspaceFromTrailingNewlineMarker(edytor)) {
-            return 'deleteContentBackward';
-        }
-        return !isCollapsed || isAtStartOfBlock || isAtStartOfText ? 'deleteContentBackward' : null;
-    }
-    if (key === 'delete') {
-        return !isCollapsed || isAtEndOfBlock || isAtEndOfText ? 'deleteContentForward' : null;
-    }
-    return null;
+    const back = dir === 'back';
+    const atBlockEdge = back ? isAtStartOfBlock : isAtEndOfBlock;
+    if (hasCommandModifier(event))
+        return dir && isCollapsed && !event.shiftKey && atBlockEdge ? intent : null;
+    if (!dir)
+        return intent;
+    const atTextEdge = back ? isAtStartOfText : isAtEndOfText;
+    const atMarker = back && isTrailingSoftBreakBackward(intentSnapshot(edytor, intent));
+    return !isCollapsed || atBlockEdge || atTextEdge || atMarker ? intent : null;
 };
 export function onKeyDown(e) {
     // A keydown the bindings are not offered offers no key to its `beforeinput`.
@@ -165,7 +98,7 @@ export function onKeyDown(e) {
         }
         return;
     }
-    if (this.selection.state.isVoidEditableElement) {
+    if (this.selection.voidField) {
         return;
     }
     // Any other native control (a link, the chrome's buttons beside the host)

package/dist/events/onPaste.d.ts

@@ -1,3 +1,16 @@
 import type { Edytor } from '../edytor.svelte.js';
-export declare const observeShiftPasteModifier: (rootNode: Node | null | undefined) => void;
+/**
+ * A paste: the browser's in a readonly view, a void's field, a kind's own
+ * control (a field bound to `block.data`, a nested editable island:
+ * `ownsEvent` — inserting the fragment at the model selection would write
+ * the document AND cancel its paste) or under a live composition (its
+ * preview owns the write path: the browser pastes, the observer reconciles
+ * it after the end, as PM input.ts:656-660). Else, unless Shift asks for
+ * plain text: an Edytor fragment; what an extension's `onPaste` claims (the
+ * `pasteFirst` ones first, then list order); a
+ * file nothing claimed inserts nothing (the Files → image seam), never its
+ * name; external HTML (HTML that carries nothing falls through); markdown
+ * text as its blocks (`paste.markdown`), except in a code block's lines.
+ * The plain text (or a URI) left is the paste occurrence's.
+ */
 export declare function onPaste(this: Edytor, e: ClipboardEvent): Promise<void>;

package/dist/events/onPaste.js

@@ -5,7 +5,6 @@ import { inCodeLines } from '../session/inputRules.js';
 import { flowOfHtml } from '../clipboard/htmlFlow.js';
 import { getDomSelectionSnapshot } from '../selection/domSelection.js';
 import { getYIndex } from '../selection/selection.utils.js';
-import { observeInternalDragSources } from './onDrop.js';
 import { runOccurrence } from './onBeforeInput.js';
 import { firstUriListEntry } from './dataTransferPayload.js';
 import { ownsEvent } from './nativeInteractiveControl.js';
@@ -13,27 +12,17 @@ import { ownsEvent } from './nativeInteractiveControl.js';
  * Shift-paste requests a plain-text paste (PM input.ts:620-630 —
  * `mod-shift-v` and `Shift+Insert` keyCode 45 both take the plain branch).
  * `ClipboardEvent` carries no modifier state, so the Shift state is tracked
- * on keydown/keyup capture at the owning root (document or shadow root).
+ * on the document's keydown/keyup capture (a shadow root's keys are composed:
+ * the document sees them first, Shift included).
  */
 let shiftPasteModifierHeld = false;
-const observedShiftRoots = new WeakSet();
-export const observeShiftPasteModifier = (rootNode) => {
-    if (!rootNode || observedShiftRoots.has(rootNode)) {
-        return;
-    }
-    observedShiftRoots.add(rootNode);
+if (typeof document !== 'undefined') {
     const track = (event) => {
         shiftPasteModifierHeld = event.shiftKey === true;
     };
-    rootNode.addEventListener('keydown', track, true);
-    rootNode.addEventListener('keyup', track, true);
-    const view = rootNode instanceof Document ? rootNode.defaultView : rootNode.ownerDocument?.defaultView;
-    view?.addEventListener('blur', () => {
-        shiftPasteModifierHeld = false;
-    });
-};
-if (typeof document !== 'undefined') {
-    observeShiftPasteModifier(document);
+    document.addEventListener('keydown', track, true);
+    document.addEventListener('keyup', track, true);
+    window.addEventListener('blur', track);
 }
 /**
  * A paste over a block selection lands at a collapsed DOM caret put outside
@@ -56,71 +45,57 @@ const syncCollapsedDomCaretForPaste = (edytor) => {
         if (selectedBlocks.has(block))
             return;
     if (text)
-        edytor.selection.setAtTextOffset(text, getYIndex(text, node, dom.anchorOffset));
+        edytor.selection.selectText(text, getYIndex(text, node, dom.anchorOffset));
 };
+/**
+ * A paste: the browser's in a readonly view, a void's field, a kind's own
+ * control (a field bound to `block.data`, a nested editable island:
+ * `ownsEvent` — inserting the fragment at the model selection would write
+ * the document AND cancel its paste) or under a live composition (its
+ * preview owns the write path: the browser pastes, the observer reconciles
+ * it after the end, as PM input.ts:656-660). Else, unless Shift asks for
+ * plain text: an Edytor fragment; what an extension's `onPaste` claims (the
+ * `pasteFirst` ones first, then list order); a
+ * file nothing claimed inserts nothing (the Files → image seam), never its
+ * name; external HTML (HTML that carries nothing falls through); markdown
+ * text as its blocks (`paste.markdown`), except in a code block's lines.
+ * The plain text (or a URI) left is the paste occurrence's.
+ */
 export async function onPaste(e) {
-    if (this.readonly || this.selection.state.isVoidEditableElement) {
-        return;
-    }
-    // A paste in a kind's own control (a field bound to `block.data`, a
-    // nested editable island) is the control's (`ownsEvent`): inserting the
-    // fragment at the model selection would write the document AND cancel its paste.
-    if (ownsEvent(this.node, e)) {
+    if (this.readonly || this.selection.voidField || ownsEvent(this.node, e) || this.isComposing)
         return;
-    }
-    if (this.isComposing) {
-        // The composition preview owns the write path — the browser performs
-        // the paste and the deferred observer reconciles it after
-        // compositionend (PM input.ts:656-660 does the same).
-        return;
-    }
-    observeInternalDragSources(this.node?.getRootNode());
-    observeShiftPasteModifier(this.node?.getRootNode());
     syncCollapsedDomCaretForPaste(this);
-    const preferPlainText = shiftPasteModifierHeld && Boolean(e.clipboardData?.getData('text/plain'));
-    if (!preferPlainText) {
-        const fragment = readEdytorClipboardFragment(e.clipboardData);
-        if (fragment) {
-            e.preventDefault();
-            return this.dispatcher.run('insertFromPaste', () => pasteFlow(this, flowOfFragment(fragment)));
-        }
-        const claimed = (plugin) => vetoable((prevent) => plugin.onPaste?.({ prevent, e }));
-        if (this.dispatcher.intercept(claimed, () => e.preventDefault()))
-            return;
-        // File payloads route only through the plugin `onPaste` hook (the
-        // Files → image seam: the image plugin with `upload` claims image
-        // files). An unclaimed file paste inserts nothing rather than silent
-        // file-name text.
-        if ((e.clipboardData?.files?.length ?? 0) > 0) {
-            e.preventDefault();
-            return;
-        }
-        // External HTML; HTML that carries nothing falls through to text/plain.
-        const flow = flowOfHtml(this, e.clipboardData?.getData('text/html'));
-        if (flow) {
-            e.preventDefault();
-            return this.dispatcher.run('insertFromPaste', () => pasteFlow(this, flow));
-        }
-        // Markdown text (`paste.markdown`): its blocks, except in a code block's lines.
-        const start = this.selection.projection.start?.block;
-        const at = start ? this.idToBlock.get(start) : undefined;
-        const markdown = at && inCodeLines(this, at)
-            ? null
-            : flowOfMarkdown(this, e.clipboardData?.getData('text/plain') ?? '');
-        if (markdown) {
-            e.preventDefault();
-            return this.dispatcher.run('insertFromPaste', () => pasteFlow(this, markdown));
+    const data = e.clipboardData;
+    const plain = data?.getData('text/plain') ?? '';
+    let flow = null;
+    if (!(shiftPasteModifierHeld && plain)) {
+        const fragment = readEdytorClipboardFragment(data);
+        if (!fragment) {
+            // The `pasteFirst` hooks (a pasted reference: page link's `fromPaste`), then the
+            // others in list order; the first that prevents claims the paste.
+            const claimed = (first) => (plugin) => !!plugin.pasteFirst === first && vetoable((prevent) => plugin.onPaste?.({ prevent, e }));
+            const stop = () => e.preventDefault();
+            if (this.dispatcher.intercept(claimed(true), stop) ||
+                this.dispatcher.intercept(claimed(false), stop))
+                return;
+            if (data?.files?.length)
+                return e.preventDefault();
         }
+        const start = this.idToBlock.get(this.selection.projection.start?.block ?? '');
+        flow = fragment
+            ? flowOfFragment(fragment)
+            : (flowOfHtml(this, data?.getData('text/html')) ??
+                (start && inCodeLines(this, start) ? null : flowOfMarkdown(this, plain)));
     }
-    if (!e.clipboardData?.getData('text/plain') &&
-        !firstUriListEntry(e.clipboardData?.getData('text/uri-list'))) {
+    if (!flow && !plain && !firstUriListEntry(data?.getData('text/uri-list')))
         return;
-    }
     e.preventDefault();
-    return runOccurrence(this, {
-        inputType: 'insertFromPaste',
-        data: e.clipboardData?.getData('text/plain') ?? '',
-        dataTransfer: e.clipboardData,
-        cancelable: true
-    });
+    return flow
+        ? this.dispatcher.run('insertFromPaste', () => pasteFlow(this, flow))
+        : runOccurrence(this, {
+            inputType: 'insertFromPaste',
+            data: plain,
+            dataTransfer: data,
+            cancelable: true
+        });
 }