@codemirror/view 6.16.0 → 6.17.1

package/dist/index.js

@@ -1,4 +1,4 @@
-import { EditorState, Text, RangeSet, MapMode, RangeValue, Facet, StateEffect, ChangeSet, findClusterBreak, EditorSelection, findColumn, CharCategory, Annotation, Prec, Transaction, codePointAt, codePointSize, combineConfig, StateField, RangeSetBuilder, countColumn } from '@codemirror/state';
+import { EditorState, Text, RangeSet, MapMode, RangeValue, Facet, StateEffect, ChangeSet, findClusterBreak, EditorSelection, findColumn, CharCategory, Annotation, Transaction, Prec, codePointAt, codePointSize, combineConfig, StateField, RangeSetBuilder, countColumn } from '@codemirror/state';
 import { StyleModule } from 'style-mod';
 import { keyName, base, shift } from 'w3c-keyname';
 
@@ -336,7 +336,7 @@ class ContentView {
     constructor() {
         this.parent = null;
         this.dom = null;
-        this.flags = 2 /* NodeDirty */;
+        this.flags = 2 /* ViewFlag.NodeDirty */;
     }
     get overrideDOMText() { return null; }
     get posAtStart() {
@@ -358,18 +358,18 @@ class ContentView {
         return this.posBefore(view) + view.length;
     }
     sync(view, track) {
-        if (this.flags & 2 /* NodeDirty */) {
+        if (this.flags & 2 /* ViewFlag.NodeDirty */) {
             let parent = this.dom;
             let prev = null, next;
             for (let child of this.children) {
-                if (child.flags & 7 /* Dirty */) {
+                if (child.flags & 7 /* ViewFlag.Dirty */) {
                     if (!child.dom && (next = prev ? prev.nextSibling : parent.firstChild)) {
                         let contentView = ContentView.get(next);
                         if (!contentView || !contentView.parent && contentView.canReuseDOM(child))
                             child.reuseDOM(next);
                     }
                     child.sync(view, track);
-                    child.flags &= ~7 /* Dirty */;
+                    child.flags &= ~7 /* ViewFlag.Dirty */;
                 }
                 next = prev ? prev.nextSibling : parent.firstChild;
                 if (track && !track.written && track.node == parent && next != child.dom)
@@ -389,11 +389,11 @@ class ContentView {
             while (next)
                 next = rm$1(next);
         }
-        else if (this.flags & 1 /* ChildDirty */) {
+        else if (this.flags & 1 /* ViewFlag.ChildDirty */) {
             for (let child of this.children)
-                if (child.flags & 7 /* Dirty */) {
+                if (child.flags & 7 /* ViewFlag.Dirty */) {
                     child.sync(view, track);
-                    child.flags &= ~7 /* Dirty */;
+                    child.flags &= ~7 /* ViewFlag.Dirty */;
                 }
         }
     }
@@ -458,23 +458,23 @@ class ContentView {
             endDOM: toI < this.children.length && toI >= 0 ? this.children[toI].dom : null };
     }
     markDirty(andParent = false) {
-        this.flags |= 2 /* NodeDirty */;
+        this.flags |= 2 /* ViewFlag.NodeDirty */;
         this.markParentsDirty(andParent);
     }
     markParentsDirty(childList) {
         for (let parent = this.parent; parent; parent = parent.parent) {
             if (childList)
-                parent.flags |= 2 /* NodeDirty */;
-            if (parent.flags & 1 /* ChildDirty */)
+                parent.flags |= 2 /* ViewFlag.NodeDirty */;
+            if (parent.flags & 1 /* ViewFlag.ChildDirty */)
                 return;
-            parent.flags |= 1 /* ChildDirty */;
+            parent.flags |= 1 /* ViewFlag.ChildDirty */;
             childList = false;
         }
     }
     setParent(parent) {
         if (this.parent != parent) {
             this.parent = parent;
-            if (this.flags & 7 /* Dirty */)
+            if (this.flags & 7 /* ViewFlag.Dirty */)
                 this.markParentsDirty(true);
         }
     }
@@ -526,7 +526,7 @@ class ContentView {
     }
     become(other) { return false; }
     canReuseDOM(other) {
-        return other.constructor == this.constructor && !((this.flags | other.flags) & 8 /* Composition */);
+        return other.constructor == this.constructor && !((this.flags | other.flags) & 8 /* ViewFlag.Composition */);
     }
     // When this is a zero-length view with a side, this should return a
     // number <= 0 to indicate it is before its position, or a
@@ -811,10 +811,10 @@ class TextView extends ContentView {
             this.createDOM(dom);
     }
     merge(from, to, source) {
-        if ((this.flags & 8 /* Composition */) ||
+        if ((this.flags & 8 /* ViewFlag.Composition */) ||
             source && (!(source instanceof TextView) ||
                 this.length - (to - from) + source.length > MaxJoinLen ||
-                (source.flags & 8 /* Composition */)))
+                (source.flags & 8 /* ViewFlag.Composition */)))
             return false;
         this.text = this.text.slice(0, from) + (source ? source.text : "") + this.text.slice(to);
         this.markDirty();
@@ -824,7 +824,7 @@ class TextView extends ContentView {
         let result = new TextView(this.text.slice(from));
         this.text = this.text.slice(0, from);
         this.markDirty();
-        result.flags |= this.flags & 8 /* Composition */;
+        result.flags |= this.flags & 8 /* ViewFlag.Composition */;
         return result;
     }
     localPosFromDOM(node, offset) {
@@ -857,18 +857,18 @@ class MarkView extends ContentView {
         return dom;
     }
     canReuseDOM(other) {
-        return super.canReuseDOM(other) && !((this.flags | other.flags) & 8 /* Composition */);
+        return super.canReuseDOM(other) && !((this.flags | other.flags) & 8 /* ViewFlag.Composition */);
     }
     reuseDOM(node) {
         if (node.nodeName == this.mark.tagName.toUpperCase()) {
             this.setDOM(node);
-            this.flags |= 4 /* AttrsDirty */ | 2 /* NodeDirty */;
+            this.flags |= 4 /* ViewFlag.AttrsDirty */ | 2 /* ViewFlag.NodeDirty */;
         }
     }
     sync(view, track) {
         if (!this.dom)
             this.setDOM(this.setAttrs(document.createElement(this.mark.tagName)));
-        else if (this.flags & 4 /* AttrsDirty */)
+        else if (this.flags & 4 /* ViewFlag.AttrsDirty */)
             this.setAttrs(this.dom);
         super.sync(view, track);
     }
@@ -939,6 +939,9 @@ function textCoords(text, pos, side) {
 }
 // Also used for collapsed ranges that don't have a placeholder widget!
 class WidgetView extends ContentView {
+    static create(widget, length, side) {
+        return new WidgetView(widget, length, side);
+    }
     constructor(widget, length, side) {
         super();
         this.widget = widget;
@@ -946,9 +949,6 @@ class WidgetView extends ContentView {
         this.side = side;
         this.prevWidget = null;
     }
-    static create(widget, length, side) {
-        return new WidgetView(widget, length, side);
-    }
     split(from) {
         let result = WidgetView.create(this.widget, this.length - from, this.side);
         this.length -= from;
@@ -1163,16 +1163,26 @@ function attrsEq(a, b, ignore) {
     return true;
 }
 function updateAttrs(dom, prev, attrs) {
-    let changed = null;
+    let changed = false;
     if (prev)
         for (let name in prev)
-            if (!(attrs && name in attrs))
-                dom.removeAttribute(changed = name);
+            if (!(attrs && name in attrs)) {
+                changed = true;
+                if (name == "style")
+                    dom.style.cssText = "";
+                else
+                    dom.removeAttribute(name);
+            }
     if (attrs)
         for (let name in attrs)
-            if (!(prev && prev[name] == attrs[name]))
-                dom.setAttribute(changed = name, attrs[name]);
-    return !!changed;
+            if (!(prev && prev[name] == attrs[name])) {
+                changed = true;
+                if (name == "style")
+                    dom.style.cssText = attrs[name];
+                else
+                    dom.setAttribute(name, attrs[name]);
+            }
+    return changed;
 }
 function getAttrs(dom) {
     let attrs = Object.create(null);
@@ -1329,8 +1339,8 @@ class Decoration extends RangeValue {
     static widget(spec) {
         let side = Math.max(-10000, Math.min(10000, spec.side || 0)), block = !!spec.block;
         side += (block && !spec.inlineOrder)
-            ? (side > 0 ? 300000000 /* BlockAfter */ : -400000000 /* BlockBefore */)
-            : (side > 0 ? 100000000 /* InlineAfter */ : -100000000 /* InlineBefore */);
+            ? (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);
     }
     /**
@@ -1340,13 +1350,13 @@ class Decoration extends 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);
     }
@@ -1377,7 +1387,7 @@ Decoration.none = 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;
@@ -1399,7 +1409,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 &&
@@ -1540,7 +1550,7 @@ class LineView extends ContentView {
     reuseDOM(node) {
         if (node.nodeName == "DIV") {
             this.setDOM(node);
-            this.flags |= 4 /* AttrsDirty */ | 2 /* NodeDirty */;
+            this.flags |= 4 /* ViewFlag.AttrsDirty */ | 2 /* ViewFlag.NodeDirty */;
         }
     }
     sync(view, track) {
@@ -1550,7 +1560,7 @@ class LineView extends ContentView {
             this.dom.className = "cm-line";
             this.prevAttrs = this.attrs ? null : undefined;
         }
-        else if (this.flags & 4 /* AttrsDirty */) {
+        else if (this.flags & 4 /* ViewFlag.AttrsDirty */) {
             clearAttributes(this.dom);
             this.dom.className = "cm-line";
             this.prevAttrs = this.attrs ? null : undefined;
@@ -1698,7 +1708,7 @@ class ContentBuilder {
         this.content = [];
         this.curLine = null;
         this.breakAtStart = 0;
-        this.pendingBuffer = 0 /* No */;
+        this.pendingBuffer = 0 /* Buf.No */;
         this.bufferMarks = [];
         // Set to false directly after a widget that covers the position after it
         this.atCursorPos = true;
@@ -1725,7 +1735,7 @@ class ContentBuilder {
     flushBuffer(active = this.bufferMarks) {
         if (this.pendingBuffer) {
             this.curLine.append(wrapMarks(new WidgetBufferView(-1), active), active.length);
-            this.pendingBuffer = 0 /* No */;
+            this.pendingBuffer = 0 /* Buf.No */;
         }
     }
     addBlockWidget(view) {
@@ -1737,7 +1747,7 @@ class ContentBuilder {
         if (this.pendingBuffer && openEnd <= this.bufferMarks.length)
             this.flushBuffer();
         else
-            this.pendingBuffer = 0 /* No */;
+            this.pendingBuffer = 0 /* Buf.No */;
         if (!this.posCovered())
             this.getLine();
     }
@@ -1766,7 +1776,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(active.length - openStart));
             this.getLine().append(wrapMarks(new TextView(this.text.slice(this.textOff, this.textOff + take)), active), openStart);
             this.atCursorPos = true;
@@ -1802,8 +1812,8 @@ class ContentBuilder {
                     (from < to || deco.startSide > 0);
                 let cursorAfter = !view.isEditable && (from < to || openStart > active.length || deco.startSide <= 0);
                 let line = this.getLine();
-                if (this.pendingBuffer == 2 /* IfCursor */ && !cursorBefore && !view.isEditable)
-                    this.pendingBuffer = 0 /* No */;
+                if (this.pendingBuffer == 2 /* Buf.IfCursor */ && !cursorBefore && !view.isEditable)
+                    this.pendingBuffer = 0 /* Buf.No */;
                 this.flushBuffer(active);
                 if (cursorBefore) {
                     line.append(wrapMarks(new WidgetBufferView(1), active), openStart);
@@ -1811,7 +1821,7 @@ class ContentBuilder {
                 }
                 line.append(wrapMarks(view, active), openStart);
                 this.atCursorPos = cursorAfter;
-                this.pendingBuffer = !cursorAfter ? 0 /* No */ : from < to || openStart > active.length ? 1 /* Yes */ : 2 /* IfCursor */;
+                this.pendingBuffer = !cursorAfter ? 0 /* Buf.No */ : from < to || openStart > active.length ? 1 /* Buf.Yes */ : 2 /* Buf.IfCursor */;
                 if (this.pendingBuffer)
                     this.bufferMarks = active.slice();
             }
@@ -2025,6 +2035,36 @@ const contentAttributes = /*@__PURE__*/Facet.define();
 // Provide decorations
 const decorations = /*@__PURE__*/Facet.define();
 const atomicRanges = /*@__PURE__*/Facet.define();
+const bidiIsolatedRanges = /*@__PURE__*/Facet.define();
+function getIsolatedRanges(view, from, to) {
+    let isolates = view.state.facet(bidiIsolatedRanges);
+    if (!isolates.length)
+        return isolates;
+    let sets = isolates.map(i => i instanceof Function ? i(view) : i);
+    let result = [];
+    RangeSet.spans(sets, from, to, {
+        point() { },
+        span(from, to, active, open) {
+            let level = result;
+            for (let i = active.length - 1; i >= 0; i--, open--) {
+                let iso = active[i].spec.bidiIsolate, update;
+                if (iso == null)
+                    continue;
+                if (open > 0 && level.length &&
+                    (update = level[level.length - 1]).to == from && update.direction == iso) {
+                    update.to = to;
+                    level = update.inner;
+                }
+                else {
+                    let add = { from, to, direction: iso, inner: [] };
+                    level.push(add);
+                    level = add.inner;
+                }
+            }
+        }
+    });
+    return result;
+}
 const scrollMargins = /*@__PURE__*/Facet.define();
 function getScrollMargins(view) {
     let left = 0, right = 0, top = 0, bottom = 0;
@@ -2138,27 +2178,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.
@@ -2216,12 +2256,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]/;
 /**
@@ -2229,6 +2269,10 @@ Represents a contiguous range of text that has a single direction
 (as in left-to-right or right-to-left).
 */
 class BidiSpan {
+    /**
+    The direction of this span.
+    */
+    get dir() { return this.level % 2 ? RTL : LTR; }
     /**
     @internal
     */
@@ -2254,10 +2298,6 @@ class BidiSpan {
         this.level = level;
     }
     /**
-    The direction of this span.
-    */
-    get dir() { return this.level % 2 ? RTL : LTR; }
-    /**
     @internal
     */
     side(end, dir) { return (this.dir == dir) == end ? this.to : this.from; }
@@ -2283,166 +2323,328 @@ class BidiSpan {
         return maybe;
     }
 }
+function isolatesEq(a, b) {
+    if (a.length != b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        let iA = a[i], iB = b[i];
+        if (iA.from != iB.from || iA.to != iB.to || iA.direction != iB.direction || !isolatesEq(iA.inner, iB.inner))
+            return false;
+    }
+    return true;
+}
 // 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))
-        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
-    // character. If the NSM is at the start of the level run, it will
-    // get the type of sor.
-    // W2. Search backwards from each instance of a European number
-    // until the first strong type (R, L, AL, or sor) is found. If an
-    // AL is found, change the type of the European number to Arabic
-    // number.
-    // W3. Change all ALs to R.
-    // (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 */)
-            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 */)
-            prevStrong = type;
-        prev = type;
-    }
-    // W5. A sequence of European terminators adjacent to European
-    // numbers changes to all European numbers.
-    // W6. Otherwise, separators and terminators change to Other
-    // Neutral.
-    // W7. Search backwards from each instance of a European number
-    // until the first strong type (R, L, or sor) is found. If an L is
-    // found, then change the type of the European number to L.
-    // (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 */))
-                type = types[i] = prev;
-            else
-                types[i] = 256 /* NI */;
-        }
-        else if (type == 64 /* ET */) {
-            let end = i + 1;
-            while (end < len && types[end] == 64 /* ET */)
-                end++;
-            let replace = (i && prev == 8 /* EN */) || (end < len && types[end] == 8 /* EN */) ? (prevStrong == 1 /* L */ ? 1 /* L */ : 8 /* EN */) : 256 /* 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 */;
-        }
-        prev = type;
-        if (type & 7 /* Strong */)
-            prevStrong = type;
-    }
-    // N0. Process bracket pairs in an isolating run sequence
-    // sequentially in the logical order of the text positions of the
-    // opening paired brackets using the logic given below. Within this
-    // scope, bidirectional types EN and AN are treated as R.
-    for (let i = 0, sI = 0, context = 0, ch, br, type; i < len; i++) {
-        // Keeps [startIndex, type, strongSeen] triples for each open
-        // bracket on BracketStack.
-        if (br = Brackets[ch = line.charCodeAt(i)]) {
-            if (br < 0) { // Closing bracket
+// Fill in the character types (in `types`) from `from` to `to` and
+// apply W normalization rules.
+function computeCharTypes(line, rFrom, rTo, isolates, outerType) {
+    for (let iI = 0; iI <= isolates.length; iI++) {
+        let from = iI ? isolates[iI - 1].to : rFrom, to = iI < isolates.length ? isolates[iI].from : rTo;
+        let prevType = iI ? 256 /* T.NI */ : outerType;
+        // W1. Examine each non-spacing mark (NSM) in the level run, and
+        // change the type of the NSM to the type of the previous
+        // character. If the NSM is at the start of the level run, it will
+        // get the type of sor.
+        // W2. Search backwards from each instance of a European number
+        // until the first strong type (R, L, AL, or sor) is found. If an
+        // AL is found, change the type of the European number to Arabic
+        // number.
+        // W3. Change all ALs to R.
+        // (Left after this: L, R, EN, AN, ET, CS, NI)
+        for (let i = from, prev = prevType, prevStrong = prevType; i < to; i++) {
+            let type = charType(line.charCodeAt(i));
+            if (type == 512 /* T.NSM */)
+                type = prev;
+            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;
+        }
+        // W5. A sequence of European terminators adjacent to European
+        // numbers changes to all European numbers.
+        // W6. Otherwise, separators and terminators change to Other
+        // Neutral.
+        // W7. Search backwards from each instance of a European number
+        // until the first strong type (R, L, or sor) is found. If an L is
+        // found, then change the type of the European number to L.
+        // (Left after this: L, R, EN+AN, NI)
+        for (let i = from, prev = prevType, prevStrong = prevType; i < to; i++) {
+            let type = types[i];
+            if (type == 128 /* T.CS */) {
+                if (i < to - 1 && prev == types[i + 1] && (prev & 24 /* T.Num */))
+                    type = types[i] = prev;
+                else
+                    types[i] = 256 /* T.NI */;
+            }
+            else if (type == 64 /* T.ET */) {
+                let end = i + 1;
+                while (end < to && types[end] == 64 /* T.ET */)
+                    end++;
+                let replace = (i && prev == 8 /* T.EN */) || (end < rTo && 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 /* T.EN */ && prevStrong == 1 /* T.L */) {
+                types[i] = 1 /* T.L */;
+            }
+            prev = type;
+            if (type & 7 /* T.Strong */)
+                prevStrong = type;
+        }
+    }
+}
+// Process brackets throughout a run sequence.
+function processBracketPairs(line, rFrom, rTo, isolates, outerType) {
+    let oppositeType = outerType == 1 /* T.L */ ? 2 /* T.R */ : 1 /* T.L */;
+    for (let iI = 0, sI = 0, context = 0; iI <= isolates.length; iI++) {
+        let from = iI ? isolates[iI - 1].to : rFrom, to = iI < isolates.length ? isolates[iI].from : rTo;
+        // N0. Process bracket pairs in an isolating run sequence
+        // sequentially in the logical order of the text positions of the
+        // opening paired brackets using the logic given below. Within this
+        // scope, bidirectional types EN and AN are treated as R.
+        for (let i = from, ch, br, type; i < to; i++) {
+            // Keeps [startIndex, type, strongSeen] triples for each open
+            // bracket on BracketStack.
+            if (br = Brackets[ch = line.charCodeAt(i)]) {
+                if (br < 0) { // Closing bracket
+                    for (let sJ = sI - 3; sJ >= 0; sJ -= 3) {
+                        if (BracketStack[sJ + 1] == -br) {
+                            let flags = BracketStack[sJ + 2];
+                            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;
+                            break;
+                        }
+                    }
+                }
+                else if (BracketStack.length == 189 /* Bracketed.MaxDepth */) {
+                    break;
+                }
+                else {
+                    BracketStack[sI++] = i;
+                    BracketStack[sI++] = ch;
+                    BracketStack[sI++] = context;
+                }
+            }
+            else if ((type = types[i]) == 2 /* T.R */ || type == 1 /* T.L */) {
+                let embed = type == outerType;
+                context = embed ? 0 : 1 /* Bracketed.OppositeBefore */;
                 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;
-                        if (type)
-                            types[i] = types[BracketStack[sJ]] = type;
-                        sI = sJ;
+                    let cur = BracketStack[sJ + 2];
+                    if (cur & 2 /* Bracketed.EmbedInside */)
                         break;
+                    if (embed) {
+                        BracketStack[sJ + 2] |= 2 /* Bracketed.EmbedInside */;
+                    }
+                    else {
+                        if (cur & 4 /* Bracketed.OppositeInside */)
+                            break;
+                        BracketStack[sJ + 2] |= 4 /* Bracketed.OppositeInside */;
                     }
                 }
             }
-            else if (BracketStack.length == 189 /* MaxDepth */) {
-                break;
+        }
+    }
+}
+function processNeutrals(rFrom, rTo, isolates, outerType) {
+    for (let iI = 0, prev = outerType; iI <= isolates.length; iI++) {
+        let from = iI ? isolates[iI - 1].to : rFrom, to = iI < isolates.length ? isolates[iI].from : rTo;
+        // N1. A sequence of neutrals takes the direction of the
+        // surrounding strong text if the text on both sides has the same
+        // direction. European and Arabic numbers act as if they were R in
+        // terms of their influence on neutrals. Start-of-level-run (sor)
+        // and end-of-level-run (eor) are used at level run boundaries.
+        // N2. Any remaining neutrals take the embedding direction.
+        // (Left after this: L, R, EN+AN)
+        for (let i = from; i < to;) {
+            let type = types[i];
+            if (type == 256 /* T.NI */) {
+                let end = i + 1;
+                for (;;) {
+                    if (end == to) {
+                        if (iI == isolates.length)
+                            break;
+                        end = isolates[iI++].to;
+                        to = iI < isolates.length ? isolates[iI].from : rTo;
+                    }
+                    else if (types[end] == 256 /* T.NI */) {
+                        end++;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                let beforeL = prev == 1 /* T.L */;
+                let afterL = (end < rTo ? types[end] : outerType) == 1 /* T.L */;
+                let replace = beforeL == afterL ? (beforeL ? 1 /* T.L */ : 2 /* T.R */) : outerType;
+                for (let j = end, jI = iI, fromJ = jI ? isolates[jI - 1].to : rFrom; j > i;) {
+                    if (j == fromJ) {
+                        j = isolates[--jI].from;
+                        fromJ = jI ? isolates[jI - 1].to : rFrom;
+                    }
+                    types[--j] = replace;
+                }
+                i = end;
             }
             else {
-                BracketStack[sI++] = i;
-                BracketStack[sI++] = ch;
-                BracketStack[sI++] = context;
+                prev = type;
+                i++;
             }
         }
-        else if ((type = types[i]) == 2 /* R */ || type == 1 /* L */) {
-            let embed = type == outerType;
-            context = embed ? 0 : 1 /* OppositeBefore */;
-            for (let sJ = sI - 3; sJ >= 0; sJ -= 3) {
-                let cur = BracketStack[sJ + 2];
-                if (cur & 2 /* EmbedInside */)
+    }
+}
+// Find the contiguous ranges of character types in a given range, and
+// emit spans for them. Flip the order of the spans as appropriate
+// based on the level, and call through to compute the spans for
+// isolates at the proper point.
+function emitSpans(line, from, to, level, baseLevel, isolates, order) {
+    let ourType = level % 2 ? 2 /* T.R */ : 1 /* T.L */;
+    if ((level % 2) == (baseLevel % 2)) { // Same dir as base direction, don't flip
+        for (let iCh = from, iI = 0; iCh < to;) {
+            // Scan a section of characters in direction ourType, unless
+            // there's another type of char right after iCh, in which case
+            // we scan a section of other characters (which, if ourType ==
+            // T.L, may contain both T.R and T.AN chars).
+            let sameDir = true, isNum = false;
+            if (iI == isolates.length || iCh < isolates[iI].from) {
+                let next = types[iCh];
+                if (next != ourType) {
+                    sameDir = false;
+                    isNum = next == 16 /* T.AN */;
+                }
+            }
+            // Holds an array of isolates to pass to a recursive call if we
+            // must recurse (to distinguish T.AN inside an RTL section in
+            // LTR text), null if we can emit directly
+            let recurse = !sameDir && ourType == 1 /* T.L */ ? [] : null;
+            let localLevel = sameDir ? level : level + 1;
+            let iScan = iCh;
+            run: for (;;) {
+                if (iI < isolates.length && iScan == isolates[iI].from) {
+                    if (isNum)
+                        break run;
+                    let iso = isolates[iI];
+                    // Scan ahead to verify that there is another char in this dir after the isolate(s)
+                    if (!sameDir)
+                        for (let upto = iso.to, jI = iI + 1;;) {
+                            if (upto == to)
+                                break run;
+                            if (jI < isolates.length && isolates[jI].from == upto)
+                                upto = isolates[jI++].to;
+                            else if (types[upto] == ourType)
+                                break run;
+                            else
+                                break;
+                        }
+                    iI++;
+                    if (recurse) {
+                        recurse.push(iso);
+                    }
+                    else {
+                        if (iso.from > iCh)
+                            order.push(new BidiSpan(iCh, iso.from, localLevel));
+                        let dirSwap = (iso.direction == LTR) != !(localLevel % 2);
+                        computeSectionOrder(line, dirSwap ? level + 1 : level, baseLevel, iso.inner, iso.from, iso.to, order);
+                        iCh = iso.to;
+                    }
+                    iScan = iso.to;
+                }
+                else if (iScan == to || (sameDir ? types[iScan] != ourType : types[iScan] == ourType)) {
                     break;
-                if (embed) {
-                    BracketStack[sJ + 2] |= 2 /* EmbedInside */;
                 }
                 else {
-                    if (cur & 4 /* OppositeInside */)
-                        break;
-                    BracketStack[sJ + 2] |= 4 /* OppositeInside */;
+                    iScan++;
                 }
             }
+            if (recurse)
+                emitSpans(line, iCh, iScan, level + 1, baseLevel, recurse, order);
+            else if (iCh < iScan)
+                order.push(new BidiSpan(iCh, iScan, localLevel));
+            iCh = iScan;
         }
     }
-    // N1. A sequence of neutrals takes the direction of the
-    // surrounding strong text if the text on both sides has the same
-    // direction. European and Arabic numbers act as if they were R in
-    // terms of their influence on neutrals. Start-of-level-run (sor)
-    // and end-of-level-run (eor) are used at level run boundaries.
-    // 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 */) {
-            let end = i + 1;
-            while (end < len && types[end] == 256 /* 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;
-            for (let j = i; j < end; j++)
-                types[j] = replace;
-            i = end - 1;
-        }
-    }
-    // Here we depart from the documented algorithm, in order to avoid
-    // building up an actual levels array. Since there are only three
-    // levels (0, 1, 2) in an implementation that doesn't take
-    // 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 */) {
-        for (let i = 0; i < len;) {
-            let start = i, rtl = types[i++] != 1 /* L */;
-            while (i < len && rtl == (types[i] != 1 /* 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 */))
-                        j--;
-                    order.push(new BidiSpan(j, end, l ? 2 : 1));
+    else {
+        // Iterate in reverse to flip the span order. Same code again, but
+        // going from the back of the section to the front
+        for (let iCh = to, iI = isolates.length; iCh > from;) {
+            let sameDir = true, isNum = false;
+            if (!iI || iCh > isolates[iI - 1].to) {
+                let next = types[iCh - 1];
+                if (next != ourType) {
+                    sameDir = false;
+                    isNum = next == 16 /* T.AN */;
                 }
             }
-            else {
-                order.push(new BidiSpan(start, i, 0));
+            let recurse = !sameDir && ourType == 1 /* T.L */ ? [] : null;
+            let localLevel = sameDir ? level : level + 1;
+            let iScan = iCh;
+            run: for (;;) {
+                if (iI && iScan == isolates[iI - 1].to) {
+                    if (isNum)
+                        break run;
+                    let iso = isolates[--iI];
+                    // Scan ahead to verify that there is another char in this dir after the isolate(s)
+                    if (!sameDir)
+                        for (let upto = iso.from, jI = iI;;) {
+                            if (upto == from)
+                                break run;
+                            if (jI && isolates[jI - 1].to == upto)
+                                upto = isolates[--jI].from;
+                            else if (types[upto - 1] == ourType)
+                                break run;
+                            else
+                                break;
+                        }
+                    if (recurse) {
+                        recurse.push(iso);
+                    }
+                    else {
+                        if (iso.to < iCh)
+                            order.push(new BidiSpan(iso.to, iCh, localLevel));
+                        let dirSwap = (iso.direction == LTR) != !(localLevel % 2);
+                        computeSectionOrder(line, dirSwap ? level + 1 : level, baseLevel, iso.inner, iso.from, iso.to, order);
+                        iCh = iso.from;
+                    }
+                    iScan = iso.from;
+                }
+                else if (iScan == from || (sameDir ? types[iScan - 1] != ourType : types[iScan - 1] == ourType)) {
+                    break;
+                }
+                else {
+                    iScan--;
+                }
             }
+            if (recurse)
+                emitSpans(line, iScan, iCh, level + 1, baseLevel, recurse, order);
+            else if (iScan < iCh)
+                order.push(new BidiSpan(iScan, iCh, localLevel));
+            iCh = iScan;
         }
     }
-    else {
-        for (let i = 0; i < len;) {
-            let start = i, rtl = types[i++] == 2 /* R */;
-            while (i < len && rtl == (types[i] == 2 /* R */))
-                i++;
-            order.push(new BidiSpan(start, i, rtl ? 1 : 2));
-        }
-    }
+}
+function computeSectionOrder(line, level, baseLevel, isolates, from, to, order) {
+    let outerType = (level % 2 ? 2 /* T.R */ : 1 /* T.L */);
+    computeCharTypes(line, from, to, isolates, outerType);
+    processBracketPairs(line, from, to, isolates, outerType);
+    processNeutrals(from, to, isolates, outerType);
+    emitSpans(line, from, to, level, baseLevel, isolates, order);
+}
+function computeOrder(line, direction, isolates) {
+    if (!line)
+        return [new BidiSpan(0, 0, direction == RTL ? 1 : 0)];
+    if (direction == LTR && !isolates.length && !BidiRE.test(line))
+        return trivialOrder(line.length);
+    if (isolates.length)
+        while (line.length > types.length)
+            types[types.length] = 256 /* T.NI */; // Make sure types array has no gaps
+    let order = [], level = direction == LTR ? 0 : 1;
+    computeSectionOrder(line, level, level, isolates, 0, line.length, order);
     return order;
 }
 function trivialOrder(length) {
@@ -2491,6 +2693,7 @@ function moveVisually(line, order, dir, start, forward) {
 }
 
 class DocView extends ContentView {
+    get length() { return this.view.state.doc.length; }
     constructor(view) {
         super();
         this.view = view;
@@ -2522,7 +2725,6 @@ class DocView extends ContentView {
         this.updateDeco();
         this.updateInner([new ChangedRange(0, 0, 0, view.state.doc.length)], 0, null);
     }
-    get length() { return this.view.state.doc.length; }
     // Update the document view to a given state.
     update(update) {
         let changedRanges = update.changedRanges;
@@ -2554,7 +2756,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.flags & 7 /* Dirty */) && changedRanges.length == 0) {
+        if (!(this.flags & 7 /* ViewFlag.Dirty */) && changedRanges.length == 0) {
             return false;
         }
         else {
@@ -2583,12 +2785,12 @@ class DocView extends ContentView {
             // to detect that situation.
             let track = browser.chrome || browser.ios ? { node: observer.selectionRange.focusNode, written: false } : undefined;
             this.sync(this.view, track);
-            this.flags &= ~7 /* Dirty */;
+            this.flags &= ~7 /* ViewFlag.Dirty */;
             if (track && (track.written || observer.selectionRange.focusNode != track.node))
                 this.forceSelection = true;
             this.dom.style.height = "";
         });
-        this.markedForComposition.forEach(cView => cView.flags &= ~8 /* Composition */);
+        this.markedForComposition.forEach(cView => cView.flags &= ~8 /* ViewFlag.Composition */);
         let gaps = [];
         if (this.view.viewport.from || this.view.viewport.to < this.view.state.doc.length)
             for (let child of this.children)
@@ -2638,7 +2840,7 @@ class DocView extends ContentView {
     }
     compositionView(composition) {
         let cur = new TextView(composition.text.nodeValue);
-        cur.flags |= 8 /* Composition */;
+        cur.flags |= 8 /* ViewFlag.Composition */;
         for (let { deco } of composition.marks)
             cur = new MarkView(deco, [cur], cur.length);
         let line = new LineView;
@@ -2647,7 +2849,7 @@ class DocView extends ContentView {
     }
     fixCompositionDOM(composition) {
         let fix = (dom, cView) => {
-            cView.flags |= 8 /* Composition */;
+            cView.flags |= 8 /* ViewFlag.Composition */;
             this.markedForComposition.add(cView);
             let prev = ContentView.get(dom);
             if (prev != cView) {
@@ -2709,15 +2911,15 @@ 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);
-                    if (main.bidiLevel != null && domSel.cursorBidiLevel != null)
-                        domSel.cursorBidiLevel = main.bidiLevel;
+                    if (main.bidiLevel != null && domSel.caretBidiLevel != null)
+                        domSel.caretBidiLevel = main.bidiLevel;
                 }
                 else if (rawSel.extend) {
                     // Selection.extend can be used to create an 'inverted' selection
@@ -2978,7 +3180,7 @@ class BlockGapWidget extends WidgetType {
     }
     get estimatedHeight() { return this.height; }
 }
-function findCompositionNode(view) {
+function findCompositionNode(view, dLen) {
     let sel = view.observer.selectionRange;
     let textNode = sel.focusNode && nearbyTextNode(sel.focusNode, sel.focusOffset, 0);
     if (!textNode)
@@ -2990,10 +3192,12 @@ function findCompositionNode(view) {
         to = from + cView.length;
     }
     else {
+        let oldLen = Math.max(0, textNode.nodeValue.length - dLen);
         up: for (let offset = 0, node = textNode;;) {
             for (let sibling = node.previousSibling, cView; sibling; sibling = sibling.previousSibling) {
                 if (cView = ContentView.get(sibling)) {
-                    from = to = cView.posAtEnd + offset;
+                    to = cView.posAtEnd + offset;
+                    from = Math.max(0, to - oldLen);
                     break up;
                 }
                 let reader = new DOMReader([], view.state);
@@ -3007,15 +3211,16 @@ function findCompositionNode(view) {
                 return null;
             let parentView = ContentView.get(node);
             if (parentView) {
-                from = to = parentView.posAtStart + offset;
+                from = parentView.posAtStart + offset;
+                to = from + oldLen;
                 break;
             }
         }
     }
-    return { from, to, node: textNode };
+    return { from, to: to, node: textNode };
 }
 function findCompositionRange(view, changes) {
-    let found = findCompositionNode(view);
+    let found = findCompositionNode(view, changes.newLength - changes.length);
     if (!found)
         return null;
     let { from: fromA, to: toA, node: textNode } = found;
@@ -3089,16 +3294,16 @@ function nearbyTextNode(startNode, startOffset, 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 {
+let DecorationComparator$1 = class DecorationComparator {
     constructor() {
         this.changes = [];
     }
     compareRange(from, to) { addRange(from, to, this.changes); }
     comparePoint(from, to) { addRange(from, to, this.changes); }
-}
+};
 function findChangedDeco(a, b, diff) {
     let comp = new DecorationComparator$1;
     RangeSet.compare(a, b, diff, comp);
@@ -3480,6 +3685,10 @@ function skipAtoms(view, oldPos, pos) {
 
 // This will also be where dragging info and such goes
 class InputState {
+    setSelectionOrigin(origin) {
+        this.lastSelectionOrigin = origin;
+        this.lastSelectionTime = Date.now();
+    }
     constructor(view) {
         this.lastKeyCode = 0;
         this.lastKeyTime = 0;
@@ -3575,10 +3784,8 @@ class InputState {
         // issue where the composition vanishes when you press enter.
         if (browser.safari)
             view.contentDOM.addEventListener("input", () => null);
-    }
-    setSelectionOrigin(origin) {
-        this.lastSelectionOrigin = origin;
-        this.lastSelectionTime = Date.now();
+        if (browser.gecko)
+            firefoxCopyCutHack(view.contentDOM.ownerDocument);
     }
     ensureHandlers(view, plugins) {
         var _a;
@@ -4284,6 +4491,18 @@ handlers.beforeinput = (view, event) => {
         }
     }
 };
+const appliedFirefoxHack = /*@__PURE__*/new Set;
+// In Firefox, when cut/copy handlers are added to the document, that
+// somehow avoids a bug where those events aren't fired when the
+// selection is empty. See https://github.com/codemirror/dev/issues/1082
+// and https://bugzilla.mozilla.org/show_bug.cgi?id=995961
+function firefoxCopyCutHack(doc) {
+    if (!appliedFirefoxHack.has(doc)) {
+        appliedFirefoxHack.add(doc);
+        doc.addEventListener("copy", () => { });
+        doc.addEventListener("cut", () => { });
+    }
+}
 
 const wrappingWhiteSpace = ["pre-wrap", "normal", "pre-line", "break-spaces"];
 class HeightOracle {
@@ -4447,13 +4666,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)
@@ -4584,7 +4803,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);
@@ -4737,12 +4956,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, oracle, top, offset) {
         let mid = top + this.left.height;
         return height < mid ? this.left.blockAt(height, oracle, top, offset)
@@ -4927,7 +5146,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() {
@@ -5137,7 +5356,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, this.heightMap, this.viewports);
     }
     updateViewportLines() {
@@ -5156,7 +5375,7 @@ class ViewState {
         let scrollAnchor = this.scrolledToBottom ? null : this.scrollAnchorAt(this.scrollTop);
         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 */;
         if (scrollAnchor) {
             this.scrollAnchorPos = update.changes.mapPos(scrollAnchor.from, -1);
             this.scrollAnchorHeight = scrollAnchor.top;
@@ -5169,13 +5388,13 @@ class ViewState {
         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 > (2000 /* Margin */ << 1))
+        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)
@@ -5201,13 +5420,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 */;
         }
         if (this.scrollTop != view.scrollDOM.scrollTop) {
             this.scrollAnchorHeight = -1;
@@ -5230,7 +5449,7 @@ class ViewState {
         if (this.contentDOMWidth != contentWidth || this.editorHeight != view.scrollDOM.clientHeight) {
             this.contentDOMWidth = domRect.width;
             this.editorHeight = view.scrollDOM.clientHeight;
-            result |= 8 /* Geometry */;
+            result |= 8 /* UpdateFlag.Geometry */;
         }
         if (measureContent) {
             let lineHeights = view.docView.measureVisibleLineHeights(this.viewport);
@@ -5241,7 +5460,7 @@ class ViewState {
                 refresh = lineHeight > 0 && oracle.refresh(whiteSpace, lineHeight, charWidth, textHeight, contentWidth / charWidth, lineHeights);
                 if (refresh) {
                     view.docView.minWidth = 0;
-                    result |= 8 /* Geometry */;
+                    result |= 8 /* UpdateFlag.Geometry */;
                 }
             }
             if (dTop > 0 && dBottom > 0)
@@ -5254,7 +5473,7 @@ class ViewState {
                 this.heightMap = (refresh ? HeightMap.empty().applyChanges(this.stateDeco, Text.empty, this.heightOracle, [new ChangedRange(0, 0, 0, view.state.doc.length)]) : 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 ||
@@ -5262,9 +5481,9 @@ class ViewState {
         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 > (2000 /* Margin */ << 1))
+        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) {
@@ -5283,10 +5502,10 @@ 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, oracle = this.heightOracle;
         let { visibleTop, visibleBottom } = this;
-        let viewport = new Viewport(map.lineAt(visibleTop - marginTop * 1000 /* Margin */, QueryType.ByHeight, oracle, 0, 0).from, map.lineAt(visibleBottom + (1 - marginTop) * 1000 /* Margin */, QueryType.ByHeight, oracle, 0, 0).to);
+        let viewport = new Viewport(map.lineAt(visibleTop - marginTop * 1000 /* VP.Margin */, QueryType.ByHeight, oracle, 0, 0).from, map.lineAt(visibleBottom + (1 - marginTop) * 1000 /* VP.Margin */, QueryType.ByHeight, oracle, 0, 0).to);
         // If scrollTarget is given, make sure the viewport includes that position
         if (scrollTarget) {
             let { head } = scrollTarget.range;
@@ -5299,7 +5518,7 @@ class ViewState {
                     topPos = block.top;
                 else
                     topPos = block.bottom - viewHeight;
-                viewport = new Viewport(map.lineAt(topPos - 1000 /* Margin */ / 2, QueryType.ByHeight, oracle, 0, 0).from, map.lineAt(topPos + viewHeight + 1000 /* Margin */ / 2, QueryType.ByHeight, oracle, 0, 0).to);
+                viewport = new Viewport(map.lineAt(topPos - 1000 /* VP.Margin */ / 2, QueryType.ByHeight, oracle, 0, 0).from, map.lineAt(topPos + viewHeight + 1000 /* VP.Margin */ / 2, QueryType.ByHeight, oracle, 0, 0).to);
             }
         }
         return viewport;
@@ -5316,10 +5535,10 @@ class ViewState {
         let { top } = this.heightMap.lineAt(from, QueryType.ByPos, this.heightOracle, 0, 0);
         let { bottom } = this.heightMap.lineAt(to, QueryType.ByPos, this.heightOracle, 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)
@@ -5339,7 +5558,7 @@ class ViewState {
     // the artifacts this might produce from the user.
     ensureLineGaps(current, mayMeasure) {
         let wrapping = this.heightOracle.lineWrapping;
-        let margin = wrapping ? 10000 /* MarginWrap */ : 2000 /* Margin */, halfMargin = margin >> 1, doubleMargin = margin << 1;
+        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 [];
@@ -5352,8 +5571,8 @@ class ViewState {
                 avoid.push(sel.to);
             for (let pos of avoid) {
                 if (pos > from && pos < to) {
-                    addGap(from, pos - 10 /* SelectionMargin */, line, structure);
-                    addGap(pos + 10 /* SelectionMargin */, to, line, structure);
+                    addGap(from, pos - 10 /* LG.SelectionMargin */, line, structure);
+                    addGap(pos + 10 /* LG.SelectionMargin */, to, line, structure);
                     return;
                 }
             }
@@ -5447,7 +5666,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)) ||
@@ -5543,7 +5762,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);
@@ -5926,7 +6145,6 @@ function applyDOMChange(view, domChange) {
         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,
@@ -5940,70 +6158,18 @@ function applyDOMChange(view, domChange) {
                 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 ||
-                    lastKey == 8 && change.insert.length < change.to - change.from) &&
+                    lastKey == 8 && change.insert.length < change.to - change.from && change.to > sel.head) &&
                     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 && 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 composition = findCompositionNode(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.
-                        composition && range.to >= composition.from && range.from <= composition.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 ||
-            view.inputState.compositionPendingChange && view.inputState.compositionEndedAt > Date.now() - 50) {
-            view.inputState.compositionPendingChange = false;
-            userEvent += ".compose";
-            if (view.inputState.compositionFirstChange) {
-                userEvent += ".start";
-                view.inputState.compositionFirstChange = false;
-            }
-        }
-        view.dispatch(tr, { scrollIntoView: true, userEvent });
+        let defaultTr;
+        let defaultInsert = () => defaultTr || (defaultTr = applyDefaultInsert(view, change, newSel));
+        if (!view.state.facet(inputHandler).some(h => h(view, change.from, change.to, text, defaultInsert)))
+            view.dispatch(defaultInsert());
         return true;
     }
     else if (newSel && !newSel.main.eq(sel)) {
@@ -6020,6 +6186,63 @@ function applyDOMChange(view, domChange) {
         return false;
     }
 }
+function applyDefaultInsert(view, change, newSel) {
+    let tr, startState = view.state, sel = startState.selection.main;
+    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 && 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 composition = findCompositionNode(view, change.insert.length - (change.to - change.from)) ||
+                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.
+                    composition && range.to >= composition.from && range.from <= composition.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 ||
+        view.inputState.compositionPendingChange && view.inputState.compositionEndedAt > Date.now() - 50) {
+        view.inputState.compositionPendingChange = false;
+        userEvent += ".compose";
+        if (view.inputState.compositionFirstChange) {
+            userEvent += ".start";
+            view.inputState.compositionFirstChange = false;
+        }
+    }
+    return startState.update(tr, { userEvent, scrollIntoView: true });
+}
 function findDiff(a, b, preferredPos, preferredSide) {
     let minLen = Math.min(a.length, b.length);
     let from = 0;
@@ -6437,7 +6660,7 @@ class DOMObserver {
             return null;
         cView.markDirty(rec.type == "attributes");
         if (rec.type == "attributes")
-            cView.flags |= 4 /* AttrsDirty */;
+            cView.flags |= 4 /* ViewFlag.AttrsDirty */;
         if (rec.type == "childList") {
             let childBefore = findChild(cView, rec.previousSibling || rec.target.previousSibling, -1);
             let childAfter = findChild(cView, rec.nextSibling || rec.target.nextSibling, 1);
@@ -6545,6 +6768,53 @@ line number gutter. It handles events and dispatches state
 transactions for editing actions.
 */
 class EditorView {
+    /**
+    The current editor state.
+    */
+    get state() { return this.viewState.state; }
+    /**
+    To be able to display large documents without consuming too much
+    memory or overloading the browser, CodeMirror only draws the
+    code that is visible (plus a margin around it) to the DOM. This
+    property tells you the extent of the current drawn viewport, in
+    document positions.
+    */
+    get viewport() { return this.viewState.viewport; }
+    /**
+    When there are, for example, large collapsed ranges in the
+    viewport, its size can be a lot bigger than the actual visible
+    content. Thus, if you are doing something like styling the
+    content in the viewport, it is preferable to only do so for
+    these ranges, which are the subset of the viewport that is
+    actually drawn.
+    */
+    get visibleRanges() { return this.viewState.visibleRanges; }
+    /**
+    Returns false when the editor is entirely scrolled out of view
+    or otherwise hidden.
+    */
+    get inView() { return this.viewState.inView; }
+    /**
+    Indicates whether the user is currently composing text via
+    [IME](https://en.wikipedia.org/wiki/Input_method), and at least
+    one change has been made in the current composition.
+    */
+    get composing() { return this.inputState.composing > 0; }
+    /**
+    Indicates whether the user is currently in composing state. Note
+    that on some platforms, like Android, this will be the case a
+    lot, since just putting the cursor on a word starts a
+    composition there.
+    */
+    get compositionStarted() { return this.inputState.composing >= 0; }
+    /**
+    The document or shadow root that the view lives in.
+    */
+    get root() { return this._root; }
+    /**
+    @internal
+    */
+    get win() { return this.dom.ownerDocument.defaultView || window; }
     /**
     Construct a new view. You'll want to either provide a `parent`
     option, or put `view.dom` into your document after creating a
@@ -6560,7 +6830,7 @@ class EditorView {
         /**
         @internal
         */
-        this.updateState = 2 /* Updating */;
+        this.updateState = 2 /* UpdateState.Updating */;
         /**
         @internal
         */
@@ -6580,7 +6850,10 @@ class EditorView {
         this.dom = document.createElement("div");
         this.dom.appendChild(this.announceDOM);
         this.dom.appendChild(this.scrollDOM);
-        this._dispatch = config.dispatch || ((tr) => this.update([tr]));
+        let { dispatch } = config;
+        this.dispatchTransactions = config.dispatchTransactions ||
+            (dispatch && ((trs) => trs.forEach(tr => dispatch(tr, this)))) ||
+            ((trs) => this.update(trs));
         this.dispatch = this.dispatch.bind(this);
         this._root = (config.root || getRoot(config.parent) || document);
         this.viewState = new ViewState(config.state || EditorState.create(config));
@@ -6593,62 +6866,16 @@ 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);
     }
-    /**
-    The current editor state.
-    */
-    get state() { return this.viewState.state; }
-    /**
-    To be able to display large documents without consuming too much
-    memory or overloading the browser, CodeMirror only draws the
-    code that is visible (plus a margin around it) to the DOM. This
-    property tells you the extent of the current drawn viewport, in
-    document positions.
-    */
-    get viewport() { return this.viewState.viewport; }
-    /**
-    When there are, for example, large collapsed ranges in the
-    viewport, its size can be a lot bigger than the actual visible
-    content. Thus, if you are doing something like styling the
-    content in the viewport, it is preferable to only do so for
-    these ranges, which are the subset of the viewport that is
-    actually drawn.
-    */
-    get visibleRanges() { return this.viewState.visibleRanges; }
-    /**
-    Returns false when the editor is entirely scrolled out of view
-    or otherwise hidden.
-    */
-    get inView() { return this.viewState.inView; }
-    /**
-    Indicates whether the user is currently composing text via
-    [IME](https://en.wikipedia.org/wiki/Input_method), and at least
-    one change has been made in the current composition.
-    */
-    get composing() { return this.inputState.composing > 0; }
-    /**
-    Indicates whether the user is currently in composing state. Note
-    that on some platforms, like Android, this will be the case a
-    lot, since just putting the cursor on a word starts a
-    composition there.
-    */
-    get compositionStarted() { return this.inputState.composing >= 0; }
-    /**
-    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) {
-        let tr = input.length == 1 && input[0] instanceof Transaction ? input[0]
-            : this.state.update(...input);
-        this._dispatch(tr, this);
+        let trs = input.length == 1 && input[0] instanceof Transaction ? input
+            : input.length == 1 && Array.isArray(input[0]) ? input[0]
+                : [this.state.update(...input)];
+        this.dispatchTransactions(trs, this);
     }
     /**
     Update the view for the given array of transactions. This will
@@ -6659,7 +6886,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 = this.state;
@@ -6676,7 +6903,7 @@ class EditorView {
         if (transactions.some(tr => tr.annotation(isFocusChange))) {
             this.inputState.notifiedFocused = focus;
             // If a focus-change transaction is being dispatched, set this update flag.
-            focusFlag = 1 /* Focus */;
+            focusFlag = 1 /* UpdateFlag.Focus */;
         }
         else if (focus != this.inputState.notifiedFocused) {
             this.inputState.notifiedFocused = focus;
@@ -6684,7 +6911,7 @@ class EditorView {
             // add a flag to this update
             dispatchFocus = focusChangeTransaction(state, focus);
             if (!dispatchFocus)
-                focusFlag = 1 /* Focus */;
+                focusFlag = 1 /* UpdateFlag.Focus */;
         }
         // If there was a pending DOM change, eagerly read it and try to
         // apply it after the given transactions.
@@ -6707,7 +6934,7 @@ class EditorView {
         update.flags |= focusFlag;
         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);
@@ -6733,7 +6960,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;
@@ -6760,13 +6987,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)
@@ -6783,7 +7010,7 @@ class EditorView {
             this.bidiCache = [];
         }
         finally {
-            this.updateState = 0 /* Idle */;
+            this.updateState = 0 /* UpdateState.Idle */;
         }
         if (hadFocus)
             this.focus();
@@ -6826,6 +7053,11 @@ class EditorView {
             return;
         if (this.measureScheduled > -1)
             this.win.cancelAnimationFrame(this.measureScheduled);
+        if (this.observer.delayedAndroidKey) {
+            this.measureScheduled = -1;
+            this.requestMeasure();
+            return;
+        }
         this.measureScheduled = 0; // Prevent requestMeasure calls from scheduling another animation frame
         if (flush)
             this.observer.forceFlush();
@@ -6848,7 +7080,7 @@ class EditorView {
                         scrollAnchorHeight = block.top;
                     }
                 }
-                this.updateState = 1 /* Measuring */;
+                this.updateState = 1 /* UpdateState.Measuring */;
                 let changed = this.viewState.measure(this);
                 if (!changed && !this.measureRequests.length && this.viewState.scrollTarget == null)
                     break;
@@ -6860,7 +7092,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 {
@@ -6877,7 +7109,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);
@@ -6920,7 +7152,7 @@ class EditorView {
             }
         }
         finally {
-            this.updateState = 0 /* Idle */;
+            this.updateState = 0 /* UpdateState.Idle */;
             this.measureScheduled = -1;
         }
         if (updated && !updated.empty)
@@ -6976,12 +7208,13 @@ class EditorView {
     }
     mountStyles() {
         this.styleModules = this.state.facet(styleModule);
-        StyleModule.mount(this.root, this.styleModules.concat(baseTheme$1).reverse());
+        let nonce = this.state.facet(EditorView.cspNonce);
+        StyleModule.mount(this.root, this.styleModules.concat(baseTheme$1).reverse(), nonce ? { nonce } : undefined);
     }
     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);
     }
     /**
@@ -7235,12 +7468,16 @@ class EditorView {
     bidiSpans(line) {
         if (line.length > MaxBidiLine)
             return trivialOrder(line.length);
-        let dir = this.textDirectionAt(line.from);
-        for (let entry of this.bidiCache)
-            if (entry.from == line.from && entry.dir == dir)
+        let dir = this.textDirectionAt(line.from), isolates;
+        for (let entry of this.bidiCache) {
+            if (entry.from == line.from && entry.dir == dir &&
+                (entry.fresh || isolatesEq(entry.isolates, isolates = getIsolatedRanges(this, line.from, line.to))))
                 return entry.order;
-        let order = computeOrder(line.text, dir);
-        this.bidiCache.push(new CachedOrder(line.from, line.to, dir, order));
+        }
+        if (!isolates)
+            isolates = getIsolatedRanges(this, line.from, line.to);
+        let order = computeOrder(line.text, dir, isolates);
+        this.bidiCache.push(new CachedOrder(line.from, line.to, dir, isolates, true, order));
         return order;
     }
     /**
@@ -7375,6 +7612,10 @@ DOM content are handled. Handlers are passed the document
 positions between which the change was found, and the new
 content. When one returns true, no further input handlers are
 called and the default behavior is prevented.
+
+The `insert` argument can be used to get the default transaction
+that would be applied for this input. This can be useful when
+dispatching the custom behavior as a separate transaction.
 */
 EditorView.inputHandler = inputHandler;
 /**
@@ -7462,6 +7703,16 @@ regions.
 */
 EditorView.atomicRanges = atomicRanges;
 /**
+When range decorations add a `unicode-bidi: isolate` style, they
+should also include a
+[`bidiIsolate`](https://codemirror.net/6/docs/ref/#view.MarkDecorationSpec.bidiIsolate) property
+in their decoration spec, and be exposed through this facet, so
+that the editor can compute the proper text order. (Other values
+for `unicode-bidi`, except of course `normal`, are not
+supported.)
+*/
+EditorView.bidiIsolatedRanges = bidiIsolatedRanges;
+/**
 Facet that allows extensions to provide additional scroll
 margins (space around the sides of the scrolling element that
 should be considered invisible). This can be useful when the
@@ -7477,6 +7728,12 @@ true.
 */
 EditorView.darkTheme = darkTheme;
 /**
+Provides a Content Security Policy nonce to use when creating
+the style sheets for the editor. Holds the empty string when no
+nonce has been provided.
+*/
+EditorView.cspNonce = /*@__PURE__*/Facet.define({ combine: values => values.length ? values[0] : "" });
+/**
 Facet that provides additional DOM attributes for the editor's
 editable DOM element.
 */
@@ -7504,20 +7761,22 @@ EditorView.announce = /*@__PURE__*/StateEffect.define();
 const MaxBidiLine = 4096;
 const BadMeasure = {};
 class CachedOrder {
-    constructor(from, to, dir, order) {
+    constructor(from, to, dir, isolates, fresh, order) {
         this.from = from;
         this.to = to;
         this.dir = dir;
+        this.isolates = isolates;
+        this.fresh = fresh;
         this.order = order;
     }
     static update(cache, changes) {
-        if (changes.empty)
+        if (changes.empty && !cache.some(c => c.fresh))
             return cache;
         let result = [], lastDir = cache.length ? cache[cache.length - 1].dir : Direction.LTR;
         for (let i = Math.max(0, cache.length - 10); i < cache.length; i++) {
             let entry = cache[i];
             if (entry.dir == lastDir && !changes.touchesRange(entry.from, entry.to))
-                result.push(new CachedOrder(changes.mapPos(entry.from, 1), changes.mapPos(entry.to, -1), entry.dir, entry.order));
+                result.push(new CachedOrder(changes.mapPos(entry.from, 1), changes.mapPos(entry.to, -1), entry.dir, entry.isolates, false, entry.order));
         }
         return result;
     }
@@ -7840,7 +8099,7 @@ function rectanglesForRange(view, className, range) {
         return pieces(top).concat(between).concat(pieces(bottom));
     }
     function piece(left, top, right, bottom) {
-        return new RectangleMarker(className, left - base.left, top - base.top - 0.01 /* Epsilon */, right - left, bottom - top + 0.01 /* Epsilon */);
+        return new RectangleMarker(className, left - base.left, top - base.top - 0.01 /* C.Epsilon */, right - left, bottom - top + 0.01 /* C.Epsilon */);
     }
     function pieces({ top, bottom, horizontal }) {
         let pieces = [];
@@ -8857,12 +9116,12 @@ const tooltipPlugin = /*@__PURE__*/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 = (_a = knownHeight.get(tView)) !== null && _a !== void 0 ? _a : size.bottom - size.top;
             let offset = tView.offset || noOffset, ltr = this.view.textDirection == 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
@@ -8896,7 +9155,7 @@ const tooltipPlugin = /*@__PURE__*/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);
@@ -8939,8 +9198,8 @@ const baseTheme = /*@__PURE__*/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",
@@ -8949,26 +9208,26 @@ const baseTheme = /*@__PURE__*/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"
             }
         },
@@ -8993,6 +9252,10 @@ const showTooltip = /*@__PURE__*/Facet.define({
 });
 const showHoverTooltip = /*@__PURE__*/Facet.define();
 class HoverTooltipHost {
+    // Needs to be static so that host tooltip instances always match
+    static create(view) {
+        return new HoverTooltipHost(view);
+    }
     constructor(view) {
         this.view = view;
         this.mounted = false;
@@ -9000,10 +9263,6 @@ class HoverTooltipHost {
         this.dom.classList.add("cm-tooltip-hover");
         this.manager = new TooltipViewManager(view, showHoverTooltip, t => this.createHostedView(t));
     }
-    // Needs to be static so that host tooltip instances always match
-    static create(view) {
-        return new HoverTooltipHost(view);
-    }
     createHostedView(tooltip) {
         let hostedView = tooltip.create(this.view);
         hostedView.dom.classList.add("cm-tooltip-section");
@@ -9083,30 +9342,41 @@ class HoverPlugin {
     }
     startHover() {
         clearTimeout(this.restartTimeout);
-        let { lastMove } = this;
-        let pos = this.view.contentDOM.contains(lastMove.target) ? this.view.posAtCoords(lastMove) : null;
-        if (pos == null)
+        let { view, lastMove } = this;
+        let desc = view.docView.nearest(lastMove.target);
+        if (!desc)
             return;
-        let posCoords = this.view.coordsAtPos(pos);
-        if (posCoords == null || lastMove.y < posCoords.top || lastMove.y > posCoords.bottom ||
-            lastMove.x < posCoords.left - this.view.defaultCharacterWidth ||
-            lastMove.x > posCoords.right + this.view.defaultCharacterWidth)
-            return;
-        let bidi = this.view.bidiSpans(this.view.state.doc.lineAt(pos)).find(s => s.from <= pos && s.to >= pos);
-        let rtl = bidi && bidi.dir == Direction.RTL ? -1 : 1;
-        let open = this.source(this.view, pos, (lastMove.x < posCoords.left ? -rtl : rtl));
+        let pos, side = 1;
+        if (desc instanceof WidgetView) {
+            pos = desc.posAtStart;
+        }
+        else {
+            pos = view.posAtCoords(lastMove);
+            if (pos == null)
+                return;
+            let posCoords = view.coordsAtPos(pos);
+            if (!posCoords ||
+                lastMove.y < posCoords.top || lastMove.y > posCoords.bottom ||
+                lastMove.x < posCoords.left - view.defaultCharacterWidth ||
+                lastMove.x > posCoords.right + view.defaultCharacterWidth)
+                return;
+            let bidi = view.bidiSpans(view.state.doc.lineAt(pos)).find(s => s.from <= pos && s.to >= pos);
+            let rtl = bidi && bidi.dir == Direction.RTL ? -1 : 1;
+            side = (lastMove.x < posCoords.left ? -rtl : rtl);
+        }
+        let open = this.source(view, pos, side);
         if (open === null || open === void 0 ? void 0 : open.then) {
             let pending = this.pending = { pos };
             open.then(result => {
                 if (this.pending == pending) {
                     this.pending = null;
                     if (result)
-                        this.view.dispatch({ effects: this.setHover.of(result) });
+                        view.dispatch({ effects: this.setHover.of(result) });
                 }
-            }, e => logException(this.view.state, e, "hover tooltip"));
+            }, e => logException(view.state, e, "hover tooltip"));
         }
         else if (open) {
-            this.view.dispatch({ effects: this.setHover.of(open) });
+            view.dispatch({ effects: this.setHover.of(open) });
         }
     }
     mousemove(event) {
@@ -9118,7 +9388,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))) {
                 this.view.dispatch({ effects: this.setHover.of(null) });
                 this.pending = null;
             }
@@ -9143,19 +9413,12 @@ function isInTooltip(elt) {
     return false;
 }
 function isOverRange(view, from, to, x, y, margin) {
-    let range = document.createRange();
-    let fromDOM = view.domAtPos(from), toDOM = view.domAtPos(to);
-    range.setEnd(toDOM.node, toDOM.offset);
-    range.setStart(fromDOM.node, fromDOM.offset);
-    let rects = range.getClientRects();
-    range.detach();
-    for (let i = 0; i < rects.length; i++) {
-        let rect = rects[i];
-        let dist = Math.max(rect.top - y, y - rect.bottom, rect.left - x, x - rect.right);
-        if (dist <= margin)
-            return true;
-    }
-    return false;
+    let rect = view.scrollDOM.getBoundingClientRect();
+    let docBottom = view.documentTop + view.documentPadding.top + view.contentHeight;
+    if (rect.left > x || rect.right < x || rect.top > y || Math.min(rect.bottom, docBottom) < y)
+        return false;
+    let pos = view.posAtCoords({ x, y }, false);
+    return pos >= from && pos <= to;
 }
 /**
 Set up a hover tooltip, which shows up when the pointer hovers
@@ -9200,7 +9463,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
     ];
 }