@maketribe/ms-app 3.0.35 → 3.0.37

package/dist/cjs/node_modules/.pnpm/@codemirror_view@6.22.1/node_modules/@codemirror/view/dist/index.js

@@ -8001,14 +8001,6 @@ function getKeymap(state) {
         Keymaps.set(bindings, map = buildKeymap(bindings.reduce((a, b) => a.concat(b), [])));
     return map;
 }
-/**
-Run the key handlers registered for a given scope. The event
-object should be a `"keydown"` event. Returns true if any of the
-handlers handled it.
-*/
-function runScopeHandlers(view, event, scope) {
-    return runHandlers(getKeymap(view.state), event, view, scope);
-}
 let storedPrefix = null;
 const PrefixTimeout = 4000;
 function buildKeymap(bindings, platform = currentPlatform) {
@@ -8137,350 +8129,7 @@ function runHandlers(map, event, view, scope) {
     return handled;
 }
 
-/**
-Implementation of [`LayerMarker`](https://codemirror.net/6/docs/ref/#view.LayerMarker) that creates
-a rectangle at a given set of coordinates.
-*/
-class RectangleMarker {
-    /**
-    Create a marker with the given class and dimensions. If `width`
-    is null, the DOM element will get no width style.
-    */
-    constructor(className, 
-    /**
-    The left position of the marker (in pixels, document-relative).
-    */
-    left, 
-    /**
-    The top position of the marker.
-    */
-    top, 
-    /**
-    The width of the marker, or null if it shouldn't get a width assigned.
-    */
-    width, 
-    /**
-    The height of the marker.
-    */
-    height) {
-        this.className = className;
-        this.left = left;
-        this.top = top;
-        this.width = width;
-        this.height = height;
-    }
-    draw() {
-        let elt = document.createElement("div");
-        elt.className = this.className;
-        this.adjust(elt);
-        return elt;
-    }
-    update(elt, prev) {
-        if (prev.className != this.className)
-            return false;
-        this.adjust(elt);
-        return true;
-    }
-    adjust(elt) {
-        elt.style.left = this.left + "px";
-        elt.style.top = this.top + "px";
-        if (this.width != null)
-            elt.style.width = this.width + "px";
-        elt.style.height = this.height + "px";
-    }
-    eq(p) {
-        return this.left == p.left && this.top == p.top && this.width == p.width && this.height == p.height &&
-            this.className == p.className;
-    }
-    /**
-    Create a set of rectangles for the given selection range,
-    assigning them theclass`className`. Will create a single
-    rectangle for empty ranges, and a set of selection-style
-    rectangles covering the range's content (in a bidi-aware
-    way) for non-empty ones.
-    */
-    static forRange(view, className, range) {
-        if (range.empty) {
-            let pos = view.coordsAtPos(range.head, range.assoc || 1);
-            if (!pos)
-                return [];
-            let base = getBase(view);
-            return [new RectangleMarker(className, pos.left - base.left, pos.top - base.top, null, pos.bottom - pos.top)];
-        }
-        else {
-            return rectanglesForRange(view, className, range);
-        }
-    }
-}
-function getBase(view) {
-    let rect = view.scrollDOM.getBoundingClientRect();
-    let left = view.textDirection == exports.Direction.LTR ? rect.left : rect.right - view.scrollDOM.clientWidth * view.scaleX;
-    return { left: left - view.scrollDOM.scrollLeft * view.scaleX, top: rect.top - view.scrollDOM.scrollTop * view.scaleY };
-}
-function wrappedLine(view, pos, inside) {
-    let range = index.EditorSelection.cursor(pos);
-    return { from: Math.max(inside.from, view.moveToLineBoundary(range, false, true).from),
-        to: Math.min(inside.to, view.moveToLineBoundary(range, true, true).from),
-        type: exports.BlockType.Text };
-}
-function rectanglesForRange(view, className, range) {
-    if (range.to <= view.viewport.from || range.from >= view.viewport.to)
-        return [];
-    let from = Math.max(range.from, view.viewport.from), to = Math.min(range.to, view.viewport.to);
-    let ltr = view.textDirection == exports.Direction.LTR;
-    let content = view.contentDOM, contentRect = content.getBoundingClientRect(), base = getBase(view);
-    let lineElt = content.querySelector(".cm-line"), lineStyle = lineElt && window.getComputedStyle(lineElt);
-    let leftSide = contentRect.left +
-        (lineStyle ? parseInt(lineStyle.paddingLeft) + Math.min(0, parseInt(lineStyle.textIndent)) : 0);
-    let rightSide = contentRect.right - (lineStyle ? parseInt(lineStyle.paddingRight) : 0);
-    let startBlock = blockAt(view, from), endBlock = blockAt(view, to);
-    let visualStart = startBlock.type == exports.BlockType.Text ? startBlock : null;
-    let visualEnd = endBlock.type == exports.BlockType.Text ? endBlock : null;
-    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));
-    }
-    else {
-        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 - (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 == exports.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 */);
-    }
-    function pieces({ top, bottom, horizontal }) {
-        let pieces = [];
-        for (let i = 0; i < horizontal.length; i += 2)
-            pieces.push(piece(horizontal[i], top, horizontal[i + 1], bottom));
-        return pieces;
-    }
-    // Gets passed from/to in line-local positions
-    function drawForLine(from, to, line) {
-        let top = 1e9, bottom = -1e9, horizontal = [];
-        function addSpan(from, fromOpen, to, toOpen, dir) {
-            // Passing 2/-2 is a kludge to force the view to return
-            // coordinates on the proper side of block widgets, since
-            // normalizing the side there, though appropriate for most
-            // 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 == exports.Direction.LTR)
-                horizontal.push(ltr && fromOpen ? leftSide : fromCoords.left, ltr && toOpen ? rightSide : toCoords.right);
-            else
-                horizontal.push(!ltr && toOpen ? leftSide : toCoords.left, !ltr && fromOpen ? rightSide : fromCoords.right);
-        }
-        let start = from !== null && from !== void 0 ? from : line.from, end = to !== null && to !== void 0 ? to : line.to;
-        // Split the range by visible range and document line
-        for (let r of view.visibleRanges)
-            if (r.to > start && r.from < end) {
-                for (let pos = Math.max(r.from, start), endPos = Math.min(r.to, end);;) {
-                    let docLine = view.state.doc.lineAt(pos);
-                    for (let span of view.bidiSpans(docLine)) {
-                        let spanFrom = span.from + docLine.from, spanTo = span.to + docLine.from;
-                        if (spanFrom >= endPos)
-                            break;
-                        if (spanTo > pos)
-                            addSpan(Math.max(spanFrom, pos), from == null && spanFrom <= start, Math.min(spanTo, endPos), to == null && spanTo >= end, span.dir);
-                    }
-                    pos = docLine.to + 1;
-                    if (pos >= endPos)
-                        break;
-                }
-            }
-        if (horizontal.length == 0)
-            addSpan(start, from == null, end, to == null, view.textDirection);
-        return { top, bottom, horizontal };
-    }
-    function drawForWidget(block, top) {
-        let y = contentRect.top + (top ? block.top : block.bottom);
-        return { top: y, bottom: y, horizontal: [] };
-    }
-}
-function sameMarker(a, b) {
-    return a.constructor == b.constructor && a.eq(b);
-}
-class LayerView {
-    constructor(view, layer) {
-        this.view = view;
-        this.layer = layer;
-        this.drawn = [];
-        this.scaleX = 1;
-        this.scaleY = 1;
-        this.measureReq = { read: this.measure.bind(this), write: this.draw.bind(this) };
-        this.dom = view.scrollDOM.appendChild(document.createElement("div"));
-        this.dom.classList.add("cm-layer");
-        if (layer.above)
-            this.dom.classList.add("cm-layer-above");
-        if (layer.class)
-            this.dom.classList.add(layer.class);
-        this.scale();
-        this.dom.setAttribute("aria-hidden", "true");
-        this.setOrder(view.state);
-        view.requestMeasure(this.measureReq);
-        if (layer.mount)
-            layer.mount(this.dom, view);
-    }
-    update(update) {
-        if (update.startState.facet(layerOrder) != update.state.facet(layerOrder))
-            this.setOrder(update.state);
-        if (this.layer.update(update, this.dom) || update.geometryChanged) {
-            this.scale();
-            update.view.requestMeasure(this.measureReq);
-        }
-    }
-    setOrder(state) {
-        let pos = 0, order = state.facet(layerOrder);
-        while (pos < order.length && order[pos] != this.layer)
-            pos++;
-        this.dom.style.zIndex = String((this.layer.above ? 150 : -1) - pos);
-    }
-    measure() {
-        return this.layer.markers(this.view);
-    }
-    scale() {
-        let { scaleX, scaleY } = this.view;
-        if (scaleX != this.scaleX || scaleY != this.scaleY) {
-            this.scaleX = scaleX;
-            this.scaleY = scaleY;
-            this.dom.style.transform = `scale(${1 / scaleX}, ${1 / scaleY})`;
-        }
-    }
-    draw(markers) {
-        if (markers.length != this.drawn.length || markers.some((p, i) => !sameMarker(p, this.drawn[i]))) {
-            let old = this.dom.firstChild, oldI = 0;
-            for (let marker of markers) {
-                if (marker.update && old && marker.constructor && this.drawn[oldI].constructor &&
-                    marker.update(old, this.drawn[oldI])) {
-                    old = old.nextSibling;
-                    oldI++;
-                }
-                else {
-                    this.dom.insertBefore(marker.draw(), old);
-                }
-            }
-            while (old) {
-                let next = old.nextSibling;
-                old.remove();
-                old = next;
-            }
-            this.drawn = markers;
-        }
-    }
-    destroy() {
-        if (this.layer.destroy)
-            this.layer.destroy(this.dom, this.view);
-        this.dom.remove();
-    }
-}
-const layerOrder = /*@__PURE__*/index.Facet.define();
-/**
-Define a layer.
-*/
-function layer(config) {
-    return [
-        ViewPlugin.define(v => new LayerView(v, config)),
-        layerOrder.of(config)
-    ];
-}
-
 const CanHidePrimary = !browser.ios; // FIXME test IE
