sqlui 0.1.76 → 0.1.77

data/client/resources/sqlui.js

@@ -5,10 +5,6 @@
    The data structure for documents. @nonabstract
    */
    class Text {
-       /**
-       @internal
-       */
-       constructor() { }
        /**
        Get the line description around the given position.
        */
@@ -103,7 +99,8 @@
            return new LineCursor(inner);
        }
        /**
-       @internal
+       Return the document as a string, using newline characters to
+       separate lines.
        */
        toString() { return this.sliceString(0); }
        /**
@@ -116,6 +113,10 @@
            return lines;
        }
        /**
+       @internal
+       */
+       constructor() { }
+       /**
        Create a `Text` instance for the given array of lines.
        */
        static of(text) {
@@ -2159,7 +2160,10 @@
        is(type) { return this.type == type; }
        /**
        Define a new effect type. The type parameter indicates the type
-       of values that his effect holds.
+       of values that his effect holds. It should be a type that
+       doesn't include `undefined`, since that is used in
+       [mapping](https://codemirror.net/6/docs/ref/#state.StateEffect.map) to indicate that an effect is
+       removed.
        */
        static define(spec = {}) {
            return new StateEffectType(spec.map || (v => v));
@@ -3302,8 +3306,7 @@
        static compare(oldSets, newSets, 
        /**
        This indicates how the underlying data changed between these
-       ranges, and is needed to synchronize the iteration. `from` and
-       `to` are coordinates in the _new_ space, after these changes.
+       ranges, and is needed to synchronize the iteration.
        */
        textDiff, comparator, 
        /**
@@ -3414,6 +3417,18 @@
    an array of [`Range`](https://codemirror.net/6/docs/ref/#state.Range) objects.
    */
    class RangeSetBuilder {
+       finishChunk(newArrays) {
+           this.chunks.push(new Chunk(this.from, this.to, this.value, this.maxPoint));
+           this.chunkPos.push(this.chunkStart);
+           this.chunkStart = -1;
+           this.setMaxPoint = Math.max(this.setMaxPoint, this.maxPoint);
+           this.maxPoint = -1;
+           if (newArrays) {
+               this.from = [];
+               this.to = [];
+               this.value = [];
+           }
+       }
        /**
        Create an empty builder.
        */
@@ -3431,18 +3446,6 @@
            this.setMaxPoint = -1;
            this.nextLayer = null;
        }
-       finishChunk(newArrays) {
-           this.chunks.push(new Chunk(this.from, this.to, this.value, this.maxPoint));
-           this.chunkPos.push(this.chunkStart);
-           this.chunkStart = -1;
-           this.setMaxPoint = Math.max(this.setMaxPoint, this.maxPoint);
-           this.maxPoint = -1;
-           if (newArrays) {
-               this.from = [];
-               this.to = [];
-               this.value = [];
-           }
-       }
        /**
        Add a range. Ranges should be added in sorted (by `from` and
        `value.startSide`) order.
@@ -3802,7 +3805,7 @@
            let end = diff < 0 ? a.to + dPos : b.to, clipEnd = Math.min(end, endB);
            if (a.point || b.point) {
                if (!(a.point && b.point && (a.point == b.point || a.point.eq(b.point)) &&
-                   sameValues(a.activeForPoint(a.to + dPos), b.activeForPoint(b.to))))
+                   sameValues(a.activeForPoint(a.to), b.activeForPoint(b.to))))
                    comparator.comparePoint(pos, clipEnd, a.point, b.point);
            }
            else {
@@ -3965,20 +3968,22 @@
      }
    }
 
-   let adoptedSet = null;
+   let adoptedSet = new Map; //<Document, StyleSet>
 
    class StyleSet {
      constructor(root) {
-       if (!root.head && root.adoptedStyleSheets && typeof CSSStyleSheet != "undefined") {
-         if (adoptedSet) {
-           root.adoptedStyleSheets = [adoptedSet.sheet, ...root.adoptedStyleSheets];
-           return root[SET] = adoptedSet
+       let doc = root.ownerDocument || root, win = doc.defaultView;
+       if (!root.head && root.adoptedStyleSheets && win.CSSStyleSheet) {
+         let adopted = adoptedSet.get(doc);
+         if (adopted) {
+           root.adoptedStyleSheets = [adopted.sheet, ...root.adoptedStyleSheets];
+           return root[SET] = adopted
          }
-         this.sheet = new CSSStyleSheet;
+         this.sheet = new win.CSSStyleSheet;
          root.adoptedStyleSheets = [this.sheet, ...root.adoptedStyleSheets];
-         adoptedSet = this;
+         adoptedSet.set(doc, this);
        } else {
-         this.styleTag = (root.ownerDocument || root).createElement("style");
+         this.styleTag = doc.createElement("style");
          let target = root.head || root;
          target.insertBefore(this.styleTag, target.firstChild);
        }
@@ -4124,10 +4129,8 @@
      222: "\""
    };
 
-   var chrome$1 = typeof navigator != "undefined" && /Chrome\/(\d+)/.exec(navigator.userAgent);
    var mac = typeof navigator != "undefined" && /Mac/.test(navigator.platform);
    var ie$1 = typeof navigator != "undefined" && /MSIE \d|Trident\/(?:[7-9]|\d{2,})\..*rv:(\d+)/.exec(navigator.userAgent);
-   var brokenModifierNames = mac || chrome$1 && +chrome$1[1] < 57;
 
    // Fill in the digit keys
    for (var i = 0; i < 10; i++) base[48 + i] = base[96 + i] = String(i);
@@ -4145,9 +4148,11 @@
    for (var code in base) if (!shift.hasOwnProperty(code)) shift[code] = base[code];
 
    function keyName(event) {
-     var ignoreKey = brokenModifierNames && (event.ctrlKey || event.altKey || event.metaKey) ||
-       ie$1 && event.shiftKey && event.key && event.key.length == 1 ||
-       event.key == "Unidentified";
+     // On macOS, keys held with Shift and Cmd don't reflect the effect of Shift in `.key`.
+     // On IE, shift effect is never included in `.key`.
+     var ignoreKey = mac && event.metaKey && event.shiftKey && !event.ctrlKey && !event.altKey ||
+         ie$1 && event.shiftKey && event.key && event.key.length == 1 ||
+         event.key == "Unidentified";
      var name = (!ignoreKey && event.key) ||
        (event.shiftKey ? shift : base)[event.keyCode] ||
        event.key || "Unidentified";
@@ -4246,7 +4251,6 @@
    function maxOffset(node) {
        return node.nodeType == 3 ? node.nodeValue.length : node.childNodes.length;
    }
-   const Rect0 = { left: 0, right: 0, top: 0, bottom: 0 };
    function flattenRect(rect, left) {
        let x = left ? rect.left : rect.right;
        return { left: x, right: x, top: rect.top, bottom: rect.bottom };
@@ -4379,7 +4383,9 @@
                this.focusNode == domSel.focusNode && this.focusOffset == domSel.focusOffset;
        }
        setRange(range) {
-           this.set(range.anchorNode, range.anchorOffset, range.focusNode, range.focusOffset);
+           let { anchorNode, focusNode } = range;
+           // Clip offsets to node size to avoid crashes when Safari reports bogus offsets (#1152)
+           this.set(anchorNode, Math.min(range.anchorOffset, anchorNode ? maxOffset(anchorNode) : 0), focusNode, Math.min(range.focusOffset, focusNode ? maxOffset(focusNode) : 0));
        }
        set(anchorNode, anchorOffset, focusNode, focusOffset) {
            this.anchorNode = anchorNode;
@@ -4452,6 +4458,8 @@
        let node = selection.focusNode, offset = selection.focusOffset;
        if (!node || selection.anchorNode != node || selection.anchorOffset != offset)
            return false;
+       // Safari can report bogus offsets (#1152)
+       offset = Math.min(offset, maxOffset(node));
        for (;;) {
            if (offset) {
                if (node.nodeType != 1)
@@ -4473,6 +4481,9 @@
            }
        }
    }
+   function isScrolledToBottom(elt) {
+       return elt.scrollTop > Math.max(1, elt.scrollHeight - elt.clientHeight - 4);
+   }
 
    class DOMPos {
        constructor(node, offset, precise = true) {
@@ -4488,7 +4499,7 @@
        constructor() {
            this.parent = null;
            this.dom = null;
-           this.dirty = 2 /* Dirty.Node */;
+           this.dirty = 2 /* Node */;
        }
        get overrideDOMText() { return null; }
        get posAtStart() {
@@ -4509,23 +4520,19 @@
        posAfter(view) {
            return this.posBefore(view) + view.length;
        }
-       // Will return a rectangle directly before (when side < 0), after
-       // (side > 0) or directly on (when the browser supports it) the
-       // given position.
-       coordsAt(_pos, _side) { return null; }
        sync(view, track) {
-           if (this.dirty & 2 /* Dirty.Node */) {
+           if (this.dirty & 2 /* Node */) {
                let parent = this.dom;
                let prev = null, next;
                for (let child of this.children) {
                    if (child.dirty) {
-                       if (!child.dom && (next = prev ? prev.nextSibling : parent.firstChild)) {
+                       if (!child.dom && (next = prev ? prev.nextSibling : parent.firstChild) && next != view.docView.compositionNode) {
                            let contentView = ContentView.get(next);
                            if (!contentView || !contentView.parent && contentView.canReuseDOM(child))
                                child.reuseDOM(next);
                        }
                        child.sync(view, track);
-                       child.dirty = 0 /* Dirty.Not */;
+                       child.dirty = 0 /* Not */;
                    }
                    next = prev ? prev.nextSibling : parent.firstChild;
                    if (track && !track.written && track.node == parent && next != child.dom)
@@ -4545,11 +4552,11 @@
                while (next)
                    next = rm$1(next);
            }
-           else if (this.dirty & 1 /* Dirty.Child */) {
+           else if (this.dirty & 1 /* Child */) {
                for (let child of this.children)
                    if (child.dirty) {
                        child.sync(view, track);
-                       child.dirty = 0 /* Dirty.Not */;
+                       child.dirty = 0 /* Not */;
                    }
            }
        }
@@ -4614,16 +4621,16 @@
                endDOM: toI < this.children.length && toI >= 0 ? this.children[toI].dom : null };
        }
        markDirty(andParent = false) {
-           this.dirty |= 2 /* Dirty.Node */;
+           this.dirty |= 2 /* Node */;
            this.markParentsDirty(andParent);
        }
        markParentsDirty(childList) {
            for (let parent = this.parent; parent; parent = parent.parent) {
                if (childList)
-                   parent.dirty |= 2 /* Dirty.Node */;
-               if (parent.dirty & 1 /* Dirty.Child */)
+                   parent.dirty |= 2 /* Node */;
+               if (parent.dirty & 1 /* Child */)
                    return;
-               parent.dirty |= 1 /* Dirty.Child */;
+               parent.dirty |= 1 /* Child */;
                childList = false;
            }
        }
@@ -4676,6 +4683,7 @@
        static get(node) { return node.cmView; }
        get isEditable() { return true; }
        get isWidget() { return false; }
+       get isHidden() { return false; }
        merge(from, to, source, hasStart, openStart, openEnd) {
            return false;
        }
@@ -4901,13 +4909,13 @@
        reuseDOM(node) {
            if (node.nodeName == this.mark.tagName.toUpperCase()) {
                this.setDOM(node);
-               this.dirty |= 4 /* Dirty.Attrs */ | 2 /* Dirty.Node */;
+               this.dirty |= 4 /* Attrs */ | 2 /* Node */;
            }
        }
        sync(view, track) {
            if (!this.dom)
                this.setDOM(this.setAttrs(document.createElement(this.mark.tagName)));
-           else if (this.dirty & 4 /* Dirty.Attrs */)
+           else if (this.dirty & 4 /* Attrs */)
                this.setAttrs(this.dom);
            super.sync(view, track);
        }
@@ -4970,7 +4978,7 @@
        }
        let rects = textRange(text, from, to).getClientRects();
        if (!rects.length)
-           return Rect0;
+           return null;
        let rect = rects[(flatten ? flatten < 0 : side >= 0) ? 0 : rects.length - 1];
        if (browser.safari && !flatten && rect.width == 0)
            rect = Array.prototype.find.call(rects, r => r.width) || rect;
@@ -5011,15 +5019,15 @@
            return true;
        }
        become(other) {
-           if (other.length == this.length && other instanceof WidgetView && other.side == this.side) {
-               if (this.widget.constructor == other.widget.constructor) {
-                   if (!this.widget.eq(other.widget))
-                       this.markDirty(true);
-                   if (this.dom && !this.prevWidget)
-                       this.prevWidget = this.widget;
-                   this.widget = other.widget;
-                   return true;
-               }
+           if (other instanceof WidgetView && other.side == this.side &&
+               this.widget.constructor == other.widget.constructor) {
+               if (!this.widget.compare(other.widget))
+                   this.markDirty(true);
+               if (this.dom && !this.prevWidget)
+                   this.prevWidget = this.widget;
+               this.widget = other.widget;
+               this.length = other.length;
+               return true;
            }
            return false;
        }
@@ -5035,22 +5043,29 @@
            return text ? text.slice(start, start + this.length) : Text.empty;
        }
        domAtPos(pos) {
-           return pos == 0 ? DOMPos.before(this.dom) : DOMPos.after(this.dom, pos == this.length);
+           return (this.length ? pos == 0 : this.side > 0)
+               ? DOMPos.before(this.dom)
+               : DOMPos.after(this.dom, pos == this.length);
        }
        domBoundsAround() { return null; }
        coordsAt(pos, side) {
+           let custom = this.widget.coordsAt(this.dom, pos, side);
+           if (custom)
+               return custom;
            let rects = this.dom.getClientRects(), rect = null;
            if (!rects.length)
-               return Rect0;
-           for (let i = pos > 0 ? rects.length - 1 : 0;; i += (pos > 0 ? -1 : 1)) {
+               return null;
+           let fromBack = this.side ? this.side < 0 : pos > 0;
+           for (let i = fromBack ? rects.length - 1 : 0;; i += (fromBack ? -1 : 1)) {
                rect = rects[i];
                if (pos > 0 ? i == 0 : i == rects.length - 1 || rect.top < rect.bottom)
                    break;
            }
-           return this.length ? rect : flattenRect(rect, this.side > 0);
+           return flattenRect(rect, !fromBack);
        }
        get isEditable() { return false; }
        get isWidget() { return true; }
+       get isHidden() { return this.widget.isHidden; }
        destroy() {
            super.destroy();
            if (this.dom)
@@ -5062,14 +5077,14 @@
            let { topView, text } = this.widget;
            if (!topView)
                return new DOMPos(text, Math.min(pos, text.nodeValue.length));
-           return scanCompositionTree(pos, 0, topView, text, (v, p) => v.domAtPos(p), p => new DOMPos(text, Math.min(p, text.nodeValue.length)));
+           return scanCompositionTree(pos, 0, topView, text, this.length - topView.length, (v, p) => v.domAtPos(p), (text, p) => new DOMPos(text, Math.min(p, text.nodeValue.length)));
        }
        sync() { this.setDOM(this.widget.toDOM()); }
        localPosFromDOM(node, offset) {
            let { topView, text } = this.widget;
            if (!topView)
                return Math.min(offset, this.length);
-           return posFromDOMInCompositionTree(node, offset, topView, text);
+           return posFromDOMInCompositionTree(node, offset, topView, text, this.length - topView.length);
        }
        ignoreMutation() { return false; }
        get overrideDOMText() { return null; }
@@ -5077,7 +5092,7 @@
            let { topView, text } = this.widget;
            if (!topView)
                return textCoords(text, pos, side);
-           return scanCompositionTree(pos, side, topView, text, (v, pos, side) => v.coordsAt(pos, side), (pos, side) => textCoords(text, pos, side));
+           return scanCompositionTree(pos, side, topView, text, this.length - topView.length, (v, pos, side) => v.coordsAt(pos, side), (text, pos, side) => textCoords(text, pos, side));
        }
        destroy() {
            var _a;
@@ -5090,35 +5105,68 @@
    // Uses the old structure of a chunk of content view frozen for
    // composition to try and find a reasonable DOM location for the given
    // offset.
-   function scanCompositionTree(pos, side, view, text, enterView, fromText) {
+   function scanCompositionTree(pos, side, view, text, dLen, enterView, fromText) {
        if (view instanceof MarkView) {
            for (let child = view.dom.firstChild; child; child = child.nextSibling) {
                let desc = ContentView.get(child);
-               if (!desc)
-                   return fromText(pos, side);
-               let hasComp = contains(child, text);
-               let len = desc.length + (hasComp ? text.nodeValue.length : 0);
-               if (pos < len || pos == len && desc.getSide() <= 0)
-                   return hasComp ? scanCompositionTree(pos, side, desc, text, enterView, fromText) : enterView(desc, pos, side);
-               pos -= len;
+               if (!desc) {
+                   let inner = scanCompositionNode(pos, side, child, fromText);
+                   if (typeof inner != "number")
+                       return inner;
+                   pos = inner;
+               }
+               else {
+                   let hasComp = contains(child, text);
+                   let len = desc.length + (hasComp ? dLen : 0);
+                   if (pos < len || pos == len && desc.getSide() <= 0)
+                       return hasComp ? scanCompositionTree(pos, side, desc, text, dLen, enterView, fromText) : enterView(desc, pos, side);
+                   pos -= len;
+               }
            }
            return enterView(view, view.length, -1);
        }
        else if (view.dom == text) {
-           return fromText(pos, side);
+           return fromText(text, pos, side);
        }
        else {
            return enterView(view, pos, side);
        }
    }
-   function posFromDOMInCompositionTree(node, offset, view, text) {
+   function scanCompositionNode(pos, side, node, fromText) {
+       if (node.nodeType == 3) {
+           let len = node.nodeValue.length;
+           if (pos <= len)
+               return fromText(node, pos, side);
+           pos -= len;
+       }
+       else if (node.nodeType == 1 && node.contentEditable != "false") {
+           for (let child = node.firstChild; child; child = child.nextSibling) {
+               let inner = scanCompositionNode(pos, side, child, fromText);
+               if (typeof inner != "number")
+                   return inner;
+               pos = inner;
+           }
+       }
+       return pos;
+   }
+   function posFromDOMInCompositionTree(node, offset, view, text, dLen) {
        if (view instanceof MarkView) {
            let pos = 0;
-           for (let child of view.children) {
-               let hasComp = contains(child.dom, text);
-               if (contains(child.dom, node))
-                   return pos + (hasComp ? posFromDOMInCompositionTree(node, offset, child, text) : child.localPosFromDOM(node, offset));
-               pos += hasComp ? text.nodeValue.length : child.length;
+           for (let child = view.dom.firstChild; child; child = child.nextSibling) {
+               let childView = ContentView.get(child);
+               if (childView) {
+                   let hasComp = contains(child, text);
+                   if (contains(child, node))
+                       return pos + (hasComp ? posFromDOMInCompositionTree(node, offset, childView, text, dLen)
+                           : childView.localPosFromDOM(node, offset));
+                   pos += childView.length + (hasComp ? dLen : 0);
+               }
+               else {
+                   let inner = posFromDOMInOpaqueNode(node, offset, child);
+                   if (inner.result != null)
+                       return pos + inner.result;
+                   pos += inner.size;
+               }
            }
        }
        else if (view.dom == text) {
@@ -5126,6 +5174,27 @@
        }
        return view.localPosFromDOM(node, offset);
    }
+   function posFromDOMInOpaqueNode(node, offset, target) {
+       if (target.nodeType == 3) {
+           return node == target ? { result: offset } : { size: target.nodeValue.length };
+       }
+       else if (target.nodeType == 1 && target.contentEditable != "false") {
+           let pos = 0;
+           for (let child = target.firstChild, i = 0;; child = child.nextSibling, i++) {
+               if (node == target && i == offset)
+                   return { result: pos };
+               if (!child)
+                   return { size: pos };
+               let inner = posFromDOMInOpaqueNode(node, offset, child);
+               if (inner.result != null)
+                   return { result: offset + inner.result };
+               pos += inner.size;
+           }
+       }
+       else {
+           return target.contains(node) ? { result: 0 } : { size: 0 };
+       }
+   }
    // These are drawn around uneditable widgets to avoid a number of
    // browser bugs that show up when the cursor is directly next to
    // uneditable inline content.
@@ -5153,43 +5222,14 @@
        localPosFromDOM() { return 0; }
        domBoundsAround() { return null; }
        coordsAt(pos) {
-           let imgRect = this.dom.getBoundingClientRect();
-           // Since the <img> height doesn't correspond to text height, try
-           // to borrow the height from some sibling node.
-           let siblingRect = inlineSiblingRect(this, this.side > 0 ? -1 : 1);
-           return siblingRect && siblingRect.top < imgRect.bottom && siblingRect.bottom > imgRect.top
-               ? { left: imgRect.left, right: imgRect.right, top: siblingRect.top, bottom: siblingRect.bottom } : imgRect;
+           return this.dom.getBoundingClientRect();
        }
        get overrideDOMText() {
            return Text.empty;
        }
+       get isHidden() { return true; }
    }
    TextView.prototype.children = WidgetView.prototype.children = WidgetBufferView.prototype.children = noChildren;
-   function inlineSiblingRect(view, side) {
-       let parent = view.parent, index = parent ? parent.children.indexOf(view) : -1;
-       while (parent && index >= 0) {
-           if (side < 0 ? index > 0 : index < parent.children.length) {
-               let next = parent.children[index + side];
-               if (next instanceof TextView) {
-                   let nextRect = next.coordsAt(side < 0 ? next.length : 0, side);
-                   if (nextRect)
-                       return nextRect;
-               }
-               index += side;
-           }
-           else if (parent instanceof MarkView && parent.parent) {
-               index = parent.parent.children.indexOf(parent) + (side < 0 ? 0 : 1);
-               parent = parent.parent;
-           }
-           else {
-               let last = parent.dom.lastChild;
-               if (last && last.nodeName == "BR")
-                   return last.getClientRects()[0];
-               break;
-           }
-       }
-       return undefined;
-   }
    function inlineDOMAtPos(parent, pos) {
        let dom = parent.dom, { children } = parent, i = 0;
        for (let off = 0; i < children.length; i++) {
@@ -5236,11 +5276,12 @@
                    if (child.children.length) {
                        scan(child, pos - off);
                    }
-                   else if (!after && (end > pos || off == end && child.getSide() > 0)) {
+                   else if ((!after || after.isHidden && side > 0) &&
+                       (end > pos || off == end && child.getSide() > 0)) {
                        after = child;
                        afterPos = pos - off;
                    }
-                   else if (off < pos || (off == end && child.getSide() < 0)) {
+                   else if (off < pos || (off == end && child.getSide() < 0) && !child.isHidden) {
                        before = child;
                        beforePos = pos - off;
                    }
@@ -5340,16 +5381,35 @@
        */
        get estimatedHeight() { return -1; }
        /**
+       For inline widgets that are displayed inline (as opposed to
+       `inline-block`) and introduce line breaks (through `<br>` tags
+       or textual newlines), this must indicate the amount of line
+       breaks they introduce. Defaults to 0.
+       */
+       get lineBreaks() { return 0; }
+       /**
        Can be used to configure which kinds of events inside the widget
        should be ignored by the editor. The default is to ignore all
        events.
        */
        ignoreEvent(event) { return true; }
        /**
+       Override the way screen coordinates for positions at/in the
+       widget are found. `pos` will be the offset into the widget, and
+       `side` the side of the position that is being queried—less than
+       zero for before, greater than zero for after, and zero for
+       directly at that position.
+       */
+       coordsAt(dom, pos, side) { return null; }
+       /**
        @internal
        */
        get customView() { return null; }
        /**
+       @internal
+       */
+       get isHidden() { return false; }
+       /**
        This is called when the an instance of the widget is removed
        from the editor view.
        */
@@ -5429,8 +5489,10 @@
        given position.
        */
        static widget(spec) {
-           let side = spec.side || 0, block = !!spec.block;
-           side += block ? (side > 0 ? 300000000 /* Side.BlockAfter */ : -400000000 /* Side.BlockBefore */) : (side > 0 ? 100000000 /* Side.InlineAfter */ : -100000000 /* Side.InlineBefore */);
+           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 */);
            return new PointDecoration(spec, side, side, block, spec.widget || null, false);
        }
        /**
@@ -5440,13 +5502,13 @@
        static replace(spec) {
            let block = !!spec.block, startSide, endSide;
            if (spec.isBlockGap) {
-               startSide = -500000000 /* Side.GapStart */;
-               endSide = 400000000 /* Side.GapEnd */;
+               startSide = -500000000 /* GapStart */;
+               endSide = 400000000 /* GapEnd */;
            }
            else {
                let { start, end } = getInclusive(spec, block);
-               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;
+               startSide = (start ? (block ? -300000000 /* BlockIncStart */ : -1 /* InlineIncStart */) : 500000000 /* NonIncStart */) - 1;
+               endSide = (end ? (block ? 200000000 /* BlockIncEnd */ : 1 /* InlineIncEnd */) : -600000000 /* NonIncEnd */) + 1;
            }
            return new PointDecoration(spec, startSide, endSide, block, spec.widget || null, true);
        }
@@ -5477,7 +5539,7 @@
    class MarkDecoration extends Decoration {
        constructor(spec) {
            let { start, end } = getInclusive(spec);
-           super(start ? -1 /* Side.InlineIncStart */ : 500000000 /* Side.NonIncStart */, end ? 1 /* Side.InlineIncEnd */ : -600000000 /* Side.NonIncEnd */, null, spec);
+           super(start ? -1 /* InlineIncStart */ : 500000000 /* NonIncStart */, end ? 1 /* InlineIncEnd */ : -600000000 /* NonIncEnd */, null, spec);
            this.tagName = spec.tagName || "span";
            this.class = spec.class || "";
            this.attrs = spec.attributes || null;
@@ -5498,7 +5560,7 @@
    MarkDecoration.prototype.point = false;
    class LineDecoration extends Decoration {
        constructor(spec) {
-           super(-200000000 /* Side.Line */, -200000000 /* Side.Line */, null, spec);
+           super(-200000000 /* Line */, -200000000 /* Line */, null, spec);
        }
        eq(other) {
            return other instanceof LineDecoration &&
@@ -5525,7 +5587,9 @@
            return this.startSide < this.endSide ? BlockType.WidgetRange
                : this.startSide <= 0 ? BlockType.WidgetBefore : BlockType.WidgetAfter;
        }
-       get heightRelevant() { return this.block || !!this.widget && this.widget.estimatedHeight >= 5; }
+       get heightRelevant() {
+           return this.block || !!this.widget && (this.widget.estimatedHeight >= 5 || this.widget.lineBreaks > 0);
+       }
        eq(other) {
            return other instanceof PointDecoration &&
                widgetsEq(this.widget, other.widget) &&
@@ -5637,7 +5701,7 @@
        reuseDOM(node) {
            if (node.nodeName == "DIV") {
                this.setDOM(node);
-               this.dirty |= 4 /* Dirty.Attrs */ | 2 /* Dirty.Node */;
+               this.dirty |= 4 /* Attrs */ | 2 /* Node */;
            }
        }
        sync(view, track) {
@@ -5647,7 +5711,7 @@
                this.dom.className = "cm-line";
                this.prevAttrs = this.attrs ? null : undefined;
            }
-           else if (this.dirty & 4 /* Dirty.Attrs */) {
+           else if (this.dirty & 4 /* Attrs */) {
                clearAttributes(this.dom);
                this.dom.className = "cm-line";
                this.prevAttrs = this.attrs ? null : undefined;
@@ -5758,14 +5822,15 @@
        }
        domBoundsAround() { return null; }
        become(other) {
-           if (other instanceof BlockWidgetView && other.type == this.type &&
+           if (other instanceof BlockWidgetView &&
                other.widget.constructor == this.widget.constructor) {
-               if (!other.widget.eq(this.widget))
+               if (!other.widget.compare(this.widget))
                    this.markDirty(true);
                if (this.dom && !this.prevWidget)
                    this.prevWidget = this.widget;
                this.widget = other.widget;
                this.length = other.length;
+               this.type = other.type;
                this.breakAfter = other.breakAfter;
                return true;
            }
@@ -5775,6 +5840,9 @@
        ignoreEvent(event) { return this.widget.ignoreEvent(event); }
        get isEditable() { return false; }
        get isWidget() { return true; }
+       coordsAt(pos, side) {
+           return this.widget.coordsAt(this.dom, pos, side);
+       }
        destroy() {
            super.destroy();
            if (this.dom)
@@ -5791,7 +5859,7 @@
            this.content = [];
            this.curLine = null;
            this.breakAtStart = 0;
-           this.pendingBuffer = 0 /* Buf.No */;
+           this.pendingBuffer = 0 /* No */;
            this.bufferMarks = [];
            // Set to false directly after a widget that covers the position after it
            this.atCursorPos = true;
@@ -5818,7 +5886,7 @@
        flushBuffer(active = this.bufferMarks) {
            if (this.pendingBuffer) {
                this.curLine.append(wrapMarks(new WidgetBufferView(-1), active), active.length);
-               this.pendingBuffer = 0 /* Buf.No */;
+               this.pendingBuffer = 0 /* No */;
            }
        }
        addBlockWidget(view) {
@@ -5830,7 +5898,7 @@
            if (this.pendingBuffer && openEnd <= this.bufferMarks.length)
                this.flushBuffer();
            else
-               this.pendingBuffer = 0 /* Buf.No */;
+               this.pendingBuffer = 0 /* No */;
            if (!this.posCovered())
                this.getLine();
        }
@@ -5859,7 +5927,7 @@
                        this.textOff = 0;
                    }
                }
-               let take = Math.min(this.text.length - this.textOff, length, 512 /* T.Chunk */);
+               let take = Math.min(this.text.length - this.textOff, length, 512 /* 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;
@@ -5891,11 +5959,12 @@
                }
                else {
                    let view = WidgetView.create(deco.widget || new NullWidget("span"), len, len ? 0 : deco.startSide);
-                   let cursorBefore = this.atCursorPos && !view.isEditable && openStart <= active.length && (from < to || deco.startSide > 0);
+                   let cursorBefore = this.atCursorPos && !view.isEditable && openStart <= active.length &&
+                       (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 /* Buf.IfCursor */ && !cursorBefore)
-                       this.pendingBuffer = 0 /* Buf.No */;
+                   if (this.pendingBuffer == 2 /* IfCursor */ && !cursorBefore && !view.isEditable)
+                       this.pendingBuffer = 0 /* No */;
                    this.flushBuffer(active);
                    if (cursorBefore) {
                        line.append(wrapMarks(new WidgetBufferView(1), active), openStart);
@@ -5903,7 +5972,7 @@
                    }
                    line.append(wrapMarks(view, active), openStart);
                    this.atCursorPos = cursorAfter;
-                   this.pendingBuffer = !cursorAfter ? 0 /* Buf.No */ : from < to || openStart > active.length ? 1 /* Buf.Yes */ : 2 /* Buf.IfCursor */;
+                   this.pendingBuffer = !cursorAfter ? 0 /* No */ : from < to || openStart > active.length ? 1 /* Yes */ : 2 /* IfCursor */;
                    if (this.pendingBuffer)
                        this.bufferMarks = active.slice();
                }
@@ -5948,6 +6017,7 @@
        eq(other) { return other.tag == this.tag; }
        toDOM() { return document.createElement(this.tag); }
        updateDOM(elt) { return elt.nodeName.toLowerCase() == this.tag; }
+       get isHidden() { return true; }
    }
 
    const clickAddsSelectionRange = /*@__PURE__*/Facet.define();
@@ -6117,6 +6187,23 @@
    const decorations = /*@__PURE__*/Facet.define();
    const atomicRanges = /*@__PURE__*/Facet.define();
    const scrollMargins = /*@__PURE__*/Facet.define();
+   function getScrollMargins(view) {
+       let left = 0, right = 0, top = 0, bottom = 0;
+       for (let source of view.state.facet(scrollMargins)) {
+           let m = source(view);
+           if (m) {
+               if (m.left != null)
+                   left = Math.max(left, m.left);
+               if (m.right != null)
+                   right = Math.max(right, m.right);
+               if (m.top != null)
+                   top = Math.max(top, m.top);
+               if (m.bottom != null)
+                   bottom = Math.max(bottom, m.bottom);
+           }
+       }
+       return { left, right, top, bottom };
+   }
    const styleModule = /*@__PURE__*/Facet.define();
    class ChangedRange {
        constructor(fromA, toA, fromB, toB) {
@@ -6212,27 +6299,27 @@
        update.
        */
        get viewportChanged() {
-           return (this.flags & 4 /* UpdateFlag.Viewport */) > 0;
+           return (this.flags & 4 /* Viewport */) > 0;
        }
        /**
        Indicates whether the height of a block element in the editor
        changed in this update.
        */
        get heightChanged() {
-           return (this.flags & 2 /* UpdateFlag.Height */) > 0;
+           return (this.flags & 2 /* 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 /* UpdateFlag.Geometry */ | 2 /* UpdateFlag.Height */)) > 0;
+           return this.docChanged || (this.flags & (8 /* Geometry */ | 2 /* Height */)) > 0;
        }
        /**
        True when this update indicates a focus change.
        */
        get focusChanged() {
-           return (this.flags & 1 /* UpdateFlag.Focus */) > 0;
+           return (this.flags & 1 /* Focus */) > 0;
        }
        /**
        Whether the document changed in this update.
@@ -6290,12 +6377,12 @@
    }
    function charType(ch) {
        return ch <= 0xf7 ? LowTypes[ch] :
-           0x590 <= ch && ch <= 0x5f4 ? 2 /* T.R */ :
+           0x590 <= ch && ch <= 0x5f4 ? 2 /* R */ :
                0x600 <= ch && ch <= 0x6f9 ? ArabicTypes[ch - 0x600] :
-                   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 */;
+                   0x6ee <= ch && ch <= 0x8ac ? 4 /* AL */ :
+                       0x2000 <= ch && ch <= 0x200b ? 256 /* NI */ :
+                           0xfb50 <= ch && ch <= 0xfdff ? 4 /* AL */ :
+                               ch == 0x200c ? 256 /* NI */ : 1 /* L */;
    }
    const BidiRE = /[\u0590-\u05f4\u0600-\u06ff\u0700-\u08ac\ufb50-\ufdff]/;
    /**
@@ -6360,8 +6447,8 @@
    // Reused array of character types
    const types = [];
    function computeOrder(line, direction) {
-       let len = line.length, outerType = direction == LTR ? 1 /* T.L */ : 2 /* T.R */, oppositeType = direction == LTR ? 2 /* T.R */ : 1 /* T.L */;
-       if (!line || outerType == 1 /* T.L */ && !BidiRE.test(line))
+       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
@@ -6375,12 +6462,12 @@
        // (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 /* T.NSM */)
+           if (type == 512 /* 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 */)
+           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;
        }
@@ -6394,26 +6481,26 @@
        // (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 /* T.CS */) {
-               if (i < len - 1 && prev == types[i + 1] && (prev & 24 /* T.Num */))
+           if (type == 128 /* CS */) {
+               if (i < len - 1 && prev == types[i + 1] && (prev & 24 /* Num */))
                    type = types[i] = prev;
                else
-                   types[i] = 256 /* T.NI */;
+                   types[i] = 256 /* NI */;
            }
-           else if (type == 64 /* T.ET */) {
+           else if (type == 64 /* ET */) {
                let end = i + 1;
-               while (end < len && types[end] == 64 /* T.ET */)
+               while (end < len && types[end] == 64 /* ET */)
                    end++;
-               let replace = (i && prev == 8 /* T.EN */) || (end < len && types[end] == 8 /* T.EN */) ? (prevStrong == 1 /* T.L */ ? 1 /* T.L */ : 8 /* T.EN */) : 256 /* T.NI */;
+               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 /* T.EN */ && prevStrong == 1 /* T.L */) {
-               types[i] = 1 /* T.L */;
+           else if (type == 8 /* EN */ && prevStrong == 1 /* L */) {
+               types[i] = 1 /* L */;
            }
            prev = type;
-           if (type & 7 /* T.Strong */)
+           if (type & 7 /* Strong */)
                prevStrong = type;
        }
        // N0. Process bracket pairs in an isolating run sequence
@@ -6428,9 +6515,9 @@
                    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;
+                           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;
@@ -6438,7 +6525,7 @@
                        }
                    }
                }
-               else if (BracketStack.length == 189 /* Bracketed.MaxDepth */) {
+               else if (BracketStack.length == 189 /* MaxDepth */) {
                    break;
                }
                else {
@@ -6447,20 +6534,20 @@
                    BracketStack[sI++] = context;
                }
            }
-           else if ((type = types[i]) == 2 /* T.R */ || type == 1 /* T.L */) {
+           else if ((type = types[i]) == 2 /* R */ || type == 1 /* L */) {
                let embed = type == outerType;
-               context = embed ? 0 : 1 /* Bracketed.OppositeBefore */;
+               context = embed ? 0 : 1 /* OppositeBefore */;
                for (let sJ = sI - 3; sJ >= 0; sJ -= 3) {
                    let cur = BracketStack[sJ + 2];
-                   if (cur & 2 /* Bracketed.EmbedInside */)
+                   if (cur & 2 /* EmbedInside */)
                        break;
                    if (embed) {
-                       BracketStack[sJ + 2] |= 2 /* Bracketed.EmbedInside */;
+                       BracketStack[sJ + 2] |= 2 /* EmbedInside */;
                    }
                    else {
-                       if (cur & 4 /* Bracketed.OppositeInside */)
+                       if (cur & 4 /* OppositeInside */)
                            break;
-                       BracketStack[sJ + 2] |= 4 /* Bracketed.OppositeInside */;
+                       BracketStack[sJ + 2] |= 4 /* OppositeInside */;
                    }
                }
            }
@@ -6473,13 +6560,13 @@
        // 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 /* T.NI */) {
+           if (types[i] == 256 /* NI */) {
                let end = i + 1;
-               while (end < len && types[end] == 256 /* T.NI */)
+               while (end < len && types[end] == 256 /* NI */)
                    end++;
-               let beforeL = (i ? types[i - 1] : outerType) == 1 /* T.L */;
-               let afterL = (end < len ? types[end] : outerType) == 1 /* T.L */;
-               let replace = beforeL == afterL ? (beforeL ? 1 /* T.L */ : 2 /* T.R */) : outerType;
+               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;
@@ -6491,15 +6578,15 @@
        // explicit embedding into account, we can build up the order on
        // the fly, without following the level-based algorithm.
        let order = [];
-       if (outerType == 1 /* T.L */) {
+       if (outerType == 1 /* L */) {
            for (let i = 0; i < len;) {
-               let start = i, rtl = types[i++] != 1 /* T.L */;
-               while (i < len && rtl == (types[i] != 1 /* T.L */))
+               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 /* T.R */;
-                       while (j > start && l == (types[j - 1] != 2 /* T.R */))
+                       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));
                    }
@@ -6511,8 +6598,8 @@
        }
        else {
            for (let i = 0; i < len;) {
-               let start = i, rtl = types[i++] == 2 /* T.R */;
-               while (i < len && rtl == (types[i] == 2 /* T.R */))
+               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));
            }
@@ -6583,6 +6670,7 @@
            let parent = start.parentNode;
            for (let cur = start;;) {
                this.findPointBefore(parent, cur);
+               let oldLen = this.text.length;
                this.readNode(cur);
                let next = cur.nextSibling;
                if (next == end)
@@ -6590,7 +6678,7 @@
                let view = ContentView.get(cur), nextView = ContentView.get(next);
                if (view && nextView ? view.breakAfter :
                    (view ? view.breakAfter : isBlockElement(cur)) ||
-                       (isBlockElement(next) && (cur.nodeName != "BR" || cur.cmIgnore)))
+                       (isBlockElement(next) && (cur.nodeName != "BR" || cur.cmIgnore) && this.text.length > oldLen))
                    this.lineBreak();
                cur = next;
            }
@@ -6675,6 +6763,7 @@
            super();
            this.view = view;
            this.compositionDeco = Decoration.none;
+           this.compositionNode = null;
            this.decorations = [];
            this.dynamicDecorationMap = [];
            // Track a minimum width for the editor. When measuring sizes in
@@ -6702,10 +6791,7 @@
            this.updateInner([new ChangedRange(0, 0, 0, view.state.doc.length)], 0);
        }
        get length() { return this.view.state.doc.length; }
-       // Update the document view to a given state. scrollIntoView can be
-       // used as a hint to compute a new viewport that includes that
-       // position, if we know the editor is going to scroll that position
-       // into view.
+       // Update the document view to a given state.
        update(update) {
            let changedRanges = update.changedRanges;
            if (this.minWidth > 0 && changedRanges.length) {
@@ -6717,10 +6803,8 @@
                    this.minWidthTo = update.changes.mapPos(this.minWidthTo, 1);
                }
            }
-           if (this.view.inputState.composing < 0)
-               this.compositionDeco = Decoration.none;
-           else if (update.transactions.length || this.dirty)
-               this.compositionDeco = computeCompositionDeco(this.view, update.changes);
+           ({ deco: this.compositionDeco, node: this.compositionNode } =
+               this.view.inputState.composing < 0 ? noComp : computeCompositionDeco(this.view, update.changes));
            // When the DOM nodes around the selection are moved to another
            // parent, Chrome sometimes reports a different selection through
            // getSelection than the one that it actually shows to the user.
@@ -6732,7 +6816,7 @@
            let prevDeco = this.decorations, deco = this.updateDeco();
            let decoDiff = findChangedDeco(prevDeco, deco, update.changes);
            changedRanges = ChangedRange.extendWithRanges(changedRanges, decoDiff);
-           if (this.dirty == 0 /* Dirty.Not */ && changedRanges.length == 0) {
+           if (this.dirty == 0 /* Not */ && changedRanges.length == 0) {
                return false;
            }
            else {
@@ -6761,7 +6845,7 @@
                // to detect that situation.
                let track = browser.chrome || browser.ios ? { node: observer.selectionRange.focusNode, written: false } : undefined;
                this.sync(this.view, track);
-               this.dirty = 0 /* Dirty.Not */;
+               this.dirty = 0 /* Not */;
                if (track && (track.written || observer.selectionRange.focusNode != track.node))
                    this.forceSelection = true;
                this.dom.style.height = "";
@@ -6790,7 +6874,10 @@
        updateSelection(mustRead = false, fromPointer = false) {
            if (mustRead || !this.view.observer.selectionRange.focusNode)
                this.view.observer.readSelectionRange();
-           if (!(fromPointer || this.mayControlSelection()))
+           let activeElt = this.view.root.activeElement, focused = activeElt == this.dom;
+           let selectionNotFocus = !focused &&
+               hasSelection(this.dom, this.view.observer.selectionRange) && !(activeElt && this.dom.contains(activeElt));
+           if (!(focused || fromPointer || selectionNotFocus))
                return;
            let force = this.forceSelection;
            this.forceSelection = false;
@@ -6800,7 +6887,7 @@
            let head = main.empty ? anchor : this.domAtPos(main.head);
            // Always reset on Firefox when next to an uneditable node to
            // avoid invisible cursor bugs (#111)
-           if (browser.gecko && main.empty && betweenUneditable(anchor)) {
+           if (browser.gecko && main.empty && !this.compositionDeco.size && betweenUneditable(anchor)) {
                let dummy = document.createTextNode("");
                this.view.observer.ignore(() => anchor.node.insertBefore(dummy, anchor.node.childNodes[anchor.offset] || null));
                anchor = head = new DOMPos(dummy, 0);
@@ -6827,10 +6914,10 @@
                        // 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 /* NextTo.Before */ | 2 /* NextTo.After */)) {
-                               let text = nearbyTextNode(anchor.node, anchor.offset, nextTo == 1 /* NextTo.Before */ ? 1 : -1);
+                           if (nextTo && nextTo != (1 /* Before */ | 2 /* After */)) {
+                               let text = nearbyTextNode(anchor.node, anchor.offset, nextTo == 1 /* Before */ ? 1 : -1);
                                if (text)
-                                   anchor = new DOMPos(text, nextTo == 1 /* NextTo.Before */ ? 0 : text.nodeValue.length);
+                                   anchor = new DOMPos(text, nextTo == 1 /* Before */ ? 0 : text.nodeValue.length);
                            }
                        }
                        rawSel.collapse(anchor.node, anchor.offset);
@@ -6860,6 +6947,11 @@
                        rawSel.removeAllRanges();
                        rawSel.addRange(range);
                    }
+                   if (selectionNotFocus && this.view.root.activeElement == this.dom) {
+                       this.dom.blur();
+                       if (activeElt)
+                           activeElt.focus();
+                   }
                });
                this.view.observer.setSelectionRange(anchor, head);
            }
@@ -6893,11 +6985,6 @@
            if (view.docView.posFromDOM(newRange.anchorNode, newRange.anchorOffset) != cursor.from)
                sel.collapse(anchorNode, anchorOffset);
        }
-       mayControlSelection() {
-           let active = this.view.root.activeElement;
-           return active == this.dom ||
-               hasSelection(this.dom, this.view.observer.selectionRange) && !(active && this.dom.contains(active));
-       }
        nearest(dom) {
            for (let cur = dom; cur;) {
                let domView = ContentView.get(cur);
@@ -7044,22 +7131,10 @@
            if (!range.empty && (other = this.coordsAt(range.anchor, range.anchor > range.head ? -1 : 1)))
                rect = { left: Math.min(rect.left, other.left), top: Math.min(rect.top, other.top),
                    right: Math.max(rect.right, other.right), bottom: Math.max(rect.bottom, other.bottom) };
-           let mLeft = 0, mRight = 0, mTop = 0, mBottom = 0;
-           for (let margins of this.view.state.facet(scrollMargins).map(f => f(this.view)))
-               if (margins) {
-                   let { left, right, top, bottom } = margins;
-                   if (left != null)
-                       mLeft = Math.max(mLeft, left);
-                   if (right != null)
-                       mRight = Math.max(mRight, right);
-                   if (top != null)
-                       mTop = Math.max(mTop, top);
-                   if (bottom != null)
-                       mBottom = Math.max(mBottom, bottom);
-               }
+           let margins = getScrollMargins(this.view);
            let targetRect = {
-               left: rect.left - mLeft, top: rect.top - mTop,
-               right: rect.right + mRight, bottom: rect.bottom + mBottom
+               left: rect.left - margins.left, top: rect.top - margins.top,
+               right: rect.right + margins.right, bottom: rect.bottom + margins.bottom
            };
            scrollRectIntoView(this.view.scrollDOM, targetRect, range.head < range.anchor ? -1 : 1, target.x, target.y, target.xMargin, target.yMargin, this.view.textDirection == Direction.LTR);
        }
@@ -7117,32 +7192,40 @@
            return { from, to: from + cView.length, node: cView.dom, text: textNode };
        }
    }
+   const noComp = { deco: Decoration.none, node: null };
    function computeCompositionDeco(view, changes) {
        let surrounding = compositionSurroundingNode(view);
        if (!surrounding)
-           return Decoration.none;
+           return noComp;
        let { from, to, node, text: textNode } = surrounding;
        let newFrom = changes.mapPos(from, 1), newTo = Math.max(newFrom, changes.mapPos(to, -1));
-       let { state } = view, text = node.nodeType == 3 ? node.nodeValue :
-           new DOMReader([], state).readRange(node.firstChild, null).text;
+       let { state } = view, reader = new DOMReader([], state);
+       if (node.nodeType == 3)
+           reader.readTextNode(node);
+       else
+           reader.readRange(node.firstChild, null);
+       let { text } = reader;
+       if (text.indexOf(LineBreakPlaceholder) > -1)
+           return noComp; // Don't try to preserve multi-line compositions
        if (newTo - newFrom < text.length) {
-           if (state.doc.sliceString(newFrom, Math.min(state.doc.length, newFrom + text.length), LineBreakPlaceholder) == text)
+           if (state.doc.sliceString(newFrom, Math.min(state.doc.length, newFrom + text.length)) == text)
                newTo = newFrom + text.length;
-           else if (state.doc.sliceString(Math.max(0, newTo - text.length), newTo, LineBreakPlaceholder) == text)
+           else if (state.doc.sliceString(Math.max(0, newTo - text.length), newTo) == text)
                newFrom = newTo - text.length;
            else
-               return Decoration.none;
+               return noComp;
        }
-       else if (state.doc.sliceString(newFrom, newTo, LineBreakPlaceholder) != text) {
-           return Decoration.none;
+       else if (state.doc.sliceString(newFrom, newTo) != text) {
+           return noComp;
        }
        let topView = ContentView.get(node);
        if (topView instanceof CompositionView)
            topView = topView.widget.topView;
        else if (topView)
            topView.parent = null;
-       return Decoration.set(Decoration.replace({ widget: new CompositionWidget(node, textNode, topView), inclusive: true })
+       let deco = Decoration.set(Decoration.replace({ widget: new CompositionWidget(node, textNode, topView), inclusive: true })
            .range(newFrom, newTo));
+       return { deco, node };
    }
    class CompositionWidget extends WidgetType {
        constructor(top, text, topView) {
@@ -7186,8 +7269,8 @@
    function nextToUneditable(node, offset) {
        if (node.nodeType != 1)
            return 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);
+       return (offset && node.childNodes[offset - 1].contentEditable == "false" ? 1 /* Before */ : 0) |
+           (offset < node.childNodes.length && node.childNodes[offset].contentEditable == "false" ? 2 /* After */ : 0);
    }
    class DecorationComparator$1 {
        constructor() {
@@ -7354,7 +7437,7 @@
        if (yOffset > docHeight)
            return view.state.doc.length;
        // Scan for a text block near the queried y position
-       for (let halfLine = view.defaultLineHeight / 2, bounced = false;;) {
+       for (let halfLine = view.viewState.heightOracle.textHeight / 2, bounced = false;;) {
            block = view.elementAtHeight(yOffset);
            if (block.type == BlockType.Text)
                break;
@@ -7434,7 +7517,8 @@
    function posAtCoordsImprecise(view, contentRect, block, x, y) {
        let into = Math.round((x - contentRect.left) * view.defaultCharacterWidth);
        if (view.lineWrapping && block.height > view.defaultLineHeight * 1.5) {
-           let line = Math.floor((y - block.top) / view.defaultLineHeight);
+           let textHeight = view.viewState.heightOracle.textHeight;
+           let line = Math.floor((y - block.top - (view.defaultLineHeight - textHeight) * 0.5) / textHeight);
            into += line * view.viewState.heightOracle.lineLength;
        }
        let content = view.state.sliceDoc(block.from, block.to);
@@ -7469,9 +7553,18 @@
            : textRange(node, 0, Math.max(node.nodeValue.length, 1)).getBoundingClientRect();
        return x - rect.left > 5;
    }
+   function blockAt(view, pos) {
+       let line = view.lineBlockAt(pos);
+       if (Array.isArray(line.type))
+           for (let l of line.type) {
+               if (l.to > pos || l.to == pos && (l.to == line.to || l.type == BlockType.Text))
+                   return l;
+           }
+       return line;
+   }
    function moveToLineBoundary(view, start, forward, includeWrap) {
-       let line = view.state.doc.lineAt(start.head);
-       let coords = !includeWrap || !view.lineWrapping ? null
+       let line = blockAt(view, start.head);
+       let coords = !includeWrap || line.type != BlockType.Text || !(view.lineWrapping || line.widgetLineBreaks) ? null
            : view.coordsAtPos(start.assoc < 0 && start.head > line.from ? start.head - 1 : start.head);
        if (coords) {
            let editorRect = view.dom.getBoundingClientRect();
@@ -7481,9 +7574,7 @@
            if (pos != null)
                return EditorSelection.cursor(pos, forward ? -1 : 1);
        }
-       let lineView = LineView.find(view.docView, start.head);
-       let end = lineView ? (forward ? lineView.posAtEnd : lineView.posAtStart) : (forward ? line.to : line.from);
-       return EditorSelection.cursor(end, forward ? -1 : 1);
+       return EditorSelection.cursor(forward ? line.to : line.from, forward ? -1 : 1);
    }
    function moveByChar(view, start, forward, by) {
        let line = view.state.doc.lineAt(start.head), spans = view.bidiSpans(line);
@@ -7538,7 +7629,7 @@
            startY = (dir < 0 ? line.top : line.bottom) + docTop;
        }
        let resolvedGoal = rect.left + goal;
-       let dist = distance !== null && distance !== void 0 ? distance : (view.defaultLineHeight >> 1);
+       let dist = distance !== null && distance !== void 0 ? distance : (view.viewState.heightOracle.textHeight >> 1);
        for (let extra = 0;; extra += 10) {
            let curY = startY + (dist + extra) * dir;
            let pos = posAtCoords(view, { x: resolvedGoal, y: curY }, false, dir);
@@ -7546,15 +7637,15 @@
                return EditorSelection.cursor(pos, start.assoc, undefined, goal);
        }
    }
-   function skipAtoms(view, oldPos, pos) {
-       let atoms = view.state.facet(atomicRanges).map(f => f(view));
+   function skipAtomicRanges(atoms, pos, bias) {
        for (;;) {
-           let moved = false;
+           let moved = 0;
            for (let set of atoms) {
-               set.between(pos.from - 1, pos.from + 1, (from, to, value) => {
-                   if (pos.from > from && pos.from < to) {
-                       pos = oldPos.head > pos.from ? EditorSelection.cursor(from, 1) : EditorSelection.cursor(to, -1);
-                       moved = true;
+               set.between(pos - 1, pos + 1, (from, to, value) => {
+                   if (pos > from && pos < to) {
+                       let side = moved || bias || (pos - from < to - pos ? -1 : 1);
+                       pos = side < 0 ? from : to;
+                       moved = side;
                    }
                });
            }
@@ -7562,6 +7653,10 @@
                return pos;
        }
    }
+   function skipAtoms(view, oldPos, pos) {
+       let newPos = skipAtomicRanges(view.state.facet(atomicRanges).map(f => f(view)), pos.from, oldPos.head > pos.from ? -1 : 1);
+       return newPos == pos.from ? pos : EditorSelection.cursor(newPos, newPos < pos.from ? 1 : -1);
+   }
 
    // This will also be where dragging info and such goes
    class InputState {
@@ -7594,7 +7689,15 @@
            // first, false means first has already been marked for this
            // composition)
            this.compositionFirstChange = null;
+           // End time of the previous composition
            this.compositionEndedAt = 0;
+           // Used in a kludge to detect when an Enter keypress should be
+           // considered part of the composition on Safari, which fires events
+           // in the wrong order
+           this.compositionPendingKey = false;
+           // Used to categorize changes as part of a composition, even when
+           // the mutation events fire shortly after the compositionend event
+           this.compositionPendingChange = false;
            this.mouseSelection = null;
            let handleEvent = (handler, event) => {
                if (this.ignoreDuringComposition(event))
@@ -7628,6 +7731,10 @@
                    }
                }
            });
+           view.scrollDOM.addEventListener("drop", (event) => {
+               if (event.target == view.scrollDOM && event.clientY > view.contentDOM.getBoundingClientRect().bottom)
+                   handleEvent(handlers.drop, event);
+           });
            if (browser.chrome && browser.chrome_version == 102) { // FIXME remove at some point
                // On Chrome 102, viewport updates somehow stop wheel-based
                // scrolling. Turning off pointer events during the scroll seems
@@ -7708,6 +7815,8 @@
            this.lastKeyTime = Date.now();
            if (event.keyCode == 9 && Date.now() < this.lastEscPress + 2000)
                return true;
+           if (event.keyCode != 27 && modifierCodes.indexOf(event.keyCode) < 0)
+               view.inputState.lastEscPress = 0;
            // Chrome for Android usually doesn't fire proper key events, but
            // occasionally does, usually surrounded by a bunch of complicated
            // composition changes. When an enter or backspace key event is
@@ -7751,8 +7860,8 @@
            // compositionend and keydown events are sometimes emitted in the
            // wrong order. The key event should still be ignored, even when
            // it happens after the compositionend event.
-           if (browser.safari && !browser.ios && Date.now() - this.compositionEndedAt < 100) {
-               this.compositionEndedAt = 0;
+           if (browser.safari && !browser.ios && this.compositionPendingKey && Date.now() - this.compositionEndedAt < 100) {
+               this.compositionPendingKey = false;
                return true;
            }
            return false;
@@ -7779,13 +7888,15 @@
    const PendingKeys = [
        { key: "Backspace", keyCode: 8, inputType: "deleteContentBackward" },
        { key: "Enter", keyCode: 13, inputType: "insertParagraph" },
+       { key: "Enter", keyCode: 13, inputType: "insertLineBreak" },
        { key: "Delete", keyCode: 46, inputType: "deleteContentForward" }
    ];
    const EmacsyPendingKeys = "dthko";
    // Key codes for modifier keys
    const modifierCodes = [16, 17, 18, 20, 91, 92, 224, 225];
+   const dragScrollMargin = 6;
    function dragScrollSpeed(dist) {
-       return dist * 0.7 + 8;
+       return Math.max(0, dist) * 0.7 + 8;
    }
    class MouseSelection {
        constructor(view, startEvent, style, mustSelect) {
@@ -7796,12 +7907,12 @@
            this.scrolling = -1;
            this.lastEvent = startEvent;
            this.scrollParent = scrollableParent(view.contentDOM);
+           this.atoms = view.state.facet(atomicRanges).map(f => f(view));
            let doc = view.contentDOM.ownerDocument;
            doc.addEventListener("mousemove", this.move = this.move.bind(this));
            doc.addEventListener("mouseup", this.up = this.up.bind(this));
            this.extend = startEvent.shiftKey;
            this.multiple = view.state.facet(EditorState.allowMultipleSelections) && addsSelectionRange(view, startEvent);
-           this.dragMove = dragMovesSelection(view, startEvent);
            this.dragging = isInPrimarySelection(view, startEvent) && getClickType(startEvent) == 1 ? null : false;
        }
        start(event) {
@@ -7822,13 +7933,14 @@
            let sx = 0, sy = 0;
            let rect = ((_a = this.scrollParent) === null || _a === void 0 ? void 0 : _a.getBoundingClientRect())
                || { left: 0, top: 0, right: this.view.win.innerWidth, bottom: this.view.win.innerHeight };
-           if (event.clientX <= rect.left)
+           let margins = getScrollMargins(this.view);
+           if (event.clientX - margins.left <= rect.left + dragScrollMargin)
                sx = -dragScrollSpeed(rect.left - event.clientX);
-           else if (event.clientX >= rect.right)
+           else if (event.clientX + margins.right >= rect.right - dragScrollMargin)
                sx = dragScrollSpeed(event.clientX - rect.right);
-           if (event.clientY <= rect.top)
+           if (event.clientY - margins.top <= rect.top + dragScrollMargin)
                sy = -dragScrollSpeed(rect.top - event.clientY);
-           else if (event.clientY >= rect.bottom)
+           else if (event.clientY + margins.bottom >= rect.bottom - dragScrollMargin)
                sy = dragScrollSpeed(event.clientY - rect.bottom);
            this.setScrollSpeed(sx, sy);
        }
@@ -7868,10 +7980,33 @@
            if (this.dragging === false)
                this.select(this.lastEvent);
        }
+       skipAtoms(sel) {
+           let ranges = null;
+           for (let i = 0; i < sel.ranges.length; i++) {
+               let range = sel.ranges[i], updated = null;
+               if (range.empty) {
+                   let pos = skipAtomicRanges(this.atoms, range.from, 0);
+                   if (pos != range.from)
+                       updated = EditorSelection.cursor(pos, -1);
+               }
+               else {
+                   let from = skipAtomicRanges(this.atoms, range.from, -1);
+                   let to = skipAtomicRanges(this.atoms, range.to, 1);
+                   if (from != range.from || to != range.to)
+                       updated = EditorSelection.range(range.from == range.anchor ? from : to, range.from == range.head ? from : to);
+               }
+               if (updated) {
+                   if (!ranges)
+                       ranges = sel.ranges.slice();
+                   ranges[i] = updated;
+               }
+           }
+           return ranges ? EditorSelection.create(ranges, sel.mainIndex) : sel;
+       }
        select(event) {
-           let selection = this.style.get(event, this.extend, this.multiple);
-           if (this.mustSelect || !selection.eq(this.view.state.selection) ||
-               selection.main.assoc != this.view.state.selection.main.assoc)
+           let { view } = this, selection = this.skipAtoms(this.style.get(event, this.extend, this.multiple));
+           if (this.mustSelect || !selection.eq(view.state.selection) ||
+               selection.main.assoc != view.state.selection.main.assoc)
                this.view.dispatch({
                    selection,
                    userEvent: "select.pointer"
@@ -7976,8 +8111,6 @@
        view.inputState.setSelectionOrigin("select");
        if (event.keyCode == 27)
            view.inputState.lastEscPress = Date.now();
-       else if (modifierCodes.indexOf(event.keyCode) < 0)
-           view.inputState.lastEscPress = 0;
    };
    handlers.touchstart = (view, e) => {
        view.inputState.lastTouchTime = Date.now();
@@ -8000,7 +8133,7 @@
        if (!style && event.button == 0)
            style = basicMouseSelection(view, event);
        if (style) {
-           let mustFocus = view.root.activeElement != view.contentDOM;
+           let mustFocus = !view.hasFocus;
            view.inputState.startMouseSelection(new MouseSelection(view, event, style, mustFocus));
            if (mustFocus)
                view.observer.ignore(() => focusPreventScroll(view.contentDOM));
@@ -8075,7 +8208,7 @@
                }
            },
            get(event, extend, multiple) {
-               let cur = queryPos(view, event);
+               let cur = queryPos(view, event), removed;
                let range = rangeForClick(view, cur.pos, cur.bias, type);
                if (start.pos != cur.pos && !extend) {
                    let startRange = rangeForClick(view, start.pos, start.bias, type);
@@ -8084,8 +8217,8 @@
                }
                if (extend)
                    return startSel.replaceRange(startSel.main.extend(range.from, range.to));
-               else if (multiple && startSel.ranges.length > 1 && startSel.ranges.some(r => r.eq(range)))
-                   return removeRange(startSel, range);
+               else if (multiple && type == 1 && startSel.ranges.length > 1 && (removed = removeRangeAround(startSel, cur.pos)))
+                   return removed;
                else if (multiple)
                    return startSel.addRange(range);
                else
@@ -8093,11 +8226,13 @@
            }
        };
    }
-   function removeRange(sel, range) {
-       for (let i = 0;; i++) {
-           if (sel.ranges[i].eq(range))
+   function removeRangeAround(sel, pos) {
+       for (let i = 0; i < sel.ranges.length; i++) {
+           let { from, to } = sel.ranges[i];
+           if (from <= pos && to >= pos)
                return EditorSelection.create(sel.ranges.slice(0, i).concat(sel.ranges.slice(i + 1)), sel.mainIndex == i ? 0 : sel.mainIndex - (sel.mainIndex > i ? 1 : 0));
        }
+       return null;
    }
    handlers.dragstart = (view, event) => {
        let { selection: { main } } = view.state;
@@ -8115,7 +8250,7 @@
        let dropPos = view.posAtCoords({ x: event.clientX, y: event.clientY }, false);
        event.preventDefault();
        let { mouseSelection } = view.inputState;
-       let del = direct && mouseSelection && mouseSelection.dragging && mouseSelection.dragMove ?
+       let del = direct && mouseSelection && mouseSelection.dragging && dragMovesSelection(view, event) ?
            { from: mouseSelection.dragging.from, to: mouseSelection.dragging.to } : null;
        let ins = { from: dropPos, insert: text };
        let changes = view.state.changes(del ? [del, ins] : ins);
@@ -8274,14 +8409,26 @@
    handlers.compositionend = view => {
        view.inputState.composing = -1;
        view.inputState.compositionEndedAt = Date.now();
+       view.inputState.compositionPendingKey = true;
+       view.inputState.compositionPendingChange = view.observer.pendingRecords().length > 0;
        view.inputState.compositionFirstChange = null;
-       if (browser.chrome && browser.android)
+       if (browser.chrome && browser.android) {
+           // Delay flushing for a bit on Android because it'll often fire a
+           // bunch of contradictory changes in a row at end of compositon
            view.observer.flushSoon();
-       setTimeout(() => {
-           // Force the composition state to be cleared if it hasn't already been
-           if (view.inputState.composing < 0 && view.docView.compositionDeco.size)
-               view.update([]);
-       }, 50);
+       }
+       else if (view.inputState.compositionPendingChange) {
+           // If we found pending records, schedule a flush.
+           Promise.resolve().then(() => view.observer.flush());
+       }
+       else {
+           // Otherwise, make sure that, if no changes come in soon, the
+           // composition view is cleared.
+           setTimeout(() => {
+               if (view.inputState.composing < 0 && view.docView.compositionDeco.size)
+                   view.update([]);
+           }, 50);
+       }
    };
    handlers.contextmenu = view => {
        view.inputState.lastContextMenu = Date.now();
@@ -8416,15 +8563,25 @@
        */
        height, 
        /**
-       The type of element this is. When querying lines, this may be
-       an array of all the blocks that make up the line.
+       @internal Weird packed field that holds an array of children
+       for composite blocks, a decoration for block widgets, and a
+       number indicating the amount of widget-create line breaks for
+       text blocks.
        */
-       type) {
+       _content) {
            this.from = from;
            this.length = length;
            this.top = top;
            this.height = height;
-           this.type = type;
+           this._content = _content;
+       }
+       /**
+       The type of element this is. When querying lines, this may be
+       an array of all the blocks that make up the line.
+       */
+       get type() {
+           return typeof this._content == "number" ? BlockType.Text :
+               Array.isArray(this._content) ? this._content : this._content.type;
        }
        /**
        The end of the element as a document position.
@@ -8435,12 +8592,26 @@
        */
        get bottom() { return this.top + this.height; }
        /**
+       If this is a widget block, this will return the widget
+       associated with it.
+       */
+       get widget() {
+           return this._content instanceof PointDecoration ? this._content.widget : null;
+       }
+       /**
+       If this is a textblock, this holds the number of line breaks
+       that appear in widgets inside the block.
+       */
+       get widgetLineBreaks() {
+           return typeof this._content == "number" ? this._content : 0;
+       }
+       /**
        @internal
        */
        join(other) {
-           let detail = (Array.isArray(this.type) ? this.type : [this])
-               .concat(Array.isArray(other.type) ? other.type : [other]);
-           return new BlockInfo(this.from, this.length + other.length, this.top, this.height + other.height, detail);
+           let content = (Array.isArray(this._content) ? this._content : [this])
+               .concat(Array.isArray(other._content) ? other._content : [other]);
+           return new BlockInfo(this.from, this.length + other.length, this.top, this.height + other.height, content);
        }
    }
    var QueryType$1 = /*@__PURE__*/(function (QueryType) {
@@ -8452,13 +8623,13 @@
    class HeightMap {
        constructor(length, // The number of characters covered
        height, // Height of this part of the document
-       flags = 2 /* Flag.Outdated */) {
+       flags = 2 /* Outdated */) {
            this.length = length;
            this.height = height;
            this.flags = flags;
        }
-       get outdated() { return (this.flags & 2 /* Flag.Outdated */) > 0; }
-       set outdated(value) { this.flags = (value ? 2 /* Flag.Outdated */ : 0) | (this.flags & ~2 /* Flag.Outdated */); }
+       get outdated() { return (this.flags & 2 /* Outdated */) > 0; }
+       set outdated(value) { this.flags = (value ? 2 /* Outdated */ : 0) | (this.flags & ~2 /* Outdated */); }
        setHeight(oracle, height) {
            if (this.height != height) {
                if (Math.abs(this.height - height) > Epsilon)
@@ -8555,12 +8726,12 @@
    }
    HeightMap.prototype.size = 1;
    class HeightMapBlock extends HeightMap {
-       constructor(length, height, type) {
+       constructor(length, height, deco) {
            super(length, height);
-           this.type = type;
+           this.deco = deco;
        }
        blockAt(_height, _oracle, top, offset) {
-           return new BlockInfo(offset, this.length, top, this.height, this.type);
+           return new BlockInfo(offset, this.length, top, this.height, this.deco || 0);
        }
        lineAt(_value, _type, oracle, top, offset) {
            return this.blockAt(0, oracle, top, offset);
@@ -8579,13 +8750,17 @@
    }
    class HeightMapText extends HeightMapBlock {
        constructor(length, height) {
-           super(length, height, BlockType.Text);
+           super(length, height, null);
            this.collapsed = 0; // Amount of collapsed content in the line
            this.widgetHeight = 0; // Maximum inline widget height
+           this.breaks = 0; // Number of widget-introduced line breaks on the line
+       }
+       blockAt(_height, _oracle, top, offset) {
+           return new BlockInfo(offset, this.length, top, this.height, this.breaks);
        }
        replace(_from, _to, nodes) {
            let node = nodes[0];
-           if (nodes.length == 1 && (node instanceof HeightMapText || node instanceof HeightMapGap && (node.flags & 4 /* Flag.SingleLine */)) &&
+           if (nodes.length == 1 && (node instanceof HeightMapText || node instanceof HeightMapGap && (node.flags & 4 /* SingleLine */)) &&
                Math.abs(this.length - node.length) < 10) {
                if (node instanceof HeightMapGap)
                    node = new HeightMapText(node.length, this.height);
@@ -8603,7 +8778,8 @@
            if (measured && measured.from <= offset && measured.more)
                this.setHeight(oracle, measured.heights[measured.index++]);
            else if (force || this.outdated)
-               this.setHeight(oracle, Math.max(this.widgetHeight, oracle.heightForLine(this.length - this.collapsed)));
+               this.setHeight(oracle, Math.max(this.widgetHeight, oracle.heightForLine(this.length - this.collapsed)) +
+                   this.breaks * oracle.lineHeight);
            this.outdated = false;
            return this;
        }
@@ -8620,7 +8796,8 @@
            if (oracle.lineWrapping) {
                let totalPerLine = Math.min(this.height, oracle.lineHeight * lines);
                perLine = totalPerLine / lines;
-               perChar = (this.height - totalPerLine) / (this.length - lines - 1);
+               if (this.length > lines + 1)
+                   perChar = (this.height - totalPerLine) / (this.length - lines - 1);
            }
            else {
                perLine = this.height / lines;
@@ -8633,12 +8810,12 @@
                let guess = offset + Math.round(Math.max(0, Math.min(1, (height - top) / this.height)) * this.length);
                let line = oracle.doc.lineAt(guess), lineHeight = perLine + line.length * perChar;
                let lineTop = Math.max(top, height - lineHeight / 2);
-               return new BlockInfo(line.from, line.length, lineTop, lineHeight, BlockType.Text);
+               return new BlockInfo(line.from, line.length, lineTop, lineHeight, 0);
            }
            else {
                let line = Math.max(0, Math.min(lastLine - firstLine, Math.floor((height - top) / perLine)));
                let { from, length } = oracle.doc.line(firstLine + line);
-               return new BlockInfo(from, length, top + perLine * line, perLine, BlockType.Text);
+               return new BlockInfo(from, length, top + perLine * line, perLine, 0);
            }
        }
        lineAt(value, type, oracle, top, offset) {
@@ -8646,13 +8823,13 @@
                return this.blockAt(value, oracle, top, offset);
            if (type == QueryType$1.ByPosNoHeight) {
                let { from, to } = oracle.doc.lineAt(value);
-               return new BlockInfo(from, to - from, 0, 0, BlockType.Text);
+               return new BlockInfo(from, to - from, 0, 0, 0);
            }
            let { firstLine, perLine, perChar } = this.heightMetrics(oracle, offset);
            let line = oracle.doc.lineAt(value), lineHeight = perLine + line.length * perChar;
            let linesAbove = line.number - firstLine;
            let lineTop = top + perLine * linesAbove + perChar * (line.from - offset - linesAbove);
-           return new BlockInfo(line.from, line.length, Math.max(top, Math.min(lineTop, top + this.height - lineHeight)), lineHeight, BlockType.Text);
+           return new BlockInfo(line.from, line.length, Math.max(top, Math.min(lineTop, top + this.height - lineHeight)), lineHeight, 0);
        }
        forEachLine(from, to, oracle, top, offset, f) {
            from = Math.max(from, offset);
@@ -8665,7 +8842,7 @@
                    lineTop += perLine * linesAbove + perChar * (from - offset - linesAbove);
                }
                let lineHeight = perLine + perChar * line.length;
-               f(new BlockInfo(line.from, line.length, lineTop, lineHeight, BlockType.Text));
+               f(new BlockInfo(line.from, line.length, lineTop, lineHeight, 0));
                lineTop += lineHeight;
                pos = line.to + 1;
            }
@@ -8736,12 +8913,12 @@
    }
    class HeightMapBranch extends HeightMap {
        constructor(left, brk, right) {
-           super(left.length + brk + right.length, left.height + right.height, brk | (left.outdated || right.outdated ? 2 /* Flag.Outdated */ : 0));
+           super(left.length + brk + right.length, left.height + right.height, brk | (left.outdated || right.outdated ? 2 /* Outdated */ : 0));
            this.left = left;
            this.right = right;
            this.size = left.size + right.size;
        }
-       get break() { return this.flags & 1 /* Flag.Break */; }
+       get break() { return this.flags & 1 /* Break */; }
        blockAt(height, oracle, top, offset) {
            let mid = top + this.left.height;
            return height < mid ? this.left.blockAt(height, oracle, top, offset)
@@ -8891,14 +9068,15 @@
        point(from, to, deco) {
            if (from < to || deco.heightRelevant) {
                let height = deco.widget ? deco.widget.estimatedHeight : 0;
+               let breaks = deco.widget ? deco.widget.lineBreaks : 0;
                if (height < 0)
                    height = this.oracle.lineHeight;
                let len = to - from;
                if (deco.block) {
-                   this.addBlock(new HeightMapBlock(len, height, deco.type));
+                   this.addBlock(new HeightMapBlock(len, height, deco));
                }
-               else if (len || height >= relevantWidgetHeight) {
-                   this.addLineDeco(height, len);
+               else if (len || breaks || height >= relevantWidgetHeight) {
+                   this.addLineDeco(height, breaks, len);
                }
            }
            else if (to > from) {
@@ -8925,7 +9103,7 @@
        blankContent(from, to) {
            let gap = new HeightMapGap(to - from);
            if (this.oracle.doc.lineAt(from).to == to)
-               gap.flags |= 4 /* Flag.SingleLine */;
+               gap.flags |= 4 /* SingleLine */;
            return gap;
        }
        ensureLine() {
@@ -8938,19 +9116,22 @@
            return line;
        }
        addBlock(block) {
+           var _a;
            this.enterLine();
-           if (block.type == BlockType.WidgetAfter && !this.isCovered)
+           let type = (_a = block.deco) === null || _a === void 0 ? void 0 : _a.type;
+           if (type == BlockType.WidgetAfter && !this.isCovered)
                this.ensureLine();
            this.nodes.push(block);
            this.writtenTo = this.pos = this.pos + block.length;
-           if (block.type != BlockType.WidgetBefore)
+           if (type != BlockType.WidgetBefore)
                this.covering = block;
        }
-       addLineDeco(height, length) {
+       addLineDeco(height, breaks, length) {
            let line = this.ensureLine();
            line.length += length;
            line.collapsed += length;
            line.widgetHeight = Math.max(line.widgetHeight, height);
+           line.breaks += breaks;
            this.writtenTo = this.pos = this.pos + length;
        }
        finish(from) {
@@ -9084,6 +9265,14 @@
            this.contentDOMHeight = 0;
            this.editorHeight = 0;
            this.editorWidth = 0;
+           this.scrollTop = 0;
+           this.scrolledToBottom = true;
+           // The vertical position (document-relative) to which to anchor the
+           // scroll position. -1 means anchor to the end of the document.
+           this.scrollAnchorPos = 0;
+           // The height at the anchor position. Set by the DOM update phase.
+           // -1 means no height available.
+           this.scrollAnchorHeight = -1;
            // See VP.MaxDOMHeight
            this.scaler = IdScaler;
            this.scrollTarget = null;
@@ -9124,7 +9313,7 @@
                }
            }
            this.viewports = viewports.sort((a, b) => a.from - b.from);
-           this.scaler = this.heightMap.height <= 7000000 /* VP.MaxDOMHeight */ ? IdScaler :
+           this.scaler = this.heightMap.height <= 7000000 /* MaxDOMHeight */ ? IdScaler :
                new BigScaler(this.heightOracle, this.heightMap, this.viewports);
        }
        updateViewportLines() {
@@ -9140,20 +9329,29 @@
            let contentChanges = update.changedRanges;
            let heightChanges = ChangedRange.extendWithRanges(contentChanges, heightRelevantDecoChanges(prevDeco, this.stateDeco, update ? update.changes : ChangeSet.empty(this.state.doc.length)));
            let prevHeight = this.heightMap.height;
+           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 /* UpdateFlag.Height */;
+               update.flags |= 2 /* Height */;
+           if (scrollAnchor) {
+               this.scrollAnchorPos = update.changes.mapPos(scrollAnchor.from, -1);
+               this.scrollAnchorHeight = scrollAnchor.top;
+           }
+           else {
+               this.scrollAnchorPos = -1;
+               this.scrollAnchorHeight = this.heightMap.height;
+           }
            let viewport = heightChanges.length ? this.mapViewport(this.viewport, update.changes) : this.viewport;
            if (scrollTarget && (scrollTarget.range.head < viewport.from || scrollTarget.range.head > viewport.to) ||
                !this.viewportIsAppropriate(viewport))
                viewport = this.getViewport(0, scrollTarget);
-           let updateLines = !update.changes.empty || (update.flags & 2 /* UpdateFlag.Height */) ||
+           let updateLines = !update.changes.empty || (update.flags & 2 /* 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 /* LG.Margin */ << 1))
+           if (this.lineGaps.length || this.viewport.to - this.viewport.from > (2000 /* Margin */ << 1))
                this.updateLineGaps(this.ensureLineGaps(this.mapLineGaps(this.lineGaps, update.changes)));
            update.flags |= this.computeVisibleRanges();
            if (scrollTarget)
@@ -9179,14 +9377,19 @@
            if (this.paddingTop != paddingTop || this.paddingBottom != paddingBottom) {
                this.paddingTop = paddingTop;
                this.paddingBottom = paddingBottom;
-               result |= 8 /* UpdateFlag.Geometry */ | 2 /* UpdateFlag.Height */;
+               result |= 8 /* Geometry */ | 2 /* Height */;
            }
            if (this.editorWidth != view.scrollDOM.clientWidth) {
                if (oracle.lineWrapping)
                    measureContent = true;
                this.editorWidth = view.scrollDOM.clientWidth;
-               result |= 8 /* UpdateFlag.Geometry */;
+               result |= 8 /* Geometry */;
+           }
+           if (this.scrollTop != view.scrollDOM.scrollTop) {
+               this.scrollAnchorHeight = -1;
+               this.scrollTop = view.scrollDOM.scrollTop;
            }
+           this.scrolledToBottom = isScrolledToBottom(view.scrollDOM);
            // Pixel viewport
            let pixelViewport = (this.printing ? fullPixelRange : visiblePixelRange)(dom, this.paddingTop);
            let dTop = pixelViewport.top - this.pixelViewport.top, dBottom = pixelViewport.bottom - this.pixelViewport.bottom;
@@ -9203,7 +9406,7 @@
            if (this.contentDOMWidth != contentWidth || this.editorHeight != view.scrollDOM.clientHeight) {
                this.contentDOMWidth = domRect.width;
                this.editorHeight = view.scrollDOM.clientHeight;
-               result |= 8 /* UpdateFlag.Geometry */;
+               result |= 8 /* Geometry */;
            }
            if (measureContent) {
                let lineHeights = view.docView.measureVisibleLineHeights(this.viewport);
@@ -9214,7 +9417,7 @@
                    refresh = lineHeight > 0 && oracle.refresh(whiteSpace, lineHeight, charWidth, textHeight, contentWidth / charWidth, lineHeights);
                    if (refresh) {
                        view.docView.minWidth = 0;
-                       result |= 8 /* UpdateFlag.Geometry */;
+                       result |= 8 /* Geometry */;
                    }
                }
                if (dTop > 0 && dBottom > 0)
@@ -9227,7 +9430,7 @@
                    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 /* UpdateFlag.Height */;
+                   result |= 2 /* Height */;
            }
            let viewportChange = !this.viewportIsAppropriate(this.viewport, bias) ||
                this.scrollTarget && (this.scrollTarget.range.head < this.viewport.from ||
@@ -9235,9 +9438,9 @@
            if (viewportChange)
                this.viewport = this.getViewport(bias, this.scrollTarget);
            this.updateForViewport();
-           if ((result & 2 /* UpdateFlag.Height */) || viewportChange)
+           if ((result & 2 /* Height */) || viewportChange)
                this.updateViewportLines();
-           if (this.lineGaps.length || this.viewport.to - this.viewport.from > (2000 /* LG.Margin */ << 1))
+           if (this.lineGaps.length || this.viewport.to - this.viewport.from > (2000 /* Margin */ << 1))
                this.updateLineGaps(this.ensureLineGaps(refresh ? [] : this.lineGaps, view));
            result |= this.computeVisibleRanges();
            if (this.mustEnforceCursorAssoc) {
@@ -9256,10 +9459,10 @@
            // 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 /* VP.Margin */ / 2));
+           let marginTop = 0.5 - Math.max(-0.5, Math.min(0.5, bias / 1000 /* Margin */ / 2));
            let map = this.heightMap, oracle = this.heightOracle;
            let { visibleTop, visibleBottom } = this;
-           let viewport = new Viewport(map.lineAt(visibleTop - marginTop * 1000 /* VP.Margin */, QueryType$1.ByHeight, oracle, 0, 0).from, map.lineAt(visibleBottom + (1 - marginTop) * 1000 /* VP.Margin */, QueryType$1.ByHeight, oracle, 0, 0).to);
+           let viewport = new Viewport(map.lineAt(visibleTop - marginTop * 1000 /* Margin */, QueryType$1.ByHeight, oracle, 0, 0).from, map.lineAt(visibleBottom + (1 - marginTop) * 1000 /* Margin */, QueryType$1.ByHeight, oracle, 0, 0).to);
            // If scrollTarget is given, make sure the viewport includes that position
            if (scrollTarget) {
                let { head } = scrollTarget.range;
@@ -9272,7 +9475,7 @@
                        topPos = block.top;
                    else
                        topPos = block.bottom - viewHeight;
-                   viewport = new Viewport(map.lineAt(topPos - 1000 /* VP.Margin */ / 2, QueryType$1.ByHeight, oracle, 0, 0).from, map.lineAt(topPos + viewHeight + 1000 /* VP.Margin */ / 2, QueryType$1.ByHeight, oracle, 0, 0).to);
+                   viewport = new Viewport(map.lineAt(topPos - 1000 /* Margin */ / 2, QueryType$1.ByHeight, oracle, 0, 0).from, map.lineAt(topPos + viewHeight + 1000 /* Margin */ / 2, QueryType$1.ByHeight, oracle, 0, 0).to);
                }
            }
            return viewport;
@@ -9289,10 +9492,10 @@
            let { top } = this.heightMap.lineAt(from, QueryType$1.ByPos, this.heightOracle, 0, 0);
            let { bottom } = this.heightMap.lineAt(to, QueryType$1.ByPos, this.heightOracle, 0, 0);
            let { visibleTop, visibleBottom } = this;
-           return (from == 0 || top <= visibleTop - Math.max(10 /* VP.MinCoverMargin */, Math.min(-bias, 250 /* VP.MaxCoverMargin */))) &&
+           return (from == 0 || top <= visibleTop - Math.max(10 /* MinCoverMargin */, Math.min(-bias, 250 /* MaxCoverMargin */))) &&
                (to == this.state.doc.length ||
-                   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 */);
+                   bottom >= visibleBottom + Math.max(10 /* MinCoverMargin */, Math.min(bias, 250 /* MaxCoverMargin */))) &&
+               (top > visibleTop - 2 * 1000 /* Margin */ && bottom < visibleBottom + 2 * 1000 /* Margin */);
        }
        mapLineGaps(gaps, changes) {
            if (!gaps.length || changes.empty)
@@ -9312,7 +9515,7 @@
        // the artifacts this might produce from the user.
        ensureLineGaps(current, mayMeasure) {
            let wrapping = this.heightOracle.lineWrapping;
-           let margin = wrapping ? 10000 /* LG.MarginWrap */ : 2000 /* LG.Margin */, halfMargin = margin >> 1, doubleMargin = margin << 1;
+           let margin = wrapping ? 10000 /* MarginWrap */ : 2000 /* 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 [];
@@ -9325,8 +9528,8 @@
                    avoid.push(sel.to);
                for (let pos of avoid) {
                    if (pos > from && pos < to) {
-                       addGap(from, pos - 10 /* LG.SelectionMargin */, line, structure);
-                       addGap(pos + 10 /* LG.SelectionMargin */, to, line, structure);
+                       addGap(from, pos - 10 /* SelectionMargin */, line, structure);
+                       addGap(pos + 10 /* SelectionMargin */, to, line, structure);
                        return;
                    }
                }
@@ -9420,7 +9623,7 @@
            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 /* UpdateFlag.Viewport */ : 0;
+           return changed ? 4 /* Viewport */ : 0;
        }
        lineBlockAt(pos) {
            return (pos >= this.viewport.from && pos <= this.viewport.to && this.viewportLines.find(b => b.from <= pos && b.to >= pos)) ||
@@ -9429,6 +9632,10 @@
        lineBlockAtHeight(height) {
            return scaleBlock(this.heightMap.lineAt(this.scaler.fromDOM(height), QueryType$1.ByHeight, this.heightOracle, 0, 0), this.scaler);
        }
+       scrollAnchorAt(scrollTop) {
+           let block = this.lineBlockAtHeight(scrollTop + 8);
+           return block.from >= this.viewport.from || this.viewportLines[0].top - scrollTop > 200 ? block : this.viewportLines[0];
+       }
        elementAtHeight(height) {
            return scaleBlock(this.heightMap.blockAt(this.scaler.fromDOM(height), this.heightOracle, 0, 0), this.scaler);
        }
@@ -9512,7 +9719,7 @@
                vpHeight += bottom - top;
                return { from, to, top, bottom, domTop: 0, domBottom: 0 };
            });
-           this.scale = (7000000 /* VP.MaxDOMHeight */ - vpHeight) / (heightMap.height - vpHeight);
+           this.scale = (7000000 /* 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);
@@ -9546,7 +9753,7 @@
        if (scaler.scale == 1)
            return block;
        let bTop = scaler.toDOM(block.top), bBottom = scaler.toDOM(block.bottom);
-       return new BlockInfo(block.from, block.length, bTop, bBottom - bTop, Array.isArray(block.type) ? block.type.map(b => scaleBlock(b, scaler)) : block.type);
+       return new BlockInfo(block.from, block.length, bTop, bBottom - bTop, Array.isArray(block._content) ? block._content.map(b => scaleBlock(b, scaler)) : block._content);
    }
 
    const theme = /*@__PURE__*/Facet.define({ combine: strs => strs.join(" ") });
@@ -9636,16 +9843,16 @@
        "&dark .cm-selectionBackground": {
            background: "#222"
        },
-       "&light.cm-focused .cm-selectionBackground": {
+       "&light.cm-focused > .cm-scroller > .cm-selectionLayer .cm-selectionBackground": {
            background: "#d7d4f0"
        },
-       "&dark.cm-focused .cm-selectionBackground": {
+       "&dark.cm-focused > .cm-scroller > .cm-selectionLayer .cm-selectionBackground": {
            background: "#233"
        },
        ".cm-cursorLayer": {
            pointerEvents: "none"
        },
-       "&.cm-focused .cm-cursorLayer": {
+       "&.cm-focused > .cm-scroller > .cm-cursorLayer": {
            animation: "steps(1) cm-blink 1.2s infinite"
        },
        // Two animations defined so that we can switch between them to
@@ -9667,7 +9874,7 @@
        ".cm-dropCursor": {
            position: "absolute"
        },
-       "&.cm-focused .cm-cursor": {
+       "&.cm-focused > .cm-scroller > .cm-cursorLayer .cm-cursor": {
            display: "block"
        },
        "&light .cm-activeLine": { backgroundColor: "#cceeff44" },
@@ -9836,13 +10043,13 @@
    function applyDOMChange(view, domChange) {
        let change;
        let { newSel } = domChange, sel = view.state.selection.main;
+       let lastKey = view.inputState.lastKeyTime > Date.now() - 100 ? view.inputState.lastKeyCode : -1;
        if (domChange.bounds) {
            let { from, to } = domChange.bounds;
            let preferredPos = sel.from, preferredSide = null;
            // Prefer anchoring to end when Backspace is pressed (or, on
            // Android, when something was deleted)
-           if (view.inputState.lastKeyCode === 8 && view.inputState.lastKeyTime > Date.now() - 100 ||
-               browser.android && domChange.text.length < to - from) {
+           if (lastKey === 8 || browser.android && domChange.text.length < to - from) {
                preferredPos = sel.to;
                preferredSide = "end";
            }
@@ -9850,7 +10057,7 @@
            if (diff) {
                // Chrome inserts two newlines when pressing shift-enter at the
                // end of a line. DomChange drops one of those.
-               if (browser.chrome && view.inputState.lastKeyCode == 13 &&
+               if (browser.chrome && lastKey == 13 &&
                    diff.toB == diff.from + 2 && domChange.text.slice(diff.from, diff.toB) == LineBreakPlaceholder + LineBreakPlaceholder)
                    diff.toB--;
                change = { from: from + diff.from, to: from + diff.toA,
@@ -9908,7 +10115,8 @@
                ((change.from == sel.from && change.to == sel.to &&
                    change.insert.length == 1 && change.insert.lines == 2 &&
                    dispatchKey(view.contentDOM, "Enter", 13)) ||
-                   (change.from == sel.from - 1 && change.to == sel.to && change.insert.length == 0 &&
+                   ((change.from == sel.from - 1 && change.to == sel.to && change.insert.length == 0 ||
+                       lastKey == 8 && change.insert.length < change.to - change.from) &&
                        dispatchKey(view.contentDOM, "Backspace", 8)) ||
                    (change.from == sel.from && change.to == sel.to + 1 && change.insert.length == 0 &&
                        dispatchKey(view.contentDOM, "Delete", 46))))
@@ -9928,8 +10136,7 @@
            }
            else {
                let changes = startState.changes(change);
-               let mainSel = newSel && !startState.selection.main.eq(newSel.main) && newSel.main.to <= changes.newLength
-                   ? newSel.main : undefined;
+               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) {
@@ -9963,7 +10170,9 @@
                }
            }
            let userEvent = "input.type";
-           if (view.composing) {
+           if (view.composing ||
+               view.inputState.compositionPendingChange && view.inputState.compositionEndedAt > Date.now() - 50) {
+               view.inputState.compositionPendingChange = false;
                userEvent += ".compose";
                if (view.inputState.compositionFirstChange) {
                    userEvent += ".start";
@@ -10126,7 +10335,7 @@
                        if (this.intersecting != this.view.inView)
                            this.onScrollChanged(document.createEvent("Event"));
                    }
-               }, {});
+               }, { threshold: [0, .001] });
                this.intersection.observe(this.dom);
                this.gapIntersection = new IntersectionObserver(entries => {
                    if (entries.length > 0 && entries[entries.length - 1].intersectionRatio > 0)
@@ -10305,7 +10514,10 @@
                    let key = this.delayedAndroidKey;
                    if (key) {
                        this.clearDelayedAndroidKey();
-                       if (!this.flush() && key.force)
+                       this.view.inputState.lastKeyCode = key.keyCode;
+                       this.view.inputState.lastKeyTime = Date.now();
+                       let flushed = this.flush();
+                       if (!flushed && key.force)
                            dispatchKey(this.dom, key.key, key.keyCode);
                    }
                };
@@ -10339,10 +10551,13 @@
            }
            this.flush();
        }
-       processRecords() {
-           let records = this.queue;
+       pendingRecords() {
            for (let mut of this.observer.takeRecords())
-               records.push(mut);
+               this.queue.push(mut);
+           return this.queue;
+       }
+       processRecords() {
+           let records = this.pendingRecords();
            if (records.length)
                this.queue = [];
            let from = -1, to = -1, typeOver = false;
@@ -10398,7 +10613,7 @@
                return null;
            cView.markDirty(rec.type == "attributes");
            if (rec.type == "attributes")
-               cView.dirty |= 4 /* Dirty.Attrs */;
+               cView.dirty |= 4 /* Attrs */;
            if (rec.type == "childList") {
                let childBefore = findChild(cView, rec.previousSibling || rec.target.previousSibling, -1);
                let childAfter = findChild(cView, rec.nextSibling || rec.target.nextSibling, 1);
@@ -10521,7 +10736,7 @@
            /**
            @internal
            */
-           this.updateState = 2 /* UpdateState.Updating */;
+           this.updateState = 2 /* Updating */;
            /**
            @internal
            */
@@ -10554,7 +10769,7 @@
            this.docView = new DocView(this);
            this.mountStyles();
            this.updateAttrs();
-           this.updateState = 0 /* UpdateState.Idle */;
+           this.updateState = 0 /* Idle */;
            this.requestMeasure();
            if (config.parent)
                config.parent.appendChild(this.dom);
@@ -10607,8 +10822,9 @@
        */
        get win() { return this.dom.ownerDocument.defaultView || window; }
        dispatch(...input) {
-           this._dispatch(input.length == 1 && input[0] instanceof Transaction ? input[0]
-               : this.state.update(...input));
+           let tr = input.length == 1 && input[0] instanceof Transaction ? input[0]
+               : this.state.update(...input);
+           this._dispatch(tr, this);
        }
        /**
        Update the view for the given array of transactions. This will
@@ -10619,7 +10835,7 @@
        as a primitive.
        */
        update(transactions) {
-           if (this.updateState != 0 /* UpdateState.Idle */)
+           if (this.updateState != 0 /* 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;
@@ -10636,7 +10852,7 @@
            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 /* UpdateFlag.Focus */;
+               focusFlag = 1 /* Focus */;
            }
            else if (focus != this.inputState.notifiedFocused) {
                this.inputState.notifiedFocused = focus;
@@ -10644,7 +10860,7 @@
                // add a flag to this update
                dispatchFocus = focusChangeTransaction(state, focus);
                if (!dispatchFocus)
-                   focusFlag = 1 /* UpdateFlag.Focus */;
+                   focusFlag = 1 /* Focus */;
            }
            // If there was a pending DOM change, eagerly read it and try to
            // apply it after the given transactions.
@@ -10667,7 +10883,7 @@
            update.flags |= focusFlag;
            let scrollTarget = this.viewState.scrollTarget;
            try {
-               this.updateState = 2 /* UpdateState.Updating */;
+               this.updateState = 2 /* Updating */;
                for (let tr of transactions) {
                    if (scrollTarget)
                        scrollTarget = scrollTarget.map(tr.changes);
@@ -10693,7 +10909,7 @@
                this.docView.updateSelection(redrawn, transactions.some(tr => tr.isUserEvent("select.pointer")));
            }
            finally {
-               this.updateState = 0 /* UpdateState.Idle */;
+               this.updateState = 0 /* Idle */;
            }
            if (update.startState.facet(theme) != update.state.facet(theme))
                this.viewState.mustMeasureContent = true;
@@ -10720,13 +10936,13 @@
        [`dispatch`](https://codemirror.net/6/docs/ref/#view.EditorView.dispatch) instead.)
        */
        setState(newState) {
-           if (this.updateState != 0 /* UpdateState.Idle */)
+           if (this.updateState != 0 /* 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 /* UpdateState.Updating */;
+           this.updateState = 2 /* Updating */;
            let hadFocus = this.hasFocus;
            try {
                for (let plugin of this.plugins)
@@ -10743,7 +10959,7 @@
                this.bidiCache = [];
            }
            finally {
-               this.updateState = 0 /* UpdateState.Idle */;
+               this.updateState = 0 /* Idle */;
            }
            if (hadFocus)
                this.focus();
@@ -10790,13 +11006,25 @@
            if (flush)
                this.observer.forceFlush();
            let updated = null;
-           let { scrollHeight, scrollTop, clientHeight } = this.scrollDOM;
-           let refHeight = scrollTop > scrollHeight - clientHeight - 4 ? scrollHeight : scrollTop;
+           let sDOM = this.scrollDOM, { scrollTop } = sDOM;
+           let { scrollAnchorPos, scrollAnchorHeight } = this.viewState;
+           if (scrollTop != this.viewState.scrollTop)
+               scrollAnchorHeight = -1;
+           this.viewState.scrollAnchorHeight = -1;
            try {
                for (let i = 0;; i++) {
-                   this.updateState = 1 /* UpdateState.Measuring */;
-                   let oldViewport = this.viewport;
-                   let refBlock = this.viewState.lineBlockAtHeight(refHeight);
+                   if (scrollAnchorHeight < 0) {
+                       if (isScrolledToBottom(sDOM)) {
+                           scrollAnchorPos = -1;
+                           scrollAnchorHeight = this.viewState.heightMap.height;
+                       }
+                       else {
+                           let block = this.viewState.scrollAnchorAt(scrollTop);
+                           scrollAnchorPos = block.from;
+                           scrollAnchorHeight = block.top;
+                       }
+                   }
+                   this.updateState = 1 /* Measuring */;
                    let changed = this.viewState.measure(this);
                    if (!changed && !this.measureRequests.length && this.viewState.scrollTarget == null)
                        break;
@@ -10808,7 +11036,7 @@
                    }
                    let measuring = [];
                    // Only run measure requests in this cycle when the viewport didn't change
-                   if (!(changed & 4 /* UpdateFlag.Viewport */))
+                   if (!(changed & 4 /* Viewport */))
                        [this.measureRequests, measuring] = [measuring, this.measureRequests];
                    let measured = measuring.map(m => {
                        try {
@@ -10819,13 +11047,13 @@
                            return BadMeasure;
                        }
                    });
-                   let update = ViewUpdate.create(this, this.state, []), redrawn = false, scrolled = false;
+                   let update = ViewUpdate.create(this, this.state, []), redrawn = false;
                    update.flags |= changed;
                    if (!updated)
                        updated = update;
                    else
                        updated.flags |= changed;
-                   this.updateState = 2 /* UpdateState.Updating */;
+                   this.updateState = 2 /* Updating */;
                    if (!update.empty) {
                        this.updatePlugins(update);
                        this.inputState.update(update);
@@ -10843,29 +11071,32 @@
                                logException(this.state, e);
                            }
                        }
-                   if (this.viewState.editorHeight) {
-                       if (this.viewState.scrollTarget) {
-                           this.docView.scrollIntoView(this.viewState.scrollTarget);
-                           this.viewState.scrollTarget = null;
-                           scrolled = true;
-                       }
-                       else {
-                           let diff = this.viewState.lineBlockAt(refBlock.from).top - refBlock.top;
-                           if (diff > 1 || diff < -1) {
-                               this.scrollDOM.scrollTop += diff;
-                               scrolled = true;
-                           }
-                       }
-                   }
                    if (redrawn)
                        this.docView.updateSelection(true);
-                   if (this.viewport.from == oldViewport.from && this.viewport.to == oldViewport.to &&
-                       !scrolled && this.measureRequests.length == 0)
+                   if (!update.viewportChanged && this.measureRequests.length == 0) {
+                       if (this.viewState.editorHeight) {
+                           if (this.viewState.scrollTarget) {
+                               this.docView.scrollIntoView(this.viewState.scrollTarget);
+                               this.viewState.scrollTarget = null;
+                               continue;
+                           }
+                           else {
+                               let newAnchorHeight = scrollAnchorPos < 0 ? this.viewState.heightMap.height :
+                                   this.viewState.lineBlockAt(scrollAnchorPos).top;
+                               let diff = newAnchorHeight - scrollAnchorHeight;
+                               if (diff > 1 || diff < -1) {
+                                   scrollTop = sDOM.scrollTop = scrollTop + diff;
+                                   scrollAnchorHeight = -1;
+                                   continue;
+                               }
+                           }
+                       }
                        break;
+                   }
                }
            }
            finally {
-               this.updateState = 0 /* UpdateState.Idle */;
+               this.updateState = 0 /* Idle */;
                this.measureScheduled = -1;
            }
            if (updated && !updated.empty)
@@ -10924,9 +11155,9 @@
            StyleModule.mount(this.root, this.styleModules.concat(baseTheme$1$2).reverse());
        }
        readMeasured() {
-           if (this.updateState == 2 /* UpdateState.Updating */)
+           if (this.updateState == 2 /* Updating */)
                throw new Error("Reading the editor layout isn't allowed during an update");
-           if (this.updateState == 0 /* UpdateState.Idle */ && this.measureScheduled > -1)
+           if (this.updateState == 0 /* Idle */ && this.measureScheduled > -1)
                this.measure(false);
        }
        /**
@@ -11720,15 +11951,6 @@
            to: Math.min(inside.to, view.moveToLineBoundary(range, true, true).from),
            type: BlockType.Text };
    }
-   function blockAt(view, pos) {
-       let line = view.lineBlockAt(pos);
-       if (Array.isArray(line.type))
-           for (let l of line.type) {
-               if (l.to > pos || l.to == pos && (l.to == line.to || l.type == BlockType.Text))
-                   return l;
-           }
-       return line;
-   }
    function rectanglesForRange(view, className, range) {
        if (range.to <= view.viewport.from || range.from >= view.viewport.to)
            return [];
@@ -11742,12 +11964,10 @@
        let startBlock = blockAt(view, from), endBlock = blockAt(view, to);
        let visualStart = startBlock.type == BlockType.Text ? startBlock : null;
        let visualEnd = endBlock.type == BlockType.Text ? endBlock : null;
-       if (view.lineWrapping) {
-           if (visualStart)
-               visualStart = wrappedLine(view, from, visualStart);
-           if (visualEnd)
-               visualEnd = wrappedLine(view, to, visualEnd);
-       }
+       if (visualStart && (view.lineWrapping || startBlock.widgetLineBreaks))
+           visualStart = wrappedLine(view, from, visualStart);
+       if (visualEnd && (view.lineWrapping || endBlock.widgetLineBreaks))
+           visualEnd = wrappedLine(view, to, visualEnd);
        if (visualStart && visualEnd && visualStart.from == visualEnd.from) {
            return pieces(drawForLine(range.from, range.to, visualStart));
        }
@@ -11755,14 +11975,15 @@
            let top = visualStart ? drawForLine(range.from, null, visualStart) : drawForWidget(startBlock, false);
            let bottom = visualEnd ? drawForLine(null, range.to, visualEnd) : drawForWidget(endBlock, true);
            let between = [];
-           if ((visualStart || startBlock).to < (visualEnd || endBlock).from - 1)
+           if ((visualStart || startBlock).to < (visualEnd || endBlock).from - (visualStart && visualEnd ? 1 : 0) ||
+               startBlock.widgetLineBreaks > 1 && top.bottom + view.defaultLineHeight / 2 < bottom.top)
                between.push(piece(leftSide, top.bottom, rightSide, bottom.top));
            else if (top.bottom < bottom.top && view.elementAtHeight((top.bottom + bottom.top) / 2).type == BlockType.Text)
                top.bottom = bottom.top = (top.bottom + bottom.top) / 2;
            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 /* C.Epsilon */, right - left, bottom - top + 0.01 /* C.Epsilon */);
+           return new RectangleMarker(className, left - base.left, top - base.top - 0.01 /* Epsilon */, right - left, bottom - top + 0.01 /* Epsilon */);
        }
        function pieces({ top, bottom, horizontal }) {
            let pieces = [];
@@ -11780,6 +12001,8 @@
                // coordsAtPos queries, would break selection drawing.
                let fromCoords = view.coordsAtPos(from, (from == line.to ? -2 : 2));
                let toCoords = view.coordsAtPos(to, (to == line.from ? 2 : -2));
+               if (!fromCoords || !toCoords)
+                   return;
                top = Math.min(fromCoords.top, toCoords.top, top);
                bottom = Math.max(fromCoords.bottom, toCoords.bottom, bottom);
                if (dir == Direction.LTR)
@@ -12394,6 +12617,17 @@
                wrap.setAttribute("aria-hidden", "true");
            return wrap;
        }
+       coordsAt(dom) {
+           let rects = dom.firstChild ? clientRectsFor(dom.firstChild) : [];
+           if (!rects.length)
+               return null;
+           let style = window.getComputedStyle(dom.parentNode);
+           let rect = flattenRect(rects[0], style.direction != "rtl");
+           let lineHeight = parseInt(style.lineHeight);
+           if (rect.bottom - rect.top > lineHeight * 1.5)
+               return { left: rect.left, right: rect.right, top: rect.top, bottom: rect.top + lineHeight };
+           return rect;
+       }
        ignoreEvent() { return false; }
    }
    /**
@@ -12491,10 +12725,10 @@
        return EditorView.mouseSelectionStyle.of((view, event) => filter(event) ? rectangleSelectionStyle(view, event) : null);
    }
    const keys = {
-       Alt: [18, e => e.altKey],
-       Control: [17, e => e.ctrlKey],
-       Shift: [16, e => e.shiftKey],
-       Meta: [91, e => e.metaKey]
+       Alt: [18, e => !!e.altKey],
+       Control: [17, e => !!e.ctrlKey],
+       Shift: [16, e => !!e.shiftKey],
+       Meta: [91, e => !!e.metaKey]
    };
    const showCrosshair = { style: "cursor: crosshair" };
    /**
@@ -12731,12 +12965,12 @@
                    continue;
                }
                let arrow = tooltip.arrow ? tView.dom.querySelector(".cm-tooltip-arrow") : null;
-               let arrowHeight = arrow ? 7 /* Arrow.Size */ : 0;
+               let arrowHeight = arrow ? 7 /* 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 /* Arrow.Offset */ : 0) + offset.x, space.right - width)
-                       : Math.max(space.left, pos.left - width + (arrow ? 14 /* Arrow.Offset */ : 0) - offset.x);
+                   : 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);
                let above = !!tooltip.above;
                if (!tooltip.strictSide && (above
                    ? pos.top - (size.bottom - size.top) - offset.y < space.top
@@ -12770,7 +13004,7 @@
                    dom.style.left = left + "px";
                }
                if (arrow)
-                   arrow.style.left = `${pos.left + (ltr ? offset.x : -offset.x) - (left + 14 /* Arrow.Offset */ - 7 /* Arrow.Size */)}px`;
+                   arrow.style.left = `${pos.left + (ltr ? offset.x : -offset.x) - (left + 14 /* Offset */ - 7 /* Size */)}px`;
                if (tView.overlap !== true)
                    others.push({ left, top, right, bottom: top + height });
                dom.classList.toggle("cm-tooltip-above", above);
@@ -12813,8 +13047,8 @@
            color: "white"
        },
        ".cm-tooltip-arrow": {
-           height: `${7 /* Arrow.Size */}px`,
-           width: `${7 /* Arrow.Size */ * 2}px`,
+           height: `${7 /* Size */}px`,
+           width: `${7 /* Size */ * 2}px`,
            position: "absolute",
            zIndex: -1,
            overflow: "hidden",
@@ -12823,26 +13057,26 @@
                position: "absolute",
                width: 0,
                height: 0,
-               borderLeft: `${7 /* Arrow.Size */}px solid transparent`,
-               borderRight: `${7 /* Arrow.Size */}px solid transparent`,
+               borderLeft: `${7 /* Size */}px solid transparent`,
+               borderRight: `${7 /* Size */}px solid transparent`,
            },
            ".cm-tooltip-above &": {
-               bottom: `-${7 /* Arrow.Size */}px`,
+               bottom: `-${7 /* Size */}px`,
                "&:before": {
-                   borderTop: `${7 /* Arrow.Size */}px solid #bbb`,
+                   borderTop: `${7 /* Size */}px solid #bbb`,
                },
                "&:after": {
-                   borderTop: `${7 /* Arrow.Size */}px solid #f5f5f5`,
+                   borderTop: `${7 /* Size */}px solid #f5f5f5`,
                    bottom: "1px"
                }
            },
            ".cm-tooltip-below &": {
-               top: `-${7 /* Arrow.Size */}px`,
+               top: `-${7 /* Size */}px`,
                "&:before": {
-                   borderBottom: `${7 /* Arrow.Size */}px solid #bbb`,
+                   borderBottom: `${7 /* Size */}px solid #bbb`,
                },
                "&:after": {
-                   borderBottom: `${7 /* Arrow.Size */}px solid #f5f5f5`,
+                   borderBottom: `${7 /* Size */}px solid #f5f5f5`,
                    top: "1px"
                }
            },
@@ -13086,6 +13320,7 @@
        elementStyle: "",
        markers: () => RangeSet.empty,
        lineMarker: () => null,
+       widgetMarker: () => null,
        lineMarkerChange: null,
        initialSpacer: null,
        updateSpacer: null,
@@ -13166,24 +13401,28 @@
            let classSet = [];
            let contexts = this.gutters.map(gutter => new UpdateContext(gutter, this.view.viewport, -this.view.documentPadding.top));
            for (let line of this.view.viewportLineBlocks) {
-               let text;
+               if (classSet.length)
+                   classSet = [];
                if (Array.isArray(line.type)) {
-                   for (let b of line.type)
-                       if (b.type == BlockType.Text) {
-                           text = b;
-                           break;
+                   let first = true;
+                   for (let b of line.type) {
+                       if (b.type == BlockType.Text && first) {
+                           advanceCursor(lineClasses, classSet, b.from);
+                           for (let cx of contexts)
+                               cx.line(this.view, b, classSet);
+                           first = false;
                        }
+                       else if (b.widget) {
+                           for (let cx of contexts)
+                               cx.widget(this.view, b);
+                       }
+                   }
                }
-               else {
-                   text = line.type == BlockType.Text ? line : undefined;
+               else if (line.type == BlockType.Text) {
+                   advanceCursor(lineClasses, classSet, line.from);
+                   for (let cx of contexts)
+                       cx.line(this.view, line, classSet);
                }
-               if (!text)
-                   continue;
-               if (classSet.length)
-                   classSet = [];
-               advanceCursor(lineClasses, classSet, line.from);
-               for (let cx of contexts)
-                   cx.line(this.view, text, classSet);
            }
            for (let cx of contexts)
                cx.finish();
@@ -13251,6 +13490,19 @@
            this.i = 0;
            this.cursor = RangeSet.iter(gutter.markers, viewport.from);
        }
+       addElement(view, block, markers) {
+           let { gutter } = this, above = block.top - this.height;
+           if (this.i == gutter.elements.length) {
+               let newElt = new GutterElement(view, block.height, above, markers);
+               gutter.elements.push(newElt);
+               gutter.dom.appendChild(newElt.dom);
+           }
+           else {
+               gutter.elements[this.i].update(view, block.height, above, markers);
+           }
+           this.height = block.bottom;
+           this.i++;
+       }
        line(view, line, extraMarkers) {
            let localMarkers = [];
            advanceCursor(this.cursor, localMarkers, line.from);
@@ -13262,17 +13514,12 @@
            let gutter = this.gutter;
            if (localMarkers.length == 0 && !gutter.config.renderEmptyElements)
                return;
-           let above = line.top - this.height;
-           if (this.i == gutter.elements.length) {
-               let newElt = new GutterElement(view, line.height, above, localMarkers);
-               gutter.elements.push(newElt);
-               gutter.dom.appendChild(newElt.dom);
-           }
-           else {
-               gutter.elements[this.i].update(view, line.height, above, localMarkers);
-           }
-           this.height = line.bottom;
-           this.i++;
+           this.addElement(view, line, localMarkers);
+       }
+       widget(view, block) {
+           let marker = this.gutter.config.widgetMarker(view, block.widget, block);
+           if (marker)
+               this.addElement(view, block, [marker]);
        }
        finish() {
            let gutter = this.gutter;
@@ -13440,6 +13687,7 @@
                return null;
            return new NumberMarker(formatNumber(view, view.state.doc.lineAt(line.from).number));
        },
+       widgetMarker: () => null,
        lineMarkerChange: update => update.startState.facet(lineNumberConfig) != update.state.facet(lineNumberConfig),
        initialSpacer(view) {
            return new NumberMarker(formatNumber(view, maxLineNumber(view.state.doc.lines)));
@@ -13815,15 +14063,16 @@
        /// not have its children iterated over (or `leave` called).
        iterate(spec) {
            let { enter, leave, from = 0, to = this.length } = spec;
-           for (let c = this.cursor((spec.mode || 0) | IterMode.IncludeAnonymous);;) {
+           let mode = spec.mode || 0, anon = (mode & IterMode.IncludeAnonymous) > 0;
+           for (let c = this.cursor(mode | IterMode.IncludeAnonymous);;) {
                let entered = false;
-               if (c.from <= to && c.to >= from && (c.type.isAnonymous || enter(c) !== false)) {
+               if (c.from <= to && c.to >= from && (!anon && c.type.isAnonymous || enter(c) !== false)) {
                    if (c.firstChild())
                        continue;
                    entered = true;
                }
                for (;;) {
-                   if (entered && leave && !c.type.isAnonymous)
+                   if (entered && leave && (anon || !c.type.isAnonymous))
                        leave(c);
                    if (c.nextSibling())
                        break;
@@ -15184,7 +15433,7 @@
                if (rule.mode == 1 /* Inherit */)
                    inheritedClass += (inheritedClass ? " " : "") + tagCls;
            }
-           this.startSpan(cursor.from, cls);
+           this.startSpan(Math.max(from, start), cls);
            if (rule.opaque)
                return;
            let mounted = cursor.tree && cursor.tree.prop(NodeProp.mounted);
@@ -15208,14 +15457,16 @@
                        break;
                    pos = next.to + start;
                    if (pos > from) {
-                       this.highlightRange(inner.cursor(), Math.max(from, next.from + start), Math.min(to, pos), inheritedClass, innerHighlighters);
-                       this.startSpan(pos, cls);
+                       this.highlightRange(inner.cursor(), Math.max(from, next.from + start), Math.min(to, pos), "", innerHighlighters);
+                       this.startSpan(Math.min(to, pos), cls);
                    }
                }
                if (hasChild)
                    cursor.parent();
            }
            else if (cursor.firstChild()) {
+               if (mounted)
+                   inheritedClass = "";
                do {
                    if (cursor.to <= from)
                        continue;
@@ -15728,7 +15979,7 @@
        });
    }
    /**
-   Syntax node prop used to register sublangauges. Should be added to
+   Syntax node prop used to register sublanguages. Should be added to
    the top level node type for the language.
    */
    const sublanguageProp = /*@__PURE__*/new NodeProp();
@@ -15892,8 +16143,15 @@
        let field = state.field(Language.state, false);
        return field ? field.tree : Tree.empty;
    }
-   // Lezer-style Input object for a Text document.
+   /**
+   Lezer-style
+   [`Input`](https://lezer.codemirror.net/docs/ref#common.Input)
+   object for a [`Text`](https://codemirror.net/6/docs/ref/#state.Text) object.
+   */
    class DocInput {
+       /**
+       Create an input object for the given document.
+       */
        constructor(doc) {
            this.doc = doc;
            this.cursorPos = 0;
@@ -16179,14 +16437,14 @@
            // state updates with parse work beyond the viewport.
            let upto = this.context.treeLen == tr.startState.doc.length ? undefined
                : Math.max(tr.changes.mapPos(this.context.treeLen), newCx.viewport.to);
-           if (!newCx.work(20 /* Work.Apply */, upto))
+           if (!newCx.work(20 /* Apply */, upto))
                newCx.takeTree();
            return new LanguageState(newCx);
        }
        static init(state) {
-           let vpTo = Math.min(3000 /* Work.InitViewport */, state.doc.length);
+           let vpTo = Math.min(3000 /* InitViewport */, state.doc.length);
            let parseState = ParseContext.create(state.facet(language).parser, state, { from: 0, to: vpTo });
-           if (!parseState.work(20 /* Work.Apply */, vpTo))
+           if (!parseState.work(20 /* Apply */, vpTo))
                parseState.takeTree();
            return new LanguageState(parseState);
        }
@@ -16203,14 +16461,14 @@
        }
    });
    let requestIdle = (callback) => {
-       let timeout = setTimeout(() => callback(), 500 /* Work.MaxPause */);
+       let timeout = setTimeout(() => callback(), 500 /* MaxPause */);
        return () => clearTimeout(timeout);
    };
    if (typeof requestIdleCallback != "undefined")
        requestIdle = (callback) => {
            let idle = -1, timeout = setTimeout(() => {
-               idle = requestIdleCallback(callback, { timeout: 500 /* Work.MaxPause */ - 100 /* Work.MinPause */ });
-           }, 100 /* Work.MinPause */);
+               idle = requestIdleCallback(callback, { timeout: 500 /* MaxPause */ - 100 /* MinPause */ });
+           }, 100 /* MinPause */);
            return () => idle < 0 ? clearTimeout(timeout) : cancelIdleCallback(idle);
        };
    const isInputPending = typeof navigator != "undefined" && ((_a = navigator.scheduling) === null || _a === void 0 ? void 0 : _a.isInputPending)
@@ -16233,7 +16491,7 @@
                this.scheduleWork();
            if (update.docChanged) {
                if (this.view.hasFocus)
-                   this.chunkBudget += 50 /* Work.ChangeBonus */;
+                   this.chunkBudget += 50 /* ChangeBonus */;
                this.scheduleWork();
            }
            this.checkAsyncSchedule(cx);
@@ -16249,19 +16507,19 @@
            this.working = null;
            let now = Date.now();
            if (this.chunkEnd < now && (this.chunkEnd < 0 || this.view.hasFocus)) { // Start a new chunk
-               this.chunkEnd = now + 30000 /* Work.ChunkTime */;
-               this.chunkBudget = 3000 /* Work.ChunkBudget */;
+               this.chunkEnd = now + 30000 /* ChunkTime */;
+               this.chunkBudget = 3000 /* ChunkBudget */;
            }
            if (this.chunkBudget <= 0)
                return; // No more budget
            let { state, viewport: { to: vpTo } } = this.view, field = state.field(Language.state);
-           if (field.tree == field.context.tree && field.context.isDone(vpTo + 100000 /* Work.MaxParseAhead */))
+           if (field.tree == field.context.tree && field.context.isDone(vpTo + 100000 /* MaxParseAhead */))
                return;
-           let endTime = Date.now() + Math.min(this.chunkBudget, 100 /* Work.Slice */, deadline && !isInputPending ? Math.max(25 /* Work.MinSlice */, deadline.timeRemaining() - 5) : 1e9);
+           let endTime = Date.now() + Math.min(this.chunkBudget, 100 /* Slice */, deadline && !isInputPending ? Math.max(25 /* MinSlice */, deadline.timeRemaining() - 5) : 1e9);
            let viewportFirst = field.context.treeLen < vpTo && state.doc.length > vpTo + 1000;
            let done = field.context.work(() => {
                return isInputPending && isInputPending() || Date.now() > endTime;
-           }, vpTo + (viewportFirst ? 0 : 100000 /* Work.MaxParseAhead */));
+           }, vpTo + (viewportFirst ? 0 : 100000 /* MaxParseAhead */));
            this.chunkBudget -= Date.now() - now;
            if (done || this.chunkBudget <= 0) {
                field.context.takeTree();
@@ -16581,13 +16839,20 @@
        on if it is covered by another such node.
        */
        get baseIndent() {
-           let line = this.state.doc.lineAt(this.node.from);
+           return this.baseIndentFor(this.node);
+       }
+       /**
+       Get the indentation for the reference line of the given node
+       (see [`baseIndent`](https://codemirror.net/6/docs/ref/#language.TreeIndentContext.baseIndent)).
+       */
+       baseIndentFor(node) {
+           let line = this.state.doc.lineAt(node.from);
            // Skip line starts that are covered by a sibling (or cousin, etc)
            for (;;) {
-               let atBreak = this.node.resolve(line.from);
+               let atBreak = node.resolve(line.from);
                while (atBreak.parent && atBreak.parent.from == atBreak.from)
                    atBreak = atBreak.parent;
-               if (isParent(atBreak, this.node))
+               if (isParent(atBreak, node))
                    break;
                line = this.state.doc.lineAt(atBreak.from);
            }
@@ -17521,7 +17786,7 @@
            if (last >= 0 && ranges[last].to > fromLine.from)
                ranges[last].to = toLine.to;
            else
-               ranges.push({ from: fromLine.from, to: toLine.to });
+               ranges.push({ from: fromLine.from + /^\s*/.exec(fromLine.text)[0].length, to: toLine.to });
        }
        return ranges;
    }
@@ -18799,7 +19064,7 @@
    - Shift-Alt-ArrowUp: [`copyLineUp`](https://codemirror.net/6/docs/ref/#commands.copyLineUp)
    - Shift-Alt-ArrowDown: [`copyLineDown`](https://codemirror.net/6/docs/ref/#commands.copyLineDown)
    - Escape: [`simplifySelection`](https://codemirror.net/6/docs/ref/#commands.simplifySelection)
-   - Ctrl-Enter (Comd-Enter on macOS): [`insertBlankLine`](https://codemirror.net/6/docs/ref/#commands.insertBlankLine)
+   - Ctrl-Enter (Cmd-Enter on macOS): [`insertBlankLine`](https://codemirror.net/6/docs/ref/#commands.insertBlankLine)
    - Alt-l (Ctrl-l on macOS): [`selectLine`](https://codemirror.net/6/docs/ref/#commands.selectLine)
    - Ctrl-i (Cmd-i on macOS): [`selectParentSyntax`](https://codemirror.net/6/docs/ref/#commands.selectParentSyntax)
    - Ctrl-[ (Cmd-[ on macOS): [`indentLess`](https://codemirror.net/6/docs/ref/#commands.indentLess)
@@ -19104,7 +19369,7 @@
            this.matchPos = toCharEnd(text, from);
            this.re = new RegExp(query, baseFlags + ((options === null || options === void 0 ? void 0 : options.ignoreCase) ? "i" : ""));
            this.test = options === null || options === void 0 ? void 0 : options.test;
-           this.flat = FlattenedDoc.get(text, from, this.chunkEnd(from + 5000 /* Chunk.Base */));
+           this.flat = FlattenedDoc.get(text, from, this.chunkEnd(from + 5000 /* Base */));
        }
        chunkEnd(pos) {
            return pos >= this.to ? this.to : this.text.lineAt(pos).to;
@@ -19411,6 +19676,7 @@
                top: false,
                caseSensitive: false,
                literal: false,
+               regexp: false,
                wholeWord: false,
                createPanel: view => new SearchPanel(view),
                scrollToMatch: range => EditorView.scrollIntoView(range)
@@ -19496,11 +19762,11 @@
                cursor = stringCursor(this.spec, state, 0, curFrom).nextOverlapping();
            return cursor.done ? null : cursor.value;
        }
-       // Searching in reverse is, rather than implementing inverted search
+       // Searching in reverse is, rather than implementing an inverted search
        // cursor, done by scanning chunk after chunk forward.
        prevMatchInRange(state, from, to) {
            for (let pos = to;;) {
-               let start = Math.max(from, pos - 10000 /* FindPrev.ChunkSize */ - this.spec.unquoted.length);
+               let start = Math.max(from, pos - 10000 /* ChunkSize */ - this.spec.unquoted.length);
                let cursor = stringCursor(this.spec, state, start, pos), range = null;
                while (!cursor.nextOverlapping().done)
                    range = cursor.value;
@@ -19508,7 +19774,7 @@
                    return range;
                if (start == from)
                    return null;
-               pos -= 10000 /* FindPrev.ChunkSize */;
+               pos -= 10000 /* ChunkSize */;
            }
        }
        prevMatch(state, curFrom, curTo) {
@@ -19559,7 +19825,7 @@
        }
        prevMatchInRange(state, from, to) {
            for (let size = 1;; size++) {
-               let start = Math.max(from, to - size * 10000 /* FindPrev.ChunkSize */);
+               let start = Math.max(from, to - size * 10000 /* ChunkSize */);
                let cursor = regexpCursor(this.spec, state, start, to), range = null;
                while (!cursor.next().done)
                    range = cursor.value;
@@ -19589,7 +19855,7 @@
            return ranges;
        }
        highlight(state, from, to, add) {
-           let cursor = regexpCursor(this.spec, state, Math.max(0, from - 250 /* RegExp.HighlightMargin */), Math.min(to + 250 /* RegExp.HighlightMargin */, state.doc.length));
+           let cursor = regexpCursor(this.spec, state, Math.max(0, from - 250 /* HighlightMargin */), Math.min(to + 250 /* HighlightMargin */, state.doc.length));
            while (!cursor.next().done)
                add(cursor.value.from, cursor.value.to);
        }
@@ -19642,7 +19908,7 @@
            let builder = new RangeSetBuilder();
            for (let i = 0, ranges = view.visibleRanges, l = ranges.length; i < l; i++) {
                let { from, to } = ranges[i];
-               while (i < l - 1 && to > ranges[i + 1].from - 2 * 250 /* RegExp.HighlightMargin */)
+               while (i < l - 1 && to > ranges[i + 1].from - 2 * 250 /* HighlightMargin */)
                    to = ranges[++i].to;
                query.highlight(view.state, from, to, (from, to) => {
                    let selected = view.state.selection.ranges.some(r => r.from == from && r.to == to);
@@ -19675,9 +19941,10 @@
        let config = view.state.facet(searchConfigFacet);
        view.dispatch({
            selection,
-           effects: [announceMatch(view, next), config.scrollToMatch(selection.main)],
+           effects: [announceMatch(view, next), config.scrollToMatch(selection.main, view)],
            userEvent: "select.search"
        });
+       selectSearchInput(view);
        return true;
    });
    /**
@@ -19694,9 +19961,10 @@
        let config = view.state.facet(searchConfigFacet);
        view.dispatch({
            selection,
-           effects: [announceMatch(view, prev), config.scrollToMatch(selection.main)],
+           effects: [announceMatch(view, prev), config.scrollToMatch(selection.main, view)],
            userEvent: "select.search"
        });
+       selectSearchInput(view);
        return true;
    });
    /**
@@ -19756,7 +20024,7 @@
            let off = changes.length == 0 || changes[0].from >= next.to ? 0 : next.to - next.from - replacement.length;
            selection = EditorSelection.single(next.from - off, next.to - off);
            effects.push(announceMatch(view, next));
-           effects.push(state.facet(searchConfigFacet).scrollToMatch(selection.main));
+           effects.push(state.facet(searchConfigFacet).scrollToMatch(selection.main, view));
        }
        view.dispatch({
            changes, selection, effects,
@@ -19789,7 +20057,7 @@
        return view.state.facet(searchConfigFacet).createPanel(view);
    }
    function defaultQuery(state, fallback) {
-       var _a, _b, _c, _d;
+       var _a, _b, _c, _d, _e;
        let sel = state.selection.main;
        let selText = sel.empty || sel.to > sel.from + 100 ? "" : state.sliceDoc(sel.from, sel.to);
        if (fallback && !selText)
@@ -19799,19 +20067,26 @@
            search: ((_a = fallback === null || fallback === void 0 ? void 0 : fallback.literal) !== null && _a !== void 0 ? _a : config.literal) ? selText : selText.replace(/\n/g, "\\n"),
            caseSensitive: (_b = fallback === null || fallback === void 0 ? void 0 : fallback.caseSensitive) !== null && _b !== void 0 ? _b : config.caseSensitive,
            literal: (_c = fallback === null || fallback === void 0 ? void 0 : fallback.literal) !== null && _c !== void 0 ? _c : config.literal,
-           wholeWord: (_d = fallback === null || fallback === void 0 ? void 0 : fallback.wholeWord) !== null && _d !== void 0 ? _d : config.wholeWord
+           regexp: (_d = fallback === null || fallback === void 0 ? void 0 : fallback.regexp) !== null && _d !== void 0 ? _d : config.regexp,
+           wholeWord: (_e = fallback === null || fallback === void 0 ? void 0 : fallback.wholeWord) !== null && _e !== void 0 ? _e : config.wholeWord
        });
    }
+   function getSearchInput(view) {
+       let panel = getPanel(view, createSearchPanel);
+       return panel && panel.dom.querySelector("[main-field]");
+   }
+   function selectSearchInput(view) {
+       let input = getSearchInput(view);
+       if (input && input == view.root.activeElement)
+           input.select();
+   }
    /**
    Make sure the search panel is open and focused.
    */
    const openSearchPanel = view => {
        let state = view.state.field(searchState, false);
        if (state && state.panel) {
-           let panel = getPanel(view, createSearchPanel);
-           if (!panel)
-               return false;
-           let searchInput = panel.dom.querySelector("[main-field]");
+           let searchInput = getSearchInput(view);
            if (searchInput && searchInput != view.root.activeElement) {
                let query = defaultQuery(view.state, state.query.spec);
                if (query.valid)
@@ -20153,13 +20428,14 @@
        };
    }
    class Option {
-       constructor(completion, source, match) {
+       constructor(completion, source, match, score) {
            this.completion = completion;
            this.source = source;
            this.match = match;
+           this.score = score;
        }
    }
-   function cur(state) { return state.selection.main.head; }
+   function cur(state) { return state.selection.main.from; }
    // Make sure the given regexp has a $ at its end and, if `start` is
    // true, a ^ at its start.
    function ensureAnchor(expr, start) {
@@ -20181,30 +20457,17 @@
    selection range that has the same text in front of it.
    */
    function insertCompletionText(state, text, from, to) {
+       let { main } = state.selection, fromOff = from - main.from, toOff = to - main.from;
        return Object.assign(Object.assign({}, state.changeByRange(range => {
-           if (range == state.selection.main)
-               return {
-                   changes: { from: from, to: to, insert: text },
-                   range: EditorSelection.cursor(from + text.length)
-               };
-           let len = to - from;
-           if (!range.empty ||
-               len && state.sliceDoc(range.from - len, range.from) != state.sliceDoc(from, to))
+           if (range != main && from != to &&
+               state.sliceDoc(range.from + fromOff, range.from + toOff) != state.sliceDoc(from, to))
                return { range };
            return {
-               changes: { from: range.from - len, to: range.from, insert: text },
-               range: EditorSelection.cursor(range.from - len + text.length)
+               changes: { from: range.from + fromOff, to: to == main.from ? range.to : range.from + toOff, insert: text },
+               range: EditorSelection.cursor(range.from + fromOff + text.length)
            };
        })), { userEvent: "input.complete" });
    }
-   function applyCompletion(view, option) {
-       const apply = option.completion.apply || option.completion.label;
-       let result = option.source;
-       if (typeof apply == "string")
-           view.dispatch(Object.assign(Object.assign({}, insertCompletionText(view.state, apply, result.from, result.to)), { annotations: pickedCompletion.of(option.completion) }));
-       else
-           apply(view, option.completion, result.from, result.to);
-   }
    const SourceCache = /*@__PURE__*/new WeakMap();
    function asSource(source) {
        if (!Array.isArray(source))
@@ -20214,6 +20477,8 @@
            SourceCache.set(source, known = completeFromList(source));
        return known;
    }
+   const startCompletionEffect = /*@__PURE__*/StateEffect.define();
+   const closeCompletionEffect = /*@__PURE__*/StateEffect.define();
 
    // A pattern matcher for fuzzy completion matching. Create an instance
    // once for a pattern, and then use that to match any number of
@@ -20246,7 +20511,7 @@
        // is. See `Penalty` above.
        match(word) {
            if (this.pattern.length == 0)
-               return [0];
+               return [-100 /* NotFull */];
            if (word.length < this.pattern.length)
                return null;
            let { chars, folded, any, precise, byWord } = this;
@@ -20254,17 +20519,17 @@
            // at the start
            if (chars.length == 1) {
                let first = codePointAt(word, 0), firstSize = codePointSize(first);
-               let score = firstSize == word.length ? 0 : -100 /* Penalty.NotFull */;
+               let score = firstSize == word.length ? 0 : -100 /* NotFull */;
                if (first == chars[0]) ;
                else if (first == folded[0])
-                   score += -200 /* Penalty.CaseFold */;
+                   score += -200 /* CaseFold */;
                else
                    return null;
                return [score, 0, firstSize];
            }
            let direct = word.indexOf(this.pattern);
            if (direct == 0)
-               return [word.length == this.pattern.length ? 0 : -100 /* Penalty.NotFull */, 0, this.pattern.length];
+               return [word.length == this.pattern.length ? 0 : -100 /* NotFull */, 0, this.pattern.length];
            let len = chars.length, anyTo = 0;
            if (direct < 0) {
                for (let i = 0, e = Math.min(word.length, 200); i < e && anyTo < len;) {
@@ -20288,7 +20553,7 @@
            let adjacentTo = 0, adjacentStart = -1, adjacentEnd = -1;
            let hasLower = /[a-z]/.test(word), wordAdjacent = true;
            // Go over the option's text, scanning for the various kinds of matches
-           for (let i = 0, e = Math.min(word.length, 200), prevType = 0 /* Tp.NonWord */; i < e && byWordTo < len;) {
+           for (let i = 0, e = Math.min(word.length, 200), prevType = 0 /* NonWord */; i < e && byWordTo < len;) {
                let next = codePointAt(word, i);
                if (direct < 0) {
                    if (preciseTo < len && next == chars[preciseTo])
@@ -20306,9 +20571,9 @@
                    }
                }
                let ch, type = next < 0xff
-                   ? (next >= 48 && next <= 57 || next >= 97 && next <= 122 ? 2 /* Tp.Lower */ : next >= 65 && next <= 90 ? 1 /* Tp.Upper */ : 0 /* Tp.NonWord */)
-                   : ((ch = fromCodePoint(next)) != ch.toLowerCase() ? 1 /* Tp.Upper */ : ch != ch.toUpperCase() ? 2 /* Tp.Lower */ : 0 /* Tp.NonWord */);
-               if (!i || type == 1 /* Tp.Upper */ && hasLower || prevType == 0 /* Tp.NonWord */ && type != 0 /* Tp.NonWord */) {
+                   ? (next >= 48 && next <= 57 || next >= 97 && next <= 122 ? 2 /* Lower */ : next >= 65 && next <= 90 ? 1 /* Upper */ : 0 /* NonWord */)
+                   : ((ch = fromCodePoint(next)) != ch.toLowerCase() ? 1 /* Upper */ : ch != ch.toUpperCase() ? 2 /* Lower */ : 0 /* NonWord */);
+               if (!i || type == 1 /* Upper */ && hasLower || prevType == 0 /* NonWord */ && type != 0 /* NonWord */) {
                    if (chars[byWordTo] == next || (folded[byWordTo] == next && (byWordFolded = true)))
                        byWord[byWordTo++] = i;
                    else if (byWord.length)
@@ -20318,17 +20583,17 @@
                i += codePointSize(next);
            }
            if (byWordTo == len && byWord[0] == 0 && wordAdjacent)
-               return this.result(-100 /* Penalty.ByWord */ + (byWordFolded ? -200 /* Penalty.CaseFold */ : 0), byWord, word);
+               return this.result(-100 /* ByWord */ + (byWordFolded ? -200 /* CaseFold */ : 0), byWord, word);
            if (adjacentTo == len && adjacentStart == 0)
-               return [-200 /* Penalty.CaseFold */ - word.length + (adjacentEnd == word.length ? 0 : -100 /* Penalty.NotFull */), 0, adjacentEnd];
+               return [-200 /* CaseFold */ - word.length + (adjacentEnd == word.length ? 0 : -100 /* NotFull */), 0, adjacentEnd];
            if (direct > -1)
-               return [-700 /* Penalty.NotStart */ - word.length, direct, direct + this.pattern.length];
+               return [-700 /* NotStart */ - word.length, direct, direct + this.pattern.length];
            if (adjacentTo == len)
-               return [-200 /* Penalty.CaseFold */ + -700 /* Penalty.NotStart */ - word.length, adjacentStart, adjacentEnd];
+               return [-200 /* CaseFold */ + -700 /* NotStart */ - word.length, adjacentStart, adjacentEnd];
            if (byWordTo == len)
-               return this.result(-100 /* Penalty.ByWord */ + (byWordFolded ? -200 /* Penalty.CaseFold */ : 0) + -700 /* Penalty.NotStart */ +
-                   (wordAdjacent ? 0 : -1100 /* Penalty.Gap */), byWord, word);
-           return chars.length == 2 ? null : this.result((any[0] ? -700 /* Penalty.NotStart */ : 0) + -200 /* Penalty.CaseFold */ + -1100 /* Penalty.Gap */, any, word);
+               return this.result(-100 /* ByWord */ + (byWordFolded ? -200 /* CaseFold */ : 0) + -700 /* NotStart */ +
+                   (wordAdjacent ? 0 : -1100 /* Gap */), byWord, word);
+           return chars.length == 2 ? null : this.result((any[0] ? -700 /* NotStart */ : 0) + -200 /* CaseFold */ + -1100 /* Gap */, any, word);
        }
        result(score, positions, word) {
            let result = [score - word.length], i = 1;
@@ -20359,6 +20624,7 @@
                aboveCursor: false,
                icons: true,
                addToOptions: [],
+               positionInfo: defaultPositionInfo,
                compareCompletions: (a, b) => a.label.localeCompare(b.label),
                interactionDelay: 75
            }, {
@@ -20374,6 +20640,36 @@
    function joinClass(a, b) {
        return a ? b ? a + " " + b : a : b;
    }
+   function defaultPositionInfo(view, list, option, info, space) {
+       let rtl = view.textDirection == Direction.RTL, left = rtl, narrow = false;
+       let side = "top", offset, maxWidth;
+       let spaceLeft = list.left - space.left, spaceRight = space.right - list.right;
+       let infoWidth = info.right - info.left, infoHeight = info.bottom - info.top;
+       if (left && spaceLeft < Math.min(infoWidth, spaceRight))
+           left = false;
+       else if (!left && spaceRight < Math.min(infoWidth, spaceLeft))
+           left = true;
+       if (infoWidth <= (left ? spaceLeft : spaceRight)) {
+           offset = Math.max(space.top, Math.min(option.top, space.bottom - infoHeight)) - list.top;
+           maxWidth = Math.min(400 /* Width */, left ? spaceLeft : spaceRight);
+       }
+       else {
+           narrow = true;
+           maxWidth = Math.min(400 /* Width */, (rtl ? list.right : space.right - list.left) - 30 /* Margin */);
+           let spaceBelow = space.bottom - list.bottom;
+           if (spaceBelow >= infoHeight || spaceBelow > list.top) { // Below the completion
+               offset = option.bottom - list.top;
+           }
+           else { // Above it
+               side = "bottom";
+               offset = list.bottom - option.top;
+           }
+       }
+       return {
+           style: `${side}: ${offset}px; max-width: ${maxWidth}px`,
+           class: "cm-completionInfo-" + (narrow ? (rtl ? "left-narrow" : "right-narrow") : left ? "left" : "right")
+       };
+   }
 
    function optionContent(config) {
        let content = config.addToOptions.slice();
@@ -20434,13 +20730,15 @@
        return { from: total - (off + 1) * max, to: total - off * max };
    }
    class CompletionTooltip {
-       constructor(view, stateField) {
+       constructor(view, stateField, applyCompletion) {
            this.view = view;
            this.stateField = stateField;
+           this.applyCompletion = applyCompletion;
            this.info = null;
-           this.placeInfo = {
+           this.infoDestroy = null;
+           this.placeInfoReq = {
                read: () => this.measureInfo(),
-               write: (pos) => this.positionInfo(pos),
+               write: (pos) => this.placeInfo(pos),
                key: this
            };
            this.space = null;
@@ -20458,16 +20756,22 @@
            this.dom.addEventListener("mousedown", (e) => {
                for (let dom = e.target, match; dom && dom != this.dom; dom = dom.parentNode) {
                    if (dom.nodeName == "LI" && (match = /-(\d+)$/.exec(dom.id)) && +match[1] < options.length) {
-                       applyCompletion(view, options[+match[1]]);
+                       this.applyCompletion(view, options[+match[1]]);
                        e.preventDefault();
                        return;
                    }
                }
            });
+           this.dom.addEventListener("focusout", (e) => {
+               let state = view.state.field(this.stateField, false);
+               if (state && state.tooltip && view.state.facet(completionConfig).closeOnBlur &&
+                   e.relatedTarget != view.contentDOM)
+                   view.dispatch({ effects: closeCompletionEffect.of(null) });
+           });
            this.list = this.dom.appendChild(this.createListBox(options, cState.id, this.range));
            this.list.addEventListener("scroll", () => {
                if (this.info)
-                   this.view.requestMeasure(this.placeInfo);
+                   this.view.requestMeasure(this.placeInfoReq);
            });
        }
        mount() { this.updateSel(); }
@@ -20497,7 +20801,7 @@
        positioned(space) {
            this.space = space;
            if (this.info)
-               this.view.requestMeasure(this.placeInfo);
+               this.view.requestMeasure(this.placeInfoReq);
        }
        updateSel() {
            let cState = this.view.state.field(this.stateField), open = cState.open;
@@ -20507,43 +20811,52 @@
                this.list = this.dom.appendChild(this.createListBox(open.options, cState.id, this.range));
                this.list.addEventListener("scroll", () => {
                    if (this.info)
-                       this.view.requestMeasure(this.placeInfo);
+                       this.view.requestMeasure(this.placeInfoReq);
                });
            }
            if (this.updateSelectedOption(open.selected)) {
-               if (this.info) {
-                   this.info.remove();
-                   this.info = null;
-               }
+               this.destroyInfo();
                let { completion } = open.options[open.selected];
                let { info } = completion;
                if (!info)
                    return;
-               let infoResult = typeof info === 'string' ? document.createTextNode(info) : info(completion);
+               let infoResult = typeof info === "string" ? document.createTextNode(info) : info(completion);
                if (!infoResult)
                    return;
-               if ('then' in infoResult) {
-                   infoResult.then(node => {
-                       if (node && this.view.state.field(this.stateField, false) == cState)
-                           this.addInfoPane(node);
+               if ("then" in infoResult) {
+                   infoResult.then(obj => {
+                       if (obj && this.view.state.field(this.stateField, false) == cState)
+                           this.addInfoPane(obj, completion);
                    }).catch(e => logException(this.view.state, e, "completion info"));
                }
                else {
-                   this.addInfoPane(infoResult);
+                   this.addInfoPane(infoResult, completion);
                }
            }
        }
-       addInfoPane(content) {
-           let dom = this.info = document.createElement("div");
-           dom.className = "cm-tooltip cm-completionInfo";
-           dom.appendChild(content);
-           this.dom.appendChild(dom);
-           this.view.requestMeasure(this.placeInfo);
+       addInfoPane(content, completion) {
+           this.destroyInfo();
+           let wrap = this.info = document.createElement("div");
+           wrap.className = "cm-tooltip cm-completionInfo";
+           if (content.nodeType != null) {
+               wrap.appendChild(content);
+               this.infoDestroy = null;
+           }
+           else {
+               let { dom, destroy } = content;
+               wrap.appendChild(dom);
+               this.infoDestroy = destroy || null;
+           }
+           this.dom.appendChild(wrap);
+           this.view.requestMeasure(this.placeInfoReq);
        }
        updateSelectedOption(selected) {
            let set = null;
            for (let opt = this.list.firstChild, i = this.range.from; opt; opt = opt.nextSibling, i++) {
-               if (i == selected) {
+               if (opt.nodeName != "LI" || !opt.id) {
+                   i--; // A section header
+               }
+               else if (i == selected) {
                    if (!opt.hasAttribute("aria-selected")) {
                        opt.setAttribute("aria-selected", "true");
                        set = opt;
@@ -20573,41 +20886,17 @@
            if (selRect.top > Math.min(space.bottom, listRect.bottom) - 10 ||
                selRect.bottom < Math.max(space.top, listRect.top) + 10)
                return null;
-           let rtl = this.view.textDirection == Direction.RTL, left = rtl, narrow = false, maxWidth;
-           let top = "", bottom = "";
-           let spaceLeft = listRect.left - space.left, spaceRight = space.right - listRect.right;
-           if (left && spaceLeft < Math.min(infoRect.width, spaceRight))
-               left = false;
-           else if (!left && spaceRight < Math.min(infoRect.width, spaceLeft))
-               left = true;
-           if (infoRect.width <= (left ? spaceLeft : spaceRight)) {
-               top = (Math.max(space.top, Math.min(selRect.top, space.bottom - infoRect.height)) - listRect.top) + "px";
-               maxWidth = Math.min(400 /* Info.Width */, left ? spaceLeft : spaceRight) + "px";
-           }
-           else {
-               narrow = true;
-               maxWidth = Math.min(400 /* Info.Width */, (rtl ? listRect.right : space.right - listRect.left) - 30 /* Info.Margin */) + "px";
-               let spaceBelow = space.bottom - listRect.bottom;
-               if (spaceBelow >= infoRect.height || spaceBelow > listRect.top) // Below the completion
-                   top = (selRect.bottom - listRect.top) + "px";
-               else // Above it
-                   bottom = (listRect.bottom - selRect.top) + "px";
-           }
-           return {
-               top, bottom, maxWidth,
-               class: narrow ? (rtl ? "left-narrow" : "right-narrow") : left ? "left" : "right",
-           };
+           return this.view.state.facet(completionConfig).positionInfo(this.view, listRect, selRect, infoRect, space);
        }
-       positionInfo(pos) {
+       placeInfo(pos) {
            if (this.info) {
                if (pos) {
-                   this.info.style.top = pos.top;
-                   this.info.style.bottom = pos.bottom;
-                   this.info.style.maxWidth = pos.maxWidth;
-                   this.info.className = "cm-tooltip cm-completionInfo cm-completionInfo-" + pos.class;
+                   if (pos.style)
+                       this.info.style.cssText = pos.style;
+                   this.info.className = "cm-tooltip cm-completionInfo " + (pos.class || "");
                }
                else {
-                   this.info.style.top = "-1e6px";
+                   this.info.style.cssText = "top: -1e6px";
                }
            }
        }
@@ -20617,8 +20906,22 @@
            ul.setAttribute("role", "listbox");
            ul.setAttribute("aria-expanded", "true");
            ul.setAttribute("aria-label", this.view.state.phrase("Completions"));
+           let curSection = null;
            for (let i = range.from; i < range.to; i++) {
-               let { completion, match } = options[i];
+               let { completion, match } = options[i], { section } = completion;
+               if (section) {
+                   let name = typeof section == "string" ? section : section.name;
+                   if (name != curSection && (i > range.from || range.from == 0)) {
+                       curSection = name;
+                       if (typeof section != "string" && section.header) {
+                           ul.appendChild(section.header(section));
+                       }
+                       else {
+                           let header = ul.appendChild(document.createElement("completion-section"));
+                           header.textContent = name;
+                       }
+                   }
+               }
                const li = ul.appendChild(document.createElement("li"));
                li.id = id + "-" + i;
                li.setAttribute("role", "option");
@@ -20637,11 +20940,22 @@
                ul.classList.add("cm-completionListIncompleteBottom");
            return ul;
        }
+       destroyInfo() {
+           if (this.info) {
+               if (this.infoDestroy)
+                   this.infoDestroy();
+               this.info.remove();
+               this.info = null;
+           }
+       }
+       destroy() {
+           this.destroyInfo();
+       }
    }
    // We allocate a new function instance every time the completion
    // changes to force redrawing/repositioning of the tooltip
-   function completionTooltip(stateField) {
-       return (view) => new CompletionTooltip(view, stateField);
+   function completionTooltip(stateField, applyCompletion) {
+       return (view) => new CompletionTooltip(view, stateField, applyCompletion);
    }
    function scrollIntoView(container, element) {
        let parent = container.getBoundingClientRect();
@@ -20659,35 +20973,59 @@
            (option.type ? 1 : 0);
    }
    function sortOptions(active, state) {
-       let options = [], i = 0;
+       let options = [];
+       let sections = null;
+       let addOption = (option) => {
+           options.push(option);
+           let { section } = option.completion;
+           if (section) {
+               if (!sections)
+                   sections = [];
+               let name = typeof section == "string" ? section : section.name;
+               if (!sections.some(s => s.name == name))
+                   sections.push(typeof section == "string" ? { name } : section);
+           }
+       };
        for (let a of active)
            if (a.hasResult()) {
                if (a.result.filter === false) {
                    let getMatch = a.result.getMatch;
                    for (let option of a.result.options) {
-                       let match = [1e9 - i++];
+                       let match = [1e9 - options.length];
                        if (getMatch)
                            for (let n of getMatch(option))
                                match.push(n);
-                       options.push(new Option(option, a, match));
+                       addOption(new Option(option, a.source, match, match[0]));
                    }
                }
                else {
                    let matcher = new FuzzyMatcher(state.sliceDoc(a.from, a.to)), match;
                    for (let option of a.result.options)
                        if (match = matcher.match(option.label)) {
-                           if (option.boost != null)
-                               match[0] += option.boost;
-                           options.push(new Option(option, a, match));
+                           addOption(new Option(option, a.source, match, match[0] + (option.boost || 0)));
                        }
                }
            }
+       if (sections) {
+           let sectionOrder = Object.create(null), pos = 0;
+           let cmp = (a, b) => { var _a, _b; return ((_a = a.rank) !== null && _a !== void 0 ? _a : 1e9) - ((_b = b.rank) !== null && _b !== void 0 ? _b : 1e9) || (a.name < b.name ? -1 : 1); };
+           for (let s of sections.sort(cmp)) {
+               pos -= 1e5;
+               sectionOrder[s.name] = pos;
+           }
+           for (let option of options) {
+               let { section } = option.completion;
+               if (section)
+                   option.score += sectionOrder[typeof section == "string" ? section : section.name];
+           }
+       }
        let result = [], prev = null;
        let compare = state.facet(completionConfig).compareCompletions;
-       for (let opt of options.sort((a, b) => (b.match[0] - a.match[0]) || compare(a.completion, b.completion))) {
-           if (!prev || prev.label != opt.completion.label || prev.detail != opt.completion.detail ||
-               (prev.type != null && opt.completion.type != null && prev.type != opt.completion.type) ||
-               prev.apply != opt.completion.apply)
+       for (let opt of options.sort((a, b) => (b.score - a.score) || compare(a.completion, b.completion))) {
+           let cur = opt.completion;
+           if (!prev || prev.label != cur.label || prev.detail != cur.detail ||
+               (prev.type != null && cur.type != null && prev.type != cur.type) ||
+               prev.apply != cur.apply || prev.boost != cur.boost)
                result.push(opt);
            else if (score(opt.completion) > score(prev))
                result[result.length - 1] = opt;
@@ -20711,7 +21049,7 @@
        static build(active, state, id, prev, conf) {
            let options = sortOptions(active, state);
            if (!options.length) {
-               return prev && active.some(a => a.state == 1 /* State.Pending */) ?
+               return prev && active.some(a => a.state == 1 /* Pending */) ?
                    new CompletionDialog(prev.options, prev.attrs, prev.tooltip, prev.timestamp, prev.selected, true) : null;
            }
            let selected = state.facet(completionConfig).selectOnOpen ? 0 : -1;
@@ -20725,7 +21063,7 @@
            }
            return new CompletionDialog(options, makeAttrs(id, selected), {
                pos: active.reduce((a, b) => b.hasResult() ? Math.min(a, b.from) : a, 1e8),
-               create: completionTooltip(completionState),
+               create: completionTooltip(completionState, applyCompletion),
                above: conf.aboveCursor,
            }, prev ? prev.timestamp : Date.now(), selected, false);
        }
@@ -20748,7 +21086,7 @@
                state.languageDataAt("autocomplete", cur(state)).map(asSource);
            let active = sources.map(source => {
                let value = this.active.find(s => s.source == source) ||
-                   new ActiveSource(source, this.active.some(a => a.state != 0 /* State.Inactive */) ? 1 /* State.Pending */ : 0 /* State.Inactive */);
+                   new ActiveSource(source, this.active.some(a => a.state != 0 /* Inactive */) ? 1 /* Pending */ : 0 /* Inactive */);
                return value.update(tr, conf);
            });
            if (active.length == this.active.length && active.every((a, i) => a == this.active[i]))
@@ -20759,10 +21097,10 @@
            if (tr.selection || active.some(a => a.hasResult() && tr.changes.touchesRange(a.from, a.to)) ||
                !sameResults(active, this.active))
                open = CompletionDialog.build(active, state, this.id, open, conf);
-           else if (open && open.disabled && !active.some(a => a.state == 1 /* State.Pending */))
+           else if (open && open.disabled && !active.some(a => a.state == 1 /* Pending */))
                open = null;
-           if (!open && active.every(a => a.state != 1 /* State.Pending */) && active.some(a => a.hasResult()))
-               active = active.map(a => a.hasResult() ? new ActiveSource(a.source, 0 /* State.Inactive */) : a);
+           if (!open && active.every(a => a.state != 1 /* Pending */) && active.some(a => a.hasResult()))
+               active = active.map(a => a.hasResult() ? new ActiveSource(a.source, 0 /* Inactive */) : a);
            for (let effect of tr.effects)
                if (effect.is(setSelectedEffect))
                    open = open && open.setSelected(effect.value, this.id);
@@ -20816,13 +21154,13 @@
                value = value.handleUserEvent(tr, event, conf);
            else if (tr.docChanged)
                value = value.handleChange(tr);
-           else if (tr.selection && value.state != 0 /* State.Inactive */)
-               value = new ActiveSource(value.source, 0 /* State.Inactive */);
+           else if (tr.selection && value.state != 0 /* Inactive */)
+               value = new ActiveSource(value.source, 0 /* Inactive */);
            for (let effect of tr.effects) {
                if (effect.is(startCompletionEffect))
-                   value = new ActiveSource(value.source, 1 /* State.Pending */, effect.value ? cur(tr.state) : -1);
+                   value = new ActiveSource(value.source, 1 /* Pending */, effect.value ? cur(tr.state) : -1);
                else if (effect.is(closeCompletionEffect))
-                   value = new ActiveSource(value.source, 0 /* State.Inactive */);
+                   value = new ActiveSource(value.source, 0 /* Inactive */);
                else if (effect.is(setActiveEffect))
                    for (let active of effect.value)
                        if (active.source == value.source)
@@ -20831,10 +21169,10 @@
            return value;
        }
        handleUserEvent(tr, type, conf) {
-           return type == "delete" || !conf.activateOnTyping ? this.map(tr.changes) : new ActiveSource(this.source, 1 /* State.Pending */);
+           return type == "delete" || !conf.activateOnTyping ? this.map(tr.changes) : new ActiveSource(this.source, 1 /* Pending */);
        }
        handleChange(tr) {
-           return tr.changes.touchesRange(cur(tr.startState)) ? new ActiveSource(this.source, 0 /* State.Inactive */) : this.map(tr.changes);
+           return tr.changes.touchesRange(cur(tr.startState)) ? new ActiveSource(this.source, 0 /* Inactive */) : this.map(tr.changes);
        }
        map(changes) {
            return changes.empty || this.explicitPos < 0 ? this : new ActiveSource(this.source, this.state, changes.mapPos(this.explicitPos));
@@ -20842,7 +21180,7 @@
    }
    class ActiveResult extends ActiveSource {
        constructor(source, explicitPos, result, from, to) {
-           super(source, 2 /* State.Result */, explicitPos);
+           super(source, 2 /* Result */, explicitPos);
            this.result = result;
            this.from = from;
            this.to = to;
@@ -20855,17 +21193,17 @@
            if ((this.explicitPos < 0 ? pos <= from : pos < this.from) ||
                pos > to ||
                type == "delete" && cur(tr.startState) == this.from)
-               return new ActiveSource(this.source, type == "input" && conf.activateOnTyping ? 1 /* State.Pending */ : 0 /* State.Inactive */);
+               return new ActiveSource(this.source, type == "input" && conf.activateOnTyping ? 1 /* Pending */ : 0 /* Inactive */);
            let explicitPos = this.explicitPos < 0 ? -1 : tr.changes.mapPos(this.explicitPos), updated;
            if (checkValid(this.result.validFor, tr.state, from, to))
                return new ActiveResult(this.source, explicitPos, this.result, from, to);
            if (this.result.update &&
                (updated = this.result.update(this.result, from, to, new CompletionContext(tr.state, pos, explicitPos >= 0))))
                return new ActiveResult(this.source, explicitPos, updated, updated.from, (_a = updated.to) !== null && _a !== void 0 ? _a : cur(tr.state));
-           return new ActiveSource(this.source, 1 /* State.Pending */, explicitPos);
+           return new ActiveSource(this.source, 1 /* Pending */, explicitPos);
        }
        handleChange(tr) {
-           return tr.changes.touchesRange(this.from, this.to) ? new ActiveSource(this.source, 0 /* State.Inactive */) : this.map(tr.changes);
+           return tr.changes.touchesRange(this.from, this.to) ? new ActiveSource(this.source, 0 /* Inactive */) : this.map(tr.changes);
        }
        map(mapping) {
            return mapping.empty ? this :
@@ -20878,8 +21216,6 @@
        let text = state.sliceDoc(from, to);
        return typeof validFor == "function" ? validFor(text, from, to, state) : ensureAnchor(validFor, true).test(text);
    }
-   const startCompletionEffect = /*@__PURE__*/StateEffect.define();
-   const closeCompletionEffect = /*@__PURE__*/StateEffect.define();
    const setActiveEffect = /*@__PURE__*/StateEffect.define({
        map(sources, mapping) { return sources.map(s => s.map(mapping)); }
    });
@@ -20892,6 +21228,17 @@
            EditorView.contentAttributes.from(f, state => state.attrs)
        ]
    });
+   function applyCompletion(view, option) {
+       const apply = option.completion.apply || option.completion.label;
+       let result = view.state.field(completionState).active.find(a => a.source == option.source);
+       if (!(result instanceof ActiveResult))
+           return false;
+       if (typeof apply == "string")
+           view.dispatch(Object.assign(Object.assign({}, insertCompletionText(view.state, apply, result.from, result.to)), { annotations: pickedCompletion.of(option.completion) }));
+       else
+           apply(view, option.completion, result.from, result.to);
+       return true;
+   }
 
    /**
    Returns a command that moves the completion selection forward or
@@ -20922,12 +21269,10 @@
    */
    const acceptCompletion = (view) => {
        let cState = view.state.field(completionState, false);
-       if (view.state.readOnly || !cState || !cState.open || cState.open.selected < 0 ||
+       if (view.state.readOnly || !cState || !cState.open || cState.open.selected < 0 || cState.open.disabled ||
            Date.now() - cState.open.timestamp < view.state.facet(completionConfig).interactionDelay)
            return false;
-       if (!cState.open.disabled)
-           applyCompletion(view, cState.open.options[cState.open.selected]);
-       return true;
+       return applyCompletion(view, cState.open.options[cState.open.selected]);
    };
    /**
    Explicitly start autocompletion.
@@ -20944,7 +21289,7 @@
    */
    const closeCompletion = (view) => {
        let cState = view.state.field(completionState, false);
-       if (!cState || !cState.active.some(a => a.state != 0 /* State.Inactive */))
+       if (!cState || !cState.active.some(a => a.state != 0 /* Inactive */))
            return false;
        view.dispatch({ effects: closeCompletionEffect.of(null) });
        return true;
@@ -20967,9 +21312,9 @@
            this.debounceUpdate = -1;
            this.running = [];
            this.debounceAccept = -1;
-           this.composing = 0 /* CompositionState.None */;
+           this.composing = 0 /* None */;
            for (let active of view.state.field(completionState).active)
-               if (active.state == 1 /* State.Pending */)
+               if (active.state == 1 /* Pending */)
                    this.startQuery(active);
        }
        update(update) {
@@ -21000,21 +21345,21 @@
            }
            if (this.debounceUpdate > -1)
                clearTimeout(this.debounceUpdate);
-           this.debounceUpdate = cState.active.some(a => a.state == 1 /* State.Pending */ && !this.running.some(q => q.active.source == a.source))
+           this.debounceUpdate = cState.active.some(a => a.state == 1 /* Pending */ && !this.running.some(q => q.active.source == a.source))
                ? setTimeout(() => this.startUpdate(), DebounceTime) : -1;
-           if (this.composing != 0 /* CompositionState.None */)
+           if (this.composing != 0 /* None */)
                for (let tr of update.transactions) {
                    if (getUserEvent(tr) == "input")
-                       this.composing = 2 /* CompositionState.Changed */;
-                   else if (this.composing == 2 /* CompositionState.Changed */ && tr.selection)
-                       this.composing = 3 /* CompositionState.ChangedAndMoved */;
+                       this.composing = 2 /* Changed */;
+                   else if (this.composing == 2 /* Changed */ && tr.selection)
+                       this.composing = 3 /* ChangedAndMoved */;
                }
        }
        startUpdate() {
            this.debounceUpdate = -1;
            let { state } = this.view, cState = state.field(completionState);
            for (let active of cState.active) {
-               if (active.state == 1 /* State.Pending */ && !this.running.some(r => r.active.source == active.source))
+               if (active.state == 1 /* Pending */ && !this.running.some(r => r.active.source == active.source))
                    this.startQuery(active);
            }
        }
@@ -21065,14 +21410,14 @@
                    }
                }
                let current = this.view.state.field(completionState).active.find(a => a.source == query.active.source);
-               if (current && current.state == 1 /* State.Pending */) {
+               if (current && current.state == 1 /* Pending */) {
                    if (query.done == null) {
                        // Explicitly failed. Should clear the pending status if it
                        // hasn't been re-set in the meantime.
-                       let active = new ActiveSource(query.active.source, 0 /* State.Inactive */);
+                       let active = new ActiveSource(query.active.source, 0 /* Inactive */);
                        for (let tr of query.updates)
                            active = active.update(tr, conf);
-                       if (active.state != 1 /* State.Pending */)
+                       if (active.state != 1 /* Pending */)
                            updated.push(active);
                    }
                    else {
@@ -21086,21 +21431,24 @@
        }
    }, {
        eventHandlers: {
-           blur() {
+           blur(event) {
                let state = this.view.state.field(completionState, false);
-               if (state && state.tooltip && this.view.state.facet(completionConfig).closeOnBlur)
-                   this.view.dispatch({ effects: closeCompletionEffect.of(null) });
+               if (state && state.tooltip && this.view.state.facet(completionConfig).closeOnBlur) {
+                   let dialog = state.open && getTooltip(this.view, state.open.tooltip);
+                   if (!dialog || !dialog.dom.contains(event.relatedTarget))
+                       this.view.dispatch({ effects: closeCompletionEffect.of(null) });
+               }
            },
            compositionstart() {
-               this.composing = 1 /* CompositionState.Started */;
+               this.composing = 1 /* Started */;
            },
            compositionend() {
-               if (this.composing == 3 /* CompositionState.ChangedAndMoved */) {
+               if (this.composing == 3 /* ChangedAndMoved */) {
                    // Safari fires compositionend events synchronously, possibly
                    // from inside an update, so dispatch asynchronously to avoid reentrancy
                    setTimeout(() => this.view.dispatch({ effects: startCompletionEffect.of(false) }), 20);
                }
-               this.composing = 0 /* CompositionState.None */;
+               this.composing = 0 /* None */;
            }
        }
    });
@@ -21119,13 +21467,21 @@
                listStyle: "none",
                margin: 0,
                padding: 0,
+               "& > li, & > completion-section": {
+                   padding: "1px 3px",
+                   lineHeight: 1.2
+               },
                "& > li": {
                    overflowX: "hidden",
                    textOverflow: "ellipsis",
-                   cursor: "pointer",
-                   padding: "1px 3px",
-                   lineHeight: 1.2
+                   cursor: "pointer"
                },
+               "& > completion-section": {
+                   display: "list-item",
+                   borderBottom: "1px solid silver",
+                   paddingLeft: "0.5em",
+                   opacity: 0.7
+               }
            }
        },
        "&light .cm-tooltip-autocomplete ul li[aria-selected]": {
@@ -21152,13 +21508,13 @@
            position: "absolute",
            padding: "3px 9px",
            width: "max-content",
-           maxWidth: `${400 /* Info.Width */}px`,
+           maxWidth: `${400 /* Width */}px`,
            boxSizing: "border-box"
        },
        ".cm-completionInfo.cm-completionInfo-left": { right: "100%" },
        ".cm-completionInfo.cm-completionInfo-right": { left: "100%" },
-       ".cm-completionInfo.cm-completionInfo-left-narrow": { right: `${30 /* Info.Margin */}px` },
-       ".cm-completionInfo.cm-completionInfo-right-narrow": { left: `${30 /* Info.Margin */}px` },
+       ".cm-completionInfo.cm-completionInfo-left-narrow": { right: `${30 /* Margin */}px` },
+       ".cm-completionInfo.cm-completionInfo-right-narrow": { left: `${30 /* Margin */}px` },
        "&light .cm-snippetField": { backgroundColor: "#00000022" },
        "&dark .cm-snippetField": { backgroundColor: "#ffffff22" },
        ".cm-snippetFieldPosition": {
@@ -21231,9 +21587,6 @@
            return mapped == null ? undefined : mapped;
        }
    });
-   const skipBracketEffect = /*@__PURE__*/StateEffect.define({
-       map(value, mapping) { return mapping.mapPos(value); }
-   });
    const closedBracket = /*@__PURE__*/new class extends RangeValue {
    };
    closedBracket.startSide = 1;
@@ -21248,12 +21601,9 @@
                    value = RangeSet.empty;
            }
            value = value.map(tr.changes);
-           for (let effect of tr.effects) {
+           for (let effect of tr.effects)
                if (effect.is(closeBracketEffect))
                    value = value.update({ add: [closedBracket.range(effect.value, effect.value + 1)] });
-               else if (effect.is(skipBracketEffect))
-                   value = value.update({ filter: from => from != effect.value });
-           }
            return value;
        }
    });
@@ -21381,15 +21731,15 @@
        });
    }
    function handleClose(state, _open, close) {
-       let dont = null, moved = state.selection.ranges.map(range => {
+       let dont = null, changes = state.changeByRange(range => {
            if (range.empty && nextChar(state.doc, range.head) == close)
-               return EditorSelection.cursor(range.head + close.length);
-           return dont = range;
+               return { changes: { from: range.head, to: range.head + close.length, insert: close },
+                   range: EditorSelection.cursor(range.head + close.length) };
+           return dont = { range };
        });
-       return dont ? null : state.update({
-           selection: EditorSelection.create(moved, state.selection.mainIndex),
+       return dont ? null : state.update(changes, {
            scrollIntoView: true,
-           effects: state.selection.ranges.map(({ from }) => skipBracketEffect.of(from))
+           userEvent: "input.type"
        });
    }
    // Handles cases where the open and close token are the same, and
@@ -21410,8 +21760,9 @@
                }
                else if (closedBracketAt(state, pos)) {
                    let isTriple = allowTriple && state.sliceDoc(pos, pos + token.length * 3) == token + token + token;
-                   return { range: EditorSelection.cursor(pos + token.length * (isTriple ? 3 : 1)),
-                       effects: skipBracketEffect.of(pos) };
+                   let content = isTriple ? token + token + token : token;
+                   return { changes: { from: pos, to: pos + content.length, insert: content },
+                       range: EditorSelection.cursor(pos + content.length) };
                }
            }
            else if (allowTriple && state.sliceDoc(pos - 2 * token.length, pos) == token + token &&
@@ -21869,22 +22220,54 @@
        // be done.
        /// @internal
        forceReduce() {
-           let reduce = this.p.parser.stateSlot(this.state, 5 /* ParseState.ForcedReduce */);
+           let { parser } = this.p;
+           let reduce = parser.stateSlot(this.state, 5 /* ParseState.ForcedReduce */);
            if ((reduce & 65536 /* Action.ReduceFlag */) == 0)
                return false;
-           let { parser } = this.p;
            if (!parser.validAction(this.state, reduce)) {
                let depth = reduce >> 19 /* Action.ReduceDepthShift */, term = reduce & 65535 /* Action.ValueMask */;
                let target = this.stack.length - depth * 3;
-               if (target < 0 || parser.getGoto(this.stack[target], term, false) < 0)
-                   return false;
-               this.storeNode(0 /* Term.Err */, this.reducePos, this.reducePos, 4, true);
+               if (target < 0 || parser.getGoto(this.stack[target], term, false) < 0) {
+                   let backup = this.findForcedReduction();
+                   if (backup == null)
+                       return false;
+                   reduce = backup;
+               }
+               this.storeNode(0 /* Term.Err */, this.pos, this.pos, 4, true);
                this.score -= 100 /* Recover.Reduce */;
            }
            this.reducePos = this.pos;
            this.reduce(reduce);
            return true;
        }
+       /// Try to scan through the automaton to find some kind of reduction
+       /// that can be applied. Used when the regular ForcedReduce field
+       /// isn't a valid action. @internal
+       findForcedReduction() {
+           let { parser } = this.p, seen = [];
+           let explore = (state, depth) => {
+               if (seen.includes(state))
+                   return;
+               seen.push(state);
+               return parser.allActions(state, (action) => {
+                   if (action & (262144 /* Action.StayFlag */ | 131072 /* Action.GotoFlag */)) ;
+                   else if (action & 65536 /* Action.ReduceFlag */) {
+                       let rDepth = (action >> 19 /* Action.ReduceDepthShift */) - depth;
+                       if (rDepth > 1) {
+                           let term = action & 65535 /* Action.ValueMask */, target = this.stack.length - rDepth * 3;
+                           if (target >= 0 && parser.getGoto(this.stack[target], term, false) >= 0)
+                               return (rDepth << 19 /* Action.ReduceDepthShift */) | 65536 /* Action.ReduceFlag */ | term;
+                       }
+                   }
+                   else {
+                       let found = explore(action, depth + 1);
+                       if (found != null)
+                           return found;
+                   }
+               });
+           };
+           return explore(this.state, 0);
+       }
        /// @internal
        forceAll() {
            while (!this.p.parser.stateFlag(this.state, 2 /* StateFlag.Accepting */)) {
@@ -21938,13 +22321,13 @@
        emitContext() {
            let last = this.buffer.length - 1;
            if (last < 0 || this.buffer[last] != -3)
-               this.buffer.push(this.curContext.hash, this.reducePos, this.reducePos, -3);
+               this.buffer.push(this.curContext.hash, this.pos, this.pos, -3);
        }
        /// @internal
        emitLookAhead() {
            let last = this.buffer.length - 1;
            if (last < 0 || this.buffer[last] != -4)
-               this.buffer.push(this.lookAhead, this.reducePos, this.reducePos, -4);
+               this.buffer.push(this.lookAhead, this.pos, this.pos, -4);
        }
        updateContext(context) {
            if (context != this.curContext.context) {
@@ -23060,18 +23443,22 @@
        }
        /// @internal
        validAction(state, action) {
-           if (action == this.stateSlot(state, 4 /* ParseState.DefaultReduce */))
-               return true;
-           for (let i = this.stateSlot(state, 1 /* ParseState.Actions */);; i += 3) {
+           return !!this.allActions(state, a => a == action ? true : null);
+       }
+       /// @internal
+       allActions(state, action) {
+           let deflt = this.stateSlot(state, 4 /* ParseState.DefaultReduce */);
+           let result = deflt ? action(deflt) : undefined;
+           for (let i = this.stateSlot(state, 1 /* ParseState.Actions */); result == null; i += 3) {
                if (this.data[i] == 65535 /* Seq.End */) {
                    if (this.data[i + 1] == 1 /* Seq.Next */)
                        i = pair(this.data, i + 2);
                    else
-                       return false;
+                       break;
                }
-               if (action == pair(this.data, i + 1))
-                   return true;
+               result = action(pair(this.data, i + 1));
            }
+           return result;
        }
        /// Get the states that can follow this one through shift actions or
        /// goto jumps. @internal
@@ -23228,10 +23615,10 @@
      Builtin = 24;
 
    function isAlpha(ch) {
-       return ch >= 65 /* Ch.A */ && ch <= 90 /* Ch.Z */ || ch >= 97 /* Ch.a */ && ch <= 122 /* Ch.z */ || ch >= 48 /* Ch._0 */ && ch <= 57 /* Ch._9 */;
+       return ch >= 65 /* A */ && ch <= 90 /* Z */ || ch >= 97 /* a */ && ch <= 122 /* z */ || ch >= 48 /* _0 */ && ch <= 57 /* _9 */;
    }
    function isHexDigit(ch) {
-       return ch >= 48 /* Ch._0 */ && ch <= 57 /* Ch._9 */ || ch >= 97 /* Ch.a */ && ch <= 102 /* Ch.f */ || ch >= 65 /* Ch.A */ && ch <= 70 /* Ch.F */;
+       return ch >= 48 /* _0 */ && ch <= 57 /* _9 */ || ch >= 97 /* a */ && ch <= 102 /* f */ || ch >= 65 /* A */ && ch <= 70 /* F */;
    }
    function readLiteral(input, endQuote, backslashEscapes) {
        for (let escaped = false;;) {
@@ -23241,7 +23628,7 @@
                input.advance();
                return;
            }
-           escaped = backslashEscapes && !escaped && input.next == 92 /* Ch.Backslash */;
+           escaped = backslashEscapes && !escaped && input.next == 92 /* Backslash */;
            input.advance();
        }
    }
@@ -23249,7 +23636,7 @@
        for (;;) {
            if (input.next < 0 || input.peek(1) < 0)
                return;
-           if (input.next == 36 /* Ch.Dollar */ && input.peek(1) == 36 /* Ch.Dollar */) {
+           if (input.next == 36 /* Dollar */ && input.peek(1) == 36 /* Dollar */) {
                input.advance(2);
                return;
            }
@@ -23258,7 +23645,7 @@
    }
    function readWord(input, result) {
        for (;;) {
-           if (input.next != 95 /* Ch.Underscore */ && !isAlpha(input.next))
+           if (input.next != 95 /* Underscore */ && !isAlpha(input.next))
                break;
            if (result != null)
                result += String.fromCharCode(input.next);
@@ -23267,7 +23654,7 @@
        return result;
    }
    function readWordOrQuoted(input) {
-       if (input.next == 39 /* Ch.SingleQuote */ || input.next == 34 /* Ch.DoubleQuote */ || input.next == 96 /* Ch.Backtick */) {
+       if (input.next == 39 /* SingleQuote */ || input.next == 34 /* DoubleQuote */ || input.next == 96 /* Backtick */) {
            let quote = input.next;
            input.advance();
            readLiteral(input, quote, false);
@@ -23277,33 +23664,33 @@
        }
    }
    function readBits(input, endQuote) {
-       while (input.next == 48 /* Ch._0 */ || input.next == 49 /* Ch._1 */)
+       while (input.next == 48 /* _0 */ || input.next == 49 /* _1 */)
            input.advance();
        if (endQuote && input.next == endQuote)
            input.advance();
    }
    function readNumber(input, sawDot) {
        for (;;) {
-           if (input.next == 46 /* Ch.Dot */) {
+           if (input.next == 46 /* Dot */) {
                if (sawDot)
                    break;
                sawDot = true;
            }
-           else if (input.next < 48 /* Ch._0 */ || input.next > 57 /* Ch._9 */) {
+           else if (input.next < 48 /* _0 */ || input.next > 57 /* _9 */) {
                break;
            }
            input.advance();
        }
-       if (input.next == 69 /* Ch.E */ || input.next == 101 /* Ch.e */) {
+       if (input.next == 69 /* E */ || input.next == 101 /* e */) {
            input.advance();
-           if (input.next == 43 /* Ch.Plus */ || input.next == 45 /* Ch.Dash */)
+           if (input.next == 43 /* Plus */ || input.next == 45 /* Dash */)
                input.advance();
-           while (input.next >= 48 /* Ch._0 */ && input.next <= 57 /* Ch._9 */)
+           while (input.next >= 48 /* _0 */ && input.next <= 57 /* _9 */)
                input.advance();
        }
    }
    function eol(input) {
-       while (!(input.next < 0 || input.next == 10 /* Ch.Newline */))
+       while (!(input.next < 0 || input.next == 10 /* Newline */))
            input.advance();
    }
    function inString(ch, str) {
@@ -23363,63 +23750,59 @@
                    input.advance();
                input.acceptToken(whitespace);
            }
-           else if (next == 36 /* Ch.Dollar */ && input.next == 36 /* Ch.Dollar */ && d.doubleDollarQuotedStrings) {
+           else if (next == 36 /* Dollar */ && input.next == 36 /* Dollar */ && d.doubleDollarQuotedStrings) {
                readDoubleDollarLiteral(input);
                input.acceptToken(String$1);
            }
-           else if (next == 39 /* Ch.SingleQuote */ || next == 34 /* Ch.DoubleQuote */ && d.doubleQuotedStrings) {
+           else if (next == 39 /* SingleQuote */ || next == 34 /* DoubleQuote */ && d.doubleQuotedStrings) {
                readLiteral(input, next, d.backslashEscapes);
                input.acceptToken(String$1);
            }
-           else if (next == 35 /* Ch.Hash */ && d.hashComments ||
-               next == 47 /* Ch.Slash */ && input.next == 47 /* Ch.Slash */ && d.slashComments) {
+           else if (next == 35 /* Hash */ && d.hashComments ||
+               next == 47 /* Slash */ && input.next == 47 /* Slash */ && d.slashComments) {
                eol(input);
                input.acceptToken(LineComment);
            }
-           else if (next == 45 /* Ch.Dash */ && input.next == 45 /* Ch.Dash */ &&
-               (!d.spaceAfterDashes || input.peek(1) == 32 /* Ch.Space */)) {
+           else if (next == 45 /* Dash */ && input.next == 45 /* Dash */ &&
+               (!d.spaceAfterDashes || input.peek(1) == 32 /* Space */)) {
                eol(input);
                input.acceptToken(LineComment);
            }
-           else if (next == 47 /* Ch.Slash */ && input.next == 42 /* Ch.Star */) {
+           else if (next == 47 /* Slash */ && input.next == 42 /* Star */) {
                input.advance();
-               for (let prev = -1, depth = 1;;) {
+               for (let depth = 1;;) {
+                   let cur = input.next;
                    if (input.next < 0)
                        break;
                    input.advance();
-                   if (prev == 42 /* Ch.Star */ && input.next == 47 /* Ch.Slash */) {
+                   if (cur == 42 /* Star */ && input.next == 47 /* Slash */) {
                        depth--;
-                       if (!depth) {
-                           input.advance();
+                       input.advance();
+                       if (!depth)
                            break;
-                       }
-                       prev = -1;
                    }
-                   else if (prev == 47 /* Ch.Slash */ && input.next == 42 /* Ch.Star */) {
+                   else if (cur == 47 /* Slash */ && input.next == 42 /* Star */) {
                        depth++;
-                       prev = -1;
-                   }
-                   else {
-                       prev = input.next;
+                       input.advance();
                    }
                }
                input.acceptToken(BlockComment);
            }
-           else if ((next == 101 /* Ch.e */ || next == 69 /* Ch.E */) && input.next == 39 /* Ch.SingleQuote */) {
+           else if ((next == 101 /* e */ || next == 69 /* E */) && input.next == 39 /* SingleQuote */) {
                input.advance();
-               readLiteral(input, 39 /* Ch.SingleQuote */, true);
+               readLiteral(input, 39 /* SingleQuote */, true);
            }
-           else if ((next == 110 /* Ch.n */ || next == 78 /* Ch.N */) && input.next == 39 /* Ch.SingleQuote */ &&
+           else if ((next == 110 /* n */ || next == 78 /* N */) && input.next == 39 /* SingleQuote */ &&
                d.charSetCasts) {
                input.advance();
-               readLiteral(input, 39 /* Ch.SingleQuote */, d.backslashEscapes);
+               readLiteral(input, 39 /* SingleQuote */, d.backslashEscapes);
                input.acceptToken(String$1);
            }
-           else if (next == 95 /* Ch.Underscore */ && d.charSetCasts) {
+           else if (next == 95 /* Underscore */ && d.charSetCasts) {
                for (let i = 0;; i++) {
-                   if (input.next == 39 /* Ch.SingleQuote */ && i > 1) {
+                   if (input.next == 39 /* SingleQuote */ && i > 1) {
                        input.advance();
-                       readLiteral(input, 39 /* Ch.SingleQuote */, d.backslashEscapes);
+                       readLiteral(input, 39 /* SingleQuote */, d.backslashEscapes);
                        input.acceptToken(String$1);
                        break;
                    }
@@ -23428,33 +23811,33 @@
                    input.advance();
                }
            }
-           else if (next == 40 /* Ch.ParenL */) {
+           else if (next == 40 /* ParenL */) {
                input.acceptToken(ParenL);
            }
-           else if (next == 41 /* Ch.ParenR */) {
+           else if (next == 41 /* ParenR */) {
                input.acceptToken(ParenR);
            }
-           else if (next == 123 /* Ch.BraceL */) {
+           else if (next == 123 /* BraceL */) {
                input.acceptToken(BraceL);
            }
-           else if (next == 125 /* Ch.BraceR */) {
+           else if (next == 125 /* BraceR */) {
                input.acceptToken(BraceR);
            }
-           else if (next == 91 /* Ch.BracketL */) {
+           else if (next == 91 /* BracketL */) {
                input.acceptToken(BracketL);
            }
-           else if (next == 93 /* Ch.BracketR */) {
+           else if (next == 93 /* BracketR */) {
                input.acceptToken(BracketR);
            }
-           else if (next == 59 /* Ch.Semi */) {
+           else if (next == 59 /* Semi */) {
                input.acceptToken(Semi);
            }
-           else if (d.unquotedBitLiterals && next == 48 /* Ch._0 */ && input.next == 98 /* Ch.b */) {
+           else if (d.unquotedBitLiterals && next == 48 /* _0 */ && input.next == 98 /* b */) {
                input.advance();
                readBits(input);
                input.acceptToken(Bits);
            }
-           else if ((next == 98 /* Ch.b */ || next == 66 /* Ch.B */) && (input.next == 39 /* Ch.SingleQuote */ || input.next == 34 /* Ch.DoubleQuote */)) {
+           else if ((next == 98 /* b */ || next == 66 /* B */) && (input.next == 39 /* SingleQuote */ || input.next == 34 /* DoubleQuote */)) {
                const quoteStyle = input.next;
                input.advance();
                if (d.treatBitsAsBytes) {
@@ -23466,24 +23849,24 @@
                    input.acceptToken(Bits);
                }
            }
-           else if (next == 48 /* Ch._0 */ && (input.next == 120 /* Ch.x */ || input.next == 88 /* Ch.X */) ||
-               (next == 120 /* Ch.x */ || next == 88 /* Ch.X */) && input.next == 39 /* Ch.SingleQuote */) {
-               let quoted = input.next == 39 /* Ch.SingleQuote */;
+           else if (next == 48 /* _0 */ && (input.next == 120 /* x */ || input.next == 88 /* X */) ||
+               (next == 120 /* x */ || next == 88 /* X */) && input.next == 39 /* SingleQuote */) {
+               let quoted = input.next == 39 /* SingleQuote */;
                input.advance();
                while (isHexDigit(input.next))
                    input.advance();
-               if (quoted && input.next == 39 /* Ch.SingleQuote */)
+               if (quoted && input.next == 39 /* SingleQuote */)
                    input.advance();
                input.acceptToken(Number$1);
            }
-           else if (next == 46 /* Ch.Dot */ && input.next >= 48 /* Ch._0 */ && input.next <= 57 /* Ch._9 */) {
+           else if (next == 46 /* Dot */ && input.next >= 48 /* _0 */ && input.next <= 57 /* _9 */) {
                readNumber(input, true);
                input.acceptToken(Number$1);
            }
-           else if (next == 46 /* Ch.Dot */) {
+           else if (next == 46 /* Dot */) {
                input.acceptToken(Dot);
            }
-           else if (next >= 48 /* Ch._0 */ && next <= 57 /* Ch._9 */) {
+           else if (next >= 48 /* _0 */ && next <= 57 /* _9 */) {
                readNumber(input, false);
                input.acceptToken(Number$1);
            }
@@ -23502,12 +23885,12 @@
                readLiteral(input, next, false);
                input.acceptToken(QuotedIdentifier);
            }
-           else if (next == 58 /* Ch.Colon */ || next == 44 /* Ch.Comma */) {
+           else if (next == 58 /* Colon */ || next == 44 /* Comma */) {
                input.acceptToken(Punctuation);
            }
            else if (isAlpha(next)) {
                let word = readWord(input, String.fromCharCode(next));
-               input.acceptToken(input.next == 46 /* Ch.Dot */ ? Identifier : (_a = d.words[word.toLowerCase()]) !== null && _a !== void 0 ? _a : Identifier);
+               input.acceptToken(input.next == 46 /* Dot */ ? Identifier : (_a = d.words[word.toLowerCase()]) !== null && _a !== void 0 ? _a : Identifier);
            }
        });
    }
@@ -23625,31 +24008,50 @@
            this.list = [];
            this.children = undefined;
        }
-       child(name) {
+       child(name, idQuote) {
            let children = this.children || (this.children = Object.create(null));
-           return children[name] || (children[name] = new CompletionLevel);
+           let found = children[name];
+           if (found)
+               return found;
+           if (name)
+               this.list.push(nameCompletion(name, "type", idQuote));
+           return (children[name] = new CompletionLevel);
        }
-       childCompletions(type) {
-           return this.children ? Object.keys(this.children).filter(x => x).map(name => ({ label: name, type })) : [];
+       addCompletions(list) {
+           for (let option of list) {
+               let found = this.list.findIndex(o => o.label == option.label);
+               if (found > -1)
+                   this.list[found] = option;
+               else
+                   this.list.push(option);
+           }
        }
    }
-   function completeFromSchema(schema, tables, schemas, defaultTableName, defaultSchemaName) {
+   function nameCompletion(label, type, idQuote) {
+       if (!/[^\w\xb5-\uffff]/.test(label))
+           return { label, type };
+       return { label, type, apply: idQuote + label + idQuote };
+   }
+   function completeFromSchema(schema, tables, schemas, defaultTableName, defaultSchemaName, dialect) {
+       var _a;
        let top = new CompletionLevel;
-       let defaultSchema = top.child(defaultSchemaName || "");
+       let idQuote = ((_a = dialect === null || dialect === void 0 ? void 0 : dialect.spec.identifierQuotes) === null || _a === void 0 ? void 0 : _a[0]) || '"';
+       let defaultSchema = top.child(defaultSchemaName || "", idQuote);
        for (let table in schema) {
-           let dot = table.indexOf(".");
-           let schemaCompletions = dot > -1 ? top.child(table.slice(0, dot)) : defaultSchema;
-           let tableCompletions = schemaCompletions.child(dot > -1 ? table.slice(dot + 1) : table);
-           tableCompletions.list = schema[table].map(val => typeof val == "string" ? { label: val, type: "property" } : val);
-       }
-       defaultSchema.list = (tables || defaultSchema.childCompletions("type"))
-           .concat(defaultTableName ? defaultSchema.child(defaultTableName).list : []);
-       for (let sName in top.children) {
-           let schema = top.child(sName);
-           if (!schema.list.length)
-               schema.list = schema.childCompletions("type");
-       }
-       top.list = defaultSchema.list.concat(schemas || top.childCompletions("type"));
+           let parts = table.split("."), base = parts.length == 1 ? defaultSchema : top;
+           for (let part of parts)
+               base = base.child(part, idQuote);
+           for (let option of schema[table])
+               if (option)
+                   base.list.push(typeof option == "string" ? nameCompletion(option, "property", idQuote) : option);
+       }
+       if (tables)
+           defaultSchema.addCompletions(tables);
+       if (schemas)
+           top.addCompletions(schemas);
+       top.addCompletions(defaultSchema.list);
+       if (defaultTableName)
+           top.addCompletions(defaultSchema.child(defaultTableName, idQuote).list);
        return (context) => {
            let { parents, from, quoted, empty, aliases } = sourceContext(context.state, context.pos);
            if (empty && !context.explicit)
@@ -23662,11 +24064,11 @@
                    if (level == top)
                        level = defaultSchema;
                    else if (level == defaultSchema && defaultTableName)
-                       level = level.child(defaultTableName);
+                       level = level.child(defaultTableName, idQuote);
                    else
                        return null;
                }
-               level = level.child(name);
+               level = level.child(name, idQuote);
            }
            let quoteAfter = quoted && context.state.sliceDoc(context.pos, context.pos + 1) == quoted;
            let options = level.list;
@@ -23733,9 +24135,14 @@
        /**
        The language for this dialect.
        */
-       language) {
+       language, 
+       /**
+       The spec used to define this dialect.
+       */
+       spec) {
            this.dialect = dialect;
            this.language = language;
+           this.spec = spec;
        }
        /**
        Returns the language for this dialect as an extension.
@@ -23756,7 +24163,7 @@
                    closeBrackets: { brackets: ["(", "[", "{", "'", '"', "`"] }
                }
            });
-           return new SQLDialect(d, language);
+           return new SQLDialect(d, language, spec);
        }
    }
    /**
@@ -23771,9 +24178,13 @@
    for the given configuration.
    */
    function schemaCompletionSource(config) {
-       return config.schema ? completeFromSchema(config.schema, config.tables, config.schemas, config.defaultTable, config.defaultSchema)
+       return config.schema ? completeFromSchema(config.schema, config.tables, config.schemas, config.defaultTable, config.defaultSchema, config.dialect || StandardSQL)
            : () => null;
    }
+   /**
+   The standard SQL dialect.
+   */
+   const StandardSQL = /*@__PURE__*/SQLDialect.define({});
    const MySQLKeywords = "accessible algorithm analyze asensitive authors auto_increment autocommit avg avg_row_length binlog btree cache catalog_name chain change changed checkpoint checksum class_origin client_statistics coalesce code collations columns comment committed completion concurrent consistent contains contributors convert database databases day_hour day_microsecond day_minute day_second delay_key_write delayed delimiter des_key_file dev_pop dev_samp deviance directory disable discard distinctrow div dual dumpfile enable enclosed ends engine engines enum errors escaped even event events every explain extended fast field fields flush force found_rows fulltext grants handler hash high_priority hosts hour_microsecond hour_minute hour_second ignore ignore_server_ids import index index_statistics infile innodb insensitive insert_method install invoker iterate keys kill linear lines list load lock logs low_priority master master_heartbeat_period master_ssl_verify_server_cert masters max max_rows maxvalue message_text middleint migrate min min_rows minute_microsecond minute_second mod mode modify mutex mysql_errno no_write_to_binlog offline offset one online optimize optionally outfile pack_keys parser partition partitions password phase plugin plugins prev processlist profile profiles purge query quick range read_write rebuild recover regexp relaylog remove rename reorganize repair repeatable replace require resume rlike row_format rtree schedule schema_name schemas second_microsecond security sensitive separator serializable server share show slave slow snapshot soname spatial sql_big_result sql_buffer_result sql_cache sql_calc_found_rows sql_no_cache sql_small_result ssl starting starts std stddev stddev_pop stddev_samp storage straight_join subclass_origin sum suspend table_name table_statistics tables tablespace terminated triggers truncate uncommitted uninstall unlock upgrade use use_frm user_resources user_statistics utc_date utc_time utc_timestamp variables views warnings xa xor year_month zerofill";
    const MySQLTypes = SQLTypes + "bool blob long longblob longtext medium mediumblob mediumint mediumtext tinyblob tinyint tinytext text bigint int1 int2 int3 int4 int8 float4 float8 varbinary varcharacter precision datetime unsigned signed";
    const MySQLBuiltin = "charset clear edit ego help nopager notee nowarning pager print prompt quit rehash source status system tee";