@codemirror/view 6.2.2 → 6.2.4

package/dist/index.cjs

@@ -109,7 +109,7 @@ function scrollRectIntoView(dom, rect, side, x, y, xMargin, yMargin, ltr) {
             }
             else {
                 if (cur.scrollHeight <= cur.clientHeight && cur.scrollWidth <= cur.clientWidth) {
-                    cur = cur.parentNode;
+                    cur = cur.assignedSlot || cur.parentNode;
                     continue;
                 }
                 let rect = cur.getBoundingClientRect();
@@ -160,24 +160,28 @@ function scrollRectIntoView(dom, rect, side, x, y, xMargin, yMargin, ltr) {
                     win.scrollBy(moveX, moveY);
                 }
                 else {
+                    let movedX = 0, movedY = 0;
                     if (moveY) {
                         let start = cur.scrollTop;
                         cur.scrollTop += moveY;
-                        moveY = cur.scrollTop - start;
+                        movedY = cur.scrollTop - start;
                     }
                     if (moveX) {
                         let start = cur.scrollLeft;
                         cur.scrollLeft += moveX;
-                        moveX = cur.scrollLeft - start;
+                        movedX = cur.scrollLeft - start;
                     }
-                    rect = { left: rect.left - moveX, top: rect.top - moveY,
-                        right: rect.right - moveX, bottom: rect.bottom - moveY };
+                    rect = { left: rect.left - movedX, top: rect.top - movedY,
+                        right: rect.right - movedX, bottom: rect.bottom - movedY };
+                    if (movedX && Math.abs(movedX - moveX) < 1)
+                        x = "nearest";
+                    if (movedY && Math.abs(movedY - moveY) < 1)
+                        y = "nearest";
                 }
             }
             if (top)
                 break;
             cur = cur.assignedSlot || cur.parentNode;