-const selectionConfig = /*@__PURE__*/index.Facet.define({
-    combine(configs) {
-        return index.combineConfig(configs, {
-            cursorBlinkRate: 1200,
-            drawRangeCursor: true
-        }, {
-            cursorBlinkRate: (a, b) => Math.min(a, b),
-            drawRangeCursor: (a, b) => a || b
-        });
-    }
-});
-/**
-Returns an extension that hides the browser's native selection and
-cursor, replacing the selection with a background behind the text
-(with the `cm-selectionBackground` class), and the
-cursors with elements overlaid over the code (using
-`cm-cursor-primary` and `cm-cursor-secondary`).
-
-This allows the editor to display secondary selection ranges, and
-tends to produce a type of selection more in line with that users
-expect in a text editor (the native selection styling will often
-leave gaps between lines and won't fill the horizontal space after
-a line when the selection continues past it).
-
-It does have a performance cost, in that it requires an extra DOM
-layout cycle for many updates (the selection is drawn based on DOM
-layout information that's only available after laying out the
-content).
-*/
-function drawSelection(config = {}) {
-    return [
-        selectionConfig.of(config),
-        cursorLayer,
-        selectionLayer,
-        hideNativeSelection,
-        nativeSelectionHidden.of(true)
-    ];
-}
-function configChanged(update) {
-    return update.startState.facet(selectionConfig) != update.state.facet(selectionConfig);
-}
-const cursorLayer = /*@__PURE__*/layer({
-    above: true,
-    markers(view) {
-        let { state } = view, conf = state.facet(selectionConfig);
-        let cursors = [];
-        for (let r of state.selection.ranges) {
-            let prim = r == state.selection.main;
-            if (r.empty ? !prim || CanHidePrimary : conf.drawRangeCursor) {
-                let className = prim ? "cm-cursor cm-cursor-primary" : "cm-cursor cm-cursor-secondary";
-                let cursor = r.empty ? r : index.EditorSelection.cursor(r.head, r.head > r.anchor ? -1 : 1);
-                for (let piece of RectangleMarker.forRange(view, className, cursor))
-                    cursors.push(piece);
-            }
-        }
-        return cursors;
-    },
-    update(update, dom) {
-        if (update.transactions.some(tr => tr.selection))
-            dom.style.animationName = dom.style.animationName == "cm-blink" ? "cm-blink2" : "cm-blink";
-        let confChange = configChanged(update);
-        if (confChange)
-            setBlinkRate(update.state, dom);
-        return update.docChanged || update.selectionSet || confChange;
-    },
-    mount(dom, view) {
-        setBlinkRate(view.state, dom);
-    },
-    class: "cm-cursorLayer"
-});
-function setBlinkRate(state, dom) {
-    dom.style.animationDuration = state.facet(selectionConfig).cursorBlinkRate + "ms";
-}
-const selectionLayer = /*@__PURE__*/layer({
-    above: false,
-    markers(view) {
-        return view.state.selection.ranges.map(r => r.empty ? [] : RectangleMarker.forRange(view, "cm-selectionBackground", r))
-            .reduce((a, b) => a.concat(b));
-    },
-    update(update, dom) {
-        return update.docChanged || update.selectionSet || update.viewportChanged || configChanged(update);
-    },
-    class: "cm-selectionLayer"
-});
 const themeSpec = {
     ".cm-line": {
         "& ::selection": { backgroundColor: "transparent !important" },
@@ -8491,406 +8140,6 @@ if (CanHidePrimary) {
     themeSpec[".cm-line"].caretColor = "transparent !important";
     themeSpec[".cm-content"] = { caretColor: "transparent !important" };
 }
-const hideNativeSelection = /*@__PURE__*/index.Prec.highest(/*@__PURE__*/EditorView.theme(themeSpec));
-
-const setDropCursorPos = /*@__PURE__*/index.StateEffect.define({
-    map(pos, mapping) { return pos == null ? null : mapping.mapPos(pos); }
-});
-const dropCursorPos = /*@__PURE__*/index.StateField.define({
-    create() { return null; },
-    update(pos, tr) {
-        if (pos != null)
-            pos = tr.changes.mapPos(pos);
-        return tr.effects.reduce((pos, e) => e.is(setDropCursorPos) ? e.value : pos, pos);
-    }
-});
-const drawDropCursor = /*@__PURE__*/ViewPlugin.fromClass(class {
-    constructor(view) {
-        this.view = view;
-        this.cursor = null;
-        this.measureReq = { read: this.readPos.bind(this), write: this.drawCursor.bind(this) };
-    }
-    update(update) {
-        var _a;
-        let cursorPos = update.state.field(dropCursorPos);
-        if (cursorPos == null) {
-            if (this.cursor != null) {
-                (_a = this.cursor) === null || _a === void 0 ? void 0 : _a.remove();
-                this.cursor = null;
-            }
-        }
-        else {
-            if (!this.cursor) {
-                this.cursor = this.view.scrollDOM.appendChild(document.createElement("div"));
-                this.cursor.className = "cm-dropCursor";
-            }
-            if (update.startState.field(dropCursorPos) != cursorPos || update.docChanged || update.geometryChanged)
-                this.view.requestMeasure(this.measureReq);
-        }
-    }
-    readPos() {
-        let { view } = this;
-        let pos = view.state.field(dropCursorPos);
-        let rect = pos != null && view.coordsAtPos(pos);
-        if (!rect)
-            return null;
-        let outer = view.scrollDOM.getBoundingClientRect();
-        return {
-            left: rect.left - outer.left + view.scrollDOM.scrollLeft * view.scaleX,
-            top: rect.top - outer.top + view.scrollDOM.scrollTop * view.scaleY,
-            height: rect.bottom - rect.top
-        };
-    }
-    drawCursor(pos) {
-        if (this.cursor) {
-            let { scaleX, scaleY } = this.view;
-            if (pos) {
-                this.cursor.style.left = pos.left / scaleX + "px";
-                this.cursor.style.top = pos.top / scaleY + "px";
-                this.cursor.style.height = pos.height / scaleY + "px";
-            }
-            else {
-                this.cursor.style.left = "-100000px";
-            }
-        }
-    }
-    destroy() {
-        if (this.cursor)
-            this.cursor.remove();
-    }
-    setDropPos(pos) {
-        if (this.view.state.field(dropCursorPos) != pos)
-            this.view.dispatch({ effects: setDropCursorPos.of(pos) });
-    }
-}, {
-    eventObservers: {
-        dragover(event) {
-            this.setDropPos(this.view.posAtCoords({ x: event.clientX, y: event.clientY }));
-        },
-        dragleave(event) {
-            if (event.target == this.view.contentDOM || !this.view.contentDOM.contains(event.relatedTarget))
-                this.setDropPos(null);
-        },
-        dragend() {
-            this.setDropPos(null);
-        },
-        drop() {
-            this.setDropPos(null);
-        }
-    }
-});
-/**
-Draws a cursor at the current drop position when something is
-dragged over the editor.
-*/
-function dropCursor() {
-    return [dropCursorPos, drawDropCursor];
-}
-
-function iterMatches(doc, re, from, to, f) {
-    re.lastIndex = 0;
-    for (let cursor = doc.iterRange(from, to), pos = from, m; !cursor.next().done; pos += cursor.value.length) {
-        if (!cursor.lineBreak)
-            while (m = re.exec(cursor.value))
-                f(pos + m.index, m);
-    }
-}
-function matchRanges(view, maxLength) {
-    let visible = view.visibleRanges;
-    if (visible.length == 1 && visible[0].from == view.viewport.from &&
-        visible[0].to == view.viewport.to)
-        return visible;
-    let result = [];
-    for (let { from, to } of visible) {
-        from = Math.max(view.state.doc.lineAt(from).from, from - maxLength);
-        to = Math.min(view.state.doc.lineAt(to).to, to + maxLength);
-        if (result.length && result[result.length - 1].to >= from)
-            result[result.length - 1].to = to;
-        else
-            result.push({ from, to });
-    }
-    return result;
-}
-/**
-Helper class used to make it easier to maintain decorations on
-visible code that matches a given regular expression. To be used
-in a [view plugin](https://codemirror.net/6/docs/ref/#view.ViewPlugin). Instances of this object
-represent a matching configuration.
-*/
-class MatchDecorator {
-    /**
-    Create a decorator.
-    */
-    constructor(config) {
-        const { regexp, decoration, decorate, boundary, maxLength = 1000 } = config;
-        if (!regexp.global)
-            throw new RangeError("The regular expression given to MatchDecorator should have its 'g' flag set");
-        this.regexp = regexp;
-        if (decorate) {
-            this.addMatch = (match, view, from, add) => decorate(add, from, from + match[0].length, match, view);
-        }
-        else if (typeof decoration == "function") {
-            this.addMatch = (match, view, from, add) => {
-                let deco = decoration(match, view, from);
-                if (deco)
-                    add(from, from + match[0].length, deco);
-            };
-        }
-        else if (decoration) {
-            this.addMatch = (match, _view, from, add) => add(from, from + match[0].length, decoration);
-        }
-        else {
-            throw new RangeError("Either 'decorate' or 'decoration' should be provided to MatchDecorator");
-        }
-        this.boundary = boundary;
-        this.maxLength = maxLength;
-    }
-    /**
-    Compute the full set of decorations for matches in the given
-    view's viewport. You'll want to call this when initializing your
-    plugin.
-    */
-    createDeco(view) {
-        let build = new index.RangeSetBuilder(), add = build.add.bind(build);
-        for (let { from, to } of matchRanges(view, this.maxLength))
-            iterMatches(view.state.doc, this.regexp, from, to, (from, m) => this.addMatch(m, view, from, add));
-        return build.finish();
-    }
-    /**
-    Update a set of decorations for a view update. `deco` _must_ be
-    the set of decorations produced by _this_ `MatchDecorator` for
-    the view state before the update.
-    */
-    updateDeco(update, deco) {
-        let changeFrom = 1e9, changeTo = -1;
-        if (update.docChanged)
-            update.changes.iterChanges((_f, _t, from, to) => {
-                if (to > update.view.viewport.from && from < update.view.viewport.to) {
-                    changeFrom = Math.min(from, changeFrom);
-                    changeTo = Math.max(to, changeTo);
-                }
-            });
-        if (update.viewportChanged || changeTo - changeFrom > 1000)
-            return this.createDeco(update.view);
-        if (changeTo > -1)
-            return this.updateRange(update.view, deco.map(update.changes), changeFrom, changeTo);
-        return deco;
-    }
-    updateRange(view, deco, updateFrom, updateTo) {
-        for (let r of view.visibleRanges) {
-            let from = Math.max(r.from, updateFrom), to = Math.min(r.to, updateTo);
-            if (to > from) {
-                let fromLine = view.state.doc.lineAt(from), toLine = fromLine.to < to ? view.state.doc.lineAt(to) : fromLine;
-                let start = Math.max(r.from, fromLine.from), end = Math.min(r.to, toLine.to);
-                if (this.boundary) {
-                    for (; from > fromLine.from; from--)
-                        if (this.boundary.test(fromLine.text[from - 1 - fromLine.from])) {
-                            start = from;
-                            break;
-                        }
-                    for (; to < toLine.to; to++)
-                        if (this.boundary.test(toLine.text[to - toLine.from])) {
-                            end = to;
-                            break;
-                        }
-                }
-                let ranges = [], m;
-                let add = (from, to, deco) => ranges.push(deco.range(from, to));
-                if (fromLine == toLine) {
-                    this.regexp.lastIndex = start - fromLine.from;
-                    while ((m = this.regexp.exec(fromLine.text)) && m.index < end - fromLine.from)
-                        this.addMatch(m, view, m.index + fromLine.from, add);
-                }
-                else {
-                    iterMatches(view.state.doc, this.regexp, start, end, (from, m) => this.addMatch(m, view, from, add));
-                }
-                deco = deco.update({ filterFrom: start, filterTo: end, filter: (from, to) => from < start || to > end, add: ranges });
-            }
-        }
-        return deco;
-    }
-}
-
-const UnicodeRegexpSupport = /x/.unicode != null ? "gu" : "g";
-const Specials = /*@__PURE__*/new RegExp("[\u0000-\u0008\u000a-\u001f\u007f-\u009f\u00ad\u061c\u200b\u200e\u200f\u2028\u2029\u202d\u202e\u2066\u2067\u2069\ufeff\ufff9-\ufffc]", UnicodeRegexpSupport);
-const Names = {
-    0: "null",
-    7: "bell",
-    8: "backspace",
-    10: "newline",
-    11: "vertical tab",
-    13: "carriage return",
-    27: "escape",
-    8203: "zero width space",
-    8204: "zero width non-joiner",
-    8205: "zero width joiner",
-    8206: "left-to-right mark",
-    8207: "right-to-left mark",
-    8232: "line separator",
-    8237: "left-to-right override",
-    8238: "right-to-left override",
-    8294: "left-to-right isolate",
-    8295: "right-to-left isolate",
-    8297: "pop directional isolate",
-    8233: "paragraph separator",
-    65279: "zero width no-break space",
-    65532: "object replacement"
-};
-let _supportsTabSize = null;
-function supportsTabSize() {
-    var _a;
-    if (_supportsTabSize == null && typeof document != "undefined" && document.body) {
-        let styles = document.body.style;
-        _supportsTabSize = ((_a = styles.tabSize) !== null && _a !== void 0 ? _a : styles.MozTabSize) != null;
-    }
-    return _supportsTabSize || false;
-}
-const specialCharConfig = /*@__PURE__*/index.Facet.define({
-    combine(configs) {
-        let config = index.combineConfig(configs, {
-            render: null,
-            specialChars: Specials,
-            addSpecialChars: null
-        });
-        if (config.replaceTabs = !supportsTabSize())
-            config.specialChars = new RegExp("\t|" + config.specialChars.source, UnicodeRegexpSupport);
-        if (config.addSpecialChars)
-            config.specialChars = new RegExp(config.specialChars.source + "|" + config.addSpecialChars.source, UnicodeRegexpSupport);
-        return config;
-    }
-});
-/**
-Returns an extension that installs highlighting of special
-characters.
-*/
-function highlightSpecialChars(
-/**
-Configuration options.
-*/
-config = {}) {
-    return [specialCharConfig.of(config), specialCharPlugin()];
-}
-let _plugin = null;
-function specialCharPlugin() {
-    return _plugin || (_plugin = ViewPlugin.fromClass(class {
-        constructor(view) {
-            this.view = view;
-            this.decorations = Decoration.none;
-            this.decorationCache = Object.create(null);
-            this.decorator = this.makeDecorator(view.state.facet(specialCharConfig));
-            this.decorations = this.decorator.createDeco(view);
-        }
-        makeDecorator(conf) {
-            return new MatchDecorator({
-                regexp: conf.specialChars,
-                decoration: (m, view, pos) => {
-                    let { doc } = view.state;
-                    let code = index.codePointAt(m[0], 0);
-                    if (code == 9) {
-                        let line = doc.lineAt(pos);
-                        let size = view.state.tabSize, col = index.countColumn(line.text, size, pos - line.from);
-                        return Decoration.replace({
-                            widget: new TabWidget((size - (col % size)) * this.view.defaultCharacterWidth / this.view.scaleX)
-                        });
-                    }
-                    return this.decorationCache[code] ||
-                        (this.decorationCache[code] = Decoration.replace({ widget: new SpecialCharWidget(conf, code) }));
-                },
-                boundary: conf.replaceTabs ? undefined : /[^]/
-            });
-        }
-        update(update) {
-            let conf = update.state.facet(specialCharConfig);
-            if (update.startState.facet(specialCharConfig) != conf) {
-                this.decorator = this.makeDecorator(conf);
-                this.decorations = this.decorator.createDeco(update.view);
-            }
-            else {
-                this.decorations = this.decorator.updateDeco(update, this.decorations);
-            }
-        }
-    }, {
-        decorations: v => v.decorations
-    }));
-}
-const DefaultPlaceholder = "\u2022";
-// Assigns placeholder characters from the Control Pictures block to
-// ASCII control characters
-function placeholder$1(code) {
-    if (code >= 32)
-        return DefaultPlaceholder;
-    if (code == 10)
-        return "\u2424";
-    return String.fromCharCode(9216 + code);
-}
-class SpecialCharWidget extends WidgetType {
-    constructor(options, code) {
-        super();
-        this.options = options;
-        this.code = code;
-    }
-    eq(other) { return other.code == this.code; }
-    toDOM(view) {
-        let ph = placeholder$1(this.code);
-        let desc = view.state.phrase("Control character") + " " + (Names[this.code] || "0x" + this.code.toString(16));
-        let custom = this.options.render && this.options.render(this.code, desc, ph);
-        if (custom)
-            return custom;
-        let span = document.createElement("span");
-        span.textContent = ph;
-        span.title = desc;
-        span.setAttribute("aria-label", desc);
-        span.className = "cm-specialChar";
-        return span;
-    }
-    ignoreEvent() { return false; }
-}
-class TabWidget extends WidgetType {
-    constructor(width) {
-        super();
-        this.width = width;
-    }
-    eq(other) { return other.width == this.width; }
-    toDOM() {
-        let span = document.createElement("span");
-        span.textContent = "\t";
-        span.className = "cm-tab";
-        span.style.width = this.width + "px";
-        return span;
-    }
-    ignoreEvent() { return false; }
-}
-
-/**
-Mark lines that have a cursor on them with the `"cm-activeLine"`
-DOM class.
-*/
-function highlightActiveLine() {
-    return activeLineHighlighter;
-}
-const lineDeco = /*@__PURE__*/Decoration.line({ class: "cm-activeLine" });
-const activeLineHighlighter = /*@__PURE__*/ViewPlugin.fromClass(class {
-    constructor(view) {
-        this.decorations = this.getDeco(view);
-    }
-    update(update) {
-        if (update.docChanged || update.selectionSet)
-            this.decorations = this.getDeco(update.view);
-    }
-    getDeco(view) {
-        let lastLineStart = -1, deco = [];
-        for (let r of view.state.selection.ranges) {
-            let line = view.lineBlockAt(r.head);
-            if (line.from > lastLineStart) {
-                deco.push(lineDeco.range(line.from));
-                lastLineStart = line.from;
-            }
-        }
-        return Decoration.set(deco);
-    }
-}, {
-    decorations: v => v.decorations
-});
 
 class Placeholder extends WidgetType {
     constructor(content) {
@@ -8937,955 +8186,10 @@ function placeholder(content) {
     }, { decorations: v => v.decorations });
 }
 
-// Don't compute precise column positions for line offsets above this
-// (since it could get expensive). Assume offset==column for them.
-const MaxOff = 2000;
-function rectangleFor(state, a, b) {
-    let startLine = Math.min(a.line, b.line), endLine = Math.max(a.line, b.line);
-    let ranges = [];
-    if (a.off > MaxOff || b.off > MaxOff || a.col < 0 || b.col < 0) {
-        let startOff = Math.min(a.off, b.off), endOff = Math.max(a.off, b.off);
-        for (let i = startLine; i <= endLine; i++) {
-            let line = state.doc.line(i);
-            if (line.length <= endOff)
-                ranges.push(index.EditorSelection.range(line.from + startOff, line.to + endOff));
-        }
-    }
-    else {
-        let startCol = Math.min(a.col, b.col), endCol = Math.max(a.col, b.col);
-        for (let i = startLine; i <= endLine; i++) {
-            let line = state.doc.line(i);
-            let start = index.findColumn(line.text, startCol, state.tabSize, true);
-            if (start < 0) {
-                ranges.push(index.EditorSelection.cursor(line.to));
-            }
-            else {
-                let end = index.findColumn(line.text, endCol, state.tabSize);
-                ranges.push(index.EditorSelection.range(line.from + start, line.from + end));
-            }
-        }
-    }
-    return ranges;
-}
-function absoluteColumn(view, x) {
-    let ref = view.coordsAtPos(view.viewport.from);
-    return ref ? Math.round(Math.abs((ref.left - x) / view.defaultCharacterWidth)) : -1;
-}
-function getPos(view, event) {
-    let offset = view.posAtCoords({ x: event.clientX, y: event.clientY }, false);
-    let line = view.state.doc.lineAt(offset), off = offset - line.from;
-    let col = off > MaxOff ? -1
-        : off == line.length ? absoluteColumn(view, event.clientX)
-            : index.countColumn(line.text, view.state.tabSize, offset - line.from);
-    return { line: line.number, col, off };
-}
-function rectangleSelectionStyle(view, event) {
-    let start = getPos(view, event), startSel = view.state.selection;
-    if (!start)
-        return null;
-    return {
-        update(update) {
-            if (update.docChanged) {
-                let newStart = update.changes.mapPos(update.startState.doc.line(start.line).from);
-                let newLine = update.state.doc.lineAt(newStart);
-                start = { line: newLine.number, col: start.col, off: Math.min(start.off, newLine.length) };
-                startSel = startSel.map(update.changes);
-            }
-        },
-        get(event, _extend, multiple) {
-            let cur = getPos(view, event);
-            if (!cur)
-                return startSel;
-            let ranges = rectangleFor(view.state, start, cur);
-            if (!ranges.length)
-                return startSel;
-            if (multiple)
-                return index.EditorSelection.create(ranges.concat(startSel.ranges));
-            else
-                return index.EditorSelection.create(ranges);
-        }
-    };
-}
-/**
-Create an extension that enables rectangular selections. By
-default, it will react to left mouse drag with the Alt key held
-down. When such a selection occurs, the text within the rectangle
-that was dragged over will be selected, as one selection
-[range](https://codemirror.net/6/docs/ref/#state.SelectionRange) per line.
-*/
-function rectangularSelection(options) {
-    let filter = (options === null || options === void 0 ? void 0 : options.eventFilter) || (e => e.altKey && e.button == 0);
-    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]
-};
-const showCrosshair = { style: "cursor: crosshair" };
 /**
-Returns an extension that turns the pointer cursor into a
-crosshair when a given modifier key, defaulting to Alt, is held
-down. Can serve as a visual hint that rectangular selection is
-going to happen when paired with
-[`rectangularSelection`](https://codemirror.net/6/docs/ref/#view.rectangularSelection).
-*/
-function crosshairCursor(options = {}) {
-    let [code, getter] = keys[options.key || "Alt"];
-    let plugin = ViewPlugin.fromClass(class {
-        constructor(view) {
-            this.view = view;
-            this.isDown = false;
-        }
-        set(isDown) {
-            if (this.isDown != isDown) {
-                this.isDown = isDown;
-                this.view.update([]);
-            }
-        }
-    }, {
-        eventObservers: {
-            keydown(e) {
-                this.set(e.keyCode == code || getter(e));
-            },
-            keyup(e) {
-                if (e.keyCode == code || !getter(e))
-                    this.set(false);
-            },
-            mousemove(e) {
-                this.set(getter(e));
-            }
-        }
-    });
-    return [
-        plugin,
-        EditorView.contentAttributes.of(view => { var _a; return ((_a = view.plugin(plugin)) === null || _a === void 0 ? void 0 : _a.isDown) ? showCrosshair : null; })
-    ];
-}
-
-const Outside = "-10000px";
-class TooltipViewManager {
-    constructor(view, facet, createTooltipView) {
-        this.facet = facet;
-        this.createTooltipView = createTooltipView;
-        this.input = view.state.facet(facet);
-        this.tooltips = this.input.filter(t => t);
-        this.tooltipViews = this.tooltips.map(createTooltipView);
-    }
-    update(update, above) {
-        var _a;
-        let input = update.state.facet(this.facet);
-        let tooltips = input.filter(x => x);
-        if (input === this.input) {
-            for (let t of this.tooltipViews)
-                if (t.update)
-                    t.update(update);
-            return false;
-        }
-        let tooltipViews = [], newAbove = above ? [] : null;
-        for (let i = 0; i < tooltips.length; i++) {
-            let tip = tooltips[i], known = -1;
-            if (!tip)
-                continue;
-            for (let i = 0; i < this.tooltips.length; i++) {
-                let other = this.tooltips[i];
-                if (other && other.create == tip.create)
-                    known = i;
-            }
-            if (known < 0) {
-                tooltipViews[i] = this.createTooltipView(tip);
-                if (newAbove)
-                    newAbove[i] = !!tip.above;
-            }
-            else {
-                let tooltipView = tooltipViews[i] = this.tooltipViews[known];
-                if (newAbove)
-                    newAbove[i] = above[known];
-                if (tooltipView.update)
-                    tooltipView.update(update);
-            }
-        }
-        for (let t of this.tooltipViews)
-            if (tooltipViews.indexOf(t) < 0) {
-                t.dom.remove();
-                (_a = t.destroy) === null || _a === void 0 ? void 0 : _a.call(t);
-            }
-        if (above) {
-            newAbove.forEach((val, i) => above[i] = val);
-            above.length = newAbove.length;
-        }
-        this.input = input;
-        this.tooltips = tooltips;
-        this.tooltipViews = tooltipViews;
-        return true;
-    }
-}
-function windowSpace(view) {
-    let { win } = view;
-    return { top: 0, left: 0, bottom: win.innerHeight, right: win.innerWidth };
-}
-const tooltipConfig = /*@__PURE__*/index.Facet.define({
-    combine: values => {
-        var _a, _b, _c;
-        return ({
-            position: browser.ios ? "absolute" : ((_a = values.find(conf => conf.position)) === null || _a === void 0 ? void 0 : _a.position) || "fixed",
-            parent: ((_b = values.find(conf => conf.parent)) === null || _b === void 0 ? void 0 : _b.parent) || null,
-            tooltipSpace: ((_c = values.find(conf => conf.tooltipSpace)) === null || _c === void 0 ? void 0 : _c.tooltipSpace) || windowSpace,
-        });
-    }
-});
-const knownHeight = /*@__PURE__*/new WeakMap();
-const tooltipPlugin = /*@__PURE__*/ViewPlugin.fromClass(class {
-    constructor(view) {
-        this.view = view;
-        this.above = [];
-        this.inView = true;
-        this.madeAbsolute = false;
-        this.lastTransaction = 0;
-        this.measureTimeout = -1;
-        let config = view.state.facet(tooltipConfig);
-        this.position = config.position;
-        this.parent = config.parent;
-        this.classes = view.themeClasses;
-        this.createContainer();
-        this.measureReq = { read: this.readMeasure.bind(this), write: this.writeMeasure.bind(this), key: this };
-        this.manager = new TooltipViewManager(view, showTooltip, t => this.createTooltip(t));
-        this.intersectionObserver = typeof IntersectionObserver == "function" ? new IntersectionObserver(entries => {
-            if (Date.now() > this.lastTransaction - 50 &&
-                entries.length > 0 && entries[entries.length - 1].intersectionRatio < 1)
-                this.measureSoon();
-        }, { threshold: [1] }) : null;
-        this.observeIntersection();
-        view.win.addEventListener("resize", this.measureSoon = this.measureSoon.bind(this));
-        this.maybeMeasure();
-    }
-    createContainer() {
-        if (this.parent) {
-            this.container = document.createElement("div");
-            this.container.style.position = "relative";
-            this.container.className = this.view.themeClasses;
-            this.parent.appendChild(this.container);
-        }
-        else {
-            this.container = this.view.dom;
-        }
-    }
-    observeIntersection() {
-        if (this.intersectionObserver) {
-            this.intersectionObserver.disconnect();
-            for (let tooltip of this.manager.tooltipViews)
-                this.intersectionObserver.observe(tooltip.dom);
-        }
-    }
-    measureSoon() {
-        if (this.measureTimeout < 0)
-            this.measureTimeout = setTimeout(() => {
-                this.measureTimeout = -1;
-                this.maybeMeasure();
-            }, 50);
-    }
-    update(update) {
-        if (update.transactions.length)
-            this.lastTransaction = Date.now();
-        let updated = this.manager.update(update, this.above);
-        if (updated)
-            this.observeIntersection();
-        let shouldMeasure = updated || update.geometryChanged;
-        let newConfig = update.state.facet(tooltipConfig);
-        if (newConfig.position != this.position && !this.madeAbsolute) {
-            this.position = newConfig.position;
-            for (let t of this.manager.tooltipViews)
-                t.dom.style.position = this.position;
-            shouldMeasure = true;
-        }
-        if (newConfig.parent != this.parent) {
-            if (this.parent)
-                this.container.remove();
-            this.parent = newConfig.parent;
-            this.createContainer();
-            for (let t of this.manager.tooltipViews)
-                this.container.appendChild(t.dom);
-            shouldMeasure = true;
-        }
-        else if (this.parent && this.view.themeClasses != this.classes) {
-            this.classes = this.container.className = this.view.themeClasses;
-        }
-        if (shouldMeasure)
-            this.maybeMeasure();
-    }
-    createTooltip(tooltip) {
-        let tooltipView = tooltip.create(this.view);
-        tooltipView.dom.classList.add("cm-tooltip");
-        if (tooltip.arrow && !tooltipView.dom.querySelector(".cm-tooltip > .cm-tooltip-arrow")) {
-            let arrow = document.createElement("div");
-            arrow.className = "cm-tooltip-arrow";
-            tooltipView.dom.appendChild(arrow);
-        }
-        tooltipView.dom.style.position = this.position;
-        tooltipView.dom.style.top = Outside;
-        tooltipView.dom.style.left = "0px";
-        this.container.appendChild(tooltipView.dom);
-        if (tooltipView.mount)
-            tooltipView.mount(this.view);
-        return tooltipView;
-    }
-    destroy() {
-        var _a, _b;
-        this.view.win.removeEventListener("resize", this.measureSoon);
-        for (let tooltipView of this.manager.tooltipViews) {
-            tooltipView.dom.remove();
-            (_a = tooltipView.destroy) === null || _a === void 0 ? void 0 : _a.call(tooltipView);
-        }
-        if (this.parent)
-            this.container.remove();
-        (_b = this.intersectionObserver) === null || _b === void 0 ? void 0 : _b.disconnect();
-        clearTimeout(this.measureTimeout);
-    }
-    readMeasure() {
-        let editor = this.view.dom.getBoundingClientRect();
-        let scaleX = 1, scaleY = 1, makeAbsolute = false;
-        if (this.position == "fixed" && this.manager.tooltipViews.length) {
-            let { dom } = this.manager.tooltipViews[0];
-            if (browser.gecko) {
-                // Firefox sets the element's `offsetParent` to the
-                // transformed element when a transform interferes with fixed
-                // positioning.
-                makeAbsolute = dom.offsetParent != this.container.ownerDocument.body;
-            }
-            else {
-                // On other browsers, we have to awkwardly try and use other
-                // information to detect a transform.
-                if (this.view.scaleX != 1 || this.view.scaleY != 1) {
-                    makeAbsolute = true;
-                }
-                else if (dom.style.top == Outside && dom.style.left == "0px") {
-                    let rect = dom.getBoundingClientRect();
-                    makeAbsolute = Math.abs(rect.top + 10000) > 1 || Math.abs(rect.left) > 1;
-                }
-            }
-        }
-        if (makeAbsolute || this.position == "absolute") {
-            if (this.parent) {
-                let rect = this.parent.getBoundingClientRect();
-                if (rect.width && rect.height) {
-                    scaleX = rect.width / this.parent.offsetWidth;
-                    scaleY = rect.height / this.parent.offsetHeight;
-                }
-            }
-            else {
-                ({ scaleX, scaleY } = this.view.viewState);
-            }
-        }
-        return {
-            editor,
-            parent: this.parent ? this.container.getBoundingClientRect() : editor,
-            pos: this.manager.tooltips.map((t, i) => {
-                let tv = this.manager.tooltipViews[i];
-                return tv.getCoords ? tv.getCoords(t.pos) : this.view.coordsAtPos(t.pos);
-            }),
-            size: this.manager.tooltipViews.map(({ dom }) => dom.getBoundingClientRect()),
-            space: this.view.state.facet(tooltipConfig).tooltipSpace(this.view),
-            scaleX, scaleY, makeAbsolute
-        };
-    }
-    writeMeasure(measured) {
-        var _a;
-        if (measured.makeAbsolute) {
-            this.madeAbsolute = true;
-            this.position = "absolute";
-            for (let t of this.manager.tooltipViews)
-                t.dom.style.position = "absolute";
-        }
-        let { editor, space, scaleX, scaleY } = measured;
-        let others = [];
-        for (let i = 0; i < this.manager.tooltips.length; i++) {
-            let tooltip = this.manager.tooltips[i], tView = this.manager.tooltipViews[i], { dom } = tView;
-            let pos = measured.pos[i], size = measured.size[i];
-            // Hide tooltips that are outside of the editor.
-            if (!pos || pos.bottom <= Math.max(editor.top, space.top) ||
-                pos.top >= Math.min(editor.bottom, space.bottom) ||
-                pos.right < Math.max(editor.left, space.left) - .1 ||
-                pos.left > Math.min(editor.right, space.right) + .1) {
-                dom.style.top = Outside;
-                continue;
-            }
-            let arrow = tooltip.arrow ? tView.dom.querySelector(".cm-tooltip-arrow") : null;
-            let arrowHeight = arrow ? 7 /* Arrow.Size */ : 0;
-            let width = size.right - size.left, height = (_a = knownHeight.get(tView)) !== null && _a !== void 0 ? _a : size.bottom - size.top;
-            let offset = tView.offset || noOffset, ltr = this.view.textDirection == exports.Direction.LTR;
-            let left = size.width > space.right - space.left ? (ltr ? space.left : space.right - size.width)
-                : ltr ? Math.min(pos.left - (arrow ? 14 /* Arrow.Offset */ : 0) + offset.x, space.right - width)
-                    : Math.max(space.left, pos.left - width + (arrow ? 14 /* Arrow.Offset */ : 0) - offset.x);
-            let above = this.above[i];
-            if (!tooltip.strictSide && (above
-                ? pos.top - (size.bottom - size.top) - offset.y < space.top
-                : pos.bottom + (size.bottom - size.top) + offset.y > space.bottom) &&
-                above == (space.bottom - pos.bottom > pos.top - space.top))
-                above = this.above[i] = !above;
-            let spaceVert = (above ? pos.top - space.top : space.bottom - pos.bottom) - arrowHeight;
-            if (spaceVert < height && tView.resize !== false) {
-                if (spaceVert < this.view.defaultLineHeight) {
-                    dom.style.top = Outside;
-                    continue;
-                }
-                knownHeight.set(tView, height);
-                dom.style.height = (height = spaceVert) / scaleY + "px";
-            }
-            else if (dom.style.height) {
-                dom.style.height = "";
-            }
-            let top = above ? pos.top - height - arrowHeight - offset.y : pos.bottom + arrowHeight + offset.y;
-            let right = left + width;
-            if (tView.overlap !== true)
-                for (let r of others)
-                    if (r.left < right && r.right > left && r.top < top + height && r.bottom > top)
-                        top = above ? r.top - height - 2 - arrowHeight : r.bottom + arrowHeight + 2;
-            if (this.position == "absolute") {
-                dom.style.top = (top - measured.parent.top) / scaleY + "px";
-                dom.style.left = (left - measured.parent.left) / scaleX + "px";
-            }
-            else {
-                dom.style.top = top / scaleY + "px";
-                dom.style.left = left / scaleX + "px";
-            }
-            if (arrow) {
-                let arrowLeft = pos.left + (ltr ? offset.x : -offset.x) - (left + 14 /* Arrow.Offset */ - 7 /* Arrow.Size */);
-                arrow.style.left = arrowLeft / scaleX + "px";
-            }
-            if (tView.overlap !== true)
-                others.push({ left, top, right, bottom: top + height });
-            dom.classList.toggle("cm-tooltip-above", above);
-            dom.classList.toggle("cm-tooltip-below", !above);
-            if (tView.positioned)
-                tView.positioned(measured.space);
-        }
-    }
-    maybeMeasure() {
-        if (this.manager.tooltips.length) {
-            if (this.view.inView)
-                this.view.requestMeasure(this.measureReq);
-            if (this.inView != this.view.inView) {
-                this.inView = this.view.inView;
-                if (!this.inView)
-                    for (let tv of this.manager.tooltipViews)
-                        tv.dom.style.top = Outside;
-            }
-        }
-    }
-}, {
-    eventObservers: {
-        scroll() { this.maybeMeasure(); }
-    }
-});
-const baseTheme = /*@__PURE__*/EditorView.baseTheme({
-    ".cm-tooltip": {
-        zIndex: 100,
-        boxSizing: "border-box"
-    },
-    "&light .cm-tooltip": {
-        border: "1px solid #bbb",
-        backgroundColor: "#f5f5f5"
-    },
-    "&light .cm-tooltip-section:not(:first-child)": {
-        borderTop: "1px solid #bbb",
-    },
-    "&dark .cm-tooltip": {
-        backgroundColor: "#333338",
-        color: "white"
-    },
-    ".cm-tooltip-arrow": {
-        height: `${7 /* Arrow.Size */}px`,
-        width: `${7 /* Arrow.Size */ * 2}px`,
-        position: "absolute",
-        zIndex: -1,
-        overflow: "hidden",
-        "&:before, &:after": {
-            content: "''",
-            position: "absolute",
-            width: 0,
-            height: 0,
-            borderLeft: `${7 /* Arrow.Size */}px solid transparent`,
-            borderRight: `${7 /* Arrow.Size */}px solid transparent`,
-        },
-        ".cm-tooltip-above &": {
-            bottom: `-${7 /* Arrow.Size */}px`,
-            "&:before": {
-                borderTop: `${7 /* Arrow.Size */}px solid #bbb`,
-            },
-            "&:after": {
-                borderTop: `${7 /* Arrow.Size */}px solid #f5f5f5`,
-                bottom: "1px"
-            }
-        },
-        ".cm-tooltip-below &": {
-            top: `-${7 /* Arrow.Size */}px`,
-            "&:before": {
-                borderBottom: `${7 /* Arrow.Size */}px solid #bbb`,
-            },
-            "&:after": {
-                borderBottom: `${7 /* Arrow.Size */}px solid #f5f5f5`,
-                top: "1px"
-            }
-        },
-    },
-    "&dark .cm-tooltip .cm-tooltip-arrow": {
-        "&:before": {
-            borderTopColor: "#333338",
-            borderBottomColor: "#333338"
-        },
-        "&:after": {
-            borderTopColor: "transparent",
-            borderBottomColor: "transparent"
-        }
-    }
-});
-const noOffset = { x: 0, y: 0 };
-/**
-Facet to which an extension can add a value to show a tooltip.
-*/
-const showTooltip = /*@__PURE__*/index.Facet.define({
-    enables: [tooltipPlugin, baseTheme]
-});
-const showHoverTooltip = /*@__PURE__*/index.Facet.define();
-class HoverTooltipHost {
-    // Needs to be static so that host tooltip instances always match
-    static create(view) {
-        return new HoverTooltipHost(view);
-    }
-    constructor(view) {
-        this.view = view;
-        this.mounted = false;
-        this.dom = document.createElement("div");
-        this.dom.classList.add("cm-tooltip-hover");
-        this.manager = new TooltipViewManager(view, showHoverTooltip, t => this.createHostedView(t));
-    }
-    createHostedView(tooltip) {
-        let hostedView = tooltip.create(this.view);
-        hostedView.dom.classList.add("cm-tooltip-section");
-        this.dom.appendChild(hostedView.dom);
-        if (this.mounted && hostedView.mount)
-            hostedView.mount(this.view);
-        return hostedView;
-    }
-    mount(view) {
-        for (let hostedView of this.manager.tooltipViews) {
-            if (hostedView.mount)
-                hostedView.mount(view);
-        }
-        this.mounted = true;
-    }
-    positioned(space) {
-        for (let hostedView of this.manager.tooltipViews) {
-            if (hostedView.positioned)
-                hostedView.positioned(space);
-        }
-    }
-    update(update) {
-        this.manager.update(update);
-    }
-    destroy() {
-        var _a;
-        for (let t of this.manager.tooltipViews)
-            (_a = t.destroy) === null || _a === void 0 ? void 0 : _a.call(t);
-    }
-    passProp(name) {
-        let value = undefined;
-        for (let view of this.manager.tooltipViews) {
-            let given = view[name];
-            if (given !== undefined) {
-                if (value === undefined)
-                    value = given;
-                else if (value !== given)
-                    return undefined;
-            }
-        }
-        return value;
-    }
-    get offset() { return this.passProp("offset"); }
-    get getCoords() { return this.passProp("getCoords"); }
-    get overlap() { return this.passProp("overlap"); }
-    get resize() { return this.passProp("resize"); }
-}
-const showHoverTooltipHost = /*@__PURE__*/showTooltip.compute([showHoverTooltip], state => {
-    let tooltips = state.facet(showHoverTooltip).filter(t => t);
-    if (tooltips.length === 0)
-        return null;
-    return {
-        pos: Math.min(...tooltips.map(t => t.pos)),
-        end: Math.max(...tooltips.map(t => { var _a; return (_a = t.end) !== null && _a !== void 0 ? _a : t.pos; })),
-        create: HoverTooltipHost.create,
-        above: tooltips[0].above,
-        arrow: tooltips.some(t => t.arrow),
-    };
-});
-class HoverPlugin {
-    constructor(view, source, field, setHover, hoverTime) {
-        this.view = view;
-        this.source = source;
-        this.field = field;
-        this.setHover = setHover;
-        this.hoverTime = hoverTime;
-        this.hoverTimeout = -1;
-        this.restartTimeout = -1;
-        this.pending = null;
-        this.lastMove = { x: 0, y: 0, target: view.dom, time: 0 };
-        this.checkHover = this.checkHover.bind(this);
-        view.dom.addEventListener("mouseleave", this.mouseleave = this.mouseleave.bind(this));
-        view.dom.addEventListener("mousemove", this.mousemove = this.mousemove.bind(this));
-    }
-    update() {
-        if (this.pending) {
-            this.pending = null;
-            clearTimeout(this.restartTimeout);
-            this.restartTimeout = setTimeout(() => this.startHover(), 20);
-        }
-    }
-    get active() {
-        return this.view.state.field(this.field);
-    }
-    checkHover() {
-        this.hoverTimeout = -1;
-        if (this.active)
-            return;
-        let hovered = Date.now() - this.lastMove.time;
-        if (hovered < this.hoverTime)
-            this.hoverTimeout = setTimeout(this.checkHover, this.hoverTime - hovered);
-        else
-            this.startHover();
-    }
-    startHover() {
-        clearTimeout(this.restartTimeout);
-        let { view, lastMove } = this;
-        let desc = view.docView.nearest(lastMove.target);
-        if (!desc)
-            return;
-        let pos, side = 1;
-        if (desc instanceof WidgetView) {
-            pos = desc.posAtStart;
-        }
-        else {
-            pos = view.posAtCoords(lastMove);
-            if (pos == null)
-                return;
-            let posCoords = view.coordsAtPos(pos);
-            if (!posCoords ||
-                lastMove.y < posCoords.top || lastMove.y > posCoords.bottom ||
-                lastMove.x < posCoords.left - view.defaultCharacterWidth ||
-                lastMove.x > posCoords.right + view.defaultCharacterWidth)
-                return;
-            let bidi = view.bidiSpans(view.state.doc.lineAt(pos)).find(s => s.from <= pos && s.to >= pos);
-            let rtl = bidi && bidi.dir == exports.Direction.RTL ? -1 : 1;
-            side = (lastMove.x < posCoords.left ? -rtl : rtl);
-        }
-        let open = this.source(view, pos, side);
-        if (open === null || open === void 0 ? void 0 : open.then) {
-            let pending = this.pending = { pos };
-            open.then(result => {
-                if (this.pending == pending) {
-                    this.pending = null;
-                    if (result)
-                        view.dispatch({ effects: this.setHover.of(result) });
-                }
-            }, e => logException(view.state, e, "hover tooltip"));
-        }
-        else if (open) {
-            view.dispatch({ effects: this.setHover.of(open) });
-        }
-    }
-    get tooltip() {
-        let plugin = this.view.plugin(tooltipPlugin);
-        let index = plugin ? plugin.manager.tooltips.findIndex(t => t.create == HoverTooltipHost.create) : -1;
-        return index > -1 ? plugin.manager.tooltipViews[index] : null;
-    }
-    mousemove(event) {
-        var _a;
-        this.lastMove = { x: event.clientX, y: event.clientY, target: event.target, time: Date.now() };
-        if (this.hoverTimeout < 0)
-            this.hoverTimeout = setTimeout(this.checkHover, this.hoverTime);
-        let { active, tooltip } = this;
-        if (active && tooltip && !isInTooltip(tooltip.dom, event) || this.pending) {
-            let { pos } = active || this.pending, end = (_a = active === null || active === void 0 ? void 0 : active.end) !== null && _a !== void 0 ? _a : pos;
-            if ((pos == end ? this.view.posAtCoords(this.lastMove) != pos
-                : !isOverRange(this.view, pos, end, event.clientX, event.clientY))) {
-                this.view.dispatch({ effects: this.setHover.of(null) });
-                this.pending = null;
-            }
-        }
-    }
-    mouseleave(event) {
-        clearTimeout(this.hoverTimeout);
-        this.hoverTimeout = -1;
-        let { active } = this;
-        if (active) {
-            let { tooltip } = this;
-            let inTooltip = tooltip && tooltip.dom.contains(event.relatedTarget);
-            if (!inTooltip)
-                this.view.dispatch({ effects: this.setHover.of(null) });
-            else
-                this.watchTooltipLeave(tooltip.dom);
-        }
-    }
-    watchTooltipLeave(tooltip) {
-        let watch = (event) => {
-            tooltip.removeEventListener("mouseleave", watch);
-            if (this.active && !this.view.dom.contains(event.relatedTarget))
-                this.view.dispatch({ effects: this.setHover.of(null) });
-        };
-        tooltip.addEventListener("mouseleave", watch);
-    }
-    destroy() {
-        clearTimeout(this.hoverTimeout);
-        this.view.dom.removeEventListener("mouseleave", this.mouseleave);
-        this.view.dom.removeEventListener("mousemove", this.mousemove);
-    }
-}
-const tooltipMargin = 4;
-function isInTooltip(tooltip, event) {
-    let rect = tooltip.getBoundingClientRect();
-    return event.clientX >= rect.left - tooltipMargin && event.clientX <= rect.right + tooltipMargin &&
-        event.clientY >= rect.top - tooltipMargin && event.clientY <= rect.bottom + tooltipMargin;
-}
-function isOverRange(view, from, to, x, y, margin) {
-    let rect = view.scrollDOM.getBoundingClientRect();
-    let docBottom = view.documentTop + view.documentPadding.top + view.contentHeight;
-    if (rect.left > x || rect.right < x || rect.top > y || Math.min(rect.bottom, docBottom) < y)
-        return false;
-    let pos = view.posAtCoords({ x, y }, false);
-    return pos >= from && pos <= to;
-}
-/**
-Set up a hover tooltip, which shows up when the pointer hovers
-over ranges of text. The callback is called when the mouse hovers
-over the document text. It should, if there is a tooltip
-associated with position `pos`, return the tooltip description
-(either directly or in a promise). The `side` argument indicates
-on which side of the position the pointer is—it will be -1 if the
-pointer is before the position, 1 if after the position.
-
-Note that all hover tooltips are hosted within a single tooltip
-container element. This allows multiple tooltips over the same
-range to be "merged" together without overlapping.
-*/
-function hoverTooltip(source, options = {}) {
-    let setHover = index.StateEffect.define();
-    let hoverState = index.StateField.define({
-        create() { return null; },
-        update(value, tr) {
-            if (value && (options.hideOnChange && (tr.docChanged || tr.selection) ||
-                options.hideOn && options.hideOn(tr, value)))
-                return null;
-            if (value && tr.docChanged) {
-                let newPos = tr.changes.mapPos(value.pos, -1, index.MapMode.TrackDel);
-                if (newPos == null)
-                    return null;
-                let copy = Object.assign(Object.create(null), value);
-                copy.pos = newPos;
-                if (value.end != null)
-                    copy.end = tr.changes.mapPos(value.end);
-                value = copy;
-            }
-            for (let effect of tr.effects) {
-                if (effect.is(setHover))
-                    value = effect.value;
-                if (effect.is(closeHoverTooltipEffect))
-                    value = null;
-            }
-            return value;
-        },
-        provide: f => showHoverTooltip.from(f)
-    });
-    return [
-        hoverState,
-        ViewPlugin.define(view => new HoverPlugin(view, source, hoverState, setHover, options.hoverTime || 300 /* Hover.Time */)),
-        showHoverTooltipHost
-    ];
-}
-/**
-Get the active tooltip view for a given tooltip, if available.
-*/
-function getTooltip(view, tooltip) {
-    let plugin = view.plugin(tooltipPlugin);
-    if (!plugin)
-        return null;
-    let found = plugin.manager.tooltips.indexOf(tooltip);
-    return found < 0 ? null : plugin.manager.tooltipViews[found];
-}
-const closeHoverTooltipEffect = /*@__PURE__*/index.StateEffect.define();
-
-const panelConfig = /*@__PURE__*/index.Facet.define({
-    combine(configs) {
-        let topContainer, bottomContainer;
-        for (let c of configs) {
-            topContainer = topContainer || c.topContainer;
-            bottomContainer = bottomContainer || c.bottomContainer;
-        }
-        return { topContainer, bottomContainer };
-    }
-});
-/**
-Get the active panel created by the given constructor, if any.
-This can be useful when you need access to your panels' DOM
-structure.
-*/
-function getPanel(view, panel) {
-    let plugin = view.plugin(panelPlugin);
-    let index = plugin ? plugin.specs.indexOf(panel) : -1;
-    return index > -1 ? plugin.panels[index] : null;
-}
-const panelPlugin = /*@__PURE__*/ViewPlugin.fromClass(class {
-    constructor(view) {
-        this.input = view.state.facet(showPanel);
-        this.specs = this.input.filter(s => s);
-        this.panels = this.specs.map(spec => spec(view));
-        let conf = view.state.facet(panelConfig);
-        this.top = new PanelGroup(view, true, conf.topContainer);
-        this.bottom = new PanelGroup(view, false, conf.bottomContainer);
-        this.top.sync(this.panels.filter(p => p.top));
-        this.bottom.sync(this.panels.filter(p => !p.top));
-        for (let p of this.panels) {
-            p.dom.classList.add("cm-panel");
-            if (p.mount)
-                p.mount();
-        }
-    }
-    update(update) {
-        let conf = update.state.facet(panelConfig);
-        if (this.top.container != conf.topContainer) {
-            this.top.sync([]);
-            this.top = new PanelGroup(update.view, true, conf.topContainer);
-        }
-        if (this.bottom.container != conf.bottomContainer) {
-            this.bottom.sync([]);
-            this.bottom = new PanelGroup(update.view, false, conf.bottomContainer);
-        }
-        this.top.syncClasses();
-        this.bottom.syncClasses();
-        let input = update.state.facet(showPanel);
-        if (input != this.input) {
-            let specs = input.filter(x => x);
-            let panels = [], top = [], bottom = [], mount = [];
-            for (let spec of specs) {
-                let known = this.specs.indexOf(spec), panel;
-                if (known < 0) {
-                    panel = spec(update.view);
-                    mount.push(panel);
-                }
-                else {
-                    panel = this.panels[known];
-                    if (panel.update)
-                        panel.update(update);
-                }
-                panels.push(panel);
-                (panel.top ? top : bottom).push(panel);
-            }
-            this.specs = specs;
-            this.panels = panels;
-            this.top.sync(top);
-            this.bottom.sync(bottom);
-            for (let p of mount) {
-                p.dom.classList.add("cm-panel");
-                if (p.mount)
-                    p.mount();
-            }
-        }
-        else {
-            for (let p of this.panels)
-                if (p.update)
-                    p.update(update);
-        }
-    }
-    destroy() {
-        this.top.sync([]);
-        this.bottom.sync([]);
-    }
-}, {
-    provide: plugin => EditorView.scrollMargins.of(view => {
-        let value = view.plugin(plugin);
-        return value && { top: value.top.scrollMargin(), bottom: value.bottom.scrollMargin() };
-    })
-});
-class PanelGroup {
-    constructor(view, top, container) {
-        this.view = view;
-        this.top = top;
-        this.container = container;
-        this.dom = undefined;
-        this.classes = "";
-        this.panels = [];
-        this.syncClasses();
-    }
-    sync(panels) {
-        for (let p of this.panels)
-            if (p.destroy && panels.indexOf(p) < 0)
-                p.destroy();
-        this.panels = panels;
-        this.syncDOM();
-    }
-    syncDOM() {
-        if (this.panels.length == 0) {
-            if (this.dom) {
-                this.dom.remove();
-                this.dom = undefined;
-            }
-            return;
-        }
-        if (!this.dom) {
-            this.dom = document.createElement("div");
-            this.dom.className = this.top ? "cm-panels cm-panels-top" : "cm-panels cm-panels-bottom";
-            this.dom.style[this.top ? "top" : "bottom"] = "0";
-            let parent = this.container || this.view.dom;
-            parent.insertBefore(this.dom, this.top ? parent.firstChild : null);
-        }
-        let curDOM = this.dom.firstChild;
-        for (let panel of this.panels) {
-            if (panel.dom.parentNode == this.dom) {
-                while (curDOM != panel.dom)
-                    curDOM = rm(curDOM);
-                curDOM = curDOM.nextSibling;
-            }
-            else {
-                this.dom.insertBefore(panel.dom, curDOM);
-            }
-        }
-        while (curDOM)
-            curDOM = rm(curDOM);
-    }
-    scrollMargin() {
-        return !this.dom || this.container ? 0
-            : Math.max(0, this.top ?
-                this.dom.getBoundingClientRect().bottom - Math.max(0, this.view.scrollDOM.getBoundingClientRect().top) :
-                Math.min(innerHeight, this.view.scrollDOM.getBoundingClientRect().bottom) - this.dom.getBoundingClientRect().top);
-    }
-    syncClasses() {
-        if (!this.container || this.classes == this.view.themeClasses)
-            return;
-        for (let cls of this.classes.split(" "))
-            if (cls)
-                this.container.classList.remove(cls);
-        for (let cls of (this.classes = this.view.themeClasses).split(" "))
-            if (cls)
-                this.container.classList.add(cls);
-    }
-}
-function rm(node) {
-    let next = node.nextSibling;
-    node.remove();
-    return next;
-}
-/**
-Opening a panel is done by providing a constructor function for
-the panel through this facet. (The panel is closed again when its
-constructor is no longer provided.) Values of `null` are ignored.
-*/
-const showPanel = /*@__PURE__*/index.Facet.define({
-    enables: panelPlugin
-});
-
-/**
-A gutter marker represents a bit of information attached to a line
-in a specific gutter. Your own custom markers have to extend this
-class.
+A gutter marker represents a bit of information attached to a line
+in a specific gutter. Your own custom markers have to extend this
+class.
 */
 class GutterMarker extends index.RangeValue {
     /**
@@ -9909,478 +8213,16 @@ GutterMarker.prototype.toDOM = undefined;
 GutterMarker.prototype.mapMode = index.MapMode.TrackBefore;
 GutterMarker.prototype.startSide = GutterMarker.prototype.endSide = -1;
 GutterMarker.prototype.point = true;
-/**
-Facet used to add a class to all gutter elements for a given line.
-Markers given to this facet should _only_ define an
-[`elementclass`](https://codemirror.net/6/docs/ref/#view.GutterMarker.elementClass), not a
-[`toDOM`](https://codemirror.net/6/docs/ref/#view.GutterMarker.toDOM) (or the marker will appear
-in all gutters for the line).
-*/
-const gutterLineClass = /*@__PURE__*/index.Facet.define();
-const defaults = {
-    class: "",
-    renderEmptyElements: false,
-    elementStyle: "",
-    markers: () => index.RangeSet.empty,
-    lineMarker: () => null,
-    widgetMarker: () => null,
-    lineMarkerChange: null,
-    initialSpacer: null,
-    updateSpacer: null,
-    domEventHandlers: {}
-};
-const activeGutters = /*@__PURE__*/index.Facet.define();
-/**
-Define an editor gutter. The order in which the gutters appear is
-determined by their extension priority.
-*/
-function gutter(config) {
-    return [gutters(), activeGutters.of(Object.assign(Object.assign({}, defaults), config))];
-}
-const unfixGutters = /*@__PURE__*/index.Facet.define({
-    combine: values => values.some(x => x)
-});
-/**
-The gutter-drawing plugin is automatically enabled when you add a
-gutter, but you can use this function to explicitly configure it.
-
-Unless `fixed` is explicitly set to `false`, the gutters are
-fixed, meaning they don't scroll along with the content
-horizontally (except on Internet Explorer, which doesn't support
-CSS [`position:
-sticky`](https://developer.mozilla.org/en-US/docs/Web/CSS/position#sticky)).
-*/
-function gutters(config) {
-    let result = [
-        gutterView,
-    ];
-    if (config && config.fixed === false)
-        result.push(unfixGutters.of(true));
-    return result;
-}
-const gutterView = /*@__PURE__*/ViewPlugin.fromClass(class {
-    constructor(view) {
-        this.view = view;
-        this.prevViewport = view.viewport;
-        this.dom = document.createElement("div");
-        this.dom.className = "cm-gutters";
-        this.dom.setAttribute("aria-hidden", "true");
-        this.dom.style.minHeight = (this.view.contentHeight / this.view.scaleY) + "px";
-        this.gutters = view.state.facet(activeGutters).map(conf => new SingleGutterView(view, conf));
-        for (let gutter of this.gutters)
-            this.dom.appendChild(gutter.dom);
-        this.fixed = !view.state.facet(unfixGutters);
-        if (this.fixed) {
-            // FIXME IE11 fallback, which doesn't support position: sticky,
-            // by using position: relative + event handlers that realign the
-            // gutter (or just force fixed=false on IE11?)
-            this.dom.style.position = "sticky";
-        }
-        this.syncGutters(false);
-        view.scrollDOM.insertBefore(this.dom, view.contentDOM);
-    }
-    update(update) {
-        if (this.updateGutters(update)) {
-            // Detach during sync when the viewport changed significantly
-            // (such as during scrolling), since for large updates that is
-            // faster.
-            let vpA = this.prevViewport, vpB = update.view.viewport;
-            let vpOverlap = Math.min(vpA.to, vpB.to) - Math.max(vpA.from, vpB.from);
-            this.syncGutters(vpOverlap < (vpB.to - vpB.from) * 0.8);
-        }
-        if (update.geometryChanged)
-            this.dom.style.minHeight = this.view.contentHeight + "px";
-        if (this.view.state.facet(unfixGutters) != !this.fixed) {
-            this.fixed = !this.fixed;
-            this.dom.style.position = this.fixed ? "sticky" : "";
-        }
-        this.prevViewport = update.view.viewport;
-    }
-    syncGutters(detach) {
-        let after = this.dom.nextSibling;
-        if (detach)
-            this.dom.remove();
-        let lineClasses = index.RangeSet.iter(this.view.state.facet(gutterLineClass), this.view.viewport.from);
-        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) {
-            if (classSet.length)
-                classSet = [];
-            if (Array.isArray(line.type)) {
-                let first = true;
-                for (let b of line.type) {
-                    if (b.type == exports.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 if (line.type == exports.BlockType.Text) {
-                advanceCursor(lineClasses, classSet, line.from);
-                for (let cx of contexts)
-                    cx.line(this.view, line, classSet);
-            }
-            else if (line.widget) {
-                for (let cx of contexts)
-                    cx.widget(this.view, line);
-            }
-        }
-        for (let cx of contexts)
-            cx.finish();
-        if (detach)
-            this.view.scrollDOM.insertBefore(this.dom, after);
-    }
-    updateGutters(update) {
-        let prev = update.startState.facet(activeGutters), cur = update.state.facet(activeGutters);
-        let change = update.docChanged || update.heightChanged || update.viewportChanged ||
-            !index.RangeSet.eq(update.startState.facet(gutterLineClass), update.state.facet(gutterLineClass), update.view.viewport.from, update.view.viewport.to);
-        if (prev == cur) {
-            for (let gutter of this.gutters)
-                if (gutter.update(update))
-                    change = true;
-        }
-        else {
-            change = true;
-            let gutters = [];
-            for (let conf of cur) {
-                let known = prev.indexOf(conf);
-                if (known < 0) {
-                    gutters.push(new SingleGutterView(this.view, conf));
-                }
-                else {
-                    this.gutters[known].update(update);
-                    gutters.push(this.gutters[known]);
-                }
-            }
-            for (let g of this.gutters) {
-                g.dom.remove();
-                if (gutters.indexOf(g) < 0)
-                    g.destroy();
-            }
-            for (let g of gutters)
-                this.dom.appendChild(g.dom);
-            this.gutters = gutters;
-        }
-        return change;
-    }
-    destroy() {
-        for (let view of this.gutters)
-            view.destroy();
-        this.dom.remove();
-    }
-}, {
-    provide: plugin => EditorView.scrollMargins.of(view => {
-        let value = view.plugin(plugin);
-        if (!value || value.gutters.length == 0 || !value.fixed)
-            return null;
-        return view.textDirection == exports.Direction.LTR
-            ? { left: value.dom.offsetWidth * view.scaleX }
-            : { right: value.dom.offsetWidth * view.scaleX };
-    })
-});
-function asArray(val) { return (Array.isArray(val) ? val : [val]); }
-function advanceCursor(cursor, collect, pos) {
-    while (cursor.value && cursor.from <= pos) {
-        if (cursor.from == pos)
-            collect.push(cursor.value);
-        cursor.next();
-    }
-}
-class UpdateContext {
-    constructor(gutter, viewport, height) {
-        this.gutter = gutter;
-        this.height = height;
-        this.i = 0;
-        this.cursor = index.RangeSet.iter(gutter.markers, viewport.from);
-    }
-    addElement(view, block, markers) {
-        let { gutter } = this, above = (block.top - this.height) / view.scaleY, height = block.height / view.scaleY;
-        if (this.i == gutter.elements.length) {
-            let newElt = new GutterElement(view, height, above, markers);
-            gutter.elements.push(newElt);
-            gutter.dom.appendChild(newElt.dom);
-        }
-        else {
-            gutter.elements[this.i].update(view, height, above, markers);
-        }
-        this.height = block.bottom;
-        this.i++;
-    }
-    line(view, line, extraMarkers) {
-        let localMarkers = [];
-        advanceCursor(this.cursor, localMarkers, line.from);
-        if (extraMarkers.length)
-            localMarkers = localMarkers.concat(extraMarkers);
-        let forLine = this.gutter.config.lineMarker(view, line, localMarkers);
-        if (forLine)
-            localMarkers.unshift(forLine);
-        let gutter = this.gutter;
-        if (localMarkers.length == 0 && !gutter.config.renderEmptyElements)
-            return;
-        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;
-        while (gutter.elements.length > this.i) {
-            let last = gutter.elements.pop();
-            gutter.dom.removeChild(last.dom);
-            last.destroy();
-        }
-    }
-}
-class SingleGutterView {
-    constructor(view, config) {
-        this.view = view;
-        this.config = config;
-        this.elements = [];
-        this.spacer = null;
-        this.dom = document.createElement("div");
-        this.dom.className = "cm-gutter" + (this.config.class ? " " + this.config.class : "");
-        for (let prop in config.domEventHandlers) {
-            this.dom.addEventListener(prop, (event) => {
-                let target = event.target, y;
-                if (target != this.dom && this.dom.contains(target)) {
-                    while (target.parentNode != this.dom)
-                        target = target.parentNode;
-                    let rect = target.getBoundingClientRect();
-                    y = (rect.top + rect.bottom) / 2;
-                }
-                else {
-                    y = event.clientY;
-                }
-                let line = view.lineBlockAtHeight(y - view.documentTop);
-                if (config.domEventHandlers[prop](view, line, event))
-                    event.preventDefault();
-            });
-        }
-        this.markers = asArray(config.markers(view));
-        if (config.initialSpacer) {
-            this.spacer = new GutterElement(view, 0, 0, [config.initialSpacer(view)]);
-            this.dom.appendChild(this.spacer.dom);
-            this.spacer.dom.style.cssText += "visibility: hidden; pointer-events: none";
-        }
-    }
-    update(update) {
-        let prevMarkers = this.markers;
-        this.markers = asArray(this.config.markers(update.view));
-        if (this.spacer && this.config.updateSpacer) {
-            let updated = this.config.updateSpacer(this.spacer.markers[0], update);
-            if (updated != this.spacer.markers[0])
-                this.spacer.update(update.view, 0, 0, [updated]);
-        }
-        let vp = update.view.viewport;
-        return !index.RangeSet.eq(this.markers, prevMarkers, vp.from, vp.to) ||
-            (this.config.lineMarkerChange ? this.config.lineMarkerChange(update) : false);
-    }
-    destroy() {
-        for (let elt of this.elements)
-            elt.destroy();
-    }
-}
-class GutterElement {
-    constructor(view, height, above, markers) {
-        this.height = -1;
-        this.above = 0;
-        this.markers = [];
-        this.dom = document.createElement("div");
-        this.dom.className = "cm-gutterElement";
-        this.update(view, height, above, markers);
-    }
-    update(view, height, above, markers) {
-        if (this.height != height) {
-            this.height = height;
-            this.dom.style.height = height + "px";
-        }
-        if (this.above != above)
-            this.dom.style.marginTop = (this.above = above) ? above + "px" : "";
-        if (!sameMarkers(this.markers, markers))
-            this.setMarkers(view, markers);
-    }
-    setMarkers(view, markers) {
-        let cls = "cm-gutterElement", domPos = this.dom.firstChild;
-        for (let iNew = 0, iOld = 0;;) {
-            let skipTo = iOld, marker = iNew < markers.length ? markers[iNew++] : null, matched = false;
-            if (marker) {
-                let c = marker.elementClass;
-                if (c)
-                    cls += " " + c;
-                for (let i = iOld; i < this.markers.length; i++)
-                    if (this.markers[i].compare(marker)) {
-                        skipTo = i;
-                        matched = true;
-                        break;
-                    }
-            }
-            else {
-                skipTo = this.markers.length;
-            }
-            while (iOld < skipTo) {
-                let next = this.markers[iOld++];
-                if (next.toDOM) {
-                    next.destroy(domPos);
-                    let after = domPos.nextSibling;
-                    domPos.remove();
-                    domPos = after;
-                }
-            }
-            if (!marker)
-                break;
-            if (marker.toDOM) {
-                if (matched)
-                    domPos = domPos.nextSibling;
-                else
-                    this.dom.insertBefore(marker.toDOM(view), domPos);
-            }
-            if (matched)
-                iOld++;
-        }
-        this.dom.className = cls;
-        this.markers = markers;
-    }
-    destroy() {
-        this.setMarkers(null, []); // First argument not used unless creating markers
-    }
-}
-function sameMarkers(a, b) {
-    if (a.length != b.length)
-        return false;
-    for (let i = 0; i < a.length; i++)
-        if (!a[i].compare(b[i]))
-            return false;
-    return true;
-}
-/**
-Facet used to provide markers to the line number gutter.
-*/
-const lineNumberMarkers = /*@__PURE__*/index.Facet.define();
-const lineNumberConfig = /*@__PURE__*/index.Facet.define({
-    combine(values) {
-        return index.combineConfig(values, { formatNumber: String, domEventHandlers: {} }, {
-            domEventHandlers(a, b) {
-                let result = Object.assign({}, a);
-                for (let event in b) {
-                    let exists = result[event], add = b[event];
-                    result[event] = exists ? (view, line, event) => exists(view, line, event) || add(view, line, event) : add;
-                }
-                return result;
-            }
-        });
-    }
-});
-class NumberMarker extends GutterMarker {
-    constructor(number) {
-        super();
-        this.number = number;
-    }
-    eq(other) { return this.number == other.number; }
-    toDOM() { return document.createTextNode(this.number); }
-}
-function formatNumber(view, number) {
-    return view.state.facet(lineNumberConfig).formatNumber(number, view.state);
-}
-const lineNumberGutter = /*@__PURE__*/activeGutters.compute([lineNumberConfig], state => ({
-    class: "cm-lineNumbers",
-    renderEmptyElements: false,
-    markers(view) { return view.state.facet(lineNumberMarkers); },
-    lineMarker(view, line, others) {
-        if (others.some(m => m.toDOM))
-            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)));
-    },
-    updateSpacer(spacer, update) {
-        let max = formatNumber(update.view, maxLineNumber(update.view.state.doc.lines));
-        return max == spacer.number ? spacer : new NumberMarker(max);
-    },
-    domEventHandlers: state.facet(lineNumberConfig).domEventHandlers
-}));
-/**
-Create a line number gutter extension.
-*/
-function lineNumbers(config = {}) {
-    return [
-        lineNumberConfig.of(config),
-        gutters(),
-        lineNumberGutter
-    ];
-}
-function maxLineNumber(lines) {
-    let last = 9;
-    while (last < lines)
-        last = last * 10 + 9;
-    return last;
-}
-const activeLineGutterMarker = /*@__PURE__*/new class extends GutterMarker {
-    constructor() {
-        super(...arguments);
-        this.elementClass = "cm-activeLineGutter";
-    }
-};
-const activeLineGutterHighlighter = /*@__PURE__*/gutterLineClass.compute(["selection"], state => {
-    let marks = [], last = -1;
-    for (let range of state.selection.ranges) {
-        let linePos = state.doc.lineAt(range.head).from;
-        if (linePos > last) {
-            last = linePos;
-            marks.push(activeLineGutterMarker.range(linePos));
-        }
-    }
-    return index.RangeSet.of(marks);
-});
-/**
-Returns an extension that adds a `cm-activeLineGutter` class to
-all gutter elements on the [active
-line](https://codemirror.net/6/docs/ref/#view.highlightActiveLine).
-*/
-function highlightActiveLineGutter() {
-    return activeLineGutterHighlighter;
-}
 
 exports.BidiSpan = BidiSpan;
 exports.BlockInfo = BlockInfo;
 exports.Decoration = Decoration;
 exports.EditorView = EditorView;
 exports.GutterMarker = GutterMarker;
-exports.MatchDecorator = MatchDecorator;
-exports.RectangleMarker = RectangleMarker;
 exports.ViewPlugin = ViewPlugin;
 exports.ViewUpdate = ViewUpdate;
 exports.WidgetType = WidgetType;
-exports.crosshairCursor = crosshairCursor;
-exports.drawSelection = drawSelection;
-exports.dropCursor = dropCursor;
-exports.getPanel = getPanel;
-exports.getTooltip = getTooltip;
-exports.gutter = gutter;
-exports.gutterLineClass = gutterLineClass;
-exports.gutters = gutters;
-exports.highlightActiveLine = highlightActiveLine;
-exports.highlightActiveLineGutter = highlightActiveLineGutter;
-exports.highlightSpecialChars = highlightSpecialChars;
-exports.hoverTooltip = hoverTooltip;
 exports.keymap = keymap;
-exports.layer = layer;
-exports.lineNumberMarkers = lineNumberMarkers;
-exports.lineNumbers = lineNumbers;
 exports.logException = logException;
 exports.placeholder = placeholder;
-exports.rectangularSelection = rectangularSelection;
-exports.runScopeHandlers = runScopeHandlers;
-exports.showPanel = showPanel;
-exports.showTooltip = showTooltip;
 //# sourceMappingURL=index.js.map