@codemirror/view 6.2.5 → 6.3.1

package/dist/index.js

@@ -871,7 +871,7 @@ class WidgetView extends ContentView {
             if (pos > 0 ? i == 0 : i == rects.length - 1 || rect.top < rect.bottom)
                 break;
         }
-        return (pos == 0 && side > 0 || pos == this.length && side <= 0) ? rect : flattenRect(rect, pos == 0);
+        return flattenRect(rect, this.side > 0);
     }
     get isEditable() { return false; }
     destroy() {
@@ -1024,7 +1024,6 @@ function inlineDOMAtPos(parent, pos) {
             break;
         off = end;
     }
-    //  if (i) return DOMPos.after(children[i - 1].dom!)
     for (let j = i; j > 0; j--) {
         let prev = children[j - 1];
         if (prev.dom.parentNode == dom)
@@ -1051,21 +1050,59 @@ function joinInlineInto(parent, view, open) {
     parent.length += view.length;
 }
 function coordsInChildren(view, pos, side) {
-    for (let off = 0, i = 0; i < view.children.length; i++) {
-        let child = view.children[i], end = off + child.length, next;
-        if ((side <= 0 || end == view.length || child.getSide() > 0 ? end >= pos : end > pos) &&
-            (pos < end || i + 1 == view.children.length || (next = view.children[i + 1]).length || next.getSide() > 0)) {
-            let flatten = 0;
-            if (end == off) {
-                if (child.getSide() <= 0)
-                    continue;
-                flatten = side = -child.getSide();
+    if (!view.children.length)
+        return fallbackRect(view);
+    return (side <= 0 ? coordsInChildrenBefore : coordsInChildrenAfter)(view, pos);
+}
+function coordsInChildrenBefore(view, pos) {
+    // Find the last leaf in the tree that touches pos and doesn't have getSide() > 0
+    let found = null, foundPos = -1;
+    function scan(view, pos) {
+        for (let i = 0, off = 0; i < view.children.length && off <= pos; i++) {
+            let child = view.children[i], end = off + child.length;
+            if (end >= pos) {
+                if (child.children.length) {
+                    if (scan(child, pos - off))
+                        return true;
+                }
+                else if (end >= pos) {
+                    if (end == pos && child.getSide() > 0)
+                        return true;
+                    found = child;
+                    foundPos = pos - off;
+                }
+            }
+            off = end;
+        }
+    }
+    scan(view, pos);
+    return found ? found.coordsAt(Math.max(0, foundPos), -1) : coordsInChildrenAfter(view, pos);
+}
+function coordsInChildrenAfter(view, pos) {
+    // Find the first leaf in the tree that touches pos and doesn't have getSide() < 0
+    let found = null, foundPos = -1;
+    function scan(view, pos) {
+        for (let i = view.children.length - 1, off = view.length; i >= 0 && off >= pos; i--) {
+            let child = view.children[i];
+            off -= child.length;
+            if (off <= pos) {
+                if (child.children.length) {
+                    if (scan(child, pos - off))
+                        return true;
+                }
+                else if (off <= pos) {
+                    if (off == pos && child.getSide() < 0)
+                        return true;
+                    found = child;
+                    foundPos = pos - off;
+                }
             }
-            let rect = child.coordsAt(Math.max(0, pos - off), side);
-            return flatten && rect ? flattenRect(rect, side < 0) : rect;
         }
-        off = end;
     }
+    scan(view, pos);
+    return found ? found.coordsAt(Math.max(0, foundPos), 1) : coordsInChildrenBefore(view, pos);
+}
+function fallbackRect(view) {
     let last = view.dom.lastChild;
     if (!last)
         return view.dom.getBoundingClientRect();
@@ -1683,7 +1720,7 @@ class ContentBuilder {
                 this.addBlockWidget(new BlockWidgetView(deco.widget || new NullWidget("div"), len, type));
             }
             else {
-                let view = WidgetView.create(deco.widget || new NullWidget("span"), len, deco.startSide);
+                let view = WidgetView.create(deco.widget || new NullWidget("span"), len, len ? 0 : deco.startSide);
                 let cursorBefore = this.atCursorPos && !view.isEditable && openStart <= active.length && (from < to || deco.startSide > 0);
                 let cursorAfter = !view.isEditable && (from < to || deco.startSide <= 0);
                 let line = this.getLine();
@@ -4820,7 +4857,7 @@ class ViewState {
         this.updateForViewport();
         if (updateLines)
             this.updateViewportLines();
-        if (this.lineGaps.length || this.viewport.to - this.viewport.from > 4000 /* LG.DoubleMargin */)
+        if (this.lineGaps.length || this.viewport.to - this.viewport.from > (2000 /* LG.Margin */ << 1))
             this.updateLineGaps(this.ensureLineGaps(this.mapLineGaps(this.lineGaps, update.changes)));
         update.flags |= this.computeVisibleRanges();
         if (scrollTarget)
@@ -4876,7 +4913,7 @@ class ViewState {
                 refresh = true;
             if (refresh || oracle.lineWrapping && Math.abs(contentWidth - this.contentDOMWidth) > oracle.charWidth) {
                 let { lineHeight, charWidth } = view.docView.measureTextSize();
-                refresh = oracle.refresh(whiteSpace, lineHeight, charWidth, contentWidth / charWidth, lineHeights);
+                refresh = lineHeight > 0 && oracle.refresh(whiteSpace, lineHeight, charWidth, contentWidth / charWidth, lineHeights);
                 if (refresh) {
                     view.docView.minWidth = 0;
                     result |= 8 /* UpdateFlag.Geometry */;
@@ -4901,8 +4938,8 @@ class ViewState {
         this.updateForViewport();
         if ((result & 2 /* UpdateFlag.Height */) || viewportChange)
             this.updateViewportLines();
-        if (this.lineGaps.length || this.viewport.to - this.viewport.from > 4000 /* LG.DoubleMargin */)
-            this.updateLineGaps(this.ensureLineGaps(refresh ? [] : this.lineGaps));
+        if (this.lineGaps.length || this.viewport.to - this.viewport.from > (2000 /* LG.Margin */ << 1))
+            this.updateLineGaps(this.ensureLineGaps(refresh ? [] : this.lineGaps, view));
         result |= this.computeVisibleRanges();
         if (this.mustEnforceCursorAssoc) {
             this.mustEnforceCursorAssoc = false;
@@ -4973,46 +5010,86 @@ class ViewState {
     // since actual DOM coordinates aren't always available and
     // predictable. Relies on generous margins (see LG.Margin) to hide
     // the artifacts this might produce from the user.
-    ensureLineGaps(current) {
+    ensureLineGaps(current, mayMeasure) {
+        let wrapping = this.heightOracle.lineWrapping;
+        let margin = wrapping ? 10000 /* LG.MarginWrap */ : 2000 /* LG.Margin */, halfMargin = margin >> 1, doubleMargin = margin << 1;
+        // The non-wrapping logic won't work at all in predominantly right-to-left text.
+        if (this.defaultTextDirection != Direction.LTR && !wrapping)
+            return [];
         let gaps = [];
-        // This won't work at all in predominantly right-to-left text.
-        if (this.defaultTextDirection != Direction.LTR)
-            return gaps;
+        let addGap = (from, to, line, structure) => {
+            if (to - from < halfMargin)
+                return;
+            let sel = this.state.selection.main, avoid = [sel.from];
+            if (!sel.empty)
+                avoid.push(sel.to);
+            for (let pos of avoid) {
+                if (pos > from && pos < to) {
+                    addGap(from, pos - 10 /* LG.SelectionMargin */, line, structure);
+                    addGap(pos + 10 /* LG.SelectionMargin */, to, line, structure);
+                    return;
+                }
+            }
+            let gap = find(current, gap => gap.from >= line.from && gap.to <= line.to &&
+                Math.abs(gap.from - from) < halfMargin && Math.abs(gap.to - to) < halfMargin &&
+                !avoid.some(pos => gap.from < pos && gap.to > pos));
+            if (!gap) {
+                // When scrolling down, snap gap ends to line starts to avoid shifts in wrapping
+                if (to < line.to && mayMeasure && wrapping &&
+                    mayMeasure.visibleRanges.some(r => r.from <= to && r.to >= to)) {
+                    let lineStart = mayMeasure.moveToLineBoundary(EditorSelection.cursor(to), false, true).head;
+                    if (lineStart > from)
+                        to = lineStart;
+                }
+                gap = new LineGap(from, to, this.gapSize(line, from, to, structure));
+            }
+            gaps.push(gap);
+        };
         for (let line of this.viewportLines) {
-            if (line.length < 4000 /* LG.DoubleMargin */)
+            if (line.length < doubleMargin)
                 continue;
             let structure = lineStructure(line.from, line.to, this.stateDeco);
-            if (structure.total < 4000 /* LG.DoubleMargin */)
+            if (structure.total < doubleMargin)
                 continue;
+            let target = this.scrollTarget ? this.scrollTarget.range.head : null;
             let viewFrom, viewTo;
-            if (this.heightOracle.lineWrapping) {
-                let marginHeight = (2000 /* LG.Margin */ / this.heightOracle.lineLength) * this.heightOracle.lineHeight;
-                viewFrom = findPosition(structure, (this.visibleTop - line.top - marginHeight) / line.height);
-                viewTo = findPosition(structure, (this.visibleBottom - line.top + marginHeight) / line.height);
+            if (wrapping) {
+                let marginHeight = (margin / this.heightOracle.lineLength) * this.heightOracle.lineHeight;
+                let top, bot;
+                if (target != null) {
+                    let targetFrac = findFraction(structure, target);
+                    let spaceFrac = ((this.visibleBottom - this.visibleTop) / 2 + marginHeight) / line.height;
+                    top = targetFrac - spaceFrac;
+                    bot = targetFrac + spaceFrac;
+                }
+                else {
+                    top = (this.visibleTop - line.top - marginHeight) / line.height;
+                    bot = (this.visibleBottom - line.top + marginHeight) / line.height;
+                }
+                viewFrom = findPosition(structure, top);
+                viewTo = findPosition(structure, bot);
             }
             else {
                 let totalWidth = structure.total * this.heightOracle.charWidth;
-                let marginWidth = 2000 /* LG.Margin */ * this.heightOracle.charWidth;
-                viewFrom = findPosition(structure, (this.pixelViewport.left - marginWidth) / totalWidth);
-                viewTo = findPosition(structure, (this.pixelViewport.right + marginWidth) / totalWidth);
+                let marginWidth = margin * this.heightOracle.charWidth;
+                let left, right;
+                if (target != null) {
+                    let targetFrac = findFraction(structure, target);
+                    let spaceFrac = ((this.pixelViewport.right - this.pixelViewport.left) / 2 + marginWidth) / totalWidth;
+                    left = targetFrac - spaceFrac;
+                    right = targetFrac + spaceFrac;
+                }
+                else {
+                    left = (this.pixelViewport.left - marginWidth) / totalWidth;
+                    right = (this.pixelViewport.right + marginWidth) / totalWidth;
+                }
+                viewFrom = findPosition(structure, left);
+                viewTo = findPosition(structure, right);
             }
-            let outside = [];
             if (viewFrom > line.from)
-                outside.push({ from: line.from, to: viewFrom });
+                addGap(line.from, viewFrom, line, structure);
             if (viewTo < line.to)
-                outside.push({ from: viewTo, to: line.to });
-            let sel = this.state.selection.main;
-            // Make sure the gaps don't cover a selection end
-            if (sel.from >= line.from && sel.from <= line.to)
-                cutRange(outside, sel.from - 10 /* LG.SelectionMargin */, sel.from + 10 /* LG.SelectionMargin */);
-            if (!sel.empty && sel.to >= line.from && sel.to <= line.to)
-                cutRange(outside, sel.to - 10 /* LG.SelectionMargin */, sel.to + 10 /* LG.SelectionMargin */);
-            for (let { from, to } of outside)
-                if (to - from > 1000 /* LG.HalfMargin */) {
-                    gaps.push(find(current, gap => gap.from >= line.from && gap.to <= line.to &&
-                        Math.abs(gap.from - from) < 1000 /* LG.HalfMargin */ && Math.abs(gap.to - to) < 1000 /* LG.HalfMargin */) ||
-                        new LineGap(from, to, this.gapSize(line, from, to, structure)));
-                }
+                addGap(viewTo, line.to, line, structure);
         }
         return gaps;
     }
@@ -5110,20 +5187,6 @@ function findFraction(structure, pos) {
     }
     return counted / structure.total;
 }
-function cutRange(ranges, from, to) {
-    for (let i = 0; i < ranges.length; i++) {
-        let r = ranges[i];
-        if (r.from < to && r.to > from) {
-            let pieces = [];
-            if (r.from < from)
-                pieces.push({ from: r.from, to: from });
-            if (r.to > to)
-                pieces.push({ from: to, to: r.to });
-            ranges.splice(i, 1, ...pieces);
-            i += pieces.length - 1;
-        }
-    }
-}
 function find(array, f) {
     for (let val of array)
         if (f(val))
@@ -5423,6 +5486,227 @@ const baseTheme$1 = /*@__PURE__*/buildTheme("." + baseThemeID, {
     }
 }, lightDarkIDs);
 
+class DOMChange {
+    constructor(view, start, end, typeOver) {
+        this.typeOver = typeOver;
+        this.bounds = null;
+        this.text = "";
+        let { impreciseHead: iHead, impreciseAnchor: iAnchor } = view.docView;
+        if (start > -1 && !view.state.readOnly && (this.bounds = view.docView.domBoundsAround(start, end, 0))) {
+            let selPoints = iHead || iAnchor ? [] : selectionPoints(view);
+            let reader = new DOMReader(selPoints, view.state);
+            reader.readRange(this.bounds.startDOM, this.bounds.endDOM);
+            this.text = reader.text;
+            this.newSel = selectionFromPoints(selPoints, this.bounds.from);
+        }
+        else {
+            let domSel = view.observer.selectionRange;
+            let head = iHead && iHead.node == domSel.focusNode && iHead.offset == domSel.focusOffset ||
+                !contains(view.contentDOM, domSel.focusNode)
+                ? view.state.selection.main.head
+                : view.docView.posFromDOM(domSel.focusNode, domSel.focusOffset);
+            let anchor = iAnchor && iAnchor.node == domSel.anchorNode && iAnchor.offset == domSel.anchorOffset ||
+                !contains(view.contentDOM, domSel.anchorNode)
+                ? view.state.selection.main.anchor
+                : view.docView.posFromDOM(domSel.anchorNode, domSel.anchorOffset);
+            this.newSel = EditorSelection.single(anchor, head);
+        }
+    }
+}
+function applyDOMChange(view, domChange) {
+    let change;
+    let { newSel } = domChange, sel = view.state.selection.main;
+    if (domChange.bounds) {
+        let { from, to } = domChange.bounds;
+        let preferredPos = sel.from, preferredSide = null;
+        // Prefer anchoring to end when Backspace is pressed (or, on
+        // Android, when something was deleted)
+        if (view.inputState.lastKeyCode === 8 && view.inputState.lastKeyTime > Date.now() - 100 ||
+            browser.android && domChange.text.length < to - from) {
+            preferredPos = sel.to;
+            preferredSide = "end";
+        }
+        let diff = findDiff(view.state.doc.sliceString(from, to, LineBreakPlaceholder), domChange.text, preferredPos - from, preferredSide);
+        if (diff) {
+            // Chrome inserts two newlines when pressing shift-enter at the
+            // end of a line. DomChange drops one of those.
+            if (browser.chrome && view.inputState.lastKeyCode == 13 &&
+                diff.toB == diff.from + 2 && domChange.text.slice(diff.from, diff.toB) == LineBreakPlaceholder + LineBreakPlaceholder)
+                diff.toB--;
+            change = { from: from + diff.from, to: from + diff.toA,
+                insert: Text.of(domChange.text.slice(diff.from, diff.toB).split(LineBreakPlaceholder)) };
+        }
+    }
+    else if (newSel && (!view.hasFocus || !view.state.facet(editable) || newSel.main.eq(sel))) {
+        newSel = null;
+    }
+    if (!change && !newSel)
+        return false;
+    if (!change && domChange.typeOver && !sel.empty && newSel && newSel.main.empty) {
+        // Heuristic to notice typing over a selected character
+        change = { from: sel.from, to: sel.to, insert: view.state.doc.slice(sel.from, sel.to) };
+    }
+    else if (change && change.from >= sel.from && change.to <= sel.to &&
+        (change.from != sel.from || change.to != sel.to) &&
+        (sel.to - sel.from) - (change.to - change.from) <= 4) {
+        // If the change is inside the selection and covers most of it,
+        // assume it is a selection replace (with identical characters at
+        // the start/end not included in the diff)
+        change = {
+            from: sel.from, to: sel.to,
+            insert: view.state.doc.slice(sel.from, change.from).append(change.insert).append(view.state.doc.slice(change.to, sel.to))
+        };
+    }
+    else if ((browser.mac || browser.android) && change && change.from == change.to && change.from == sel.head - 1 &&
+        /^\. ?$/.test(change.insert.toString())) {
+        // Detect insert-period-on-double-space Mac and Android behavior,
+        // and transform it into a regular space insert.
+        if (newSel && change.insert.length == 2)
+            newSel = EditorSelection.single(newSel.main.anchor - 1, newSel.main.head - 1);
+        change = { from: sel.from, to: sel.to, insert: Text.of([" "]) };
+    }
+    if (change) {
+        let startState = view.state;
+        if (browser.ios && view.inputState.flushIOSKey(view))
+            return true;
+        // Android browsers don't fire reasonable key events for enter,
+        // backspace, or delete. So this detects changes that look like
+        // they're caused by those keys, and reinterprets them as key
+        // events. (Some of these keys are also handled by beforeinput
+        // events and the pendingAndroidKey mechanism, but that's not
+        // reliable in all situations.)
+        if (browser.android &&
+            ((change.from == sel.from && change.to == sel.to &&
+                change.insert.length == 1 && change.insert.lines == 2 &&
+                dispatchKey(view.contentDOM, "Enter", 13)) ||
+                (change.from == sel.from - 1 && change.to == sel.to && change.insert.length == 0 &&
+                    dispatchKey(view.contentDOM, "Backspace", 8)) ||
+                (change.from == sel.from && change.to == sel.to + 1 && change.insert.length == 0 &&
+                    dispatchKey(view.contentDOM, "Delete", 46))))
+            return true;
+        let text = change.insert.toString();
+        if (view.state.facet(inputHandler).some(h => h(view, change.from, change.to, text)))
+            return true;
+        if (view.inputState.composing >= 0)
+            view.inputState.composing++;
+        let tr;
+        if (change.from >= sel.from && change.to <= sel.to && change.to - change.from >= (sel.to - sel.from) / 3 &&
+            (!newSel || newSel.main.empty && newSel.main.from == change.from + change.insert.length) &&
+            view.inputState.composing < 0) {
+            let before = sel.from < change.from ? startState.sliceDoc(sel.from, change.from) : "";
+            let after = sel.to > change.to ? startState.sliceDoc(change.to, sel.to) : "";
+            tr = startState.replaceSelection(view.state.toText(before + change.insert.sliceString(0, undefined, view.state.lineBreak) + after));
+        }
+        else {
+            let changes = startState.changes(change);
+            let mainSel = newSel && !startState.selection.main.eq(newSel.main) && newSel.main.to <= changes.newLength
+                ? newSel.main : undefined;
+            // Try to apply a composition change to all cursors
+            if (startState.selection.ranges.length > 1 && view.inputState.composing >= 0 &&
+                change.to <= sel.to && change.to >= sel.to - 10) {
+                let replaced = view.state.sliceDoc(change.from, change.to);
+                let compositionRange = compositionSurroundingNode(view) || view.state.doc.lineAt(sel.head);
+                let offset = sel.to - change.to, size = sel.to - sel.from;
+                tr = startState.changeByRange(range => {
+                    if (range.from == sel.from && range.to == sel.to)
+                        return { changes, range: mainSel || range.map(changes) };
+                    let to = range.to - offset, from = to - replaced.length;
+                    if (range.to - range.from != size || view.state.sliceDoc(from, to) != replaced ||
+                        // Unfortunately, there's no way to make multiple
+                        // changes in the same node work without aborting
+                        // composition, so cursors in the composition range are
+                        // ignored.
+                        compositionRange && range.to >= compositionRange.from && range.from <= compositionRange.to)
+                        return { range };
+                    let rangeChanges = startState.changes({ from, to, insert: change.insert }), selOff = range.to - sel.to;
+                    return {
+                        changes: rangeChanges,
+                        range: !mainSel ? range.map(rangeChanges) :
+                            EditorSelection.range(Math.max(0, mainSel.anchor + selOff), Math.max(0, mainSel.head + selOff))
+                    };
+                });
+            }
+            else {
+                tr = {
+                    changes,
+                    selection: mainSel && startState.selection.replaceRange(mainSel)
+                };
+            }
+        }
+        let userEvent = "input.type";
+        if (view.composing) {
+            userEvent += ".compose";
+            if (view.inputState.compositionFirstChange) {
+                userEvent += ".start";
+                view.inputState.compositionFirstChange = false;
+            }
+        }
+        view.dispatch(tr, { scrollIntoView: true, userEvent });
+        return true;
+    }
+    else if (newSel && !newSel.main.eq(sel)) {
+        let scrollIntoView = false, userEvent = "select";
+        if (view.inputState.lastSelectionTime > Date.now() - 50) {
+            if (view.inputState.lastSelectionOrigin == "select")
+                scrollIntoView = true;
+            userEvent = view.inputState.lastSelectionOrigin;
+        }
+        view.dispatch({ selection: newSel, scrollIntoView, userEvent });
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+function findDiff(a, b, preferredPos, preferredSide) {
+    let minLen = Math.min(a.length, b.length);
+    let from = 0;
+    while (from < minLen && a.charCodeAt(from) == b.charCodeAt(from))
+        from++;
+    if (from == minLen && a.length == b.length)
+        return null;
+    let toA = a.length, toB = b.length;
+    while (toA > 0 && toB > 0 && a.charCodeAt(toA - 1) == b.charCodeAt(toB - 1)) {
+        toA--;
+        toB--;
+    }
+    if (preferredSide == "end") {
+        let adjust = Math.max(0, from - Math.min(toA, toB));
+        preferredPos -= toA + adjust - from;
+    }
+    if (toA < from && a.length < b.length) {
+        let move = preferredPos <= from && preferredPos >= toA ? from - preferredPos : 0;
+        from -= move;
+        toB = from + (toB - toA);
+        toA = from;
+    }
+    else if (toB < from) {
+        let move = preferredPos <= from && preferredPos >= toB ? from - preferredPos : 0;
+        from -= move;
+        toA = from + (toA - toB);
+        toB = from;
+    }
+    return { from, toA, toB };
+}
+function selectionPoints(view) {
+    let result = [];
+    if (view.root.activeElement != view.contentDOM)
+        return result;
+    let { anchorNode, anchorOffset, focusNode, focusOffset } = view.observer.selectionRange;
+    if (anchorNode) {
+        result.push(new DOMPoint(anchorNode, anchorOffset));
+        if (focusNode != anchorNode || focusOffset != anchorOffset)
+            result.push(new DOMPoint(focusNode, focusOffset));
+    }
+    return result;
+}
+function selectionFromPoints(points, base) {
+    if (points.length == 0)
+        return null;
+    let anchor = points[0].pos, head = points.length == 2 ? points[1].pos : anchor;
+    return anchor > -1 && head > -1 ? EditorSelection.single(anchor + base, head + base) : null;
+}
+
 const observeOptions = {
     childList: true,
     characterData: true,
@@ -5434,10 +5718,8 @@ const observeOptions = {
 // DOMCharacterDataModified there
 const useCharData = browser.ie && browser.ie_version <= 11;
 class DOMObserver {
-    constructor(view, onChange, onScrollChanged) {
+    constructor(view) {
         this.view = view;
-        this.onChange = onChange;
-        this.onScrollChanged = onScrollChanged;
         this.active = false;
         // The known selection. Kept in our own object, as opposed to just
         // directly accessing the selection because:
@@ -5452,6 +5734,7 @@ class DOMObserver {
         this.resizeTimeout = -1;
         this.queue = [];
         this.delayedAndroidKey = null;
+        this.flushingAndroidKey = -1;
         this.lastChange = 0;
         this.scrollTargets = [];
         this.intersection = null;
@@ -5520,6 +5803,11 @@ class DOMObserver {
         this.listenForScroll();
         this.readSelectionRange();
     }
+    onScrollChanged(e) {
+        this.view.inputState.runScrollHandlers(this.view, e);
+        if (this.intersecting)
+            this.view.measure();
+    }
     onScroll(e) {
         if (this.intersecting)
             this.flush(false);
@@ -5679,14 +5967,17 @@ class DOMObserver {
     // them or, if that has no effect, dispatches the given key.
     delayAndroidKey(key, keyCode) {
         var _a;
-        if (!this.delayedAndroidKey)
-            this.view.win.requestAnimationFrame(() => {
+        if (!this.delayedAndroidKey) {
+            let flush = () => {
                 let key = this.delayedAndroidKey;
-                this.delayedAndroidKey = null;
-                this.delayedFlush = -1;
-                if (!this.flush() && key.force)
-                    dispatchKey(this.dom, key.key, key.keyCode);
-            });
+                if (key) {
+                    this.clearDelayedAndroidKey();
+                    if (!this.flush() && key.force)
+                        dispatchKey(this.dom, key.key, key.keyCode);
+                }
+            };
+            this.flushingAndroidKey = this.view.win.requestAnimationFrame(flush);
+        }
         // Since backspace beforeinput is sometimes signalled spuriously,
         // Enter always takes precedence.
         if (!this.delayedAndroidKey || key == "Enter")
@@ -5699,6 +5990,11 @@ class DOMObserver {
                 force: this.lastChange < Date.now() - 50 || !!((_a = this.delayedAndroidKey) === null || _a === void 0 ? void 0 : _a.force)
             };
     }
+    clearDelayedAndroidKey() {
+        this.win.cancelAnimationFrame(this.flushingAndroidKey);
+        this.delayedAndroidKey = null;
+        this.flushingAndroidKey = -1;
+    }
     flushSoon() {
         if (this.delayedFlush < 0)
             this.delayedFlush = this.view.win.requestAnimationFrame(() => { this.delayedFlush = -1; this.flush(); });
@@ -5733,6 +6029,17 @@ class DOMObserver {
         }
         return { from, to, typeOver };
     }
+    readChange() {
+        let { from, to, typeOver } = this.processRecords();
+        let newSel = this.selectionChanged && hasSelection(this.dom, this.selectionRange);
+        if (from < 0 && !newSel)
+            return null;
+        if (from > -1)
+            this.lastChange = Date.now();
+        this.view.inputState.lastFocusTime = 0;
+        this.selectionChanged = false;
+        return new DOMChange(this.view, from, to, typeOver);
+    }
     // Apply pending changes, if any
     flush(readSelection = true) {
         // Completely hold off flushing when pending keys are set—the code
@@ -5742,16 +6049,11 @@ class DOMObserver {
             return false;
         if (readSelection)
             this.readSelectionRange();
-        let { from, to, typeOver } = this.processRecords();
-        let newSel = this.selectionChanged && hasSelection(this.dom, this.selectionRange);
-        if (from < 0 && !newSel)
+        let domChange = this.readChange();
+        if (!domChange)
             return false;
-        if (from > -1)
-            this.lastChange = Date.now();
-        this.view.inputState.lastFocusTime = 0;
-        this.selectionChanged = false;
         let startState = this.view.state;
-        let handled = this.onChange(from, to, typeOver);
+        let handled = applyDOMChange(this.view, domChange);
         // The view wasn't updated
         if (this.view.state == startState)
             this.view.update([]);
@@ -5807,6 +6109,8 @@ class DOMObserver {
         this.removeWindowListeners(this.win);
         clearTimeout(this.parentCheck);
         clearTimeout(this.resizeTimeout);
+        this.win.cancelAnimationFrame(this.delayedFlush);
+        this.win.cancelAnimationFrame(this.flushingAndroidKey);
     }
 }
 function findChild(cView, dom, dir) {
@@ -5848,213 +6152,6 @@ function safariSelectionRangeHack(view) {
     return { anchorNode, anchorOffset, focusNode, focusOffset };
 }
 
-function applyDOMChange(view, start, end, typeOver) {
-    let change, newSel;
-    let sel = view.state.selection.main;
-    if (start > -1) {
-        let bounds = view.docView.domBoundsAround(start, end, 0);
-        if (!bounds || view.state.readOnly)
-            return false;
-        let { from, to } = bounds;
-        let selPoints = view.docView.impreciseHead || view.docView.impreciseAnchor ? [] : selectionPoints(view);
-        let reader = new DOMReader(selPoints, view.state);
-        reader.readRange(bounds.startDOM, bounds.endDOM);
-        let preferredPos = sel.from, preferredSide = null;
-        // Prefer anchoring to end when Backspace is pressed (or, on
-        // Android, when something was deleted)
-        if (view.inputState.lastKeyCode === 8 && view.inputState.lastKeyTime > Date.now() - 100 ||
-            browser.android && reader.text.length < to - from) {
-            preferredPos = sel.to;
-            preferredSide = "end";
-        }
-        let diff = findDiff(view.state.doc.sliceString(from, to, LineBreakPlaceholder), reader.text, preferredPos - from, preferredSide);
-        if (diff) {
-            // Chrome inserts two newlines when pressing shift-enter at the
-            // end of a line. This drops one of those.
-            if (browser.chrome && view.inputState.lastKeyCode == 13 &&
-                diff.toB == diff.from + 2 && reader.text.slice(diff.from, diff.toB) == LineBreakPlaceholder + LineBreakPlaceholder)
-                diff.toB--;
-            change = { from: from + diff.from, to: from + diff.toA,
-                insert: Text.of(reader.text.slice(diff.from, diff.toB).split(LineBreakPlaceholder)) };
-        }
-        newSel = selectionFromPoints(selPoints, from);
-    }
-    else if (view.hasFocus || !view.state.facet(editable)) {
-        let domSel = view.observer.selectionRange;
-        let { impreciseHead: iHead, impreciseAnchor: iAnchor } = view.docView;
-        let head = iHead && iHead.node == domSel.focusNode && iHead.offset == domSel.focusOffset ||
-            !contains(view.contentDOM, domSel.focusNode)
-            ? view.state.selection.main.head
-            : view.docView.posFromDOM(domSel.focusNode, domSel.focusOffset);
-        let anchor = iAnchor && iAnchor.node == domSel.anchorNode && iAnchor.offset == domSel.anchorOffset ||
-            !contains(view.contentDOM, domSel.anchorNode)
-            ? view.state.selection.main.anchor
-            : view.docView.posFromDOM(domSel.anchorNode, domSel.anchorOffset);
-        if (head != sel.head || anchor != sel.anchor)
-            newSel = EditorSelection.single(anchor, head);
-    }
-    if (!change && !newSel)
-        return false;
-    // Heuristic to notice typing over a selected character
-    if (!change && typeOver && !sel.empty && newSel && newSel.main.empty)
-        change = { from: sel.from, to: sel.to, insert: view.state.doc.slice(sel.from, sel.to) };
-    // If the change is inside the selection and covers most of it,
-    // assume it is a selection replace (with identical characters at
-    // the start/end not included in the diff)
-    else if (change && change.from >= sel.from && change.to <= sel.to &&
-        (change.from != sel.from || change.to != sel.to) &&
-        (sel.to - sel.from) - (change.to - change.from) <= 4)
-        change = {
-            from: sel.from, to: sel.to,
-            insert: view.state.doc.slice(sel.from, change.from).append(change.insert).append(view.state.doc.slice(change.to, sel.to))
-        };
-    // Detect insert-period-on-double-space Mac behavior, and transform
-    // it into a regular space insert.
-    else if ((browser.mac || browser.android) && change && change.from == change.to && change.from == sel.head - 1 &&
-        change.insert.toString() == ".")
-        change = { from: sel.from, to: sel.to, insert: Text.of([" "]) };
-    if (change) {
-        let startState = view.state;
-        if (browser.ios && view.inputState.flushIOSKey(view))
-            return true;
-        // Android browsers don't fire reasonable key events for enter,
-        // backspace, or delete. So this detects changes that look like
-        // they're caused by those keys, and reinterprets them as key
-        // events. (Some of these keys are also handled by beforeinput
-        // events and the pendingAndroidKey mechanism, but that's not
-        // reliable in all situations.)
-        if (browser.android &&
-            ((change.from == sel.from && change.to == sel.to &&
-                change.insert.length == 1 && change.insert.lines == 2 &&
-                dispatchKey(view.contentDOM, "Enter", 13)) ||
-                (change.from == sel.from - 1 && change.to == sel.to && change.insert.length == 0 &&
-                    dispatchKey(view.contentDOM, "Backspace", 8)) ||
-                (change.from == sel.from && change.to == sel.to + 1 && change.insert.length == 0 &&
-                    dispatchKey(view.contentDOM, "Delete", 46))))
-            return true;
-        let text = change.insert.toString();
-        if (view.state.facet(inputHandler).some(h => h(view, change.from, change.to, text)))
-            return true;
-        if (view.inputState.composing >= 0)
-            view.inputState.composing++;
-        let tr;
-        if (change.from >= sel.from && change.to <= sel.to && change.to - change.from >= (sel.to - sel.from) / 3 &&
-            (!newSel || newSel.main.empty && newSel.main.from == change.from + change.insert.length) &&
-            view.inputState.composing < 0) {
-            let before = sel.from < change.from ? startState.sliceDoc(sel.from, change.from) : "";
-            let after = sel.to > change.to ? startState.sliceDoc(change.to, sel.to) : "";
-            tr = startState.replaceSelection(view.state.toText(before + change.insert.sliceString(0, undefined, view.state.lineBreak) + after));
-        }
-        else {
-            let changes = startState.changes(change);
-            let mainSel = newSel && !startState.selection.main.eq(newSel.main) && newSel.main.to <= changes.newLength
-                ? newSel.main : undefined;
-            // Try to apply a composition change to all cursors
-            if (startState.selection.ranges.length > 1 && view.inputState.composing >= 0 &&
-                change.to <= sel.to && change.to >= sel.to - 10) {
-                let replaced = view.state.sliceDoc(change.from, change.to);
-                let compositionRange = compositionSurroundingNode(view) || view.state.doc.lineAt(sel.head);
-                let offset = sel.to - change.to, size = sel.to - sel.from;
-                tr = startState.changeByRange(range => {
-                    if (range.from == sel.from && range.to == sel.to)
-                        return { changes, range: mainSel || range.map(changes) };
-                    let to = range.to - offset, from = to - replaced.length;
-                    if (range.to - range.from != size || view.state.sliceDoc(from, to) != replaced ||
-                        // Unfortunately, there's no way to make multiple
-                        // changes in the same node work without aborting
-                        // composition, so cursors in the composition range are
-                        // ignored.
-                        compositionRange && range.to >= compositionRange.from && range.from <= compositionRange.to)
-                        return { range };
-                    let rangeChanges = startState.changes({ from, to, insert: change.insert }), selOff = range.to - sel.to;
-                    return {
-                        changes: rangeChanges,
-                        range: !mainSel ? range.map(rangeChanges) :
-                            EditorSelection.range(Math.max(0, mainSel.anchor + selOff), Math.max(0, mainSel.head + selOff))
-                    };
-                });
-            }
-            else {
-                tr = {
-                    changes,
-                    selection: mainSel && startState.selection.replaceRange(mainSel)
-                };
-            }
-        }
-        let userEvent = "input.type";
-        if (view.composing) {
-            userEvent += ".compose";
-            if (view.inputState.compositionFirstChange) {
-                userEvent += ".start";
-                view.inputState.compositionFirstChange = false;
-            }
-        }
-        view.dispatch(tr, { scrollIntoView: true, userEvent });
-        return true;
-    }
-    else if (newSel && !newSel.main.eq(sel)) {
-        let scrollIntoView = false, userEvent = "select";
-        if (view.inputState.lastSelectionTime > Date.now() - 50) {
-            if (view.inputState.lastSelectionOrigin == "select")
-                scrollIntoView = true;
-            userEvent = view.inputState.lastSelectionOrigin;
-        }
-        view.dispatch({ selection: newSel, scrollIntoView, userEvent });
-        return true;
-    }
-    else {
-        return false;
-    }
-}
-function findDiff(a, b, preferredPos, preferredSide) {
-    let minLen = Math.min(a.length, b.length);
-    let from = 0;
-    while (from < minLen && a.charCodeAt(from) == b.charCodeAt(from))
-        from++;
-    if (from == minLen && a.length == b.length)
-        return null;
-    let toA = a.length, toB = b.length;
-    while (toA > 0 && toB > 0 && a.charCodeAt(toA - 1) == b.charCodeAt(toB - 1)) {
-        toA--;
-        toB--;
-    }
-    if (preferredSide == "end") {
-        let adjust = Math.max(0, from - Math.min(toA, toB));
-        preferredPos -= toA + adjust - from;
-    }
-    if (toA < from && a.length < b.length) {
-        let move = preferredPos <= from && preferredPos >= toA ? from - preferredPos : 0;
-        from -= move;
-        toB = from + (toB - toA);
-        toA = from;
-    }
-    else if (toB < from) {
-        let move = preferredPos <= from && preferredPos >= toB ? from - preferredPos : 0;
-        from -= move;
-        toA = from + (toA - toB);
-        toB = from;
-    }
-    return { from, toA, toB };
-}
-function selectionPoints(view) {
-    let result = [];
-    if (view.root.activeElement != view.contentDOM)
-        return result;
-    let { anchorNode, anchorOffset, focusNode, focusOffset } = view.observer.selectionRange;
-    if (anchorNode) {
-        result.push(new DOMPoint(anchorNode, anchorOffset));
-        if (focusNode != anchorNode || focusOffset != anchorOffset)
-            result.push(new DOMPoint(focusNode, focusOffset));
-    }
-    return result;
-}
-function selectionFromPoints(points, base) {
-    if (points.length == 0)
-        return null;
-    let anchor = points[0].pos, head = points.length == 2 ? points[1].pos : anchor;
-    return anchor > -1 && head > -1 ? EditorSelection.single(anchor + base, head + base) : null;
-}
-
 // The editor's update state machine looks something like this:
 //
 //     Idle → Updating ⇆ Idle (unchecked) → Measuring → Idle
@@ -6117,13 +6214,7 @@ class EditorView {
         this.plugins = this.state.facet(viewPlugin).map(spec => new PluginInstance(spec));
         for (let plugin of this.plugins)
             plugin.update(this);
-        this.observer = new DOMObserver(this, (from, to, typeOver) => {
-            return applyDOMChange(this, from, to, typeOver);
-        }, event => {
-            this.inputState.runScrollHandlers(this, event);
-            if (this.observer.intersecting)
-                this.measure();
-        });
+        this.observer = new DOMObserver(this);
         this.inputState = new InputState(this);
         this.inputState.ensureHandlers(this, this.plugins);
         this.docView = new DocView(this);
@@ -6207,7 +6298,20 @@ class EditorView {
             this.viewState.state = state;
             return;
         }
-        this.observer.clear();
+        // If there was a pending DOM change, eagerly read it and try to
+        // apply it after the given transactions.
+        let pendingKey = this.observer.delayedAndroidKey, domChange = null;
+        if (pendingKey) {
+            this.observer.clearDelayedAndroidKey();
+            domChange = this.observer.readChange();
+            // Only try to apply DOM changes if the transactions didn't
+            // change the doc or selection.
+            if (domChange && !this.state.doc.eq(state.doc) || !this.state.selection.eq(state.selection))
+                domChange = null;
+        }
+        else {
+            this.observer.clear();
+        }
         // When the phrases change, redraw the editor
         if (state.facet(EditorState.phrases) != this.state.facet(EditorState.phrases))
             return this.setState(state);
@@ -6249,6 +6353,10 @@ class EditorView {
         if (!update.empty)
             for (let listener of this.state.facet(updateListener))
                 listener(update);
+        if (domChange) {
+            if (!applyDOMChange(this, domChange) && pendingKey.force)
+                dispatchKey(this.contentDOM, pendingKey.key, pendingKey.keyCode);
+        }
     }
     /**
     Reset the view to the given state. (This will cause the entire
@@ -7086,6 +7194,7 @@ function buildKeymap(bindings, platform = currentPlatform) {
             throw new Error("Key binding " + name + " is used both as a regular binding and as a multi-stroke prefix");
     };
     let add = (scope, key, command, preventDefault) => {
+        var _a, _b;
         let scopeObj = bound[scope] || (bound[scope] = Object.create(null));
         let parts = key.split(/ (?!$)/).map(k => normalizeKeyName(k, platform));
         for (let i = 1; i < parts.length; i++) {
@@ -7094,7 +7203,7 @@ function buildKeymap(bindings, platform = currentPlatform) {
             if (!scopeObj[prefix])
                 scopeObj[prefix] = {
                     preventDefault: true,
-                    commands: [(view) => {
+                    run: [(view) => {
                             let ourObj = storedPrefix = { view, prefix, scope };
                             setTimeout(() => { if (storedPrefix == ourObj)
                                 storedPrefix = null; }, PrefixTimeout);
@@ -7104,16 +7213,26 @@ function buildKeymap(bindings, platform = currentPlatform) {
         }
         let full = parts.join(" ");
         checkPrefix(full, false);
-        let binding = scopeObj[full] || (scopeObj[full] = { preventDefault: false, commands: [] });
-        binding.commands.push(command);
+        let binding = scopeObj[full] || (scopeObj[full] = { preventDefault: false, run: ((_b = (_a = scopeObj._any) === null || _a === void 0 ? void 0 : _a.run) === null || _b === void 0 ? void 0 : _b.slice()) || [] });
+        if (command)
+            binding.run.push(command);
         if (preventDefault)
             binding.preventDefault = true;
     };
     for (let b of bindings) {
+        let scopes = b.scope ? b.scope.split(" ") : ["editor"];
+        if (b.any)
+            for (let scope of scopes) {
+                let scopeObj = bound[scope] || (bound[scope] = Object.create(null));
+                if (!scopeObj._any)
+                    scopeObj._any = { preventDefault: false, run: [] };
+                for (let key in scopeObj)
+                    scopeObj[key].run.push(b.any);
+            }
         let name = b[platform] || b.key;
         if (!name)
             continue;
-        for (let scope of b.scope ? b.scope.split(" ") : ["editor"]) {
+        for (let scope of scopes) {
             add(scope, name, b.run, b.preventDefault);
             if (b.shift)
                 add(scope, "Shift-" + name, b.shift, b.preventDefault);
@@ -7130,11 +7249,15 @@ function runHandlers(map, event, view, scope) {
         if (fallthrough = modifierCodes.indexOf(event.keyCode) < 0)
             storedPrefix = null;
     }
+    let ran = new Set;
     let runFor = (binding) => {
         if (binding) {
-            for (let cmd of binding.commands)
-                if (cmd(view))
-                    return true;
+            for (let cmd of binding.run)
+                if (!ran.has(cmd)) {
+                    ran.add(cmd);
+                    if (cmd(view, event))
+                        return true;
+                }
             if (binding.preventDefault)
                 fallthrough = true;
         }
@@ -7156,6 +7279,8 @@ function runHandlers(map, event, view, scope) {
             if (runFor(scopeObj[prefix + modifiers(name, event, true)]))
                 return true;
         }
+        if (runFor(scopeObj._any))
+            return true;
     }
     return fallthrough;
 }