-            x = y = "nearest";
         }
         else if (cur.nodeType == 11) { // A shadow root
             cur = cur.host;
@@ -308,7 +312,7 @@ class ContentView {
     constructor() {
         this.parent = null;
         this.dom = null;
-        this.dirty = 2 /* Node */;
+        this.dirty = 2 /* Dirty.Node */;
     }
     get editorView() {
         if (!this.parent)
@@ -339,7 +343,7 @@ class ContentView {
     // given position.
     coordsAt(_pos, _side) { return null; }
     sync(track) {
-        if (this.dirty & 2 /* Node */) {
+        if (this.dirty & 2 /* Dirty.Node */) {
             let parent = this.dom;
             let prev = null, next;
             for (let child of this.children) {
@@ -350,7 +354,7 @@ class ContentView {
                             child.reuseDOM(next);
                     }
                     child.sync(track);
-                    child.dirty = 0 /* Not */;
+                    child.dirty = 0 /* Dirty.Not */;
                 }
                 next = prev ? prev.nextSibling : parent.firstChild;
                 if (track && !track.written && track.node == parent && next != child.dom)
@@ -370,11 +374,11 @@ class ContentView {
             while (next)
                 next = rm$1(next);
         }
-        else if (this.dirty & 1 /* Child */) {
+        else if (this.dirty & 1 /* Dirty.Child */) {
             for (let child of this.children)
                 if (child.dirty) {
                     child.sync(track);
-                    child.dirty = 0 /* Not */;
+                    child.dirty = 0 /* Dirty.Not */;
                 }
         }
     }
@@ -439,16 +443,16 @@ class ContentView {
             endDOM: toI < this.children.length && toI >= 0 ? this.children[toI].dom : null };
     }
     markDirty(andParent = false) {
-        this.dirty |= 2 /* Node */;
+        this.dirty |= 2 /* Dirty.Node */;
         this.markParentsDirty(andParent);
     }
     markParentsDirty(childList) {
         for (let parent = this.parent; parent; parent = parent.parent) {
             if (childList)
-                parent.dirty |= 2 /* Node */;
-            if (parent.dirty & 1 /* Child */)
+                parent.dirty |= 2 /* Dirty.Node */;
+            if (parent.dirty & 1 /* Dirty.Child */)
                 return;
-            parent.dirty |= 1 /* Child */;
+            parent.dirty |= 1 /* Dirty.Child */;
             childList = false;
         }
     }
@@ -724,13 +728,13 @@ class MarkView extends ContentView {
     reuseDOM(node) {
         if (node.nodeName == this.mark.tagName.toUpperCase()) {
             this.setDOM(node);
-            this.dirty |= 4 /* Attrs */ | 2 /* Node */;
+            this.dirty |= 4 /* Dirty.Attrs */ | 2 /* Dirty.Node */;
         }
     }
     sync(track) {
         if (!this.dom)
             this.setDOM(this.setAttrs(document.createElement(this.mark.tagName)));
-        else if (this.dirty & 4 /* Attrs */)
+        else if (this.dirty & 4 /* Dirty.Attrs */)
             this.setAttrs(this.dom);
         super.sync(track);
     }
@@ -1240,7 +1244,7 @@ class Decoration extends state.RangeValue {
     */
     static widget(spec) {
         let side = spec.side || 0, block = !!spec.block;
-        side += block ? (side > 0 ? 300000000 /* BlockAfter */ : -400000000 /* BlockBefore */) : (side > 0 ? 100000000 /* InlineAfter */ : -100000000 /* InlineBefore */);
+        side += block ? (side > 0 ? 300000000 /* Side.BlockAfter */ : -400000000 /* Side.BlockBefore */) : (side > 0 ? 100000000 /* Side.InlineAfter */ : -100000000 /* Side.InlineBefore */);
         return new PointDecoration(spec, side, side, block, spec.widget || null, false);
     }
     /**
@@ -1250,13 +1254,13 @@ class Decoration extends state.RangeValue {
     static replace(spec) {
         let block = !!spec.block, startSide, endSide;
         if (spec.isBlockGap) {
-            startSide = -500000000 /* GapStart */;
-            endSide = 400000000 /* GapEnd */;
+            startSide = -500000000 /* Side.GapStart */;
+            endSide = 400000000 /* Side.GapEnd */;
         }
         else {
             let { start, end } = getInclusive(spec, block);
-            startSide = (start ? (block ? -300000000 /* BlockIncStart */ : -1 /* InlineIncStart */) : 500000000 /* NonIncStart */) - 1;
-            endSide = (end ? (block ? 200000000 /* BlockIncEnd */ : 1 /* InlineIncEnd */) : -600000000 /* NonIncEnd */) + 1;
+            startSide = (start ? (block ? -300000000 /* Side.BlockIncStart */ : -1 /* Side.InlineIncStart */) : 500000000 /* Side.NonIncStart */) - 1;
+            endSide = (end ? (block ? 200000000 /* Side.BlockIncEnd */ : 1 /* Side.InlineIncEnd */) : -600000000 /* Side.NonIncEnd */) + 1;
         }
         return new PointDecoration(spec, startSide, endSide, block, spec.widget || null, true);
     }
@@ -1287,7 +1291,7 @@ Decoration.none = state.RangeSet.empty;
 class MarkDecoration extends Decoration {
     constructor(spec) {
         let { start, end } = getInclusive(spec);
-        super(start ? -1 /* InlineIncStart */ : 500000000 /* NonIncStart */, end ? 1 /* InlineIncEnd */ : -600000000 /* NonIncEnd */, null, spec);
+        super(start ? -1 /* Side.InlineIncStart */ : 500000000 /* Side.NonIncStart */, end ? 1 /* Side.InlineIncEnd */ : -600000000 /* Side.NonIncEnd */, null, spec);
         this.tagName = spec.tagName || "span";
         this.class = spec.class || "";
         this.attrs = spec.attributes || null;
@@ -1308,7 +1312,7 @@ class MarkDecoration extends Decoration {
 MarkDecoration.prototype.point = false;
 class LineDecoration extends Decoration {
     constructor(spec) {
-        super(-200000000 /* Line */, -200000000 /* Line */, null, spec);
+        super(-200000000 /* Side.Line */, -200000000 /* Side.Line */, null, spec);
     }
     eq(other) {
         return other instanceof LineDecoration && attrsEq(this.spec.attributes, other.spec.attributes);
@@ -1445,7 +1449,7 @@ class LineView extends ContentView {
     reuseDOM(node) {
         if (node.nodeName == "DIV") {
             this.setDOM(node);
-            this.dirty |= 4 /* Attrs */ | 2 /* Node */;
+            this.dirty |= 4 /* Dirty.Attrs */ | 2 /* Dirty.Node */;
         }
     }
     sync(track) {
@@ -1455,7 +1459,7 @@ class LineView extends ContentView {
             this.dom.className = "cm-line";
             this.prevAttrs = this.attrs ? null : undefined;
         }
-        else if (this.dirty & 4 /* Attrs */) {
+        else if (this.dirty & 4 /* Dirty.Attrs */) {
             clearAttributes(this.dom);
             this.dom.className = "cm-line";
             this.prevAttrs = this.attrs ? null : undefined;
@@ -1585,7 +1589,7 @@ class ContentBuilder {
         this.content = [];
         this.curLine = null;
         this.breakAtStart = 0;
-        this.pendingBuffer = 0 /* No */;
+        this.pendingBuffer = 0 /* Buf.No */;
         // Set to false directly after a widget that covers the position after it
         this.atCursorPos = true;
         this.openStart = -1;
@@ -1611,7 +1615,7 @@ class ContentBuilder {
     flushBuffer(active) {
         if (this.pendingBuffer) {
             this.curLine.append(wrapMarks(new WidgetBufferView(-1), active), active.length);
-            this.pendingBuffer = 0 /* No */;
+            this.pendingBuffer = 0 /* Buf.No */;
         }
     }
     addBlockWidget(view) {
@@ -1623,7 +1627,7 @@ class ContentBuilder {
         if (!openEnd)
             this.flushBuffer([]);
         else
-            this.pendingBuffer = 0 /* No */;
+            this.pendingBuffer = 0 /* Buf.No */;
         if (!this.posCovered())
             this.getLine();
     }
@@ -1651,7 +1655,7 @@ class ContentBuilder {
                     this.textOff = 0;
                 }
             }
-            let take = Math.min(this.text.length - this.textOff, length, 512 /* Chunk */);
+            let take = Math.min(this.text.length - this.textOff, length, 512 /* T.Chunk */);
             this.flushBuffer(active.slice(0, openStart));
             this.getLine().append(wrapMarks(new TextView(this.text.slice(this.textOff, this.textOff + take)), active), openStart);
             this.atCursorPos = true;
@@ -1686,8 +1690,8 @@ class ContentBuilder {
                 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();
-                if (this.pendingBuffer == 2 /* IfCursor */ && !cursorBefore)
-                    this.pendingBuffer = 0 /* No */;
+                if (this.pendingBuffer == 2 /* Buf.IfCursor */ && !cursorBefore)
+                    this.pendingBuffer = 0 /* Buf.No */;
                 this.flushBuffer(active);
                 if (cursorBefore) {
                     line.append(wrapMarks(new WidgetBufferView(1), active), openStart);
@@ -1695,7 +1699,7 @@ class ContentBuilder {
                 }
                 line.append(wrapMarks(view, active), openStart);
                 this.atCursorPos = cursorAfter;
-                this.pendingBuffer = !cursorAfter ? 0 /* No */ : from < to ? 1 /* Yes */ : 2 /* IfCursor */;
+                this.pendingBuffer = !cursorAfter ? 0 /* Buf.No */ : from < to ? 1 /* Buf.Yes */ : 2 /* Buf.IfCursor */;
             }
         }
         else if (this.doc.lineAt(this.pos).from == this.pos) { // Line decoration
@@ -1988,7 +1992,7 @@ class ViewUpdate {
         let focus = view.hasFocus;
         if (focus != view.inputState.notifiedFocused) {
             view.inputState.notifiedFocused = focus;
-            this.flags |= 1 /* Focus */;
+            this.flags |= 1 /* UpdateFlag.Focus */;
         }
     }
     /**
@@ -2003,27 +2007,27 @@ class ViewUpdate {
     update.
     */
     get viewportChanged() {
-        return (this.flags & 4 /* Viewport */) > 0;
+        return (this.flags & 4 /* UpdateFlag.Viewport */) > 0;
     }
     /**
     Indicates whether the height of a block element in the editor
     changed in this update.
     */
     get heightChanged() {
-        return (this.flags & 2 /* Height */) > 0;
+        return (this.flags & 2 /* UpdateFlag.Height */) > 0;
     }
     /**
     Returns true when the document was modified or the size of the
     editor, or elements within the editor, changed.
     */
     get geometryChanged() {
-        return this.docChanged || (this.flags & (8 /* Geometry */ | 2 /* Height */)) > 0;
+        return this.docChanged || (this.flags & (8 /* UpdateFlag.Geometry */ | 2 /* UpdateFlag.Height */)) > 0;
     }
     /**
     True when this update indicates a focus change.
     */
     get focusChanged() {
-        return (this.flags & 1 /* Focus */) > 0;
+        return (this.flags & 1 /* UpdateFlag.Focus */) > 0;
     }
     /**
     Whether the document changed in this update.
@@ -2082,12 +2086,12 @@ for (let p of ["()", "[]", "{}"]) {
 }
 function charType(ch) {
     return ch <= 0xf7 ? LowTypes[ch] :
-        0x590 <= ch && ch <= 0x5f4 ? 2 /* R */ :
+        0x590 <= ch && ch <= 0x5f4 ? 2 /* T.R */ :
             0x600 <= ch && ch <= 0x6f9 ? ArabicTypes[ch - 0x600] :
-                0x6ee <= ch && ch <= 0x8ac ? 4 /* AL */ :
-                    0x2000 <= ch && ch <= 0x200b ? 256 /* NI */ :
-                        0xfb50 <= ch && ch <= 0xfdff ? 4 /* AL */ :
-                            ch == 0x200c ? 256 /* NI */ : 1 /* L */;
+                0x6ee <= ch && ch <= 0x8ac ? 4 /* T.AL */ :
+                    0x2000 <= ch && ch <= 0x200b ? 256 /* T.NI */ :
+                        0xfb50 <= ch && ch <= 0xfdff ? 4 /* T.AL */ :
+                            ch == 0x200c ? 256 /* T.NI */ : 1 /* T.L */;
 }
 const BidiRE = /[\u0590-\u05f4\u0600-\u06ff\u0700-\u08ac\ufb50-\ufdff]/;
 /**
@@ -2152,8 +2156,8 @@ class BidiSpan {
 // Reused array of character types
 const types = [];
 function computeOrder(line, direction) {
-    let len = line.length, outerType = direction == LTR ? 1 /* L */ : 2 /* R */, oppositeType = direction == LTR ? 2 /* R */ : 1 /* L */;
-    if (!line || outerType == 1 /* L */ && !BidiRE.test(line))
+    let len = line.length, outerType = direction == LTR ? 1 /* T.L */ : 2 /* T.R */, oppositeType = direction == LTR ? 2 /* T.R */ : 1 /* T.L */;
+    if (!line || outerType == 1 /* T.L */ && !BidiRE.test(line))
         return trivialOrder(len);
     // W1. Examine each non-spacing mark (NSM) in the level run, and
     // change the type of the NSM to the type of the previous
@@ -2167,12 +2171,12 @@ function computeOrder(line, direction) {
     // (Left after this: L, R, EN, AN, ET, CS, NI)
     for (let i = 0, prev = outerType, prevStrong = outerType; i < len; i++) {
         let type = charType(line.charCodeAt(i));
-        if (type == 512 /* NSM */)
+        if (type == 512 /* T.NSM */)
             type = prev;
-        else if (type == 8 /* EN */ && prevStrong == 4 /* AL */)
-            type = 16 /* AN */;
-        types[i] = type == 4 /* AL */ ? 2 /* R */ : type;
-        if (type & 7 /* Strong */)
+        else if (type == 8 /* T.EN */ && prevStrong == 4 /* T.AL */)
+            type = 16 /* T.AN */;
+        types[i] = type == 4 /* T.AL */ ? 2 /* T.R */ : type;
+        if (type & 7 /* T.Strong */)
             prevStrong = type;
         prev = type;
     }
@@ -2186,26 +2190,26 @@ function computeOrder(line, direction) {
     // (Left after this: L, R, EN+AN, NI)
     for (let i = 0, prev = outerType, prevStrong = outerType; i < len; i++) {
         let type = types[i];
-        if (type == 128 /* CS */) {
-            if (i < len - 1 && prev == types[i + 1] && (prev & 24 /* Num */))
+        if (type == 128 /* T.CS */) {
+            if (i < len - 1 && prev == types[i + 1] && (prev & 24 /* T.Num */))
                 type = types[i] = prev;
             else
-                types[i] = 256 /* NI */;
+                types[i] = 256 /* T.NI */;
         }
-        else if (type == 64 /* ET */) {
+        else if (type == 64 /* T.ET */) {
             let end = i + 1;
-            while (end < len && types[end] == 64 /* ET */)
+            while (end < len && types[end] == 64 /* T.ET */)
                 end++;
-            let replace = (i && prev == 8 /* EN */) || (end < len && types[end] == 8 /* EN */) ? (prevStrong == 1 /* L */ ? 1 /* L */ : 8 /* EN */) : 256 /* NI */;
+            let replace = (i && prev == 8 /* T.EN */) || (end < len && types[end] == 8 /* T.EN */) ? (prevStrong == 1 /* T.L */ ? 1 /* T.L */ : 8 /* T.EN */) : 256 /* T.NI */;
             for (let j = i; j < end; j++)
                 types[j] = replace;
             i = end - 1;
         }
-        else if (type == 8 /* EN */ && prevStrong == 1 /* L */) {
-            types[i] = 1 /* L */;
+        else if (type == 8 /* T.EN */ && prevStrong == 1 /* T.L */) {
+            types[i] = 1 /* T.L */;
         }
         prev = type;
-        if (type & 7 /* Strong */)
+        if (type & 7 /* T.Strong */)
             prevStrong = type;
     }
     // N0. Process bracket pairs in an isolating run sequence
@@ -2220,9 +2224,9 @@ function computeOrder(line, direction) {
                 for (let sJ = sI - 3; sJ >= 0; sJ -= 3) {
                     if (BracketStack[sJ + 1] == -br) {
                         let flags = BracketStack[sJ + 2];
-                        let type = (flags & 2 /* EmbedInside */) ? outerType :
-                            !(flags & 4 /* OppositeInside */) ? 0 :
-                                (flags & 1 /* OppositeBefore */) ? oppositeType : outerType;
+                        let type = (flags & 2 /* Bracketed.EmbedInside */) ? outerType :
+                            !(flags & 4 /* Bracketed.OppositeInside */) ? 0 :
+                                (flags & 1 /* Bracketed.OppositeBefore */) ? oppositeType : outerType;
                         if (type)
                             types[i] = types[BracketStack[sJ]] = type;
                         sI = sJ;
@@ -2230,7 +2234,7 @@ function computeOrder(line, direction) {
                     }
                 }
             }
-            else if (BracketStack.length == 189 /* MaxDepth */) {
+            else if (BracketStack.length == 189 /* Bracketed.MaxDepth */) {
                 break;
             }
             else {
@@ -2239,20 +2243,20 @@ function computeOrder(line, direction) {
                 BracketStack[sI++] = context;
             }
         }
-        else if ((type = types[i]) == 2 /* R */ || type == 1 /* L */) {
+        else if ((type = types[i]) == 2 /* T.R */ || type == 1 /* T.L */) {
             let embed = type == outerType;
-            context = embed ? 0 : 1 /* OppositeBefore */;
+            context = embed ? 0 : 1 /* Bracketed.OppositeBefore */;
             for (let sJ = sI - 3; sJ >= 0; sJ -= 3) {
                 let cur = BracketStack[sJ + 2];
-                if (cur & 2 /* EmbedInside */)
+                if (cur & 2 /* Bracketed.EmbedInside */)
                     break;
                 if (embed) {
-                    BracketStack[sJ + 2] |= 2 /* EmbedInside */;
+                    BracketStack[sJ + 2] |= 2 /* Bracketed.EmbedInside */;
                 }
                 else {
-                    if (cur & 4 /* OppositeInside */)
+                    if (cur & 4 /* Bracketed.OppositeInside */)
                         break;
-                    BracketStack[sJ + 2] |= 4 /* OppositeInside */;
+                    BracketStack[sJ + 2] |= 4 /* Bracketed.OppositeInside */;
                 }
             }
         }
@@ -2265,13 +2269,13 @@ function computeOrder(line, direction) {
     // N2. Any remaining neutrals take the embedding direction.
     // (Left after this: L, R, EN+AN)
     for (let i = 0; i < len; i++) {
-        if (types[i] == 256 /* NI */) {
+        if (types[i] == 256 /* T.NI */) {
             let end = i + 1;
-            while (end < len && types[end] == 256 /* NI */)
+            while (end < len && types[end] == 256 /* T.NI */)
                 end++;
-            let beforeL = (i ? types[i - 1] : outerType) == 1 /* L */;
-            let afterL = (end < len ? types[end] : outerType) == 1 /* L */;
-            let replace = beforeL == afterL ? (beforeL ? 1 /* L */ : 2 /* R */) : outerType;
+            let beforeL = (i ? types[i - 1] : outerType) == 1 /* T.L */;
+            let afterL = (end < len ? types[end] : outerType) == 1 /* T.L */;
+            let replace = beforeL == afterL ? (beforeL ? 1 /* T.L */ : 2 /* T.R */) : outerType;
             for (let j = i; j < end; j++)
                 types[j] = replace;
             i = end - 1;
@@ -2283,15 +2287,15 @@ function computeOrder(line, direction) {
     // explicit embedding into account, we can build up the order on
     // the fly, without following the level-based algorithm.
     let order = [];
-    if (outerType == 1 /* L */) {
+    if (outerType == 1 /* T.L */) {
         for (let i = 0; i < len;) {
-            let start = i, rtl = types[i++] != 1 /* L */;
-            while (i < len && rtl == (types[i] != 1 /* L */))
+            let start = i, rtl = types[i++] != 1 /* T.L */;
+            while (i < len && rtl == (types[i] != 1 /* T.L */))
                 i++;
             if (rtl) {
                 for (let j = i; j > start;) {
-                    let end = j, l = types[--j] != 2 /* R */;
-                    while (j > start && l == (types[j - 1] != 2 /* R */))
+                    let end = j, l = types[--j] != 2 /* T.R */;
+                    while (j > start && l == (types[j - 1] != 2 /* T.R */))
                         j--;
                     order.push(new BidiSpan(j, end, l ? 2 : 1));
                 }
@@ -2303,8 +2307,8 @@ function computeOrder(line, direction) {
     }
     else {
         for (let i = 0; i < len;) {
-            let start = i, rtl = types[i++] == 2 /* R */;
-            while (i < len && rtl == (types[i] == 2 /* R */))
+            let start = i, rtl = types[i++] == 2 /* T.R */;
+            while (i < len && rtl == (types[i] == 2 /* T.R */))
                 i++;
             order.push(new BidiSpan(start, i, rtl ? 1 : 2));
         }
@@ -2525,7 +2529,7 @@ class DocView extends ContentView {
         let prevDeco = this.decorations, deco = this.updateDeco();
         let decoDiff = findChangedDeco(prevDeco, deco, update.changes);
         changedRanges = ChangedRange.extendWithRanges(changedRanges, decoDiff);
-        if (this.dirty == 0 /* Not */ && changedRanges.length == 0) {
+        if (this.dirty == 0 /* Dirty.Not */ && changedRanges.length == 0) {
             return false;
         }
         else {
@@ -2554,7 +2558,7 @@ class DocView extends ContentView {
             // to detect that situation.
             let track = browser.chrome || browser.ios ? { node: observer.selectionRange.focusNode, written: false } : undefined;
             this.sync(track);
-            this.dirty = 0 /* Not */;
+            this.dirty = 0 /* Dirty.Not */;
             if (track && (track.written || observer.selectionRange.focusNode != track.node))
                 this.forceSelection = true;
             this.dom.style.height = "";
@@ -2583,8 +2587,7 @@ class DocView extends ContentView {
     updateSelection(mustRead = false, fromPointer = false) {
         if (mustRead || !this.view.observer.selectionRange.focusNode)
             this.view.observer.readSelectionRange();
-        if (!(fromPointer || this.mayControlSelection()) ||
-            browser.ios && this.view.inputState.rapidCompositionStart)
+        if (!(fromPointer || this.mayControlSelection()))
             return;
         let force = this.forceSelection;
         this.forceSelection = false;
@@ -2621,10 +2624,10 @@ class DocView extends ContentView {
                     // Work around https://bugzilla.mozilla.org/show_bug.cgi?id=1612076
                     if (browser.gecko) {
                         let nextTo = nextToUneditable(anchor.node, anchor.offset);
-                        if (nextTo && nextTo != (1 /* Before */ | 2 /* After */)) {
-                            let text = nearbyTextNode(anchor.node, anchor.offset, nextTo == 1 /* Before */ ? 1 : -1);
+                        if (nextTo && nextTo != (1 /* NextTo.Before */ | 2 /* NextTo.After */)) {
+                            let text = nearbyTextNode(anchor.node, anchor.offset, nextTo == 1 /* NextTo.Before */ ? 1 : -1);
                             if (text)
-                                anchor = new DOMPos(text, nextTo == 1 /* Before */ ? 0 : text.nodeValue.length);
+                                anchor = new DOMPos(text, nextTo == 1 /* NextTo.Before */ ? 0 : text.nodeValue.length);
                         }
                     }
                     rawSel.collapse(anchor.node, anchor.offset);
@@ -2956,8 +2959,8 @@ function nearbyTextNode(node, offset, side) {
 function nextToUneditable(node, offset) {
     if (node.nodeType != 1)
         return 0;
-    return (offset && node.childNodes[offset - 1].contentEditable == "false" ? 1 /* Before */ : 0) |
-        (offset < node.childNodes.length && node.childNodes[offset].contentEditable == "false" ? 2 /* After */ : 0);
+    return (offset && node.childNodes[offset - 1].contentEditable == "false" ? 1 /* NextTo.Before */ : 0) |
+        (offset < node.childNodes.length && node.childNodes[offset].contentEditable == "false" ? 2 /* NextTo.After */ : 0);
 }
 class DecorationComparator$1 {
     constructor() {
@@ -3312,7 +3315,7 @@ function skipAtoms(view, oldPos, pos) {
         for (let set of atoms) {
             set.between(pos.from - 1, pos.from + 1, (from, to, value) => {
                 if (pos.from > from && pos.from < to) {
-                    pos = oldPos.from > pos.from ? state.EditorSelection.cursor(from, 1) : state.EditorSelection.cursor(to, -1);
+                    pos = oldPos.head > pos.from ? state.EditorSelection.cursor(from, 1) : state.EditorSelection.cursor(to, -1);
                     moved = true;
                 }
             });
@@ -3354,7 +3357,6 @@ class InputState {
         // composition)
         this.compositionFirstChange = null;
         this.compositionEndedAt = 0;
-        this.rapidCompositionStart = false;
         this.mouseSelection = null;
         for (let type in handlers) {
             let handler = handlers[type];
@@ -3502,8 +3504,7 @@ class InputState {
         return false;
     }
     mustFlushObserver(event) {
-        return (event.type == "keydown" && event.keyCode != 229) ||
-            event.type == "compositionend" && !browser.ios;
+        return event.type == "keydown" && event.keyCode != 229;
     }
     startMouseSelection(mouseSelection) {
         if (this.mouseSelection)
@@ -3771,8 +3772,7 @@ function basicMouseSelection(view, event) {
     return {
         update(update) {
             if (update.docChanged) {
-                if (start)
-                    start.pos = update.changes.mapPos(start.pos);
+                start.pos = update.changes.mapPos(start.pos);
                 startSel = startSel.map(update.changes);
                 lastEvent = null;
             }
@@ -3785,8 +3785,6 @@ function basicMouseSelection(view, event) {
                 cur = last = queryPos(view, event);
                 lastEvent = event;
             }
-            if (!cur || !start)
-                return startSel;
             let range = rangeForClick(view, cur.pos, cur.bias, type);
             if (start.pos != cur.pos && !extend) {
                 let startRange = rangeForClick(view, start.pos, start.bias, type);
@@ -3958,36 +3956,24 @@ handlers.blur = view => {
     view.observer.clearSelectionRange();
     updateForFocusChange(view);
 };
-function forceClearComposition(view, rapid) {
-    if (view.docView.compositionDeco.size) {
-        view.inputState.rapidCompositionStart = rapid;
-        try {
-            view.update([]);
-        }
-        finally {
-            view.inputState.rapidCompositionStart = false;
-        }
-    }
-}
 handlers.compositionstart = handlers.compositionupdate = view => {
     if (view.inputState.compositionFirstChange == null)
         view.inputState.compositionFirstChange = true;
     if (view.inputState.composing < 0) {
         // FIXME possibly set a timeout to clear it again on Android
         view.inputState.composing = 0;
-        if (view.docView.compositionDeco.size) {
-            view.observer.flush();
-            forceClearComposition(view, true);
-        }
     }
 };
 handlers.compositionend = view => {
     view.inputState.composing = -1;
     view.inputState.compositionEndedAt = Date.now();
     view.inputState.compositionFirstChange = null;
+    if (browser.chrome && browser.android)
+        view.observer.flushSoon();
     setTimeout(() => {
-        if (view.inputState.composing < 0)
-            forceClearComposition(view, false);
+        // Force the composition state to be cleared if it hasn't already been
+        if (view.inputState.composing < 0 && view.docView.compositionDeco.size)
+            view.update([]);
     }, 50);
 };
 handlers.contextmenu = view => {
@@ -4158,13 +4144,13 @@ const Epsilon = 1e-3;
 class HeightMap {
     constructor(length, // The number of characters covered
     height, // Height of this part of the document
-    flags = 2 /* Outdated */) {
+    flags = 2 /* Flag.Outdated */) {
         this.length = length;
         this.height = height;
         this.flags = flags;
     }
-    get outdated() { return (this.flags & 2 /* Outdated */) > 0; }
-    set outdated(value) { this.flags = (value ? 2 /* Outdated */ : 0) | (this.flags & ~2 /* Outdated */); }
+    get outdated() { return (this.flags & 2 /* Flag.Outdated */) > 0; }
+    set outdated(value) { this.flags = (value ? 2 /* Flag.Outdated */ : 0) | (this.flags & ~2 /* Flag.Outdated */); }
     setHeight(oracle, height) {
         if (this.height != height) {
             if (Math.abs(this.height - height) > Epsilon)
@@ -4291,7 +4277,7 @@ class HeightMapText extends HeightMapBlock {
     }
     replace(_from, _to, nodes) {
         let node = nodes[0];
-        if (nodes.length == 1 && (node instanceof HeightMapText || node instanceof HeightMapGap && (node.flags & 4 /* SingleLine */)) &&
+        if (nodes.length == 1 && (node instanceof HeightMapText || node instanceof HeightMapGap && (node.flags & 4 /* Flag.SingleLine */)) &&
             Math.abs(this.length - node.length) < 10) {
             if (node instanceof HeightMapGap)
                 node = new HeightMapText(node.length, this.height);
@@ -4417,12 +4403,12 @@ class HeightMapGap extends HeightMap {
 }
 class HeightMapBranch extends HeightMap {
     constructor(left, brk, right) {
-        super(left.length + brk + right.length, left.height + right.height, brk | (left.outdated || right.outdated ? 2 /* Outdated */ : 0));
+        super(left.length + brk + right.length, left.height + right.height, brk | (left.outdated || right.outdated ? 2 /* Flag.Outdated */ : 0));
         this.left = left;
         this.right = right;
         this.size = left.size + right.size;
     }
-    get break() { return this.flags & 1 /* Break */; }
+    get break() { return this.flags & 1 /* Flag.Break */; }
     blockAt(height, doc, top, offset) {
         let mid = top + this.left.height;
         return height < mid ? this.left.blockAt(height, doc, top, offset)
@@ -4606,7 +4592,7 @@ class NodeBuilder {
     blankContent(from, to) {
         let gap = new HeightMapGap(to - from);
         if (this.oracle.doc.lineAt(from).to == to)
-            gap.flags |= 4 /* SingleLine */;
+            gap.flags |= 4 /* Flag.SingleLine */;
         return gap;
     }
     ensureLine() {
@@ -4677,10 +4663,10 @@ class DecorationComparator {
 
 function visiblePixelRange(dom, paddingTop) {
     let rect = dom.getBoundingClientRect();
-    let left = Math.max(0, rect.left), right = Math.min(innerWidth, rect.right);
-    let top = Math.max(0, rect.top), bottom = Math.min(innerHeight, rect.bottom);
-    let body = dom.ownerDocument.body;
-    for (let parent = dom.parentNode; parent && parent != body;) {
+    let doc = dom.ownerDocument, win = doc.defaultView;
+    let left = Math.max(0, rect.left), right = Math.min(win.innerWidth, rect.right);
+    let top = Math.max(0, rect.top), bottom = Math.min(win.innerHeight, rect.bottom);
+    for (let parent = dom.parentNode; parent && parent != doc.body;) {
         if (parent.nodeType == 1) {
             let elt = parent;
             let style = window.getComputedStyle(elt);
@@ -4804,7 +4790,7 @@ class ViewState {
             }
         }
         this.viewports = viewports.sort((a, b) => a.from - b.from);
-        this.scaler = this.heightMap.height <= 7000000 /* MaxDOMHeight */ ? IdScaler :
+        this.scaler = this.heightMap.height <= 7000000 /* VP.MaxDOMHeight */ ? IdScaler :
             new BigScaler(this.heightOracle.doc, this.heightMap, this.viewports);
     }
     updateViewportLines() {
@@ -4822,18 +4808,18 @@ class ViewState {
         let prevHeight = this.heightMap.height;
         this.heightMap = this.heightMap.applyChanges(this.stateDeco, update.startState.doc, this.heightOracle.setDoc(this.state.doc), heightChanges);
         if (this.heightMap.height != prevHeight)
-            update.flags |= 2 /* Height */;
+            update.flags |= 2 /* UpdateFlag.Height */;
         let viewport = heightChanges.length ? this.mapViewport(this.viewport, update.changes) : this.viewport;
         if (scrollTarget && (scrollTarget.range.head < viewport.from || scrollTarget.range.head > viewport.to) ||
             !this.viewportIsAppropriate(viewport))
             viewport = this.getViewport(0, scrollTarget);
-        let updateLines = !update.changes.empty || (update.flags & 2 /* Height */) ||
+        let updateLines = !update.changes.empty || (update.flags & 2 /* UpdateFlag.Height */) ||
             viewport.from != this.viewport.from || viewport.to != this.viewport.to;
         this.viewport = viewport;
         this.updateForViewport();
         if (updateLines)
             this.updateViewportLines();
-        if (this.lineGaps.length || this.viewport.to - this.viewport.from > 4000 /* DoubleMargin */)
+        if (this.lineGaps.length || this.viewport.to - this.viewport.from > 4000 /* LG.DoubleMargin */)
             this.updateLineGaps(this.ensureLineGaps(this.mapLineGaps(this.lineGaps, update.changes)));
         update.flags |= this.computeVisibleRanges();
         if (scrollTarget)
@@ -4857,13 +4843,13 @@ class ViewState {
         if (this.paddingTop != paddingTop || this.paddingBottom != paddingBottom) {
             this.paddingTop = paddingTop;
             this.paddingBottom = paddingBottom;
-            result |= 8 /* Geometry */ | 2 /* Height */;
+            result |= 8 /* UpdateFlag.Geometry */ | 2 /* UpdateFlag.Height */;
         }
         if (this.editorWidth != view.scrollDOM.clientWidth) {
             if (oracle.lineWrapping)
                 measureContent = true;
             this.editorWidth = view.scrollDOM.clientWidth;
-            result |= 8 /* Geometry */;
+            result |= 8 /* UpdateFlag.Geometry */;
         }
         // Pixel viewport
         let pixelViewport = (this.printing ? fullPixelRange : visiblePixelRange)(dom, this.paddingTop);
@@ -4875,13 +4861,13 @@ class ViewState {
             if (inView)
                 measureContent = true;
         }
-        if (!this.inView)
+        if (!this.inView && !this.scrollTarget)
             return 0;
         let contentWidth = dom.clientWidth;
         if (this.contentDOMWidth != contentWidth || this.editorHeight != view.scrollDOM.clientHeight) {
             this.contentDOMWidth = contentWidth;
             this.editorHeight = view.scrollDOM.clientHeight;
-            result |= 8 /* Geometry */;
+            result |= 8 /* UpdateFlag.Geometry */;
         }
         if (measureContent) {
             let lineHeights = view.docView.measureVisibleLineHeights(this.viewport);
@@ -4892,7 +4878,7 @@ class ViewState {
                 refresh = oracle.refresh(whiteSpace, lineHeight, charWidth, contentWidth / charWidth, lineHeights);
                 if (refresh) {
                     view.docView.minWidth = 0;
-                    result |= 8 /* Geometry */;
+                    result |= 8 /* UpdateFlag.Geometry */;
                 }
             }
             if (dTop > 0 && dBottom > 0)
@@ -4905,16 +4891,16 @@ class ViewState {
                 this.heightMap = this.heightMap.updateHeight(oracle, 0, refresh, new MeasuredHeights(vp.from, heights));
             }
             if (oracle.heightChanged)
-                result |= 2 /* Height */;
+                result |= 2 /* UpdateFlag.Height */;
         }
         let viewportChange = !this.viewportIsAppropriate(this.viewport, bias) ||
             this.scrollTarget && (this.scrollTarget.range.head < this.viewport.from || this.scrollTarget.range.head > this.viewport.to);
         if (viewportChange)
             this.viewport = this.getViewport(bias, this.scrollTarget);
         this.updateForViewport();
-        if ((result & 2 /* Height */) || viewportChange)
+        if ((result & 2 /* UpdateFlag.Height */) || viewportChange)
             this.updateViewportLines();
-        if (this.lineGaps.length || this.viewport.to - this.viewport.from > 4000 /* DoubleMargin */)
+        if (this.lineGaps.length || this.viewport.to - this.viewport.from > 4000 /* LG.DoubleMargin */)
             this.updateLineGaps(this.ensureLineGaps(refresh ? [] : this.lineGaps));
         result |= this.computeVisibleRanges();
         if (this.mustEnforceCursorAssoc) {
@@ -4933,9 +4919,9 @@ class ViewState {
         // This will divide VP.Margin between the top and the
         // bottom, depending on the bias (the change in viewport position
         // since the last update). It'll hold a number between 0 and 1
-        let marginTop = 0.5 - Math.max(-0.5, Math.min(0.5, bias / 1000 /* Margin */ / 2));
+        let marginTop = 0.5 - Math.max(-0.5, Math.min(0.5, bias / 1000 /* VP.Margin */ / 2));
         let map = this.heightMap, doc = this.state.doc, { visibleTop, visibleBottom } = this;
-        let viewport = new Viewport(map.lineAt(visibleTop - marginTop * 1000 /* Margin */, QueryType.ByHeight, doc, 0, 0).from, map.lineAt(visibleBottom + (1 - marginTop) * 1000 /* Margin */, QueryType.ByHeight, doc, 0, 0).to);
+        let viewport = new Viewport(map.lineAt(visibleTop - marginTop * 1000 /* VP.Margin */, QueryType.ByHeight, doc, 0, 0).from, map.lineAt(visibleBottom + (1 - marginTop) * 1000 /* VP.Margin */, QueryType.ByHeight, doc, 0, 0).to);
         // If scrollTarget is given, make sure the viewport includes that position
         if (scrollTarget) {
             let { head } = scrollTarget.range;
@@ -4948,7 +4934,7 @@ class ViewState {
                     topPos = block.top;
                 else
                     topPos = block.bottom - viewHeight;
-                viewport = new Viewport(map.lineAt(topPos - 1000 /* Margin */ / 2, QueryType.ByHeight, doc, 0, 0).from, map.lineAt(topPos + viewHeight + 1000 /* Margin */ / 2, QueryType.ByHeight, doc, 0, 0).to);
+                viewport = new Viewport(map.lineAt(topPos - 1000 /* VP.Margin */ / 2, QueryType.ByHeight, doc, 0, 0).from, map.lineAt(topPos + viewHeight + 1000 /* VP.Margin */ / 2, QueryType.ByHeight, doc, 0, 0).to);
             }
         }
         return viewport;
@@ -4965,10 +4951,10 @@ class ViewState {
         let { top } = this.heightMap.lineAt(from, QueryType.ByPos, this.state.doc, 0, 0);
         let { bottom } = this.heightMap.lineAt(to, QueryType.ByPos, this.state.doc, 0, 0);
         let { visibleTop, visibleBottom } = this;
-        return (from == 0 || top <= visibleTop - Math.max(10 /* MinCoverMargin */, Math.min(-bias, 250 /* MaxCoverMargin */))) &&
+        return (from == 0 || top <= visibleTop - Math.max(10 /* VP.MinCoverMargin */, Math.min(-bias, 250 /* VP.MaxCoverMargin */))) &&
             (to == this.state.doc.length ||
-                bottom >= visibleBottom + Math.max(10 /* MinCoverMargin */, Math.min(bias, 250 /* MaxCoverMargin */))) &&
-            (top > visibleTop - 2 * 1000 /* Margin */ && bottom < visibleBottom + 2 * 1000 /* Margin */);
+                bottom >= visibleBottom + Math.max(10 /* VP.MinCoverMargin */, Math.min(bias, 250 /* VP.MaxCoverMargin */))) &&
+            (top > visibleTop - 2 * 1000 /* VP.Margin */ && bottom < visibleBottom + 2 * 1000 /* VP.Margin */);
     }
     mapLineGaps(gaps, changes) {
         if (!gaps.length || changes.empty)
@@ -4992,20 +4978,20 @@ class ViewState {
         if (this.defaultTextDirection != exports.Direction.LTR)
             return gaps;
         for (let line of this.viewportLines) {
-            if (line.length < 4000 /* DoubleMargin */)
+            if (line.length < 4000 /* LG.DoubleMargin */)
                 continue;
             let structure = lineStructure(line.from, line.to, this.stateDeco);
-            if (structure.total < 4000 /* DoubleMargin */)
+            if (structure.total < 4000 /* LG.DoubleMargin */)
                 continue;
             let viewFrom, viewTo;
             if (this.heightOracle.lineWrapping) {
-                let marginHeight = (2000 /* Margin */ / this.heightOracle.lineLength) * this.heightOracle.lineHeight;
+                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);
             }
             else {
                 let totalWidth = structure.total * this.heightOracle.charWidth;
-                let marginWidth = 2000 /* Margin */ * 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);
             }
@@ -5017,13 +5003,13 @@ class ViewState {
             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 /* SelectionMargin */, sel.from + 10 /* SelectionMargin */);
+                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 /* SelectionMargin */, sel.to + 10 /* SelectionMargin */);
+                cutRange(outside, sel.to - 10 /* LG.SelectionMargin */, sel.to + 10 /* LG.SelectionMargin */);
             for (let { from, to } of outside)
-                if (to - from > 1000 /* HalfMargin */) {
+                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 /* HalfMargin */ && Math.abs(gap.to - to) < 1000 /* HalfMargin */) ||
+                        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)));
                 }
         }
@@ -5056,7 +5042,7 @@ class ViewState {
         let changed = ranges.length != this.visibleRanges.length ||
             this.visibleRanges.some((r, i) => r.from != ranges[i].from || r.to != ranges[i].to);
         this.visibleRanges = ranges;
-        return changed ? 4 /* Viewport */ : 0;
+        return changed ? 4 /* UpdateFlag.Viewport */ : 0;
     }
     lineBlockAt(pos) {
         return (pos >= this.viewport.from && pos <= this.viewport.to && this.viewportLines.find(b => b.from <= pos && b.to >= pos)) ||
@@ -5162,7 +5148,7 @@ class BigScaler {
             vpHeight += bottom - top;
             return { from, to, top, bottom, domTop: 0, domBottom: 0 };
         });
-        this.scale = (7000000 /* MaxDOMHeight */ - vpHeight) / (heightMap.height - vpHeight);
+        this.scale = (7000000 /* VP.MaxDOMHeight */ - vpHeight) / (heightMap.height - vpHeight);
         for (let obj of this.viewports) {
             obj.domTop = domBase + (obj.top - base) * this.scale;
             domBase = obj.domBottom = obj.domTop + (obj.bottom - obj.top);
@@ -5319,8 +5305,8 @@ const baseTheme$1 = buildTheme("." + baseThemeID, {
     "&.cm-focused .cm-cursor": {
         display: "block"
     },
-    "&light .cm-activeLine": { backgroundColor: "#f3f9ff" },
-    "&dark .cm-activeLine": { backgroundColor: "#223039" },
+    "&light .cm-activeLine": { backgroundColor: "#cceeff44" },
+    "&dark .cm-activeLine": { backgroundColor: "#99eeff33" },
     "&light .cm-specialChar": { color: "red" },
     "&dark .cm-specialChar": { color: "#f78" },
     ".cm-gutters": {
@@ -5465,6 +5451,7 @@ class DOMObserver {
         this.resizeTimeout = -1;
         this.queue = [];
         this.delayedAndroidKey = null;
+        this.lastChange = 0;
         this.scrollTargets = [];
         this.intersection = null;
         this.resize = null;
@@ -5511,8 +5498,7 @@ class DOMObserver {
             });
             this.resize.observe(view.scrollDOM);
         }
-        this.win = view.dom.ownerDocument.defaultView;
-        this.addWindowListeners(this.win);
+        this.addWindowListeners(this.win = view.win);
         this.start();
         if (typeof IntersectionObserver == "function") {
             this.intersection = new IntersectionObserver(entries => {
@@ -5691,26 +5677,34 @@ class DOMObserver {
     // detected (via beforeinput or keydown), and then tries to flush
     // them or, if that has no effect, dispatches the given key.
     delayAndroidKey(key, keyCode) {
+        var _a;
         if (!this.delayedAndroidKey)
-            requestAnimationFrame(() => {
+            this.view.win.requestAnimationFrame(() => {
                 let key = this.delayedAndroidKey;
                 this.delayedAndroidKey = null;
                 this.delayedFlush = -1;
-                if (!this.flush())
+                if (!this.flush() && key.force)
                     dispatchKey(this.dom, key.key, key.keyCode);
             });
         // Since backspace beforeinput is sometimes signalled spuriously,
         // Enter always takes precedence.
         if (!this.delayedAndroidKey || key == "Enter")
-            this.delayedAndroidKey = { key, keyCode };
+            this.delayedAndroidKey = {
+                key, keyCode,
+                // Only run the key handler when no changes are detected if
+                // this isn't coming right after another change, in which case
+                // it is probably part of a weird chain of updates, and should
+                // be ignored if it returns the DOM to its previous state.
+                force: this.lastChange < Date.now() - 50 || !!((_a = this.delayedAndroidKey) === null || _a === void 0 ? void 0 : _a.force)
+            };
     }
     flushSoon() {
         if (this.delayedFlush < 0)
-            this.delayedFlush = window.setTimeout(() => { this.delayedFlush = -1; this.flush(); }, 20);
+            this.delayedFlush = this.view.win.requestAnimationFrame(() => { this.delayedFlush = -1; this.flush(); });
     }
     forceFlush() {
         if (this.delayedFlush >= 0) {
-            window.clearTimeout(this.delayedFlush);
+            this.view.win.cancelAnimationFrame(this.delayedFlush);
             this.delayedFlush = -1;
         }
         this.flush();
@@ -5744,13 +5738,15 @@ class DOMObserver {
         // managing those will make sure processRecords is called and the
         // view is resynchronized after
         if (this.delayedFlush >= 0 || this.delayedAndroidKey)
-            return;
+            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)
-            return;
+            return false;
+        if (from > -1)
+            this.lastChange = Date.now();
         this.view.inputState.lastFocusTime = 0;
         this.selectionChanged = false;
         let startState = this.view.state;
@@ -5766,7 +5762,7 @@ class DOMObserver {
             return null;
         cView.markDirty(rec.type == "attributes");
         if (rec.type == "attributes")
-            cView.dirty |= 4 /* Attrs */;
+            cView.dirty |= 4 /* Dirty.Attrs */;
         if (rec.type == "childList") {
             let childBefore = findChild(cView, rec.previousSibling || rec.target.previousSibling, -1);
             let childAfter = findChild(cView, rec.nextSibling || rec.target.nextSibling, 1);
@@ -6093,7 +6089,7 @@ class EditorView {
         /**
         @internal
         */
-        this.updateState = 2 /* Updating */;
+        this.updateState = 2 /* UpdateState.Updating */;
         /**
         @internal
         */
@@ -6132,7 +6128,7 @@ class EditorView {
         this.docView = new DocView(this);
         this.mountStyles();
         this.updateAttrs();
-        this.updateState = 0 /* Idle */;
+        this.updateState = 0 /* UpdateState.Idle */;
         this.requestMeasure();
         if (config.parent)
             config.parent.appendChild(this.dom);
@@ -6180,6 +6176,10 @@ class EditorView {
     The document or shadow root that the view lives in.
     */
     get root() { return this._root; }
+    /**
+    @internal
+    */
+    get win() { return this.dom.ownerDocument.defaultView || window; }
     dispatch(...input) {
         this._dispatch(input.length == 1 && input[0] instanceof state.Transaction ? input[0]
             : this.state.update(...input));
@@ -6193,7 +6193,7 @@ class EditorView {
     as a primitive.
     */
     update(transactions) {
-        if (this.updateState != 0 /* Idle */)
+        if (this.updateState != 0 /* UpdateState.Idle */)
             throw new Error("Calls to EditorView.update are not allowed while an update is in progress");
         let redrawn = false, attrsChanged = false, update;
         let state$1 = this.state;
@@ -6213,7 +6213,7 @@ class EditorView {
         update = ViewUpdate.create(this, state$1, transactions);
         let scrollTarget = this.viewState.scrollTarget;
         try {
-            this.updateState = 2 /* Updating */;
+            this.updateState = 2 /* UpdateState.Updating */;
             for (let tr of transactions) {
                 if (scrollTarget)
                     scrollTarget = scrollTarget.map(tr.changes);
@@ -6239,7 +6239,7 @@ class EditorView {
             this.docView.updateSelection(redrawn, transactions.some(tr => tr.isUserEvent("select.pointer")));
         }
         finally {
-            this.updateState = 0 /* Idle */;
+            this.updateState = 0 /* UpdateState.Idle */;
         }
         if (update.startState.facet(theme) != update.state.facet(theme))
             this.viewState.mustMeasureContent = true;
@@ -6257,13 +6257,13 @@ class EditorView {
     [`dispatch`](https://codemirror.net/6/docs/ref/#view.EditorView.dispatch) instead.)
     */
     setState(newState) {
-        if (this.updateState != 0 /* Idle */)
+        if (this.updateState != 0 /* UpdateState.Idle */)
             throw new Error("Calls to EditorView.setState are not allowed while an update is in progress");
         if (this.destroyed) {
             this.viewState.state = newState;
             return;
         }
-        this.updateState = 2 /* Updating */;
+        this.updateState = 2 /* UpdateState.Updating */;
         let hadFocus = this.hasFocus;
         try {
             for (let plugin of this.plugins)
@@ -6280,7 +6280,7 @@ class EditorView {
             this.bidiCache = [];
         }
         finally {
-            this.updateState = 0 /* Idle */;
+            this.updateState = 0 /* UpdateState.Idle */;
         }
         if (hadFocus)
             this.focus();
@@ -6331,7 +6331,7 @@ class EditorView {
         let refHeight = scrollTop > scrollHeight - clientHeight - 4 ? scrollHeight : scrollTop;
         try {
             for (let i = 0;; i++) {
-                this.updateState = 1 /* Measuring */;
+                this.updateState = 1 /* UpdateState.Measuring */;
                 let oldViewport = this.viewport;
                 let refBlock = this.viewState.lineBlockAtHeight(refHeight);
                 let changed = this.viewState.measure(this);
@@ -6345,7 +6345,7 @@ class EditorView {
                 }
                 let measuring = [];
                 // Only run measure requests in this cycle when the viewport didn't change
-                if (!(changed & 4 /* Viewport */))
+                if (!(changed & 4 /* UpdateFlag.Viewport */))
                     [this.measureRequests, measuring] = [measuring, this.measureRequests];
                 let measured = measuring.map(m => {
                     try {
@@ -6362,7 +6362,7 @@ class EditorView {
                     updated = update;
                 else
                     updated.flags |= changed;
-                this.updateState = 2 /* Updating */;
+                this.updateState = 2 /* UpdateState.Updating */;
                 if (!update.empty) {
                     this.updatePlugins(update);
                     this.inputState.update(update);
@@ -6400,7 +6400,7 @@ class EditorView {
             }
         }
         finally {
-            this.updateState = 0 /* Idle */;
+            this.updateState = 0 /* UpdateState.Idle */;
             this.measureScheduled = -1;
         }
         if (updated && !updated.empty)
@@ -6459,9 +6459,9 @@ class EditorView {
         styleMod.StyleModule.mount(this.root, this.styleModules.concat(baseTheme$1).reverse());
     }
     readMeasured() {
-        if (this.updateState == 2 /* Updating */)
+        if (this.updateState == 2 /* UpdateState.Updating */)
             throw new Error("Reading the editor layout isn't allowed during an update");
-        if (this.updateState == 0 /* Idle */ && this.measureScheduled > -1)
+        if (this.updateState == 0 /* UpdateState.Idle */ && this.measureScheduled > -1)
             this.measure(false);
     }
     /**
@@ -6474,7 +6474,7 @@ class EditorView {
     */
     requestMeasure(request) {
         if (this.measureScheduled < 0)
-            this.measureScheduled = requestAnimationFrame(() => this.measure());
+            this.measureScheduled = this.win.requestAnimationFrame(() => this.measure());
         if (request) {
             if (request.key != null)
                 for (let i = 0; i < this.measureRequests.length; i++) {
@@ -7349,7 +7349,7 @@ function measureRange(view, range) {
         return pieces(top).concat(between).concat(pieces(bottom));
     }
     function piece(left, top, right, bottom) {
-        return new Piece(left - base.left, top - base.top - 0.01 /* Epsilon */, right - left, bottom - top + 0.01 /* Epsilon */, "cm-selectionBackground");
+        return new Piece(left - base.left, top - base.top - 0.01 /* C.Epsilon */, right - left, bottom - top + 0.01 /* C.Epsilon */, "cm-selectionBackground");
     }
     function pieces({ top, bottom, horizontal }) {
         let pieces = [];
@@ -7543,9 +7543,15 @@ class MatchDecorator {
         if (decorate) {
             this.addMatch = (match, view, from, add) => decorate(add, from, from + match[0].length, match, view);
         }
+        else if (typeof decoration == "function") {
+            this.addMatch = (match, view, from, add) => {
+                let deco = decoration(match, view, from);
+                if (deco)
+                    add(from, from + match[0].length, deco);
+            };
+        }
         else if (decoration) {
-            let getDeco = typeof decoration == "function" ? decoration : () => decoration;
-            this.addMatch = (match, view, from, add) => add(from, from + match[0].length, getDeco(match, view, from));
+            this.addMatch = (match, _view, from, add) => add(from, from + match[0].length, decoration);
         }
         else {
             throw new RangeError("Either 'decorate' or 'decoration' should be provided to MatchDecorator");
@@ -7812,8 +7818,6 @@ const activeLineHighlighter = ViewPlugin.fromClass(class {
     getDeco(view) {
         let lastLineStart = -1, deco = [];
         for (let r of view.state.selection.ranges) {
-            if (!r.empty)
-                return Decoration.none;
             let line = view.lineBlockAt(r.head);
             if (line.from > lastLineStart) {
                 deco.push(lineDeco.range(line.from));
@@ -8031,8 +8035,9 @@ Creates an extension that configures tooltip behavior.
 function tooltips(config = {}) {
     return tooltipConfig.of(config);
 }
-function windowSpace() {
-    return { top: 0, left: 0, bottom: innerHeight, right: innerWidth };
+function windowSpace(view) {
+    let { win } = view;
+    return { top: 0, left: 0, bottom: win.innerHeight, right: win.innerWidth };
 }
 const tooltipConfig = state.Facet.define({
     combine: values => {
@@ -8046,7 +8051,6 @@ const tooltipConfig = state.Facet.define({
 });
 const tooltipPlugin = ViewPlugin.fromClass(class {
     constructor(view) {
-        var _a;
         this.view = view;
         this.inView = true;
         this.lastTransaction = 0;
@@ -8064,7 +8068,7 @@ const tooltipPlugin = ViewPlugin.fromClass(class {
                 this.measureSoon();
         }, { threshold: [1] }) : null;
         this.observeIntersection();
-        (_a = view.dom.ownerDocument.defaultView) === null || _a === void 0 ? void 0 : _a.addEventListener("resize", this.measureSoon = this.measureSoon.bind(this));
+        view.win.addEventListener("resize", this.measureSoon = this.measureSoon.bind(this));
         this.maybeMeasure();
     }
     createContainer() {
@@ -8137,11 +8141,11 @@ const tooltipPlugin = ViewPlugin.fromClass(class {
         return tooltipView;
     }
     destroy() {
-        var _a, _b;
-        (_a = this.view.dom.ownerDocument.defaultView) === null || _a === void 0 ? void 0 : _a.removeEventListener("resize", this.measureSoon);
+        var _a;
+        this.view.win.removeEventListener("resize", this.measureSoon);
         for (let { dom } of this.manager.tooltipViews)
             dom.remove();
-        (_b = this.intersectionObserver) === null || _b === void 0 ? void 0 : _b.disconnect();
+        (_a = this.intersectionObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
         clearTimeout(this.measureTimeout);
     }
     readMeasure() {
@@ -8172,12 +8176,12 @@ const tooltipPlugin = ViewPlugin.fromClass(class {
                 continue;
             }
             let arrow = tooltip.arrow ? tView.dom.querySelector(".cm-tooltip-arrow") : null;
-            let arrowHeight = arrow ? 7 /* Size */ : 0;
+            let arrowHeight = arrow ? 7 /* Arrow.Size */ : 0;
             let width = size.right - size.left, height = size.bottom - size.top;
             let offset = tView.offset || noOffset, ltr = this.view.textDirection == exports.Direction.LTR;
             let left = size.width > space.right - space.left ? (ltr ? space.left : space.right - size.width)
-                : ltr ? Math.min(pos.left - (arrow ? 14 /* Offset */ : 0) + offset.x, space.right - width)
-                    : Math.max(space.left, pos.left - width + (arrow ? 14 /* Offset */ : 0) - offset.x);
+                : ltr ? Math.min(pos.left - (arrow ? 14 /* Arrow.Offset */ : 0) + offset.x, space.right - width)
+                    : Math.max(space.left, pos.left - width + (arrow ? 14 /* Arrow.Offset */ : 0) - offset.x);
             let above = !!tooltip.above;
             if (!tooltip.strictSide && (above
                 ? pos.top - (size.bottom - size.top) - offset.y < space.top
@@ -8199,7 +8203,7 @@ const tooltipPlugin = ViewPlugin.fromClass(class {
                 dom.style.left = left + "px";
             }
             if (arrow)
-                arrow.style.left = `${pos.left + (ltr ? offset.x : -offset.x) - (left + 14 /* Offset */ - 7 /* Size */)}px`;
+                arrow.style.left = `${pos.left + (ltr ? offset.x : -offset.x) - (left + 14 /* Arrow.Offset */ - 7 /* Arrow.Size */)}px`;
             if (tView.overlap !== true)
                 others.push({ left, top, right, bottom: top + height });
             dom.classList.toggle("cm-tooltip-above", above);
@@ -8241,8 +8245,8 @@ const baseTheme = EditorView.baseTheme({
         color: "white"
     },
     ".cm-tooltip-arrow": {
-        height: `${7 /* Size */}px`,
-        width: `${7 /* Size */ * 2}px`,
+        height: `${7 /* Arrow.Size */}px`,
+        width: `${7 /* Arrow.Size */ * 2}px`,
         position: "absolute",
         zIndex: -1,
         overflow: "hidden",
@@ -8251,26 +8255,26 @@ const baseTheme = EditorView.baseTheme({
             position: "absolute",
             width: 0,
             height: 0,
-            borderLeft: `${7 /* Size */}px solid transparent`,
-            borderRight: `${7 /* Size */}px solid transparent`,
+            borderLeft: `${7 /* Arrow.Size */}px solid transparent`,
+            borderRight: `${7 /* Arrow.Size */}px solid transparent`,
         },
         ".cm-tooltip-above &": {
-            bottom: `-${7 /* Size */}px`,
+            bottom: `-${7 /* Arrow.Size */}px`,
             "&:before": {
-                borderTop: `${7 /* Size */}px solid #bbb`,
+                borderTop: `${7 /* Arrow.Size */}px solid #bbb`,
             },
             "&:after": {
-                borderTop: `${7 /* Size */}px solid #f5f5f5`,
+                borderTop: `${7 /* Arrow.Size */}px solid #f5f5f5`,
                 bottom: "1px"
             }
         },
         ".cm-tooltip-below &": {
-            top: `-${7 /* Size */}px`,
+            top: `-${7 /* Arrow.Size */}px`,
             "&:before": {
-                borderBottom: `${7 /* Size */}px solid #bbb`,
+                borderBottom: `${7 /* Arrow.Size */}px solid #bbb`,
             },
             "&:after": {
-                borderBottom: `${7 /* Size */}px solid #f5f5f5`,
+                borderBottom: `${7 /* Arrow.Size */}px solid #f5f5f5`,
                 top: "1px"
             }
         },
@@ -8415,7 +8419,7 @@ class HoverPlugin {
         if (tooltip && !isInTooltip(this.lastMove.target) || this.pending) {
             let { pos } = tooltip || this.pending, end = (_a = tooltip === null || tooltip === void 0 ? void 0 : tooltip.end) !== null && _a !== void 0 ? _a : pos;
             if ((pos == end ? this.view.posAtCoords(this.lastMove) != pos
-                : !isOverRange(this.view, pos, end, event.clientX, event.clientY, 6 /* MaxDist */))) {
+                : !isOverRange(this.view, pos, end, event.clientX, event.clientY, 6 /* Hover.MaxDist */))) {
                 this.view.dispatch({ effects: this.setHover.of(null) });
                 this.pending = null;
             }
@@ -8497,7 +8501,7 @@ function hoverTooltip(source, options = {}) {
     });
     return [
         hoverState,
-        ViewPlugin.define(view => new HoverPlugin(view, source, hoverState, setHover, options.hoverTime || 300 /* Time */)),
+        ViewPlugin.define(view => new HoverPlugin(view, source, hoverState, setHover, options.hoverTime || 300 /* Hover.Time */)),
         showHoverTooltipHost
     ];
 }
@@ -9128,14 +9132,13 @@ const activeLineGutterMarker = new class extends GutterMarker {
 };
 const activeLineGutterHighlighter = gutterLineClass.compute(["selection"], state$1 => {
     let marks = [], last = -1;
-    for (let range of state$1.selection.ranges)
-        if (range.empty) {
-            let linePos = state$1.doc.lineAt(range.head).from;
-            if (linePos > last) {
-                last = linePos;
-                marks.push(activeLineGutterMarker.range(linePos));
-            }
+    for (let range of state$1.selection.ranges) {
+        let linePos = state$1.doc.lineAt(range.head).from;
+        if (linePos > last) {
+            last = linePos;
+            marks.push(activeLineGutterMarker.range(linePos));
         }
+    }
     return state.RangeSet.of(marks);
 });
 /**