@uiw/react-codemirror 4.6.0 → 4.7.0

package/dist/codemirror.js

@@ -12,7 +12,7 @@ return /******/ (() => { // webpackBootstrap
 /******/ 	"use strict";
 /******/ 	var __webpack_modules__ = ({
 
-/***/ 497:
+/***/ 963:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 
@@ -93,700 +93,6 @@ var external_root_React_commonjs2_react_commonjs_react_amd_react_ = __webpack_re
 var basic_setup_ = __webpack_require__(573);
 // EXTERNAL MODULE: external {"root":["CM","@codemirror/state"],"commonjs":"@codemirror/state","commonjs2":"@codemirror/state"}
 var state_ = __webpack_require__(242);
-;// CONCATENATED MODULE: ./node_modules/@codemirror/text/dist/index.js
-// Compressed representation of the Grapheme_Cluster_Break=Extend
-// information from
-// http://www.unicode.org/Public/13.0.0/ucd/auxiliary/GraphemeBreakProperty.txt.
-// Each pair of elements represents a range, as an offet from the
-// previous range and a length. Numbers are in base-36, with the empty
-// string being a shorthand for 1.
-let extend = /*@__PURE__*/"lc,34,7n,7,7b,19,,,,2,,2,,,20,b,1c,l,g,,2t,7,2,6,2,2,,4,z,,u,r,2j,b,1m,9,9,,o,4,,9,,3,,5,17,3,3b,f,,w,1j,,,,4,8,4,,3,7,a,2,t,,1m,,,,2,4,8,,9,,a,2,q,,2,2,1l,,4,2,4,2,2,3,3,,u,2,3,,b,2,1l,,4,5,,2,4,,k,2,m,6,,,1m,,,2,,4,8,,7,3,a,2,u,,1n,,,,c,,9,,14,,3,,1l,3,5,3,,4,7,2,b,2,t,,1m,,2,,2,,3,,5,2,7,2,b,2,s,2,1l,2,,,2,4,8,,9,,a,2,t,,20,,4,,2,3,,,8,,29,,2,7,c,8,2q,,2,9,b,6,22,2,r,,,,,,1j,e,,5,,2,5,b,,10,9,,2u,4,,6,,2,2,2,p,2,4,3,g,4,d,,2,2,6,,f,,jj,3,qa,3,t,3,t,2,u,2,1s,2,,7,8,,2,b,9,,19,3,3b,2,y,,3a,3,4,2,9,,6,3,63,2,2,,1m,,,7,,,,,2,8,6,a,2,,1c,h,1r,4,1c,7,,,5,,14,9,c,2,w,4,2,2,,3,1k,,,2,3,,,3,1m,8,2,2,48,3,,d,,7,4,,6,,3,2,5i,1m,,5,ek,,5f,x,2da,3,3x,,2o,w,fe,6,2x,2,n9w,4,,a,w,2,28,2,7k,,3,,4,,p,2,5,,47,2,q,i,d,,12,8,p,b,1a,3,1c,,2,4,2,2,13,,1v,6,2,2,2,2,c,,8,,1b,,1f,,,3,2,2,5,2,,,16,2,8,,6m,,2,,4,,fn4,,kh,g,g,g,a6,2,gt,,6a,,45,5,1ae,3,,2,5,4,14,3,4,,4l,2,fx,4,ar,2,49,b,4w,,1i,f,1k,3,1d,4,2,2,1x,3,10,5,,8,1q,,c,2,1g,9,a,4,2,,2n,3,2,,,2,6,,4g,,3,8,l,2,1l,2,,,,,m,,e,7,3,5,5f,8,2,3,,,n,,29,,2,6,,,2,,,2,,2,6j,,2,4,6,2,,2,r,2,2d,8,2,,,2,2y,,,,2,6,,,2t,3,2,4,,5,77,9,,2,6t,,a,2,,,4,,40,4,2,2,4,,w,a,14,6,2,4,8,,9,6,2,3,1a,d,,2,ba,7,,6,,,2a,m,2,7,,2,,2,3e,6,3,,,2,,7,,,20,2,3,,,,9n,2,f0b,5,1n,7,t4,,1r,4,29,,f5k,2,43q,,,3,4,5,8,8,2,7,u,4,44,3,1iz,1j,4,1e,8,,e,,m,5,,f,11s,7,,h,2,7,,2,,5,79,7,c5,4,15s,7,31,7,240,5,gx7k,2o,3k,6o".split(",").map(s => s ? parseInt(s, 36) : 1);
-// Convert offsets into absolute values
-for (let i = 1; i < extend.length; i++)
-    extend[i] += extend[i - 1];
-function isExtendingChar(code) {
-    for (let i = 1; i < extend.length; i += 2)
-        if (extend[i] > code)
-            return extend[i - 1] <= code;
-    return false;
-}
-function isRegionalIndicator(code) {
-    return code >= 0x1F1E6 && code <= 0x1F1FF;
-}
-const ZWJ = 0x200d;
-/**
-Returns a next grapheme cluster break _after_ (not equal to)
-`pos`, if `forward` is true, or before otherwise. Returns `pos`
-itself if no further cluster break is available in the string.
-Moves across surrogate pairs, extending characters (when
-`includeExtending` is true), characters joined with zero-width
-joiners, and flag emoji.
-*/
-function findClusterBreak(str, pos, forward = true, includeExtending = true) {
-    return (forward ? nextClusterBreak : prevClusterBreak)(str, pos, includeExtending);
-}
-function nextClusterBreak(str, pos, includeExtending) {
-    if (pos == str.length)
-        return pos;
-    // If pos is in the middle of a surrogate pair, move to its start
-    if (pos && surrogateLow(str.charCodeAt(pos)) && surrogateHigh(str.charCodeAt(pos - 1)))
-        pos--;
-    let prev = codePointAt(str, pos);
-    pos += codePointSize(prev);
-    while (pos < str.length) {
-        let next = codePointAt(str, pos);
-        if (prev == ZWJ || next == ZWJ || includeExtending && isExtendingChar(next)) {
-            pos += codePointSize(next);
-            prev = next;
-        }
-        else if (isRegionalIndicator(next)) {
-            let countBefore = 0, i = pos - 2;
-            while (i >= 0 && isRegionalIndicator(codePointAt(str, i))) {
-                countBefore++;
-                i -= 2;
-            }
-            if (countBefore % 2 == 0)
-                break;
-            else
-                pos += 2;
-        }
-        else {
-            break;
-        }
-    }
-    return pos;
-}
-function prevClusterBreak(str, pos, includeExtending) {
-    while (pos > 0) {
-        let found = nextClusterBreak(str, pos - 2, includeExtending);
-        if (found < pos)
-            return found;
-        pos--;
-    }
-    return 0;
-}
-function surrogateLow(ch) { return ch >= 0xDC00 && ch < 0xE000; }
-function surrogateHigh(ch) { return ch >= 0xD800 && ch < 0xDC00; }
-/**
-Find the code point at the given position in a string (like the
-[`codePointAt`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/codePointAt)
-string method).
-*/
-function codePointAt(str, pos) {
-    let code0 = str.charCodeAt(pos);
-    if (!surrogateHigh(code0) || pos + 1 == str.length)
-        return code0;
-    let code1 = str.charCodeAt(pos + 1);
-    if (!surrogateLow(code1))
-        return code0;
-    return ((code0 - 0xd800) << 10) + (code1 - 0xdc00) + 0x10000;
-}
-/**
-Given a Unicode codepoint, return the JavaScript string that
-respresents it (like
-[`String.fromCodePoint`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCodePoint)).
-*/
-function fromCodePoint(code) {
-    if (code <= 0xffff)
-        return String.fromCharCode(code);
-    code -= 0x10000;
-    return String.fromCharCode((code >> 10) + 0xd800, (code & 1023) + 0xdc00);
-}
-/**
-The first character that takes up two positions in a JavaScript
-string. It is often useful to compare with this after calling
-`codePointAt`, to figure out whether your character takes up 1 or
-2 index positions.
-*/
-function codePointSize(code) { return code < 0x10000 ? 1 : 2; }
-
-/**
-Count the column position at the given offset into the string,
-taking extending characters and tab size into account.
-*/
-function dist_countColumn(string, tabSize, to = string.length) {
-    let n = 0;
-    for (let i = 0; i < to;) {
-        if (string.charCodeAt(i) == 9) {
-            n += tabSize - (n % tabSize);
-            i++;
-        }
-        else {
-            n++;
-            i = findClusterBreak(string, i);
-        }
-    }
-    return n;
-}
-/**
-Find the offset that corresponds to the given column position in a
-string, taking extending characters and tab size into account. By
-default, the string length is returned when it is too short to
-reach the column. Pass `strict` true to make it return -1 in that
-situation.
-*/
-function findColumn(string, col, tabSize, strict) {
-    for (let i = 0, n = 0;;) {
-        if (n >= col)
-            return i;
-        if (i == string.length)
-            break;
-        n += string.charCodeAt(i) == 9 ? tabSize - (n % tabSize) : 1;
-        i = findClusterBreak(string, i);
-    }
-    return strict === true ? -1 : string.length;
-}
-
-/**
-The data structure for documents.
-*/
-class dist_Text {
-    /**
-    @internal
-    */
-    constructor() { }
-    /**
-    Get the line description around the given position.
-    */
-    lineAt(pos) {
-        if (pos < 0 || pos > this.length)
-            throw new RangeError(`Invalid position ${pos} in document of length ${this.length}`);
-        return this.lineInner(pos, false, 1, 0);
-    }
-    /**
-    Get the description for the given (1-based) line number.
-    */
-    line(n) {
-        if (n < 1 || n > this.lines)
-            throw new RangeError(`Invalid line number ${n} in ${this.lines}-line document`);
-        return this.lineInner(n, true, 1, 0);
-    }
-    /**
-    Replace a range of the text with the given content.
-    */
-    replace(from, to, text) {
-        let parts = [];
-        this.decompose(0, from, parts, 2 /* To */);
-        if (text.length)
-            text.decompose(0, text.length, parts, 1 /* From */ | 2 /* To */);
-        this.decompose(to, this.length, parts, 1 /* From */);
-        return TextNode.from(parts, this.length - (to - from) + text.length);
-    }
-    /**
-    Append another document to this one.
-    */
-    append(other) {
-        return this.replace(this.length, this.length, other);
-    }
-    /**
-    Retrieve the text between the given points.
-    */
-    slice(from, to = this.length) {
-        let parts = [];
-        this.decompose(from, to, parts, 0);
-        return TextNode.from(parts, to - from);
-    }
-    /**
-    Test whether this text is equal to another instance.
-    */
-    eq(other) {
-        if (other == this)
-            return true;
-        if (other.length != this.length || other.lines != this.lines)
-            return false;
-        let start = this.scanIdentical(other, 1), end = this.length - this.scanIdentical(other, -1);
-        let a = new RawTextCursor(this), b = new RawTextCursor(other);
-        for (let skip = start, pos = start;;) {
-            a.next(skip);
-            b.next(skip);
-            skip = 0;
-            if (a.lineBreak != b.lineBreak || a.done != b.done || a.value != b.value)
-                return false;
-            pos += a.value.length;
-            if (a.done || pos >= end)
-                return true;
-        }
-    }
-    /**
-    Iterate over the text. When `dir` is `-1`, iteration happens
-    from end to start. This will return lines and the breaks between
-    them as separate strings, and for long lines, might split lines
-    themselves into multiple chunks as well.
-    */
-    iter(dir = 1) { return new RawTextCursor(this, dir); }
-    /**
-    Iterate over a range of the text. When `from` > `to`, the
-    iterator will run in reverse.
-    */
-    iterRange(from, to = this.length) { return new PartialTextCursor(this, from, to); }
-    /**
-    Return a cursor that iterates over the given range of lines,
-    _without_ returning the line breaks between, and yielding empty
-    strings for empty lines.
-    
-    When `from` and `to` are given, they should be 1-based line numbers.
-    */
-    iterLines(from, to) {
-        let inner;
-        if (from == null) {
-            inner = this.iter();
-        }
-        else {
-            if (to == null)
-                to = this.lines + 1;
-            let start = this.line(from).from;
-            inner = this.iterRange(start, Math.max(start, to == this.lines + 1 ? this.length : to <= 1 ? 0 : this.line(to - 1).to));
-        }
-        return new LineCursor(inner);
-    }
-    /**
-    @internal
-    */
-    toString() { return this.sliceString(0); }
-    /**
-    Convert the document to an array of lines (which can be
-    deserialized again via [`Text.of`](https://codemirror.net/6/docs/ref/#text.Text^of)).
-    */
-    toJSON() {
-        let lines = [];
-        this.flatten(lines);
-        return lines;
-    }
-    /**
-    Create a `Text` instance for the given array of lines.
-    */
-    static of(text) {
-        if (text.length == 0)
-            throw new RangeError("A document must have at least one line");
-        if (text.length == 1 && !text[0])
-            return dist_Text.empty;
-        return text.length <= 32 /* Branch */ ? new TextLeaf(text) : TextNode.from(TextLeaf.split(text, []));
-    }
-}
-// Leaves store an array of line strings. There are always line breaks
-// between these strings. Leaves are limited in size and have to be
-// contained in TextNode instances for bigger documents.
-class TextLeaf extends dist_Text {
-    constructor(text, length = textLength(text)) {
-        super();
-        this.text = text;
-        this.length = length;
-    }
-    get lines() { return this.text.length; }
-    get children() { return null; }
-    lineInner(target, isLine, line, offset) {
-        for (let i = 0;; i++) {
-            let string = this.text[i], end = offset + string.length;
-            if ((isLine ? line : end) >= target)
-                return new Line(offset, end, line, string);
-            offset = end + 1;
-            line++;
-        }
-    }
-    decompose(from, to, target, open) {
-        let text = from <= 0 && to >= this.length ? this
-            : new TextLeaf(sliceText(this.text, from, to), Math.min(to, this.length) - Math.max(0, from));
-        if (open & 1 /* From */) {
-            let prev = target.pop();
-            let joined = appendText(text.text, prev.text.slice(), 0, text.length);
-            if (joined.length <= 32 /* Branch */) {
-                target.push(new TextLeaf(joined, prev.length + text.length));
-            }
-            else {
-                let mid = joined.length >> 1;
-                target.push(new TextLeaf(joined.slice(0, mid)), new TextLeaf(joined.slice(mid)));
-            }
-        }
-        else {
-            target.push(text);
-        }
-    }
-    replace(from, to, text) {
-        if (!(text instanceof TextLeaf))
-            return super.replace(from, to, text);
-        let lines = appendText(this.text, appendText(text.text, sliceText(this.text, 0, from)), to);
-        let newLen = this.length + text.length - (to - from);
-        if (lines.length <= 32 /* Branch */)
-            return new TextLeaf(lines, newLen);
-        return TextNode.from(TextLeaf.split(lines, []), newLen);
-    }
-    sliceString(from, to = this.length, lineSep = "\n") {
-        let result = "";
-        for (let pos = 0, i = 0; pos <= to && i < this.text.length; i++) {
-            let line = this.text[i], end = pos + line.length;
-            if (pos > from && i)
-                result += lineSep;
-            if (from < end && to > pos)
-                result += line.slice(Math.max(0, from - pos), to - pos);
-            pos = end + 1;
-        }
-        return result;
-    }
-    flatten(target) {
-        for (let line of this.text)
-            target.push(line);
-    }
-    scanIdentical() { return 0; }
-    static split(text, target) {
-        let part = [], len = -1;
-        for (let line of text) {
-            part.push(line);
-            len += line.length + 1;
-            if (part.length == 32 /* Branch */) {
-                target.push(new TextLeaf(part, len));
-                part = [];
-                len = -1;
-            }
-        }
-        if (len > -1)
-            target.push(new TextLeaf(part, len));
-        return target;
-    }
-}
-// Nodes provide the tree structure of the `Text` type. They store a
-// number of other nodes or leaves, taking care to balance themselves
-// on changes. There are implied line breaks _between_ the children of
-// a node (but not before the first or after the last child).
-class TextNode extends dist_Text {
-    constructor(children, length) {
-        super();
-        this.children = children;
-        this.length = length;
-        this.lines = 0;
-        for (let child of children)
-            this.lines += child.lines;
-    }
-    lineInner(target, isLine, line, offset) {
-        for (let i = 0;; i++) {
-            let child = this.children[i], end = offset + child.length, endLine = line + child.lines - 1;
-            if ((isLine ? endLine : end) >= target)
-                return child.lineInner(target, isLine, line, offset);
-            offset = end + 1;
-            line = endLine + 1;
-        }
-    }
-    decompose(from, to, target, open) {
-        for (let i = 0, pos = 0; pos <= to && i < this.children.length; i++) {
-            let child = this.children[i], end = pos + child.length;
-            if (from <= end && to >= pos) {
-                let childOpen = open & ((pos <= from ? 1 /* From */ : 0) | (end >= to ? 2 /* To */ : 0));
-                if (pos >= from && end <= to && !childOpen)
-                    target.push(child);
-                else
-                    child.decompose(from - pos, to - pos, target, childOpen);
-            }
-            pos = end + 1;
-        }
-    }
-    replace(from, to, text) {
-        if (text.lines < this.lines)
-            for (let i = 0, pos = 0; i < this.children.length; i++) {
-                let child = this.children[i], end = pos + child.length;
-                // Fast path: if the change only affects one child and the
-                // child's size remains in the acceptable range, only update
-                // that child
-                if (from >= pos && to <= end) {
-                    let updated = child.replace(from - pos, to - pos, text);
-                    let totalLines = this.lines - child.lines + updated.lines;
-                    if (updated.lines < (totalLines >> (5 /* BranchShift */ - 1)) &&
-                        updated.lines > (totalLines >> (5 /* BranchShift */ + 1))) {
-                        let copy = this.children.slice();
-                        copy[i] = updated;
-                        return new TextNode(copy, this.length - (to - from) + text.length);
-                    }
-                    return super.replace(pos, end, updated);
-                }
-                pos = end + 1;
-            }
-        return super.replace(from, to, text);
-    }
-    sliceString(from, to = this.length, lineSep = "\n") {
-        let result = "";
-        for (let i = 0, pos = 0; i < this.children.length && pos <= to; i++) {
-            let child = this.children[i], end = pos + child.length;
-            if (pos > from && i)
-                result += lineSep;
-            if (from < end && to > pos)
-                result += child.sliceString(from - pos, to - pos, lineSep);
-            pos = end + 1;
-        }
-        return result;
-    }
-    flatten(target) {
-        for (let child of this.children)
-            child.flatten(target);
-    }
-    scanIdentical(other, dir) {
-        if (!(other instanceof TextNode))
-            return 0;
-        let length = 0;
-        let [iA, iB, eA, eB] = dir > 0 ? [0, 0, this.children.length, other.children.length]
-            : [this.children.length - 1, other.children.length - 1, -1, -1];
-        for (;; iA += dir, iB += dir) {
-            if (iA == eA || iB == eB)
-                return length;
-            let chA = this.children[iA], chB = other.children[iB];
-            if (chA != chB)
-                return length + chA.scanIdentical(chB, dir);
-            length += chA.length + 1;
-        }
-    }
-    static from(children, length = children.reduce((l, ch) => l + ch.length + 1, -1)) {
-        let lines = 0;
-        for (let ch of children)
-            lines += ch.lines;
-        if (lines < 32 /* Branch */) {
-            let flat = [];
-            for (let ch of children)
-                ch.flatten(flat);
-            return new TextLeaf(flat, length);
-        }
-        let chunk = Math.max(32 /* Branch */, lines >> 5 /* BranchShift */), maxChunk = chunk << 1, minChunk = chunk >> 1;
-        let chunked = [], currentLines = 0, currentLen = -1, currentChunk = [];
-        function add(child) {
-            let last;
-            if (child.lines > maxChunk && child instanceof TextNode) {
-                for (let node of child.children)
-                    add(node);
-            }
-            else if (child.lines > minChunk && (currentLines > minChunk || !currentLines)) {
-                flush();
-                chunked.push(child);
-            }
-            else if (child instanceof TextLeaf && currentLines &&
-                (last = currentChunk[currentChunk.length - 1]) instanceof TextLeaf &&
-                child.lines + last.lines <= 32 /* Branch */) {
-                currentLines += child.lines;
-                currentLen += child.length + 1;
-                currentChunk[currentChunk.length - 1] = new TextLeaf(last.text.concat(child.text), last.length + 1 + child.length);
-            }
-            else {
-                if (currentLines + child.lines > chunk)
-                    flush();
-                currentLines += child.lines;
-                currentLen += child.length + 1;
-                currentChunk.push(child);
-            }
-        }
-        function flush() {
-            if (currentLines == 0)
-                return;
-            chunked.push(currentChunk.length == 1 ? currentChunk[0] : TextNode.from(currentChunk, currentLen));
-            currentLen = -1;
-            currentLines = currentChunk.length = 0;
-        }
-        for (let child of children)
-            add(child);
-        flush();
-        return chunked.length == 1 ? chunked[0] : new TextNode(chunked, length);
-    }
-}
-dist_Text.empty = /*@__PURE__*/new TextLeaf([""], 0);
-function textLength(text) {
-    let length = -1;
-    for (let line of text)
-        length += line.length + 1;
-    return length;
-}
-function appendText(text, target, from = 0, to = 1e9) {
-    for (let pos = 0, i = 0, first = true; i < text.length && pos <= to; i++) {
-        let line = text[i], end = pos + line.length;
-        if (end >= from) {
-            if (end > to)
-                line = line.slice(0, to - pos);
-            if (pos < from)
-                line = line.slice(from - pos);
-            if (first) {
-                target[target.length - 1] += line;
-                first = false;
-            }
-            else
-                target.push(line);
-        }
-        pos = end + 1;
-    }
-    return target;
-}
-function sliceText(text, from, to) {
-    return appendText(text, [""], from, to);
-}
-class RawTextCursor {
-    constructor(text, dir = 1) {
-        this.dir = dir;
-        this.done = false;
-        this.lineBreak = false;
-        this.value = "";
-        this.nodes = [text];
-        this.offsets = [dir > 0 ? 1 : (text instanceof TextLeaf ? text.text.length : text.children.length) << 1];
-    }
-    nextInner(skip, dir) {
-        this.done = this.lineBreak = false;
-        for (;;) {
-            let last = this.nodes.length - 1;
-            let top = this.nodes[last], offsetValue = this.offsets[last], offset = offsetValue >> 1;
-            let size = top instanceof TextLeaf ? top.text.length : top.children.length;
-            if (offset == (dir > 0 ? size : 0)) {
-                if (last == 0) {
-                    this.done = true;
-                    this.value = "";
-                    return this;
-                }
-                if (dir > 0)
-                    this.offsets[last - 1]++;
-                this.nodes.pop();
-                this.offsets.pop();
-            }
-            else if ((offsetValue & 1) == (dir > 0 ? 0 : 1)) {
-                this.offsets[last] += dir;
-                if (skip == 0) {
-                    this.lineBreak = true;
-                    this.value = "\n";
-                    return this;
-                }
-                skip--;
-            }
-            else if (top instanceof TextLeaf) {
-                // Move to the next string
-                let next = top.text[offset + (dir < 0 ? -1 : 0)];
-                this.offsets[last] += dir;
-                if (next.length > Math.max(0, skip)) {
-                    this.value = skip == 0 ? next : dir > 0 ? next.slice(skip) : next.slice(0, next.length - skip);
-                    return this;
-                }
-                skip -= next.length;
-            }
-            else {
-                let next = top.children[offset + (dir < 0 ? -1 : 0)];
-                if (skip > next.length) {
-                    skip -= next.length;
-                    this.offsets[last] += dir;
-                }
-                else {
-                    if (dir < 0)
-                        this.offsets[last]--;
-                    this.nodes.push(next);
-                    this.offsets.push(dir > 0 ? 1 : (next instanceof TextLeaf ? next.text.length : next.children.length) << 1);
-                }
-            }
-        }
-    }
-    next(skip = 0) {
-        if (skip < 0) {
-            this.nextInner(-skip, (-this.dir));
-            skip = this.value.length;
-        }
-        return this.nextInner(skip, this.dir);
-    }
-}
-class PartialTextCursor {
-    constructor(text, start, end) {
-        this.value = "";
-        this.done = false;
-        this.cursor = new RawTextCursor(text, start > end ? -1 : 1);
-        this.pos = start > end ? text.length : 0;
-        this.from = Math.min(start, end);
-        this.to = Math.max(start, end);
-    }
-    nextInner(skip, dir) {
-        if (dir < 0 ? this.pos <= this.from : this.pos >= this.to) {
-            this.value = "";
-            this.done = true;
-            return this;
-        }
-        skip += Math.max(0, dir < 0 ? this.pos - this.to : this.from - this.pos);
-        let limit = dir < 0 ? this.pos - this.from : this.to - this.pos;
-        if (skip > limit)
-            skip = limit;
-        limit -= skip;
-        let { value } = this.cursor.next(skip);
-        this.pos += (value.length + skip) * dir;
-        this.value = value.length <= limit ? value : dir < 0 ? value.slice(value.length - limit) : value.slice(0, limit);
-        this.done = !this.value;
-        return this;
-    }
-    next(skip = 0) {
-        if (skip < 0)
-            skip = Math.max(skip, this.from - this.pos);
-        else if (skip > 0)
-            skip = Math.min(skip, this.to - this.pos);
-        return this.nextInner(skip, this.cursor.dir);
-    }
-    get lineBreak() { return this.cursor.lineBreak && this.value != ""; }
-}
-class LineCursor {
-    constructor(inner) {
-        this.inner = inner;
-        this.afterBreak = true;
-        this.value = "";
-        this.done = false;
-    }
-    next(skip = 0) {
-        let { done, lineBreak, value } = this.inner.next(skip);
-        if (done) {
-            this.done = true;
-            this.value = "";
-        }
-        else if (lineBreak) {
-            if (this.afterBreak) {
-                this.value = "";
-            }
-            else {
-                this.afterBreak = true;
-                this.next();
-            }
-        }
-        else {
-            this.value = value;
-            this.afterBreak = false;
-        }
-        return this;
-    }
-    get lineBreak() { return false; }
-}
-if (typeof Symbol != "undefined") {
-    dist_Text.prototype[Symbol.iterator] = function () { return this.iter(); };
-    RawTextCursor.prototype[Symbol.iterator] = PartialTextCursor.prototype[Symbol.iterator] =
-        LineCursor.prototype[Symbol.iterator] = function () { return this; };
-}
-/**
-This type describes a line in the document. It is created
-on-demand when lines are [queried](https://codemirror.net/6/docs/ref/#text.Text.lineAt).
-*/
-class Line {
-    /**
-    @internal
-    */
-    constructor(
-    /**
-    The position of the start of the line.
-    */
-    from, 
-    /**
-    The position at the end of the line (_before_ the line break,
-    or at the end of document for the last line).
-    */
-    to, 
-    /**
-    This line's line number (1-based).
-    */
-    number, 
-    /**
-    The line's content.
-    */
-    text) {
-        this.from = from;
-        this.to = to;
-        this.number = number;
-        this.text = text;
-    }
-    /**
-    The length of the line (not including any line break after it).
-    */
-    get length() { return this.to - this.from; }
-}
-
-
-
 // EXTERNAL MODULE: external {"root":["CM","@codemirror/view"],"commonjs":"@codemirror/view","commonjs2":"@codemirror/view"}
 var view_ = __webpack_require__(105);
 ;// CONCATENATED MODULE: ./node_modules/@lezer/common/dist/index.js
@@ -824,7 +130,7 @@ class dist_NodeProp {
         if (this.perNode)
             throw new RangeError("Can't add per-node props to node types");
         if (typeof match != "function")
-            match = NodeType.match(match);
+            match = dist_NodeType.match(match);
         return (type) => {
             let result = match(type);
             return result === undefined ? null : [this, result];
@@ -881,7 +187,7 @@ class MountedTree {
 }
 const noProps = Object.create(null);
 /// Each node in a syntax tree has a node type associated with it.
-class NodeType {
+class dist_NodeType {
     /// @internal
     constructor(
     /// The name of the node type. Not necessarily unique, but if the
@@ -905,7 +211,7 @@ class NodeType {
         let props = spec.props && spec.props.length ? Object.create(null) : noProps;
         let flags = (spec.top ? 1 /* Top */ : 0) | (spec.skipped ? 2 /* Skipped */ : 0) |
             (spec.error ? 4 /* Error */ : 0) | (spec.name == null ? 8 /* Anonymous */ : 0);
-        let type = new NodeType(spec.name || "", props, spec.id, flags);
+        let type = new dist_NodeType(spec.name || "", props, spec.id, flags);
         if (spec.props)
             for (let src of spec.props) {
                 if (!Array.isArray(src))
@@ -962,7 +268,7 @@ class NodeType {
     }
 }
 /// An empty dummy node type to use when no actual type is available.
-NodeType.none = new NodeType("", Object.create(null), 0, 8 /* Anonymous */);
+dist_NodeType.none = new dist_NodeType("", Object.create(null), 0, 8 /* Anonymous */);
 /// A node set holds a collection of node types. It is used to
 /// compactly represent trees by storing their type ids, rather than a
 /// full pointer to the type object, in a numeric array. Each parser
@@ -996,12 +302,34 @@ class NodeSet {
                     newProps[add[0].id] = add[1];
                 }
             }
-            newTypes.push(newProps ? new NodeType(type.name, newProps, type.id, type.flags) : type);
+            newTypes.push(newProps ? new dist_NodeType(type.name, newProps, type.id, type.flags) : type);
         }
         return new NodeSet(newTypes);
     }
 }
 const CachedNode = new WeakMap(), CachedInnerNode = new WeakMap();
+/// Options that control iteration. Can be combined with the `|`
+/// operator to enable multiple ones.
+var IterMode;
+(function (IterMode) {
+    /// When enabled, iteration will only visit [`Tree`](#common.Tree)
+    /// objects, not nodes packed into
+    /// [`TreeBuffer`](#common.TreeBuffer)s.
+    IterMode[IterMode["ExcludeBuffers"] = 1] = "ExcludeBuffers";
+    /// Enable this to make iteration include anonymous nodes (such as
+    /// the nodes that wrap repeated grammar constructs into a balanced
+    /// tree).
+    IterMode[IterMode["IncludeAnonymous"] = 2] = "IncludeAnonymous";
+    /// By default, regular [mounted](#common.NodeProp^mounted) nodes
+    /// replace their base node in iteration. Enable this to ignore them
+    /// instead.
+    IterMode[IterMode["IgnoreMounts"] = 4] = "IgnoreMounts";
+    /// This option only applies in
+    /// [`enter`](#common.SyntaxNode.enter)-style methods. It tells the
+    /// library to not enter mounted overlays if one covers the given
+    /// position.
+    IterMode[IterMode["IgnoreOverlays"] = 8] = "IgnoreOverlays";
+})(IterMode || (IterMode = {}));
 /// A piece of syntax tree. There are two ways to approach these
 /// trees: the way they are actually stored in memory, and the
 /// convenient way.
@@ -1016,7 +344,7 @@ const CachedNode = new WeakMap(), CachedInnerNode = new WeakMap();
 /// [`SyntaxNode`](#common.SyntaxNode) interface instead, which provides
 /// a view on some part of this data structure, and can be used to
 /// move around to adjacent nodes.
-class Tree {
+class dist_Tree {
     /// Construct a new tree. See also [`Tree.build`](#common.Tree^build).
     constructor(
     /// The type of the top node.
@@ -1060,25 +388,22 @@ class Tree {
             (/\W/.test(this.type.name) && !this.type.isError ? JSON.stringify(this.type.name) : this.type.name) +
                 (children.length ? "(" + children + ")" : "");
     }
-    /// Get a [tree cursor](#common.TreeCursor) rooted at this tree. When
-    /// `pos` is given, the cursor is [moved](#common.TreeCursor.moveTo)
-    /// to the given position and side.
-    cursor(pos, side = 0) {
-        let scope = (pos != null && CachedNode.get(this)) || this.topNode;
+    /// Get a [tree cursor](#common.TreeCursor) positioned at the top of
+    /// the tree. Mode can be used to [control](#common.IterMode) which
+    /// nodes the cursor visits.
+    cursor(mode = 0) {
+        return new TreeCursor(this.topNode, mode);
+    }
+    /// Get a [tree cursor](#common.TreeCursor) pointing into this tree
+    /// at the given position and side (see
+    /// [`moveTo`](#common.TreeCursor.moveTo).
+    cursorAt(pos, side = 0, mode = 0) {
+        let scope = CachedNode.get(this) || this.topNode;
         let cursor = new TreeCursor(scope);
-        if (pos != null) {
-            cursor.moveTo(pos, side);
-            CachedNode.set(this, cursor._tree);
-        }
+        cursor.moveTo(pos, side);
+        CachedNode.set(this, cursor._tree);
         return cursor;
     }
-    /// Get a [tree cursor](#common.TreeCursor) that, unlike regular
-    /// cursors, doesn't skip through
-    /// [anonymous](#common.NodeType.isAnonymous) nodes and doesn't
-    /// automatically enter mounted nodes.
-    fullCursor() {
-        return new TreeCursor(this.topNode, 1 /* Full */);
-    }
     /// Get a [syntax node](#common.SyntaxNode) object for the top of the
     /// tree.
     get topNode() {
@@ -1111,23 +436,21 @@ class Tree {
     /// 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(), get = () => c.node;;) {
-            let mustLeave = false;
-            if (c.from <= to && c.to >= from && (c.type.isAnonymous || enter(c.type, c.from, c.to, get) !== false)) {
+        for (let c = this.cursor((spec.mode || 0) | IterMode.IncludeAnonymous);;) {
+            let entered = false;
+            if (c.from <= to && c.to >= from && (c.type.isAnonymous || enter(c) !== false)) {
                 if (c.firstChild())
                     continue;
-                if (!c.type.isAnonymous)
-                    mustLeave = true;
+                entered = true;
             }
             for (;;) {
-                if (mustLeave && leave)
-                    leave(c.type, c.from, c.to, get);
-                mustLeave = c.type.isAnonymous;
+                if (entered && leave && !c.type.isAnonymous)
+                    leave(c);
                 if (c.nextSibling())
                     break;
                 if (!c.parent())
                     return;
-                mustLeave = true;
+                entered = true;
             }
         }
     }
@@ -1151,14 +474,14 @@ class Tree {
     /// [`NodeType.none`](#common.NodeType^none).
     balance(config = {}) {
         return this.children.length <= 8 /* BranchFactor */ ? this :
-            balanceRange(NodeType.none, this.children, this.positions, 0, this.children.length, 0, this.length, (children, positions, length) => new Tree(this.type, children, positions, length, this.propValues), config.makeTree || ((children, positions, length) => new Tree(NodeType.none, children, positions, length)));
+            balanceRange(dist_NodeType.none, this.children, this.positions, 0, this.children.length, 0, this.length, (children, positions, length) => new dist_Tree(this.type, children, positions, length, this.propValues), config.makeTree || ((children, positions, length) => new dist_Tree(dist_NodeType.none, children, positions, length)));
     }
     /// Build a tree from a postfix-ordered buffer of node information,
     /// or a cursor over such a buffer.
     static build(data) { return buildTree(data); }
 }
 /// The empty tree
-Tree.empty = new Tree(NodeType.none, [], [], 0);
+dist_Tree.empty = new dist_Tree(dist_NodeType.none, [], [], 0);
 class FlatBufferCursor {
     constructor(buffer, index) {
         this.buffer = buffer;
@@ -1190,7 +513,7 @@ class TreeBuffer {
         this.set = set;
     }
     /// @internal
-    get type() { return NodeType.none; }
+    get type() { return dist_NodeType.none; }
     /// @internal
     toString() {
         let result = [];
@@ -1278,72 +601,73 @@ function resolveNode(node, pos, side, overlays) {
             return node;
         node = parent;
     }
+    let mode = overlays ? 0 : IterMode.IgnoreOverlays;
     // Must go up out of overlays when those do not overlap with pos
     if (overlays)
         for (let scan = node, parent = scan.parent; parent; scan = parent, parent = scan.parent) {
-            if (scan instanceof TreeNode && scan.index < 0 && ((_a = parent.enter(pos, side, true)) === null || _a === void 0 ? void 0 : _a.from) != scan.from)
+            if (scan instanceof TreeNode && scan.index < 0 && ((_a = parent.enter(pos, side, mode)) === null || _a === void 0 ? void 0 : _a.from) != scan.from)
                 node = parent;
         }
     for (;;) {
-        let inner = node.enter(pos, side, overlays);
+        let inner = node.enter(pos, side, mode);
         if (!inner)
             return node;
         node = inner;
     }
 }
 class TreeNode {
-    constructor(node, _from, 
+    constructor(_tree, from, 
     // Index in parent node, set to -1 if the node is not a direct child of _parent.node (overlay)
     index, _parent) {
-        this.node = node;
-        this._from = _from;
+        this._tree = _tree;
+        this.from = from;
         this.index = index;
         this._parent = _parent;
     }
-    get type() { return this.node.type; }
-    get name() { return this.node.type.name; }
-    get from() { return this._from; }
-    get to() { return this._from + this.node.length; }
+    get type() { return this._tree.type; }
+    get name() { return this._tree.type.name; }
+    get to() { return this.from + this._tree.length; }
     nextChild(i, dir, pos, side, mode = 0) {
         for (let parent = this;;) {
-            for (let { children, positions } = parent.node, e = dir > 0 ? children.length : -1; i != e; i += dir) {
-                let next = children[i], start = positions[i] + parent._from;
+            for (let { children, positions } = parent._tree, e = dir > 0 ? children.length : -1; i != e; i += dir) {
+                let next = children[i], start = positions[i] + parent.from;
                 if (!checkSide(side, pos, start, start + next.length))
                     continue;
                 if (next instanceof TreeBuffer) {
-                    if (mode & 2 /* NoEnterBuffer */)
+                    if (mode & IterMode.ExcludeBuffers)
                         continue;
                     let index = next.findChild(0, next.buffer.length, dir, pos - start, side);
                     if (index > -1)
                         return new BufferNode(new BufferContext(parent, next, i, start), null, index);
                 }
-                else if ((mode & 1 /* Full */) || (!next.type.isAnonymous || hasChild(next))) {
+                else if ((mode & IterMode.IncludeAnonymous) || (!next.type.isAnonymous || hasChild(next))) {
                     let mounted;
-                    if (!(mode & 1 /* Full */) && next.props && (mounted = next.prop(dist_NodeProp.mounted)) && !mounted.overlay)
+                    if (!(mode & IterMode.IgnoreMounts) &&
+                        next.props && (mounted = next.prop(dist_NodeProp.mounted)) && !mounted.overlay)
                         return new TreeNode(mounted.tree, start, i, parent);
                     let inner = new TreeNode(next, start, i, parent);
-                    return (mode & 1 /* Full */) || !inner.type.isAnonymous ? inner
+                    return (mode & IterMode.IncludeAnonymous) || !inner.type.isAnonymous ? inner
                         : inner.nextChild(dir < 0 ? next.children.length - 1 : 0, dir, pos, side);
                 }
             }
-            if ((mode & 1 /* Full */) || !parent.type.isAnonymous)
+            if ((mode & IterMode.IncludeAnonymous) || !parent.type.isAnonymous)
                 return null;
             if (parent.index >= 0)
                 i = parent.index + dir;
             else
-                i = dir < 0 ? -1 : parent._parent.node.children.length;
+                i = dir < 0 ? -1 : parent._parent._tree.children.length;
             parent = parent._parent;
             if (!parent)
                 return null;
         }
     }
     get firstChild() { return this.nextChild(0, 1, 0, 4 /* DontCare */); }
-    get lastChild() { return this.nextChild(this.node.children.length - 1, -1, 0, 4 /* DontCare */); }
+    get lastChild() { return this.nextChild(this._tree.children.length - 1, -1, 0, 4 /* DontCare */); }
     childAfter(pos) { return this.nextChild(0, 1, pos, 2 /* After */); }
-    childBefore(pos) { return this.nextChild(this.node.children.length - 1, -1, pos, -2 /* Before */); }
-    enter(pos, side, overlays = true, buffers = true) {
+    childBefore(pos) { return this.nextChild(this._tree.children.length - 1, -1, pos, -2 /* Before */); }
+    enter(pos, side, mode = 0) {
         let mounted;
-        if (overlays && (mounted = this.node.prop(dist_NodeProp.mounted)) && mounted.overlay) {
+        if (!(mode & IterMode.IgnoreOverlays) && (mounted = this._tree.prop(dist_NodeProp.mounted)) && mounted.overlay) {
             let rPos = pos - this.from;
             for (let { from, to } of mounted.overlay) {
                 if ((side > 0 ? from <= rPos : from < rPos) &&
@@ -1351,7 +675,7 @@ class TreeNode {
                     return new TreeNode(mounted.tree, mounted.overlay[0].from + this.from, -1, this);
             }
         }
-        return this.nextChild(0, 1, pos, side, buffers ? 0 : 2 /* NoEnterBuffer */);
+        return this.nextChild(0, 1, pos, side, mode);
     }
     nextSignificantParent() {
         let val = this;
@@ -1368,9 +692,9 @@ class TreeNode {
     get prevSibling() {
         return this._parent && this.index >= 0 ? this._parent.nextChild(this.index - 1, -1, 0, 4 /* DontCare */) : null;
     }
-    get cursor() { return new TreeCursor(this); }
-    get tree() { return this.node; }
-    toTree() { return this.node; }
+    cursor(mode = 0) { return new TreeCursor(this, mode); }
+    get tree() { return this._tree; }
+    toTree() { return this._tree; }
     resolve(pos, side = 0) {
         return resolveNode(this, pos, side, false);
     }
@@ -1386,10 +710,12 @@ class TreeNode {
         return getChildren(this, type, before, after);
     }
     /// @internal
-    toString() { return this.node.toString(); }
+    toString() { return this._tree.toString(); }
+    get node() { return this; }
+    matchContext(context) { return matchNodeContext(this, context); }
 }
 function getChildren(node, type, before, after) {
-    let cur = node.cursor, result = [];
+    let cur = node.cursor(), result = [];
     if (!cur.firstChild())
         return result;
     if (before != null)
@@ -1405,6 +731,18 @@ function getChildren(node, type, before, after) {
             return after == null ? result : [];
     }
 }
+function matchNodeContext(node, context, i = context.length - 1) {
+    for (let p = node.parent; i >= 0; p = p.parent) {
+        if (!p)
+            return false;
+        if (!p.type.isAnonymous) {
+            if (context[i] && context[i] != p.name)
+                return false;
+            i--;
+        }
+    }
+    return true;
+}
 class BufferContext {
     constructor(parent, buffer, index, start) {
         this.parent = parent;
@@ -1432,8 +770,8 @@ class BufferNode {
     get lastChild() { return this.child(-1, 0, 4 /* DontCare */); }
     childAfter(pos) { return this.child(1, pos, 2 /* After */); }
     childBefore(pos) { return this.child(-1, pos, -2 /* Before */); }
-    enter(pos, side, overlays, buffers = true) {
-        if (!buffers)
+    enter(pos, side, mode = 0) {
+        if (mode & IterMode.ExcludeBuffers)
             return null;
         let { buffer } = this.context;
         let index = buffer.findChild(this.index + 4, buffer.buffer[this.index + 3], side > 0 ? 1 : -1, pos - this.context.start, side);
@@ -1459,7 +797,7 @@ class BufferNode {
             return this.externalSibling(-1);
         return new BufferNode(this.context, this._parent, buffer.findChild(parentStart, this.index, -1, 0, 4 /* DontCare */));
     }
-    get cursor() { return new TreeCursor(this); }
+    cursor(mode = 0) { return new TreeCursor(this, mode); }
     get tree() { return null; }
     toTree() {
         let children = [], positions = [];
@@ -1470,7 +808,7 @@ class BufferNode {
             children.push(buffer.slice(startI, endI, from, to));
             positions.push(0);
         }
-        return new Tree(this.type, children, positions, this.to - this.from);
+        return new dist_Tree(this.type, children, positions, this.to - this.from);
     }
     resolve(pos, side = 0) {
         return resolveNode(this, pos, side, false);
@@ -1488,6 +826,8 @@ class BufferNode {
     getChildren(type, before = null, after = null) {
         return getChildren(this, type, before, after);
     }
+    get node() { return this; }
+    matchContext(context) { return matchNodeContext(this, context); }
 }
 /// A tree cursor object focuses on a given node in a syntax tree, and
 /// allows you to move to adjacent nodes.
@@ -1497,8 +837,10 @@ class TreeCursor {
     /// @internal
     mode = 0) {
         this.mode = mode;
+        /// @internal
         this.buffer = null;
         this.stack = [];
+        /// @internal
         this.index = 0;
         this.bufferNode = null;
         if (node instanceof TreeNode) {
@@ -1549,7 +891,7 @@ class TreeCursor {
     /// @internal
     enterChild(dir, pos, side) {
         if (!this.buffer)
-            return this.yield(this._tree.nextChild(dir < 0 ? this._tree.node.children.length - 1 : 0, dir, pos, side, this.mode));
+            return this.yield(this._tree.nextChild(dir < 0 ? this._tree._tree.children.length - 1 : 0, dir, pos, side, this.mode));
         let { buffer } = this.buffer;
         let index = buffer.findChild(this.index + 4, buffer.buffer[this.index + 3], dir, pos - this.buffer.start, side);
         if (index < 0)
@@ -1571,18 +913,18 @@ class TreeCursor {
     /// will also enter [overlaid](#common.MountedTree.overlay)
     /// [mounted](#common.NodeProp^mounted) trees unless `overlays` is
     /// set to false.
-    enter(pos, side, overlays = true, buffers = true) {
+    enter(pos, side, mode = this.mode) {
         if (!this.buffer)
-            return this.yield(this._tree.enter(pos, side, overlays && !(this.mode & 1 /* Full */), buffers));
-        return buffers ? this.enterChild(1, pos, side) : false;
+            return this.yield(this._tree.enter(pos, side, mode));
+        return mode & IterMode.ExcludeBuffers ? false : this.enterChild(1, pos, side);
     }
     /// Move to the node's parent node, if this isn't the top node.
     parent() {
         if (!this.buffer)
-            return this.yieldNode((this.mode & 1 /* Full */) ? this._tree._parent : this._tree.parent);
+            return this.yieldNode((this.mode & IterMode.IncludeAnonymous) ? this._tree._parent : this._tree.parent);
         if (this.stack.length)
             return this.yieldBuf(this.stack.pop());
-        let parent = (this.mode & 1 /* Full */) ? this.buffer.parent : this.buffer.parent.nextSignificantParent();
+        let parent = (this.mode & IterMode.IncludeAnonymous) ? this.buffer.parent : this.buffer.parent.nextSignificantParent();
         this.buffer = null;
         return this.yieldNode(parent);
     }
@@ -1628,9 +970,12 @@ class TreeCursor {
         }
         for (; parent; { index, _parent: parent } = parent) {
             if (index > -1)
-                for (let i = index + dir, e = dir < 0 ? -1 : parent.node.children.length; i != e; i += dir) {
-                    let child = parent.node.children[i];
-                    if ((this.mode & 1 /* Full */) || child instanceof TreeBuffer || !child.type.isAnonymous || hasChild(child))
+                for (let i = index + dir, e = dir < 0 ? -1 : parent._tree.children.length; i != e; i += dir) {
+                    let child = parent._tree.children[i];
+                    if ((this.mode & IterMode.IncludeAnonymous) ||
+                        child instanceof TreeBuffer ||
+                        !child.type.isAnonymous ||
+                        hasChild(child))
                         return false;
                 }
         }
@@ -1698,7 +1043,55 @@ class TreeCursor {
     /// any. Will return null when the node is in a [tree
     /// buffer](#common.TreeBuffer).
     get tree() {
-        return this.buffer ? null : this._tree.node;
+        return this.buffer ? null : this._tree._tree;
+    }
+    /// Iterate over the current node and all its descendants, calling
+    /// `enter` when entering a node and `leave`, if given, when leaving
+    /// one. When `enter` returns `false`, any children of that node are
+    /// skipped, and `leave` isn't called for it.
+    iterate(enter, leave) {
+        for (let depth = 0;;) {
+            let mustLeave = false;
+            if (this.type.isAnonymous || enter(this) !== false) {
+                if (this.firstChild()) {
+                    depth++;
+                    continue;
+                }
+                if (!this.type.isAnonymous)
+                    mustLeave = true;
+            }
+            for (;;) {
+                if (mustLeave && leave)
+                    leave(this);
+                mustLeave = this.type.isAnonymous;
+                if (this.nextSibling())
+                    break;
+                if (!depth)
+                    return;
+                this.parent();
+                depth--;
+                mustLeave = true;
+            }
+        }
+    }
+    /// Test whether the current node matches a given context—a sequence
+    /// of direct parent node names. Empty strings in the context array
+    /// are treated as wildcards.
+    matchContext(context) {
+        if (!this.buffer)
+            return matchNodeContext(this.node, context);
+        let { buffer } = this.buffer, { types } = buffer.set;
+        for (let i = context.length - 1, d = this.stack.length - 1; i >= 0; d--) {
+            if (d < 0)
+                return matchNodeContext(this.node, context, i);
+            let type = types[buffer.buffer[this.stack[d]]];
+            if (!type.isAnonymous) {
+                if (context[i] && context[i] != type.name)
+                    return false;
+                i--;
+            }
+        }
+        return true;
     }
 }
 function hasChild(tree) {
@@ -1781,7 +1174,7 @@ function buildTree(data) {
     function makeBalanced(type) {
         return (children, positions, length) => {
             let lookAhead = 0, lastI = children.length - 1, last, lookAheadProp;
-            if (lastI >= 0 && (last = children[lastI]) instanceof Tree) {
+            if (lastI >= 0 && (last = children[lastI]) instanceof dist_Tree) {
                 if (!lastI && last.type == type && last.length == length)
                     return last;
                 if (lookAheadProp = last.prop(dist_NodeProp.lookAhead))
@@ -1808,7 +1201,7 @@ function buildTree(data) {
             let pair = [dist_NodeProp.lookAhead, lookAhead];
             props = props ? [pair].concat(props) : [pair];
         }
-        return new Tree(type, children, positions, length, props);
+        return new dist_Tree(type, children, positions, length, props);
     }
     function findBufferSize(maxSize, inRepeat) {
         // Scan through the buffer to find previous siblings that fit
@@ -1890,7 +1283,7 @@ function buildTree(data) {
     while (cursor.pos > 0)
         takeNode(data.start || 0, data.bufferStart || 0, children, positions, -1);
     let length = (_a = data.length) !== null && _a !== void 0 ? _a : (children.length ? positions[0] + children[0].length : 0);
-    return new Tree(types[data.topID], children.reverse(), positions.reverse(), length);
+    return new dist_Tree(types[data.topID], children.reverse(), positions.reverse(), length);
 }
 const nodeSizeCache = new WeakMap;
 function nodeSize(balanceType, node) {
@@ -1900,7 +1293,7 @@ function nodeSize(balanceType, node) {
     if (size == null) {
         size = 1;
         for (let child of node.children) {
-            if (child.type != balanceType || !(child instanceof Tree)) {
+            if (child.type != balanceType || !(child instanceof dist_Tree)) {
                 size = 1;
                 break;
             }
@@ -1958,6 +1351,48 @@ mkTree) {
     divide(children, positions, from, to, 0);
     return (mkTop || mkTree)(localChildren, localPositions, length);
 }
+/// Provides a way to associate values with pieces of trees. As long
+/// as that part of the tree is reused, the associated values can be
+/// retrieved from an updated tree.
+class NodeWeakMap {
+    constructor() {
+        this.map = new WeakMap();
+    }
+    setBuffer(buffer, index, value) {
+        let inner = this.map.get(buffer);
+        if (!inner)
+            this.map.set(buffer, inner = new Map);
+        inner.set(index, value);
+    }
+    getBuffer(buffer, index) {
+        let inner = this.map.get(buffer);
+        return inner && inner.get(index);
+    }
+    /// Set the value for this syntax node.
+    set(node, value) {
+        if (node instanceof BufferNode)
+            this.setBuffer(node.context.buffer, node.index, value);
+        else if (node instanceof TreeNode)
+            this.map.set(node.tree, value);
+    }
+    /// Retrieve value for this syntax node, if it exists in the map.
+    get(node) {
+        return node instanceof BufferNode ? this.getBuffer(node.context.buffer, node.index)
+            : node instanceof TreeNode ? this.map.get(node.tree) : undefined;
+    }
+    /// Set the value for the node that a cursor currently points to.
+    cursorSet(cursor, value) {
+        if (cursor.buffer)
+            this.setBuffer(cursor.buffer.buffer, cursor.index, value);
+        else
+            this.map.set(cursor.tree, value);
+    }
+    /// Retrieve the value for the node that a cursor currently points
+    /// to.
+    cursorGet(cursor) {
+        return cursor.buffer ? this.getBuffer(cursor.buffer.buffer, cursor.index) : this.map.get(cursor.tree);
+    }
+}
 
 /// Tree fragments are used during [incremental
 /// parsing](#common.Parser.startParse) to track parts of old trees
@@ -2042,7 +1477,7 @@ class TreeFragment {
     }
 }
 /// A superclass that parsers should extend.
-class Parser {
+class dist_Parser {
     /// Start a parse, returning a [partial parse](#common.PartialParse)
     /// object. [`fragments`](#common.TreeFragment) can be passed in to
     /// make the parse incremental.
@@ -2140,7 +1575,7 @@ class MixedParse {
         if (this.innerDone == this.inner.length) {
             let result = this.baseTree;
             if (this.stoppedAt != null)
-                result = new Tree(result.type, result.children, result.positions, result.length, result.propValues.concat([[stoppedInner, this.stoppedAt]]));
+                result = new dist_Tree(result.type, result.children, result.positions, result.length, result.propValues.concat([[stoppedInner, this.stoppedAt]]));
             return result;
         }
         let inner = this.inner[this.innerDone], done = inner.parse.advance();
@@ -2178,7 +1613,7 @@ class MixedParse {
         let fragmentCursor = new FragmentCursor(this.fragments);
         let overlay = null;
         let covered = null;
-        let cursor = new TreeCursor(new TreeNode(this.baseTree, this.ranges[0].from, 0, null), 1 /* Full */);
+        let cursor = new TreeCursor(new TreeNode(this.baseTree, this.ranges[0].from, 0, null), IterMode.IncludeAnonymous | IterMode.IgnoreMounts);
         scan: for (let nest, isCovered; this.stoppedAt == null || cursor.from < this.stoppedAt;) {
             let enter = true, range;
             if (fragmentCursor.hasNode(cursor)) {
@@ -2295,9 +1730,9 @@ function materialize(cursor) {
         children.push(isTarget ? node.toTree() : split(i + 4, b[i + 3], buf.set.types[b[i]], from, to - from));
         positions.push(from - innerOffset);
         sliceBuf(buf, b[i + 3], endI, children, positions, innerOffset);
-        return new Tree(type, children, positions, length);
+        return new dist_Tree(type, children, positions, length);
     }
-    base.children[i] = split(0, b.length, NodeType.none, 0, buf.length);
+    base.children[i] = split(0, b.length, dist_NodeType.none, 0, buf.length);
     // Move the cursor back to the target node
     for (let d = 0; d <= depth; d++)
         cursor.childAfter(node.from);
@@ -2306,13 +1741,13 @@ class StructureCursor {
     constructor(root, offset) {
         this.offset = offset;
         this.done = false;
-        this.cursor = root.fullCursor();
+        this.cursor = root.cursor(IterMode.IncludeAnonymous | IterMode.IgnoreMounts);
     }
     // Move to the first node (in pre-order) that starts at or after `pos`.
     moveTo(pos) {
         let { cursor } = this, p = pos - this.offset;
         while (!this.done && cursor.from < p) {
-            if (cursor.to >= pos && cursor.enter(p, 1, false, false)) ;
+            if (cursor.to >= pos && cursor.enter(p, 1, IterMode.IgnoreOverlays | IterMode.ExcludeBuffers)) ;
             else if (!cursor.next(false))
                 this.done = true;
         }
@@ -2323,7 +1758,7 @@ class StructureCursor {
             for (let tree = this.cursor.tree;;) {
                 if (tree == cursor.tree)
                     return true;
-                if (tree.children.length && tree.positions[0] == 0 && tree.children[0] instanceof Tree)
+                if (tree.children.length && tree.positions[0] == 0 && tree.children[0] instanceof dist_Tree)
                     tree = tree.children[0];
                 else
                     break;
@@ -2478,25 +1913,836 @@ function enterFragments(mounts, ranges) {
 
 
 
-;// CONCATENATED MODULE: ./node_modules/@codemirror/language/dist/index.js
-
-
-
+;// CONCATENATED MODULE: ./node_modules/@lezer/highlight/dist/index.js
 
 
-var _a;
-/**
-Node prop stored in a grammar's top syntax node to provide the
-facet that stores language data for that language.
-*/
-const languageDataProp = /*@__PURE__*/new dist_NodeProp();
-/**
-Helper function to define a facet (to be added to the top syntax
-node(s) for a language via
-[`languageDataProp`](https://codemirror.net/6/docs/ref/#language.languageDataProp)), that will be
-used to associate language data with the language. You
-probably only need this when subclassing
-[`Language`](https://codemirror.net/6/docs/ref/#language.Language).
+let nextTagID = 0;
+/// Highlighting tags are markers that denote a highlighting category.
+/// They are [associated](#highlight.styleTags) with parts of a syntax
+/// tree by a language mode, and then mapped to an actual CSS style by
+/// a [highlighter](#highlight.Highlighter).
+///
+/// Because syntax tree node types and highlight styles have to be
+/// able to talk the same language, CodeMirror uses a mostly _closed_
+/// [vocabulary](#highlight.tags) of syntax tags (as opposed to
+/// traditional open string-based systems, which make it hard for
+/// highlighting themes to cover all the tokens produced by the
+/// various languages).
+///
+/// It _is_ possible to [define](#highlight.Tag^define) your own
+/// highlighting tags for system-internal use (where you control both
+/// the language package and the highlighter), but such tags will not
+/// be picked up by regular highlighters (though you can derive them
+/// from standard tags to allow highlighters to fall back to those).
+class Tag {
+    /// @internal
+    constructor(
+    /// The set of this tag and all its parent tags, starting with
+    /// this one itself and sorted in order of decreasing specificity.
+    set, 
+    /// The base unmodified tag that this one is based on, if it's
+    /// modified @internal
+    base, 
+    /// The modifiers applied to this.base @internal
+    modified) {
+        this.set = set;
+        this.base = base;
+        this.modified = modified;
+        /// @internal
+        this.id = nextTagID++;
+    }
+    /// Define a new tag. If `parent` is given, the tag is treated as a
+    /// sub-tag of that parent, and
+    /// [highlighters](#highlight.tagHighlighter) that don't mention
+    /// this tag will try to fall back to the parent tag (or grandparent
+    /// tag, etc).
+    static define(parent) {
+        if (parent === null || parent === void 0 ? void 0 : parent.base)
+            throw new Error("Can not derive from a modified tag");
+        let tag = new Tag([], null, []);
+        tag.set.push(tag);
+        if (parent)
+            for (let t of parent.set)
+                tag.set.push(t);
+        return tag;
+    }
+    /// Define a tag _modifier_, which is a function that, given a tag,
+    /// will return a tag that is a subtag of the original. Applying the
+    /// same modifier to a twice tag will return the same value (`m1(t1)
+    /// == m1(t1)`) and applying multiple modifiers will, regardless or
+    /// order, produce the same tag (`m1(m2(t1)) == m2(m1(t1))`).
+    ///
+    /// When multiple modifiers are applied to a given base tag, each
+    /// smaller set of modifiers is registered as a parent, so that for
+    /// example `m1(m2(m3(t1)))` is a subtype of `m1(m2(t1))`,
+    /// `m1(m3(t1)`, and so on.
+    static defineModifier() {
+        let mod = new Modifier;
+        return (tag) => {
+            if (tag.modified.indexOf(mod) > -1)
+                return tag;
+            return Modifier.get(tag.base || tag, tag.modified.concat(mod).sort((a, b) => a.id - b.id));
+        };
+    }
+}
+let nextModifierID = 0;
+class Modifier {
+    constructor() {
+        this.instances = [];
+        this.id = nextModifierID++;
+    }
+    static get(base, mods) {
+        if (!mods.length)
+            return base;
+        let exists = mods[0].instances.find(t => t.base == base && sameArray(mods, t.modified));
+        if (exists)
+            return exists;
+        let set = [], tag = new Tag(set, base, mods);
+        for (let m of mods)
+            m.instances.push(tag);
+        let configs = permute(mods);
+        for (let parent of base.set)
+            for (let config of configs)
+                set.push(Modifier.get(parent, config));
+        return tag;
+    }
+}
+function sameArray(a, b) {
+    return a.length == b.length && a.every((x, i) => x == b[i]);
+}
+function permute(array) {
+    let result = [array];
+    for (let i = 0; i < array.length; i++) {
+        for (let a of permute(array.slice(0, i).concat(array.slice(i + 1))))
+            result.push(a);
+    }
+    return result;
+}
+/// This function is used to add a set of tags to a language syntax
+/// via [`NodeSet.extend`](#common.NodeSet.extend) or
+/// [`LRParser.configure`](#lr.LRParser.configure).
+///
+/// The argument object maps node selectors to [highlighting
+/// tags](#highlight.Tag) or arrays of tags.
+///
+/// Node selectors may hold one or more (space-separated) node paths.
+/// Such a path can be a [node name](#common.NodeType.name), or
+/// multiple node names (or `*` wildcards) separated by slash
+/// characters, as in `"Block/Declaration/VariableName"`. Such a path
+/// matches the final node but only if its direct parent nodes are the
+/// other nodes mentioned. A `*` in such a path matches any parent,
+/// but only a single level—wildcards that match multiple parents
+/// aren't supported, both for efficiency reasons and because Lezer
+/// trees make it rather hard to reason about what they would match.)
+///
+/// A path can be ended with `/...` to indicate that the tag assigned
+/// to the node should also apply to all child nodes, even if they
+/// match their own style (by default, only the innermost style is
+/// used).
+///
+/// When a path ends in `!`, as in `Attribute!`, no further matching
+/// happens for the node's child nodes, and the entire node gets the
+/// given style.
+///
+/// In this notation, node names that contain `/`, `!`, `*`, or `...`
+/// must be quoted as JSON strings.
+///
+/// For example:
+///
+/// ```javascript
+/// parser.withProps(
+///   styleTags({
+///     // Style Number and BigNumber nodes
+///     "Number BigNumber": tags.number,
+///     // Style Escape nodes whose parent is String
+///     "String/Escape": tags.escape,
+///     // Style anything inside Attributes nodes
+///     "Attributes!": tags.meta,
+///     // Add a style to all content inside Italic nodes
+///     "Italic/...": tags.emphasis,
+///     // Style InvalidString nodes as both `string` and `invalid`
+///     "InvalidString": [tags.string, tags.invalid],
+///     // Style the node named "/" as punctuation
+///     '"/"': tags.punctuation
+///   })
+/// )
+/// ```
+function styleTags(spec) {
+    let byName = Object.create(null);
+    for (let prop in spec) {
+        let tags = spec[prop];
+        if (!Array.isArray(tags))
+            tags = [tags];
+        for (let part of prop.split(" "))
+            if (part) {
+                let pieces = [], mode = 2 /* Normal */, rest = part;
+                for (let pos = 0;;) {
+                    if (rest == "..." && pos > 0 && pos + 3 == part.length) {
+                        mode = 1 /* Inherit */;
+                        break;
+                    }
+                    let m = /^"(?:[^"\\]|\\.)*?"|[^\/!]+/.exec(rest);
+                    if (!m)
+                        throw new RangeError("Invalid path: " + part);
+                    pieces.push(m[0] == "*" ? "" : m[0][0] == '"' ? JSON.parse(m[0]) : m[0]);
+                    pos += m[0].length;
+                    if (pos == part.length)
+                        break;
+                    let next = part[pos++];
+                    if (pos == part.length && next == "!") {
+                        mode = 0 /* Opaque */;
+                        break;
+                    }
+                    if (next != "/")
+                        throw new RangeError("Invalid path: " + part);
+                    rest = part.slice(pos);
+                }
+                let last = pieces.length - 1, inner = pieces[last];
+                if (!inner)
+                    throw new RangeError("Invalid path: " + part);
+                let rule = new Rule(tags, mode, last > 0 ? pieces.slice(0, last) : null);
+                byName[inner] = rule.sort(byName[inner]);
+            }
+    }
+    return ruleNodeProp.add(byName);
+}
+const ruleNodeProp = new dist_NodeProp();
+class Rule {
+    constructor(tags, mode, context, next) {
+        this.tags = tags;
+        this.mode = mode;
+        this.context = context;
+        this.next = next;
+    }
+    sort(other) {
+        if (!other || other.depth < this.depth) {
+            this.next = other;
+            return this;
+        }
+        other.next = this.sort(other.next);
+        return other;
+    }
+    get depth() { return this.context ? this.context.length : 0; }
+}
+/// Define a [highlighter](#highlight.Highlighter) from an array of
+/// tag/class pairs. Classes associated with more specific tags will
+/// take precedence.
+function tagHighlighter(tags, options) {
+    let map = Object.create(null);
+    for (let style of tags) {
+        if (!Array.isArray(style.tag))
+            map[style.tag.id] = style.class;
+        else
+            for (let tag of style.tag)
+                map[tag.id] = style.class;
+    }
+    let { scope, all = null } = options || {};
+    return {
+        style: (tags) => {
+            let cls = all;
+            for (let tag of tags) {
+                for (let sub of tag.set) {
+                    let tagClass = map[sub.id];
+                    if (tagClass) {
+                        cls = cls ? cls + " " + tagClass : tagClass;
+                        break;
+                    }
+                }
+            }
+            return cls;
+        },
+        scope: scope
+    };
+}
+function highlightTags(highlighters, tags) {
+    let result = null;
+    for (let highlighter of highlighters) {
+        let value = highlighter.style(tags);
+        if (value)
+            result = result ? result + " " + value : value;
+    }
+    return result;
+}
+/// Highlight the given [tree](#common.Tree) with the given
+/// [highlighter](#highlight.Highlighter).
+function highlightTree(tree, highlighter, 
+/// Assign styling to a region of the text. Will be called, in order
+/// of position, for any ranges where more than zero classes apply.
+/// `classes` is a space separated string of CSS classes.
+putStyle, 
+/// The start of the range to highlight.
+from = 0, 
+/// The end of the range.
+to = tree.length) {
+    let builder = new HighlightBuilder(from, Array.isArray(highlighter) ? highlighter : [highlighter], putStyle);
+    builder.highlightRange(tree.cursor(), from, to, "", builder.highlighters);
+    builder.flush(to);
+}
+class HighlightBuilder {
+    constructor(at, highlighters, span) {
+        this.at = at;
+        this.highlighters = highlighters;
+        this.span = span;
+        this.class = "";
+    }
+    startSpan(at, cls) {
+        if (cls != this.class) {
+            this.flush(at);
+            if (at > this.at)
+                this.at = at;
+            this.class = cls;
+        }
+    }
+    flush(to) {
+        if (to > this.at && this.class)
+            this.span(this.at, to, this.class);
+    }
+    highlightRange(cursor, from, to, inheritedClass, highlighters) {
+        let { type, from: start, to: end } = cursor;
+        if (start >= to || end <= from)
+            return;
+        if (type.isTop)
+            highlighters = this.highlighters.filter(h => !h.scope || h.scope(type));
+        let cls = inheritedClass;
+        let rule = type.prop(ruleNodeProp), opaque = false;
+        while (rule) {
+            if (!rule.context || cursor.matchContext(rule.context)) {
+                let tagCls = highlightTags(highlighters, rule.tags);
+                if (tagCls) {
+                    if (cls)
+                        cls += " ";
+                    cls += tagCls;
+                    if (rule.mode == 1 /* Inherit */)
+                        inheritedClass += (inheritedClass ? " " : "") + tagCls;
+                    else if (rule.mode == 0 /* Opaque */)
+                        opaque = true;
+                }
+                break;
+            }
+            rule = rule.next;
+        }
+        this.startSpan(cursor.from, cls);
+        if (opaque)
+            return;
+        let mounted = cursor.tree && cursor.tree.prop(dist_NodeProp.mounted);
+        if (mounted && mounted.overlay) {
+            let inner = cursor.node.enter(mounted.overlay[0].from + start, 1);
+            let innerHighlighters = this.highlighters.filter(h => !h.scope || h.scope(mounted.tree.type));
+            let hasChild = cursor.firstChild();
+            for (let i = 0, pos = start;; i++) {
+                let next = i < mounted.overlay.length ? mounted.overlay[i] : null;
+                let nextPos = next ? next.from + start : end;
+                let rangeFrom = Math.max(from, pos), rangeTo = Math.min(to, nextPos);
+                if (rangeFrom < rangeTo && hasChild) {
+                    while (cursor.from < rangeTo) {
+                        this.highlightRange(cursor, rangeFrom, rangeTo, inheritedClass, highlighters);
+                        this.startSpan(Math.min(to, cursor.to), cls);
+                        if (cursor.to >= nextPos || !cursor.nextSibling())
+                            break;
+                    }
+                }
+                if (!next || nextPos > to)
+                    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);
+                }
+            }
+            if (hasChild)
+                cursor.parent();
+        }
+        else if (cursor.firstChild()) {
+            do {
+                if (cursor.to <= from)
+                    continue;
+                if (cursor.from >= to)
+                    break;
+                this.highlightRange(cursor, from, to, inheritedClass, highlighters);
+                this.startSpan(Math.min(to, cursor.to), cls);
+            } while (cursor.nextSibling());
+            cursor.parent();
+        }
+    }
+}
+const t = Tag.define;
+const comment = t(), dist_name = t(), typeName = t(dist_name), propertyName = t(dist_name), literal = t(), string = t(literal), number = t(literal), content = t(), heading = t(content), keyword = t(), operator = t(), punctuation = t(), bracket = t(punctuation), meta = t();
+/// The default set of highlighting [tags](#highlight.Tag).
+///
+/// This collection is heavily biased towards programming languages,
+/// and necessarily incomplete. A full ontology of syntactic
+/// constructs would fill a stack of books, and be impractical to
+/// write themes for. So try to make do with this set. If all else
+/// fails, [open an
+/// issue](https://github.com/codemirror/codemirror.next) to propose a
+/// new tag, or [define](#highlight.Tag^define) a local custom tag for
+/// your use case.
+///
+/// Note that it is not obligatory to always attach the most specific
+/// tag possible to an element—if your grammar can't easily
+/// distinguish a certain type of element (such as a local variable),
+/// it is okay to style it as its more general variant (a variable).
+/// 
+/// For tags that extend some parent tag, the documentation links to
+/// the parent.
+const tags = {
+    /// A comment.
+    comment,
+    /// A line [comment](#highlight.tags.comment).
+    lineComment: t(comment),
+    /// A block [comment](#highlight.tags.comment).
+    blockComment: t(comment),
+    /// A documentation [comment](#highlight.tags.comment).
+    docComment: t(comment),
+    /// Any kind of identifier.
+    name: dist_name,
+    /// The [name](#highlight.tags.name) of a variable.
+    variableName: t(dist_name),
+    /// A type [name](#highlight.tags.name).
+    typeName: typeName,
+    /// A tag name (subtag of [`typeName`](#highlight.tags.typeName)).
+    tagName: t(typeName),
+    /// A property or field [name](#highlight.tags.name).
+    propertyName: propertyName,
+    /// An attribute name (subtag of [`propertyName`](#highlight.tags.propertyName)).
+    attributeName: t(propertyName),
+    /// The [name](#highlight.tags.name) of a class.
+    className: t(dist_name),
+    /// A label [name](#highlight.tags.name).
+    labelName: t(dist_name),
+    /// A namespace [name](#highlight.tags.name).
+    namespace: t(dist_name),
+    /// The [name](#highlight.tags.name) of a macro.
+    macroName: t(dist_name),
+    /// A literal value.
+    literal,
+    /// A string [literal](#highlight.tags.literal).
+    string,
+    /// A documentation [string](#highlight.tags.string).
+    docString: t(string),
+    /// A character literal (subtag of [string](#highlight.tags.string)).
+    character: t(string),
+    /// An attribute value (subtag of [string](#highlight.tags.string)).
+    attributeValue: t(string),
+    /// A number [literal](#highlight.tags.literal).
+    number,
+    /// An integer [number](#highlight.tags.number) literal.
+    integer: t(number),
+    /// A floating-point [number](#highlight.tags.number) literal.
+    float: t(number),
+    /// A boolean [literal](#highlight.tags.literal).
+    bool: t(literal),
+    /// Regular expression [literal](#highlight.tags.literal).
+    regexp: t(literal),
+    /// An escape [literal](#highlight.tags.literal), for example a
+    /// backslash escape in a string.
+    escape: t(literal),
+    /// A color [literal](#highlight.tags.literal).
+    color: t(literal),
+    /// A URL [literal](#highlight.tags.literal).
+    url: t(literal),
+    /// A language keyword.
+    keyword,
+    /// The [keyword](#highlight.tags.keyword) for the self or this
+    /// object.
+    self: t(keyword),
+    /// The [keyword](#highlight.tags.keyword) for null.
+    null: t(keyword),
+    /// A [keyword](#highlight.tags.keyword) denoting some atomic value.
+    atom: t(keyword),
+    /// A [keyword](#highlight.tags.keyword) that represents a unit.
+    unit: t(keyword),
+    /// A modifier [keyword](#highlight.tags.keyword).
+    modifier: t(keyword),
+    /// A [keyword](#highlight.tags.keyword) that acts as an operator.
+    operatorKeyword: t(keyword),
+    /// A control-flow related [keyword](#highlight.tags.keyword).
+    controlKeyword: t(keyword),
+    /// A [keyword](#highlight.tags.keyword) that defines something.
+    definitionKeyword: t(keyword),
+    /// A [keyword](#highlight.tags.keyword) related to defining or
+    /// interfacing with modules.
+    moduleKeyword: t(keyword),
+    /// An operator.
+    operator,
+    /// An [operator](#highlight.tags.operator) that defines something.
+    derefOperator: t(operator),
+    /// Arithmetic-related [operator](#highlight.tags.operator).
+    arithmeticOperator: t(operator),
+    /// Logical [operator](#highlight.tags.operator).
+    logicOperator: t(operator),
+    /// Bit [operator](#highlight.tags.operator).
+    bitwiseOperator: t(operator),
+    /// Comparison [operator](#highlight.tags.operator).
+    compareOperator: t(operator),
+    /// [Operator](#highlight.tags.operator) that updates its operand.
+    updateOperator: t(operator),
+    /// [Operator](#highlight.tags.operator) that defines something.
+    definitionOperator: t(operator),
+    /// Type-related [operator](#highlight.tags.operator).
+    typeOperator: t(operator),
+    /// Control-flow [operator](#highlight.tags.operator).
+    controlOperator: t(operator),
+    /// Program or markup punctuation.
+    punctuation,
+    /// [Punctuation](#highlight.tags.punctuation) that separates
+    /// things.
+    separator: t(punctuation),
+    /// Bracket-style [punctuation](#highlight.tags.punctuation).
+    bracket,
+    /// Angle [brackets](#highlight.tags.bracket) (usually `<` and `>`
+    /// tokens).
+    angleBracket: t(bracket),
+    /// Square [brackets](#highlight.tags.bracket) (usually `[` and `]`
+    /// tokens).
+    squareBracket: t(bracket),
+    /// Parentheses (usually `(` and `)` tokens). Subtag of
+    /// [bracket](#highlight.tags.bracket).
+    paren: t(bracket),
+    /// Braces (usually `{` and `}` tokens). Subtag of
+    /// [bracket](#highlight.tags.bracket).
+    brace: t(bracket),
+    /// Content, for example plain text in XML or markup documents.
+    content,
+    /// [Content](#highlight.tags.content) that represents a heading.
+    heading,
+    /// A level 1 [heading](#highlight.tags.heading).
+    heading1: t(heading),
+    /// A level 2 [heading](#highlight.tags.heading).
+    heading2: t(heading),
+    /// A level 3 [heading](#highlight.tags.heading).
+    heading3: t(heading),
+    /// A level 4 [heading](#highlight.tags.heading).
+    heading4: t(heading),
+    /// A level 5 [heading](#highlight.tags.heading).
+    heading5: t(heading),
+    /// A level 6 [heading](#highlight.tags.heading).
+    heading6: t(heading),
+    /// A prose separator (such as a horizontal rule).
+    contentSeparator: t(content),
+    /// [Content](#highlight.tags.content) that represents a list.
+    list: t(content),
+    /// [Content](#highlight.tags.content) that represents a quote.
+    quote: t(content),
+    /// [Content](#highlight.tags.content) that is emphasized.
+    emphasis: t(content),
+    /// [Content](#highlight.tags.content) that is styled strong.
+    strong: t(content),
+    /// [Content](#highlight.tags.content) that is part of a link.
+    link: t(content),
+    /// [Content](#highlight.tags.content) that is styled as code or
+    /// monospace.
+    monospace: t(content),
+    /// [Content](#highlight.tags.content) that has a strike-through
+    /// style.
+    strikethrough: t(content),
+    /// Inserted text in a change-tracking format.
+    inserted: t(),
+    /// Deleted text.
+    deleted: t(),
+    /// Changed text.
+    changed: t(),
+    /// An invalid or unsyntactic element.
+    invalid: t(),
+    /// Metadata or meta-instruction.
+    meta,
+    /// [Metadata](#highlight.tags.meta) that applies to the entire
+    /// document.
+    documentMeta: t(meta),
+    /// [Metadata](#highlight.tags.meta) that annotates or adds
+    /// attributes to a given syntactic element.
+    annotation: t(meta),
+    /// Processing instruction or preprocessor directive. Subtag of
+    /// [meta](#highlight.tags.meta).
+    processingInstruction: t(meta),
+    /// [Modifier](#highlight.Tag^defineModifier) that indicates that a
+    /// given element is being defined. Expected to be used with the
+    /// various [name](#highlight.tags.name) tags.
+    definition: Tag.defineModifier(),
+    /// [Modifier](#highlight.Tag^defineModifier) that indicates that
+    /// something is constant. Mostly expected to be used with
+    /// [variable names](#highlight.tags.variableName).
+    constant: Tag.defineModifier(),
+    /// [Modifier](#highlight.Tag^defineModifier) used to indicate that
+    /// a [variable](#highlight.tags.variableName) or [property
+    /// name](#highlight.tags.propertyName) is being called or defined
+    /// as a function.
+    function: Tag.defineModifier(),
+    /// [Modifier](#highlight.Tag^defineModifier) that can be applied to
+    /// [names](#highlight.tags.name) to indicate that they belong to
+    /// the language's standard environment.
+    standard: Tag.defineModifier(),
+    /// [Modifier](#highlight.Tag^defineModifier) that indicates a given
+    /// [names](#highlight.tags.name) is local to some scope.
+    local: Tag.defineModifier(),
+    /// A generic variant [modifier](#highlight.Tag^defineModifier) that
+    /// can be used to tag language-specific alternative variants of
+    /// some common tag. It is recommended for themes to define special
+    /// forms of at least the [string](#highlight.tags.string) and
+    /// [variable name](#highlight.tags.variableName) tags, since those
+    /// come up a lot.
+    special: Tag.defineModifier()
+};
+/// This is a highlighter that adds stable, predictable classes to
+/// tokens, for styling with external CSS.
+///
+/// The following tags are mapped to their name prefixed with `"tok-"`
+/// (for example `"tok-comment"`):
+///
+/// * [`link`](#highlight.tags.link)
+/// * [`heading`](#highlight.tags.heading)
+/// * [`emphasis`](#highlight.tags.emphasis)
+/// * [`strong`](#highlight.tags.strong)
+/// * [`keyword`](#highlight.tags.keyword)
+/// * [`atom`](#highlight.tags.atom) [`bool`](#highlight.tags.bool)
+/// * [`url`](#highlight.tags.url)
+/// * [`labelName`](#highlight.tags.labelName)
+/// * [`inserted`](#highlight.tags.inserted)
+/// * [`deleted`](#highlight.tags.deleted)
+/// * [`literal`](#highlight.tags.literal)
+/// * [`string`](#highlight.tags.string)
+/// * [`number`](#highlight.tags.number)
+/// * [`variableName`](#highlight.tags.variableName)
+/// * [`typeName`](#highlight.tags.typeName)
+/// * [`namespace`](#highlight.tags.namespace)
+/// * [`className`](#highlight.tags.className)
+/// * [`macroName`](#highlight.tags.macroName)
+/// * [`propertyName`](#highlight.tags.propertyName)
+/// * [`operator`](#highlight.tags.operator)
+/// * [`comment`](#highlight.tags.comment)
+/// * [`meta`](#highlight.tags.meta)
+/// * [`punctuation`](#highlight.tags.punctuation)
+/// * [`invalid`](#highlight.tags.invalid)
+///
+/// In addition, these mappings are provided:
+///
+/// * [`regexp`](#highlight.tags.regexp),
+///   [`escape`](#highlight.tags.escape), and
+///   [`special`](#highlight.tags.special)[`(string)`](#highlight.tags.string)
+///   are mapped to `"tok-string2"`
+/// * [`special`](#highlight.tags.special)[`(variableName)`](#highlight.tags.variableName)
+///   to `"tok-variableName2"`
+/// * [`local`](#highlight.tags.local)[`(variableName)`](#highlight.tags.variableName)
+///   to `"tok-variableName tok-local"`
+/// * [`definition`](#highlight.tags.definition)[`(variableName)`](#highlight.tags.variableName)
+///   to `"tok-variableName tok-definition"`
+/// * [`definition`](#highlight.tags.definition)[`(propertyName)`](#highlight.tags.propertyName)
+///   to `"tok-propertyName tok-definition"`
+const classHighlighter = tagHighlighter([
+    { tag: tags.link, class: "tok-link" },
+    { tag: tags.heading, class: "tok-heading" },
+    { tag: tags.emphasis, class: "tok-emphasis" },
+    { tag: tags.strong, class: "tok-strong" },
+    { tag: tags.keyword, class: "tok-keyword" },
+    { tag: tags.atom, class: "tok-atom" },
+    { tag: tags.bool, class: "tok-bool" },
+    { tag: tags.url, class: "tok-url" },
+    { tag: tags.labelName, class: "tok-labelName" },
+    { tag: tags.inserted, class: "tok-inserted" },
+    { tag: tags.deleted, class: "tok-deleted" },
+    { tag: tags.literal, class: "tok-literal" },
+    { tag: tags.string, class: "tok-string" },
+    { tag: tags.number, class: "tok-number" },
+    { tag: [tags.regexp, tags.escape, tags.special(tags.string)], class: "tok-string2" },
+    { tag: tags.variableName, class: "tok-variableName" },
+    { tag: tags.local(tags.variableName), class: "tok-variableName tok-local" },
+    { tag: tags.definition(tags.variableName), class: "tok-variableName tok-definition" },
+    { tag: tags.special(tags.variableName), class: "tok-variableName2" },
+    { tag: tags.definition(tags.propertyName), class: "tok-propertyName tok-definition" },
+    { tag: tags.typeName, class: "tok-typeName" },
+    { tag: tags.namespace, class: "tok-namespace" },
+    { tag: tags.className, class: "tok-className" },
+    { tag: tags.macroName, class: "tok-macroName" },
+    { tag: tags.propertyName, class: "tok-propertyName" },
+    { tag: tags.operator, class: "tok-operator" },
+    { tag: tags.comment, class: "tok-comment" },
+    { tag: tags.meta, class: "tok-meta" },
+    { tag: tags.invalid, class: "tok-invalid" },
+    { tag: tags.punctuation, class: "tok-punctuation" }
+]);
+
+
+
+;// CONCATENATED MODULE: ./node_modules/style-mod/src/style-mod.js
+const C = "\u037c"
+const COUNT = typeof Symbol == "undefined" ? "__" + C : Symbol.for(C)
+const SET = typeof Symbol == "undefined" ? "__styleSet" + Math.floor(Math.random() * 1e8) : Symbol("styleSet")
+const style_mod_top = typeof globalThis != "undefined" ? globalThis : typeof window != "undefined" ? window : {}
+
+// :: - Style modules encapsulate a set of CSS rules defined from
+// JavaScript. Their definitions are only available in a given DOM
+// root after it has been _mounted_ there with `StyleModule.mount`.
+//
+// Style modules should be created once and stored somewhere, as
+// opposed to re-creating them every time you need them. The amount of
+// CSS rules generated for a given DOM root is bounded by the amount
+// of style modules that were used. So to avoid leaking rules, don't
+// create these dynamically, but treat them as one-time allocations.
+class StyleModule {
+  // :: (Object<Style>, ?{finish: ?(string) → string})
+  // Create a style module from the given spec.
+  //
+  // When `finish` is given, it is called on regular (non-`@`)
+  // selectors (after `&` expansion) to compute the final selector.
+  constructor(spec, options) {
+    this.rules = []
+    let {finish} = options || {}
+
+    function splitSelector(selector) {
+      return /^@/.test(selector) ? [selector] : selector.split(/,\s*/)
+    }
+
+    function render(selectors, spec, target, isKeyframes) {
+      let local = [], isAt = /^@(\w+)\b/.exec(selectors[0]), keyframes = isAt && isAt[1] == "keyframes"
+      if (isAt && spec == null) return target.push(selectors[0] + ";")
+      for (let prop in spec) {
+        let value = spec[prop]
+        if (/&/.test(prop)) {
+          render(prop.split(/,\s*/).map(part => selectors.map(sel => part.replace(/&/, sel))).reduce((a, b) => a.concat(b)),
+                 value, target)
+        } else if (value && typeof value == "object") {
+          if (!isAt) throw new RangeError("The value of a property (" + prop + ") should be a primitive value.")
+          render(splitSelector(prop), value, local, keyframes)
+        } else if (value != null) {
+          local.push(prop.replace(/_.*/, "").replace(/[A-Z]/g, l => "-" + l.toLowerCase()) + ": " + value + ";")
+        }
+      }
+      if (local.length || keyframes) {
+        target.push((finish && !isAt && !isKeyframes ? selectors.map(finish) : selectors).join(", ") +
+                    " {" + local.join(" ") + "}")
+      }
+    }
+
+    for (let prop in spec) render(splitSelector(prop), spec[prop], this.rules)
+  }
+
+  // :: () → string
+  // Returns a string containing the module's CSS rules.
+  getRules() { return this.rules.join("\n") }
+
+  // :: () → string
+  // Generate a new unique CSS class name.
+  static newName() {
+    let id = style_mod_top[COUNT] || 1
+    style_mod_top[COUNT] = id + 1
+    return C + id.toString(36)
+  }
+
+  // :: (union<Document, ShadowRoot>, union<[StyleModule], StyleModule>)
+  //
+  // Mount the given set of modules in the given DOM root, which ensures
+  // that the CSS rules defined by the module are available in that
+  // context.
+  //
+  // Rules are only added to the document once per root.
+  //
+  // Rule order will follow the order of the modules, so that rules from
+  // modules later in the array take precedence of those from earlier
+  // modules. If you call this function multiple times for the same root
+  // in a way that changes the order of already mounted modules, the old
+  // order will be changed.
+  static mount(root, modules) {
+    (root[SET] || new StyleSet(root)).mount(Array.isArray(modules) ? modules : [modules])
+  }
+}
+
+let adoptedSet = null
+
+class StyleSet {
+  constructor(root) {
+    if (!root.head && root.adoptedStyleSheets && typeof CSSStyleSheet != "undefined") {
+      if (adoptedSet) {
+        root.adoptedStyleSheets = [adoptedSet.sheet].concat(root.adoptedStyleSheets)
+        return root[SET] = adoptedSet
+      }
+      this.sheet = new CSSStyleSheet
+      root.adoptedStyleSheets = [this.sheet].concat(root.adoptedStyleSheets)
+      adoptedSet = this
+    } else {
+      this.styleTag = (root.ownerDocument || root).createElement("style")
+      let target = root.head || root
+      target.insertBefore(this.styleTag, target.firstChild)
+    }
+    this.modules = []
+    root[SET] = this
+  }
+
+  mount(modules) {
+    let sheet = this.sheet
+    let pos = 0 /* Current rule offset */, j = 0 /* Index into this.modules */
+    for (let i = 0; i < modules.length; i++) {
+      let mod = modules[i], index = this.modules.indexOf(mod)
+      if (index < j && index > -1) { // Ordering conflict
+        this.modules.splice(index, 1)
+        j--
+        index = -1
+      }
+      if (index == -1) {
+        this.modules.splice(j++, 0, mod)
+        if (sheet) for (let k = 0; k < mod.rules.length; k++)
+          sheet.insertRule(mod.rules[k], pos++)
+      } else {
+        while (j < index) pos += this.modules[j++].rules.length
+        pos += mod.rules.length
+        j++
+      }
+    }
+
+    if (!sheet) {
+      let text = ""
+      for (let i = 0; i < this.modules.length; i++)
+        text += this.modules[i].getRules() + "\n"
+      this.styleTag.textContent = text
+    }
+  }
+}
+
+// Style::Object<union<Style,string>>
+//
+// A style is an object that, in the simple case, maps CSS property
+// names to strings holding their values, as in `{color: "red",
+// fontWeight: "bold"}`. The property names can be given in
+// camel-case—the library will insert a dash before capital letters
+// when converting them to CSS.
+//
+// If you include an underscore in a property name, it and everything
+// after it will be removed from the output, which can be useful when
+// providing a property multiple times, for browser compatibility
+// reasons.
+//
+// A property in a style object can also be a sub-selector, which
+// extends the current context to add a pseudo-selector or a child
+// selector. Such a property should contain a `&` character, which
+// will be replaced by the current selector. For example `{"&:before":
+// {content: '"hi"'}}`. Sub-selectors and regular properties can
+// freely be mixed in a given object. Any property containing a `&` is
+// assumed to be a sub-selector.
+//
+// Finally, a property can specify an @-block to be wrapped around the
+// styles defined inside the object that's the property's value. For
+// example to create a media query you can do `{"@media screen and
+// (min-width: 400px)": {...}}`.
+
+;// CONCATENATED MODULE: ./node_modules/@codemirror/language/dist/index.js
+
+
+
+
+
+
+var _a;
+/**
+Node prop stored in a parser's top syntax node to provide the
+facet that stores language-specific data for that language.
+*/
+const languageDataProp = /*@__PURE__*/new dist_NodeProp();
+/**
+Helper function to define a facet (to be added to the top syntax
+node(s) for a language via
+[`languageDataProp`](https://codemirror.net/6/docs/ref/#language.languageDataProp)), that will be
+used to associate language data with the language. You
+probably only need this when subclassing
+[`Language`](https://codemirror.net/6/docs/ref/#language.Language).
 */
 function defineLanguageFacet(baseData) {
     return Facet.define({
@@ -2506,31 +2752,27 @@ function defineLanguageFacet(baseData) {
 /**
 A language object manages parsing and per-language
 [metadata](https://codemirror.net/6/docs/ref/#state.EditorState.languageDataAt). Parse data is
-managed as a [Lezer](https://lezer.codemirror.net) tree. You'll
-want to subclass this class for custom parsers, or use the
-[`LRLanguage`](https://codemirror.net/6/docs/ref/#language.LRLanguage) or
-[`StreamLanguage`](https://codemirror.net/6/docs/ref/#stream-parser.StreamLanguage) abstractions for
-[Lezer](https://lezer.codemirror.net/) or stream parsers.
+managed as a [Lezer](https://lezer.codemirror.net) tree. The class
+can be used directly, via the [`LRLanguage`](https://codemirror.net/6/docs/ref/#language.LRLanguage)
+subclass for [Lezer](https://lezer.codemirror.net/) LR parsers, or
+via the [`StreamLanguage`](https://codemirror.net/6/docs/ref/#language.StreamLanguage) subclass
+for stream parsers.
 */
 class Language {
     /**
-    Construct a language object. You usually don't need to invoke
-    this directly. But when you do, make sure you use
-    [`defineLanguageFacet`](https://codemirror.net/6/docs/ref/#language.defineLanguageFacet) to create
-    the first argument.
+    Construct a language object. If you need to invoke this
+    directly, first define a data facet with
+    [`defineLanguageFacet`](https://codemirror.net/6/docs/ref/#language.defineLanguageFacet), and then
+    configure your parser to [attach](https://codemirror.net/6/docs/ref/#language.languageDataProp) it
+    to the language's outer syntax node.
     */
     constructor(
     /**
-    The [language data](https://codemirror.net/6/docs/ref/#state.EditorState.languageDataAt) data
-    facet used for this language.
-    */
-    data, parser, 
-    /**
-    The node type of the top node of trees produced by this parser.
+    The [language data](https://codemirror.net/6/docs/ref/#state.EditorState.languageDataAt) facet
+    used for this language.
     */
-    topNode, extraExtensions = []) {
+    data, parser, extraExtensions = []) {
         this.data = data;
-        this.topNode = topNode;
         // Kludge to define EditorState.tree as a debugging helper,
         // without the EditorState package actually knowing about
         // languages and lezer trees.
@@ -2584,7 +2826,7 @@ class Language {
             }
             for (let i = 0; i < tree.children.length; i++) {
                 let ch = tree.children[i];
-                if (ch instanceof Tree)
+                if (ch instanceof dist_Tree)
                     explore(ch, tree.positions[i] + from);
             }
         };
@@ -2607,7 +2849,7 @@ function languageDataFacetAt(state, pos, side) {
         return null;
     let facet = topLang.data;
     if (topLang.allowsNesting) {
-        for (let node = dist_syntaxTree(state).topNode; node; node = node.enter(pos, side, true, false))
+        for (let node = dist_syntaxTree(state).topNode; node; node = node.enter(pos, side, IterMode.ExcludeBuffers))
             facet = node.type.prop(languageDataProp) || facet;
     }
     return facet;
@@ -2619,7 +2861,7 @@ parsers.
 */
 class LRLanguage extends (/* unused pure expression or super */ null && (Language)) {
     constructor(data, parser) {
-        super(data, parser, parser.topNode);
+        super(data, parser);
         this.parser = parser;
     }
     /**
@@ -2638,16 +2880,17 @@ class LRLanguage extends (/* unused pure expression or super */ null && (Languag
     configure(options) {
         return new LRLanguage(this.data, this.parser.configure(options));
     }
-    get allowsNesting() { return this.parser.wrappers.length > 0; } // FIXME
+    get allowsNesting() { return this.parser.hasWrappers(); }
 }
 /**
 Get the syntax tree for a state, which is the current (possibly
-incomplete) parse tree of active [language](https://codemirror.net/6/docs/ref/#language.Language),
-or the empty tree if there is no language available.
+incomplete) parse tree of the active
+[language](https://codemirror.net/6/docs/ref/#language.Language), or the empty tree if there is no
+language available.
 */
 function dist_syntaxTree(state) {
     let field = state.field(Language.state, false);
-    return field ? field.tree : Tree.empty;
+    return field ? field.tree : dist_Tree.empty;
 }
 /**
 Try to get a parse tree that spans at least up to `upto`. The
@@ -2664,7 +2907,7 @@ Queries whether there is a full syntax tree available up to the
 given document position. If there isn't, the background parse
 process _might_ still be working and update the tree further, but
 there is no guarantee of that—the parser will [stop
-working](https://codemirror.net/6/docs/ref/#language.syntaxParserStopped) when it has spent a
+working](https://codemirror.net/6/docs/ref/#language.syntaxParserRunning) when it has spent a
 certain amount of time or has moved beyond the visible viewport.
 Always returns false if no language has been enabled.
 */
@@ -2673,6 +2916,18 @@ function syntaxTreeAvailable(state, upto = state.doc.length) {
     return ((_a = state.field(Language.state, false)) === null || _a === void 0 ? void 0 : _a.context.isDone(upto)) || false;
 }
 /**
+Move parsing forward, and update the editor state afterwards to
+reflect the new tree. Will work for at most `timeout`
+milliseconds. Returns true if the parser managed get to the given
+position in that time.
+*/
+function forceParsing(view, upto = view.viewport.to, timeout = 100) {
+    let success = ensureSyntaxTree(view.state, upto, timeout);
+    if (success != dist_syntaxTree(view.state))
+        view.dispatch({});
+    return !!success;
+}
+/**
 Tells you whether the language parser is planning to do more
 parsing work (in a `requestIdleCallback` pseudo-thread) or has
 stopped running, either because it parsed the entire document,
@@ -2730,7 +2985,11 @@ class ParseContext {
     /**
     @internal
     */
-    tree, treeLen, 
+    tree, 
+    /**
+    @internal
+    */
+    treeLen, 
     /**
     The current editor viewport (or some overapproximation
     thereof). Intended to be used for opportunistically avoiding
@@ -2773,7 +3032,7 @@ class ParseContext {
     work(until, upto) {
         if (upto != null && upto >= this.state.doc.length)
             upto = undefined;
-        if (this.tree != Tree.empty && this.isDone(upto !== null && upto !== void 0 ? upto : this.state.doc.length)) {
+        if (this.tree != dist_Tree.empty && this.isDone(upto !== null && upto !== void 0 ? upto : this.state.doc.length)) {
             this.takeTree();
             return true;
         }
@@ -2845,7 +3104,7 @@ class ParseContext {
             let ranges = [];
             changes.iterChangedRanges((fromA, toA, fromB, toB) => ranges.push({ fromA, toA, fromB, toB }));
             fragments = TreeFragment.applyChanges(fragments, ranges);
-            tree = Tree.empty;
+            tree = dist_Tree.empty;
             treeLen = 0;
             viewport = { from: changes.mapPos(viewport.from, -1), to: changes.mapPos(viewport.to, 1) };
             if (this.skipped.length) {
@@ -2906,7 +3165,7 @@ class ParseContext {
     promise resolves.
     */
     static getSkippingParser(until) {
-        return new class extends Parser {
+        return new class extends dist_Parser {
             createParse(input, fragments, ranges) {
                 let from = ranges[0].from, to = ranges[ranges.length - 1].to;
                 let parser = {
@@ -2920,7 +3179,7 @@ class ParseContext {
                                 cx.scheduleOn = cx.scheduleOn ? Promise.all([cx.scheduleOn, until]) : until;
                         }
                         this.parsedPos = to;
-                        return new Tree(NodeType.none, [], [], to - from);
+                        return new dist_Tree(dist_NodeType.none, [], [], to - from);
                     },
                     stoppedAt: null,
                     stopAt() { }
@@ -2969,7 +3228,7 @@ class LanguageState {
     }
     static init(state) {
         let vpTo = Math.min(3000 /* InitViewport */, state.doc.length);
-        let parseState = new ParseContext(state.facet(language).parser, state, [], Tree.empty, 0, { from: 0, to: vpTo }, [], null);
+        let parseState = new ParseContext(state.facet(language).parser, state, [], dist_Tree.empty, 0, { from: 0, to: vpTo }, [], null);
         if (!parseState.work(20 /* Apply */, vpTo))
             parseState.takeTree();
         return new LanguageState(parseState);
@@ -3083,7 +3342,7 @@ const language = /*@__PURE__*/state_.Facet.define({
     enables: [Language.state, parseWorker]
 });
 /**
-This class bundles a [language object](https://codemirror.net/6/docs/ref/#language.Language) with an
+This class bundles a [language](https://codemirror.net/6/docs/ref/#language.Language) with an
 optional set of supporting extensions. Language packages are
 encouraged to export a function that optionally takes a
 configuration object and returns a `LanguageSupport` instance, as
@@ -3091,7 +3350,7 @@ the main way for client code to use the package.
 */
 class LanguageSupport {
     /**
-    Create a support object.
+    Create a language support object.
     */
     constructor(
     /**
@@ -3404,7 +3663,7 @@ function indentFrom(node, pos, base) {
 function topIndent() { return 0; }
 /**
 Objects of this type provide context information and helper
-methods to indentation functions.
+methods to indentation functions registered on syntax nodes.
 */
 class TreeIndentContext extends (/* unused pure expression or super */ null && (dist_IndentContext)) {
     /**
@@ -3579,7 +3838,7 @@ the extent of a line, such a function should return a foldable
 range that starts on that line (but continues beyond it), if one
 can be found.
 */
-const foldService = /*@__PURE__*/(/* unused pure expression or super */ null && (Facet.define()));
+const foldService = /*@__PURE__*/state_.Facet.define();
 /**
 This node prop is used to associate folding information with
 syntax node types. Given a syntax node, it should check whether
@@ -3598,7 +3857,7 @@ function foldInside(node) {
 }
 function syntaxFolding(state, start, end) {
     let tree = dist_syntaxTree(state);
-    if (tree.length == 0)
+    if (tree.length < end)
         return null;
     let inner = tree.resolveInner(end);
     let found = null;
@@ -3636,116 +3895,1791 @@ function foldable(state, lineStart, lineEnd) {
     }
     return syntaxFolding(state, lineStart, lineEnd);
 }
-
-
-
-;// CONCATENATED MODULE: ./node_modules/@codemirror/commands/dist/index.js
-
-
-
-
-
-
-
-function updateSel(sel, by) {
-    return state_.EditorSelection.create(sel.ranges.map(by), sel.mainIndex);
-}
-function setSel(state, selection) {
-    return state.update({ selection, scrollIntoView: true, userEvent: "select" });
-}
-function moveSel({ state, dispatch }, how) {
-    let selection = updateSel(state.selection, how);
-    if (selection.eq(state.selection))
-        return false;
-    dispatch(setSel(state, selection));
-    return true;
-}
-function rangeEnd(range, forward) {
-    return state_.EditorSelection.cursor(forward ? range.to : range.from);
-}
-function cursorByChar(view, forward) {
-    return moveSel(view, range => range.empty ? view.moveByChar(range, forward) : rangeEnd(range, forward));
+function mapRange(range, mapping) {
+    let from = mapping.mapPos(range.from, 1), to = mapping.mapPos(range.to, -1);
+    return from >= to ? undefined : { from, to };
 }
 /**
-Move the selection one character to the left (which is backward in
-left-to-right text, forward in right-to-left text).
+State effect that can be attached to a transaction to fold the
+given range. (You probably only need this in exceptional
+circumstances—usually you'll just want to let
+[`foldCode`](https://codemirror.net/6/docs/ref/#language.foldCode) and the [fold
+gutter](https://codemirror.net/6/docs/ref/#language.foldGutter) create the transactions.)
 */
-const cursorCharLeft = view => cursorByChar(view, view.textDirection != view_.Direction.LTR);
+const foldEffect = /*@__PURE__*/state_.StateEffect.define({ map: mapRange });
 /**
-Move the selection one character to the right.
+State effect that unfolds the given range (if it was folded).
 */
-const cursorCharRight = view => cursorByChar(view, view.textDirection == view_.Direction.LTR);
+const unfoldEffect = /*@__PURE__*/state_.StateEffect.define({ map: mapRange });
+function selectedLines(view) {
+    let lines = [];
+    for (let { head } of view.state.selection.ranges) {
+        if (lines.some(l => l.from <= head && l.to >= head))
+            continue;
+        lines.push(view.lineBlockAt(head));
+    }
+    return lines;
+}
+const foldState = /*@__PURE__*/state_.StateField.define({
+    create() {
+        return view_.Decoration.none;
+    },
+    update(folded, tr) {
+        folded = folded.map(tr.changes);
+        for (let e of tr.effects) {
+            if (e.is(foldEffect) && !foldExists(folded, e.value.from, e.value.to))
+                folded = folded.update({ add: [foldWidget.range(e.value.from, e.value.to)] });
+            else if (e.is(unfoldEffect))
+                folded = folded.update({ filter: (from, to) => e.value.from != from || e.value.to != to,
+                    filterFrom: e.value.from, filterTo: e.value.to });
+        }
+        // Clear folded ranges that cover the selection head
+        if (tr.selection) {
+            let onSelection = false, { head } = tr.selection.main;
+            folded.between(head, head, (a, b) => { if (a < head && b > head)
+                onSelection = true; });
+            if (onSelection)
+                folded = folded.update({
+                    filterFrom: head,
+                    filterTo: head,
+                    filter: (a, b) => b <= head || a >= head
+                });
+        }
+        return folded;
+    },
+    provide: f => view_.EditorView.decorations.from(f)
+});
 /**
-Move the selection one character forward.
+Get a [range set](https://codemirror.net/6/docs/ref/#state.RangeSet) containing the folded ranges
+in the given state.
 */
-const cursorCharForward = view => cursorByChar(view, true);
+function foldedRanges(state) {
+    return state.field(foldState, false) || RangeSet.empty;
+}
+function findFold(state, from, to) {
+    var _a;
+    let found = null;
+    (_a = state.field(foldState, false)) === null || _a === void 0 ? void 0 : _a.between(from, to, (from, to) => {
+        if (!found || found.from > from)
+            found = { from, to };
+    });
+    return found;
+}
+function foldExists(folded, from, to) {
+    let found = false;
+    folded.between(from, from, (a, b) => { if (a == from && b == to)
+        found = true; });
+    return found;
+}
+function maybeEnable(state, other) {
+    return state.field(foldState, false) ? other : other.concat(state_.StateEffect.appendConfig.of(codeFolding()));
+}
 /**
-Move the selection one character backward.
+Fold the lines that are selected, if possible.
 */
-const cursorCharBackward = view => cursorByChar(view, false);
-function cursorByGroup(view, forward) {
-    return moveSel(view, range => range.empty ? view.moveByGroup(range, forward) : rangeEnd(range, forward));
+const foldCode = view => {
+    for (let line of selectedLines(view)) {
+        let range = foldable(view.state, line.from, line.to);
+        if (range) {
+            view.dispatch({ effects: maybeEnable(view.state, [foldEffect.of(range), announceFold(view, range)]) });
+            return true;
+        }
+    }
+    return false;
+};
+/**
+Unfold folded ranges on selected lines.
+*/
+const unfoldCode = view => {
+    if (!view.state.field(foldState, false))
+        return false;
+    let effects = [];
+    for (let line of selectedLines(view)) {
+        let folded = findFold(view.state, line.from, line.to);
+        if (folded)
+            effects.push(unfoldEffect.of(folded), announceFold(view, folded, false));
+    }
+    if (effects.length)
+        view.dispatch({ effects });
+    return effects.length > 0;
+};
+function announceFold(view, range, fold = true) {
+    let lineFrom = view.state.doc.lineAt(range.from).number, lineTo = view.state.doc.lineAt(range.to).number;
+    return view_.EditorView.announce.of(`${view.state.phrase(fold ? "Folded lines" : "Unfolded lines")} ${lineFrom} ${view.state.phrase("to")} ${lineTo}.`);
 }
 /**
-Move the selection to the left across one group of word or
-non-word (but also non-space) characters.
+Fold all top-level foldable ranges. Note that, in most cases,
+folding information will depend on the [syntax
+tree](https://codemirror.net/6/docs/ref/#language.syntaxTree), and folding everything may not work
+reliably when the document hasn't been fully parsed (either
+because the editor state was only just initialized, or because the
+document is so big that the parser decided not to parse it
+entirely).
 */
-const cursorGroupLeft = view => cursorByGroup(view, view.textDirection != Direction.LTR);
+const foldAll = view => {
+    let { state } = view, effects = [];
+    for (let pos = 0; pos < state.doc.length;) {
+        let line = view.lineBlockAt(pos), range = foldable(state, line.from, line.to);
+        if (range)
+            effects.push(foldEffect.of(range));
+        pos = (range ? view.lineBlockAt(range.to) : line).to + 1;
+    }
+    if (effects.length)
+        view.dispatch({ effects: maybeEnable(view.state, effects) });
+    return !!effects.length;
+};
 /**
-Move the selection one group to the right.
+Unfold all folded code.
 */
-const cursorGroupRight = view => cursorByGroup(view, view.textDirection == Direction.LTR);
+const unfoldAll = view => {
+    let field = view.state.field(foldState, false);
+    if (!field || !field.size)
+        return false;
+    let effects = [];
+    field.between(0, view.state.doc.length, (from, to) => { effects.push(unfoldEffect.of({ from, to })); });
+    view.dispatch({ effects });
+    return true;
+};
 /**
-Move the selection one group forward.
+Default fold-related key bindings.
+
+ - Ctrl-Shift-[ (Cmd-Alt-[ on macOS): [`foldCode`](https://codemirror.net/6/docs/ref/#language.foldCode).
+ - Ctrl-Shift-] (Cmd-Alt-] on macOS): [`unfoldCode`](https://codemirror.net/6/docs/ref/#language.unfoldCode).
+ - Ctrl-Alt-[: [`foldAll`](https://codemirror.net/6/docs/ref/#language.foldAll).
+ - Ctrl-Alt-]: [`unfoldAll`](https://codemirror.net/6/docs/ref/#language.unfoldAll).
 */
-const cursorGroupForward = view => cursorByGroup(view, true);
+const foldKeymap = [
+    { key: "Ctrl-Shift-[", mac: "Cmd-Alt-[", run: foldCode },
+    { key: "Ctrl-Shift-]", mac: "Cmd-Alt-]", run: unfoldCode },
+    { key: "Ctrl-Alt-[", run: foldAll },
+    { key: "Ctrl-Alt-]", run: unfoldAll }
+];
+const defaultConfig = {
+    placeholderDOM: null,
+    placeholderText: "…"
+};
+const foldConfig = /*@__PURE__*/state_.Facet.define({
+    combine(values) { return (0,state_.combineConfig)(values, defaultConfig); }
+});
 /**
-Move the selection one group backward.
+Create an extension that configures code folding.
 */
-const cursorGroupBackward = view => cursorByGroup(view, false);
-function moveBySubword(view, range, forward) {
-    let categorize = view.state.charCategorizer(range.from);
-    return view.moveByChar(range, forward, start => {
-        let cat = CharCategory.Space, pos = range.from;
-        let done = false, sawUpper = false, sawLower = false;
-        let step = (next) => {
-            if (done)
-                return false;
-            pos += forward ? next.length : -next.length;
-            let nextCat = categorize(next), ahead;
-            if (cat == CharCategory.Space)
-                cat = nextCat;
-            if (cat != nextCat)
-                return false;
-            if (cat == CharCategory.Word) {
-                if (next.toLowerCase() == next) {
-                    if (!forward && sawUpper)
-                        return false;
-                    sawLower = true;
-                }
-                else if (sawLower) {
-                    if (forward)
-                        return false;
-                    done = true;
-                }
-                else {
-                    if (sawUpper && forward && categorize(ahead = view.state.sliceDoc(pos, pos + 1)) == CharCategory.Word &&
-                        ahead.toLowerCase() == ahead)
-                        return false;
-                    sawUpper = true;
-                }
-            }
-            return true;
-        };
-        step(start);
-        return step;
-    });
+function codeFolding(config) {
+    let result = [foldState, baseTheme$1];
+    if (config)
+        result.push(foldConfig.of(config));
+    return result;
 }
-function cursorBySubword(view, forward) {
-    return moveSel(view, range => range.empty ? moveBySubword(view, range, forward) : rangeEnd(range, forward));
+const foldWidget = /*@__PURE__*/view_.Decoration.replace({ widget: /*@__PURE__*/new class extends view_.WidgetType {
+        toDOM(view) {
+            let { state } = view, conf = state.facet(foldConfig);
+            let onclick = (event) => {
+                let line = view.lineBlockAt(view.posAtDOM(event.target));
+                let folded = findFold(view.state, line.from, line.to);
+                if (folded)
+                    view.dispatch({ effects: unfoldEffect.of(folded) });
+                event.preventDefault();
+            };
+            if (conf.placeholderDOM)
+                return conf.placeholderDOM(view, onclick);
+            let element = document.createElement("span");
+            element.textContent = conf.placeholderText;
+            element.setAttribute("aria-label", state.phrase("folded code"));
+            element.title = state.phrase("unfold");
+            element.className = "cm-foldPlaceholder";
+            element.onclick = onclick;
+            return element;
+        }
+    } });
+const foldGutterDefaults = {
+    openText: "⌄",
+    closedText: "›",
+    markerDOM: null,
+    domEventHandlers: {},
+};
+class FoldMarker extends (/* unused pure expression or super */ null && (GutterMarker)) {
+    constructor(config, open) {
+        super();
+        this.config = config;
+        this.open = open;
+    }
+    eq(other) { return this.config == other.config && this.open == other.open; }
+    toDOM(view) {
+        if (this.config.markerDOM)
+            return this.config.markerDOM(this.open);
+        let span = document.createElement("span");
+        span.textContent = this.open ? this.config.openText : this.config.closedText;
+        span.title = view.state.phrase(this.open ? "Fold line" : "Unfold line");
+        return span;
+    }
 }
 /**
-Move the selection one group or camel-case subword forward.
+Create an extension that registers a fold gutter, which shows a
+fold status indicator before foldable lines (which can be clicked
+to fold or unfold the line).
+*/
+function foldGutter(config = {}) {
+    let fullConfig = Object.assign(Object.assign({}, foldGutterDefaults), config);
+    let canFold = new FoldMarker(fullConfig, true), canUnfold = new FoldMarker(fullConfig, false);
+    let markers = ViewPlugin.fromClass(class {
+        constructor(view) {
+            this.from = view.viewport.from;
+            this.markers = this.buildMarkers(view);
+        }
+        update(update) {
+            if (update.docChanged || update.viewportChanged ||
+                update.startState.facet(language) != update.state.facet(language) ||
+                update.startState.field(foldState, false) != update.state.field(foldState, false) ||
+                dist_syntaxTree(update.startState) != dist_syntaxTree(update.state))
+                this.markers = this.buildMarkers(update.view);
+        }
+        buildMarkers(view) {
+            let builder = new RangeSetBuilder();
+            for (let line of view.viewportLineBlocks) {
+                let mark = findFold(view.state, line.from, line.to) ? canUnfold
+                    : foldable(view.state, line.from, line.to) ? canFold : null;
+                if (mark)
+                    builder.add(line.from, line.from, mark);
+            }
+            return builder.finish();
+        }
+    });
+    let { domEventHandlers } = fullConfig;
+    return [
+        markers,
+        gutter({
+            class: "cm-foldGutter",
+            markers(view) { var _a; return ((_a = view.plugin(markers)) === null || _a === void 0 ? void 0 : _a.markers) || RangeSet.empty; },
+            initialSpacer() {
+                return new FoldMarker(fullConfig, false);
+            },
+            domEventHandlers: Object.assign(Object.assign({}, domEventHandlers), { click: (view, line, event) => {
+                    if (domEventHandlers.click && domEventHandlers.click(view, line, event))
+                        return true;
+                    let folded = findFold(view.state, line.from, line.to);
+                    if (folded) {
+                        view.dispatch({ effects: unfoldEffect.of(folded) });
+                        return true;
+                    }
+                    let range = foldable(view.state, line.from, line.to);
+                    if (range) {
+                        view.dispatch({ effects: foldEffect.of(range) });
+                        return true;
+                    }
+                    return false;
+                } })
+        }),
+        codeFolding()
+    ];
+}
+const baseTheme$1 = /*@__PURE__*/view_.EditorView.baseTheme({
+    ".cm-foldPlaceholder": {
+        backgroundColor: "#eee",
+        border: "1px solid #ddd",
+        color: "#888",
+        borderRadius: ".2em",
+        margin: "0 1px",
+        padding: "0 1px",
+        cursor: "pointer"
+    },
+    ".cm-foldGutter span": {
+        padding: "0 1px",
+        cursor: "pointer"
+    }
+});
+
+/**
+A highlight style associates CSS styles with higlighting
+[tags](https://lezer.codemirror.net/docs/ref#highlight.Tag).
+*/
+class HighlightStyle {
+    constructor(spec, options) {
+        let modSpec;
+        function def(spec) {
+            let cls = StyleModule.newName();
+            (modSpec || (modSpec = Object.create(null)))["." + cls] = spec;
+            return cls;
+        }
+        const scopeOpt = options.scope;
+        this.scope = scopeOpt instanceof Language ? (type) => type.prop(languageDataProp) == scopeOpt.data
+            : scopeOpt ? (type) => type == scopeOpt : undefined;
+        this.style = tagHighlighter(spec.map(style => ({
+            tag: style.tag,
+            class: style.class || def(Object.assign({}, style, { tag: null }))
+        })), {
+            all: typeof options.all == "string" ? options.all : options.all ? def(options.all) : undefined,
+        }).style;
+        this.module = modSpec ? new StyleModule(modSpec) : null;
+        this.themeType = options.themeType;
+    }
+    /**
+    Create a highlighter style that associates the given styles to
+    the given tags. The specs must be objects that hold a style tag
+    or array of tags in their `tag` property, and either a single
+    `class` property providing a static CSS class (for highlighter
+    that rely on external styling), or a
+    [`style-mod`](https://github.com/marijnh/style-mod#documentation)-style
+    set of CSS properties (which define the styling for those tags).
+    
+    The CSS rules created for a highlighter will be emitted in the
+    order of the spec's properties. That means that for elements that
+    have multiple tags associated with them, styles defined further
+    down in the list will have a higher CSS precedence than styles
+    defined earlier.
+    */
+    static define(specs, options) {
+        return new HighlightStyle(specs, options || {});
+    }
+}
+const highlighterFacet = /*@__PURE__*/state_.Facet.define();
+const fallbackHighlighter = /*@__PURE__*/state_.Facet.define({
+    combine(values) { return values.length ? [values[0]] : null; }
+});
+function getHighlighters(state) {
+    let main = state.facet(highlighterFacet);
+    return main.length ? main : state.facet(fallbackHighlighter);
+}
+/**
+Wrap a highlighter in an editor extension that uses it to apply
+syntax highlighting to the editor content.
+
+When multiple (non-fallback) styles are provided, the styling
+applied is the union of the classes they emit.
+*/
+function syntaxHighlighting(highlighter, options) {
+    let ext = [treeHighlighter], themeType;
+    if (highlighter instanceof HighlightStyle) {
+        if (highlighter.module)
+            ext.push(EditorView.styleModule.of(highlighter.module));
+        themeType = highlighter.themeType;
+    }
+    if (options === null || options === void 0 ? void 0 : options.fallback)
+        ext.push(fallbackHighlighter.of(highlighter));
+    else if (themeType)
+        ext.push(highlighterFacet.computeN([EditorView.darkTheme], state => {
+            return state.facet(EditorView.darkTheme) == (themeType == "dark") ? [highlighter] : [];
+        }));
+    else
+        ext.push(highlighterFacet.of(highlighter));
+    return ext;
+}
+/**
+Returns the CSS classes (if any) that the highlighters active in
+the state would assign to the given style
+[tags](https://lezer.codemirror.net/docs/ref#highlight.Tag) and
+(optional) language
+[scope](https://codemirror.net/6/docs/ref/#language.HighlightStyle^define^options.scope).
+*/
+function highlightingFor(state, tags, scope) {
+    let highlighters = getHighlighters(state);
+    let result = null;
+    if (highlighters)
+        for (let highlighter of highlighters) {
+            if (!highlighter.scope || scope && highlighter.scope(scope)) {
+                let cls = highlighter.style(tags);
+                if (cls)
+                    result = result ? result + " " + cls : cls;
+            }
+        }
+    return result;
+}
+class TreeHighlighter {
+    constructor(view) {
+        this.markCache = Object.create(null);
+        this.tree = dist_syntaxTree(view.state);
+        this.decorations = this.buildDeco(view, getHighlighters(view.state));
+    }
+    update(update) {
+        let tree = dist_syntaxTree(update.state), highlighters = getHighlighters(update.state);
+        let styleChange = highlighters != getHighlighters(update.startState);
+        if (tree.length < update.view.viewport.to && !styleChange && tree.type == this.tree.type) {
+            this.decorations = this.decorations.map(update.changes);
+        }
+        else if (tree != this.tree || update.viewportChanged || styleChange) {
+            this.tree = tree;
+            this.decorations = this.buildDeco(update.view, highlighters);
+        }
+    }
+    buildDeco(view, highlighters) {
+        if (!highlighters || !this.tree.length)
+            return view_.Decoration.none;
+        let builder = new state_.RangeSetBuilder();
+        for (let { from, to } of view.visibleRanges) {
+            highlightTree(this.tree, highlighters, (from, to, style) => {
+                builder.add(from, to, this.markCache[style] || (this.markCache[style] = view_.Decoration.mark({ class: style })));
+            }, from, to);
+        }
+        return builder.finish();
+    }
+}
+const treeHighlighter = /*@__PURE__*/state_.Prec.high(/*@__PURE__*/view_.ViewPlugin.fromClass(TreeHighlighter, {
+    decorations: v => v.decorations
+}));
+/**
+A default highlight style (works well with light themes).
+*/
+const defaultHighlightStyle = /*@__PURE__*/HighlightStyle.define([
+    { tag: tags.meta,
+        color: "#7a757a" },
+    { tag: tags.link,
+        textDecoration: "underline" },
+    { tag: tags.heading,
+        textDecoration: "underline",
+        fontWeight: "bold" },
+    { tag: tags.emphasis,
+        fontStyle: "italic" },
+    { tag: tags.strong,
+        fontWeight: "bold" },
+    { tag: tags.strikethrough,
+        textDecoration: "line-through" },
+    { tag: tags.keyword,
+        color: "#708" },
+    { tag: [tags.atom, tags.bool, tags.url, tags.contentSeparator, tags.labelName],
+        color: "#219" },
+    { tag: [tags.literal, tags.inserted],
+        color: "#164" },
+    { tag: [tags.string, tags.deleted],
+        color: "#a11" },
+    { tag: [tags.regexp, tags.escape, /*@__PURE__*/tags.special(tags.string)],
+        color: "#e40" },
+    { tag: /*@__PURE__*/tags.definition(tags.variableName),
+        color: "#00f" },
+    { tag: /*@__PURE__*/tags.local(tags.variableName),
+        color: "#30a" },
+    { tag: [tags.typeName, tags.namespace],
+        color: "#085" },
+    { tag: tags.className,
+        color: "#167" },
+    { tag: [/*@__PURE__*/tags.special(tags.variableName), tags.macroName],
+        color: "#256" },
+    { tag: /*@__PURE__*/tags.definition(tags.propertyName),
+        color: "#00c" },
+    { tag: tags.comment,
+        color: "#940" },
+    { tag: tags.invalid,
+        color: "#f00" }
+]);
+
+const baseTheme = /*@__PURE__*/view_.EditorView.baseTheme({
+    "&.cm-focused .cm-matchingBracket": { backgroundColor: "#328c8252" },
+    "&.cm-focused .cm-nonmatchingBracket": { backgroundColor: "#bb555544" }
+});
+const DefaultScanDist = 10000, DefaultBrackets = "()[]{}";
+const bracketMatchingConfig = /*@__PURE__*/state_.Facet.define({
+    combine(configs) {
+        return (0,state_.combineConfig)(configs, {
+            afterCursor: true,
+            brackets: DefaultBrackets,
+            maxScanDistance: DefaultScanDist,
+            renderMatch: defaultRenderMatch
+        });
+    }
+});
+const matchingMark = /*@__PURE__*/view_.Decoration.mark({ class: "cm-matchingBracket" }), nonmatchingMark = /*@__PURE__*/view_.Decoration.mark({ class: "cm-nonmatchingBracket" });
+function defaultRenderMatch(match) {
+    let decorations = [];
+    let mark = match.matched ? matchingMark : nonmatchingMark;
+    decorations.push(mark.range(match.start.from, match.start.to));
+    if (match.end)
+        decorations.push(mark.range(match.end.from, match.end.to));
+    return decorations;
+}
+const bracketMatchingState = /*@__PURE__*/state_.StateField.define({
+    create() { return view_.Decoration.none; },
+    update(deco, tr) {
+        if (!tr.docChanged && !tr.selection)
+            return deco;
+        let decorations = [];
+        let config = tr.state.facet(bracketMatchingConfig);
+        for (let range of tr.state.selection.ranges) {
+            if (!range.empty)
+                continue;
+            let match = dist_matchBrackets(tr.state, range.head, -1, config)
+                || (range.head > 0 && dist_matchBrackets(tr.state, range.head - 1, 1, config))
+                || (config.afterCursor &&
+                    (dist_matchBrackets(tr.state, range.head, 1, config) ||
+                        (range.head < tr.state.doc.length && dist_matchBrackets(tr.state, range.head + 1, -1, config))));
+            if (match)
+                decorations = decorations.concat(config.renderMatch(match, tr.state));
+        }
+        return view_.Decoration.set(decorations, true);
+    },
+    provide: f => view_.EditorView.decorations.from(f)
+});
+const bracketMatchingUnique = [
+    bracketMatchingState,
+    baseTheme
+];
+/**
+Create an extension that enables bracket matching. Whenever the
+cursor is next to a bracket, that bracket and the one it matches
+are highlighted. Or, when no matching bracket is found, another
+highlighting style is used to indicate this.
+*/
+function bracketMatching(config = {}) {
+    return [bracketMatchingConfig.of(config), bracketMatchingUnique];
+}
+function matchingNodes(node, dir, brackets) {
+    let byProp = node.prop(dir < 0 ? dist_NodeProp.openedBy : dist_NodeProp.closedBy);
+    if (byProp)
+        return byProp;
+    if (node.name.length == 1) {
+        let index = brackets.indexOf(node.name);
+        if (index > -1 && index % 2 == (dir < 0 ? 1 : 0))
+            return [brackets[index + dir]];
+    }
+    return null;
+}
+/**
+Find the matching bracket for the token at `pos`, scanning
+direction `dir`. Only the `brackets` and `maxScanDistance`
+properties are used from `config`, if given. Returns null if no
+bracket was found at `pos`, or a match result otherwise.
+*/
+function dist_matchBrackets(state, pos, dir, config = {}) {
+    let maxScanDistance = config.maxScanDistance || DefaultScanDist, brackets = config.brackets || DefaultBrackets;
+    let tree = dist_syntaxTree(state), node = tree.resolveInner(pos, dir);
+    for (let cur = node; cur; cur = cur.parent) {
+        let matches = matchingNodes(cur.type, dir, brackets);
+        if (matches && cur.from < cur.to)
+            return matchMarkedBrackets(state, pos, dir, cur, matches, brackets);
+    }
+    return matchPlainBrackets(state, pos, dir, tree, node.type, maxScanDistance, brackets);
+}
+function matchMarkedBrackets(_state, _pos, dir, token, matching, brackets) {
+    let parent = token.parent, firstToken = { from: token.from, to: token.to };
+    let depth = 0, cursor = parent === null || parent === void 0 ? void 0 : parent.cursor();
+    if (cursor && (dir < 0 ? cursor.childBefore(token.from) : cursor.childAfter(token.to)))
+        do {
+            if (dir < 0 ? cursor.to <= token.from : cursor.from >= token.to) {
+                if (depth == 0 && matching.indexOf(cursor.type.name) > -1 && cursor.from < cursor.to) {
+                    return { start: firstToken, end: { from: cursor.from, to: cursor.to }, matched: true };
+                }
+                else if (matchingNodes(cursor.type, dir, brackets)) {
+                    depth++;
+                }
+                else if (matchingNodes(cursor.type, -dir, brackets)) {
+                    depth--;
+                    if (depth == 0)
+                        return {
+                            start: firstToken,
+                            end: cursor.from == cursor.to ? undefined : { from: cursor.from, to: cursor.to },
+                            matched: false
+                        };
+                }
+            }
+        } while (dir < 0 ? cursor.prevSibling() : cursor.nextSibling());
+    return { start: firstToken, matched: false };
+}
+function matchPlainBrackets(state, pos, dir, tree, tokenType, maxScanDistance, brackets) {
+    let startCh = dir < 0 ? state.sliceDoc(pos - 1, pos) : state.sliceDoc(pos, pos + 1);
+    let bracket = brackets.indexOf(startCh);
+    if (bracket < 0 || (bracket % 2 == 0) != (dir > 0))
+        return null;
+    let startToken = { from: dir < 0 ? pos - 1 : pos, to: dir > 0 ? pos + 1 : pos };
+    let iter = state.doc.iterRange(pos, dir > 0 ? state.doc.length : 0), depth = 0;
+    for (let distance = 0; !(iter.next()).done && distance <= maxScanDistance;) {
+        let text = iter.value;
+        if (dir < 0)
+            distance += text.length;
+        let basePos = pos + distance * dir;
+        for (let pos = dir > 0 ? 0 : text.length - 1, end = dir > 0 ? text.length : -1; pos != end; pos += dir) {
+            let found = brackets.indexOf(text[pos]);
+            if (found < 0 || tree.resolve(basePos + pos, 1).type != tokenType)
+                continue;
+            if ((found % 2 == 0) == (dir > 0)) {
+                depth++;
+            }
+            else if (depth == 1) { // Closing
+                return { start: startToken, end: { from: basePos + pos, to: basePos + pos + 1 }, matched: (found >> 1) == (bracket >> 1) };
+            }
+            else {
+                depth--;
+            }
+        }
+        if (dir > 0)
+            distance += text.length;
+    }
+    return iter.done ? { start: startToken, matched: false } : null;
+}
+
+// Counts the column offset in a string, taking tabs into account.
+// Used mostly to find indentation.
+function countCol(string, end, tabSize, startIndex = 0, startValue = 0) {
+    if (end == null) {
+        end = string.search(/[^\s\u00a0]/);
+        if (end == -1)
+            end = string.length;
+    }
+    let n = startValue;
+    for (let i = startIndex; i < end; i++) {
+        if (string.charCodeAt(i) == 9)
+            n += tabSize - (n % tabSize);
+        else
+            n++;
+    }
+    return n;
+}
+/**
+Encapsulates a single line of input. Given to stream syntax code,
+which uses it to tokenize the content.
+*/
+class StringStream {
+    /**
+    @internal
+    */
+    constructor(
+    /**
+    The line.
+    */
+    string, tabSize, 
+    /**
+    The current indent unit size.
+    */
+    indentUnit) {
+        this.string = string;
+        this.tabSize = tabSize;
+        this.indentUnit = indentUnit;
+        /**
+        The current position on the line.
+        */
+        this.pos = 0;
+        /**
+        The start position of the current token.
+        */
+        this.start = 0;
+        this.lastColumnPos = 0;
+        this.lastColumnValue = 0;
+    }
+    /**
+    True if we are at the end of the line.
+    */
+    eol() { return this.pos >= this.string.length; }
+    /**
+    True if we are at the start of the line.
+    */
+    sol() { return this.pos == 0; }
+    /**
+    Get the next code unit after the current position, or undefined
+    if we're at the end of the line.
+    */
+    peek() { return this.string.charAt(this.pos) || undefined; }
+    /**
+    Read the next code unit and advance `this.pos`.
+    */
+    next() {
+        if (this.pos < this.string.length)
+            return this.string.charAt(this.pos++);
+    }
+    /**
+    Match the next character against the given string, regular
+    expression, or predicate. Consume and return it if it matches.
+    */
+    eat(match) {
+        let ch = this.string.charAt(this.pos);
+        let ok;
+        if (typeof match == "string")
+            ok = ch == match;
+        else
+            ok = ch && (match instanceof RegExp ? match.test(ch) : match(ch));
+        if (ok) {
+            ++this.pos;
+            return ch;
+        }
+    }
+    /**
+    Continue matching characters that match the given string,
+    regular expression, or predicate function. Return true if any
+    characters were consumed.
+    */
+    eatWhile(match) {
+        let start = this.pos;
+        while (this.eat(match)) { }
+        return this.pos > start;
+    }
+    /**
+    Consume whitespace ahead of `this.pos`. Return true if any was
+    found.
+    */
+    eatSpace() {
+        let start = this.pos;
+        while (/[\s\u00a0]/.test(this.string.charAt(this.pos)))
+            ++this.pos;
+        return this.pos > start;
+    }
+    /**
+    Move to the end of the line.
+    */
+    skipToEnd() { this.pos = this.string.length; }
+    /**
+    Move to directly before the given character, if found on the
+    current line.
+    */
+    skipTo(ch) {
+        let found = this.string.indexOf(ch, this.pos);
+        if (found > -1) {
+            this.pos = found;
+            return true;
+        }
+    }
+    /**
+    Move back `n` characters.
+    */
+    backUp(n) { this.pos -= n; }
+    /**
+    Get the column position at `this.pos`.
+    */
+    column() {
+        if (this.lastColumnPos < this.start) {
+            this.lastColumnValue = countCol(this.string, this.start, this.tabSize, this.lastColumnPos, this.lastColumnValue);
+            this.lastColumnPos = this.start;
+        }
+        return this.lastColumnValue;
+    }
+    /**
+    Get the indentation column of the current line.
+    */
+    indentation() {
+        return countCol(this.string, null, this.tabSize);
+    }
+    /**
+    Match the input against the given string or regular expression
+    (which should start with a `^`). Return true or the regexp match
+    if it matches.
+    
+    Unless `consume` is set to `false`, this will move `this.pos`
+    past the matched text.
+    
+    When matching a string `caseInsensitive` can be set to true to
+    make the match case-insensitive.
+    */
+    match(pattern, consume, caseInsensitive) {
+        if (typeof pattern == "string") {
+            let cased = (str) => caseInsensitive ? str.toLowerCase() : str;
+            let substr = this.string.substr(this.pos, pattern.length);
+            if (cased(substr) == cased(pattern)) {
+                if (consume !== false)
+                    this.pos += pattern.length;
+                return true;
+            }
+            else
+                return null;
+        }
+        else {
+            let match = this.string.slice(this.pos).match(pattern);
+            if (match && match.index > 0)
+                return null;
+            if (match && consume !== false)
+                this.pos += match[0].length;
+            return match;
+        }
+    }
+    /**
+    Get the current token.
+    */
+    current() { return this.string.slice(this.start, this.pos); }
+}
+
+function fullParser(spec) {
+    return {
+        token: spec.token,
+        blankLine: spec.blankLine || (() => { }),
+        startState: spec.startState || (() => true),
+        copyState: spec.copyState || defaultCopyState,
+        indent: spec.indent || (() => null),
+        languageData: spec.languageData || {},
+        tokenTable: spec.tokenTable || noTokens
+    };
+}
+function defaultCopyState(state) {
+    if (typeof state != "object")
+        return state;
+    let newState = {};
+    for (let prop in state) {
+        let val = state[prop];
+        newState[prop] = (val instanceof Array ? val.slice() : val);
+    }
+    return newState;
+}
+/**
+A [language](https://codemirror.net/6/docs/ref/#language.Language) class based on a CodeMirror
+5-style [streaming parser](https://codemirror.net/6/docs/ref/#language.StreamParser).
+*/
+class StreamLanguage extends (/* unused pure expression or super */ null && (Language)) {
+    constructor(parser) {
+        let data = defineLanguageFacet(parser.languageData);
+        let p = fullParser(parser), self;
+        let impl = new class extends Parser {
+            createParse(input, fragments, ranges) {
+                return new Parse(self, input, fragments, ranges);
+            }
+        };
+        super(data, impl, [indentService.of((cx, pos) => this.getIndent(cx, pos))]);
+        this.topNode = docID(data);
+        self = this;
+        this.streamParser = p;
+        this.stateAfter = new NodeProp({ perNode: true });
+        this.tokenTable = parser.tokenTable ? new TokenTable(p.tokenTable) : defaultTokenTable;
+    }
+    /**
+    Define a stream language.
+    */
+    static define(spec) { return new StreamLanguage(spec); }
+    getIndent(cx, pos) {
+        let tree = dist_syntaxTree(cx.state), at = tree.resolve(pos);
+        while (at && at.type != this.topNode)
+            at = at.parent;
+        if (!at)
+            return null;
+        let start = findState(this, tree, 0, at.from, pos), statePos, state;
+        if (start) {
+            state = start.state;
+            statePos = start.pos + 1;
+        }
+        else {
+            state = this.streamParser.startState(cx.unit);
+            statePos = 0;
+        }
+        if (pos - statePos > 10000 /* MaxIndentScanDist */)
+            return null;
+        while (statePos < pos) {
+            let line = cx.state.doc.lineAt(statePos), end = Math.min(pos, line.to);
+            if (line.length) {
+                let stream = new StringStream(line.text, cx.state.tabSize, cx.unit);
+                while (stream.pos < end - line.from)
+                    readToken(this.streamParser.token, stream, state);
+            }
+            else {
+                this.streamParser.blankLine(state, cx.unit);
+            }
+            if (end == pos)
+                break;
+            statePos = line.to + 1;
+        }
+        let { text } = cx.lineAt(pos);
+        return this.streamParser.indent(state, /^\s*(.*)/.exec(text)[1], cx);
+    }
+    get allowsNesting() { return false; }
+}
+function findState(lang, tree, off, startPos, before) {
+    let state = off >= startPos && off + tree.length <= before && tree.prop(lang.stateAfter);
+    if (state)
+        return { state: lang.streamParser.copyState(state), pos: off + tree.length };
+    for (let i = tree.children.length - 1; i >= 0; i--) {
+        let child = tree.children[i], pos = off + tree.positions[i];
+        let found = child instanceof Tree && pos < before && findState(lang, child, pos, startPos, before);
+        if (found)
+            return found;
+    }
+    return null;
+}
+function cutTree(lang, tree, from, to, inside) {
+    if (inside && from <= 0 && to >= tree.length)
+        return tree;
+    if (!inside && tree.type == lang.topNode)
+        inside = true;
+    for (let i = tree.children.length - 1; i >= 0; i--) {
+        let pos = tree.positions[i], child = tree.children[i], inner;
+        if (pos < to && child instanceof Tree) {
+            if (!(inner = cutTree(lang, child, from - pos, to - pos, inside)))
+                break;
+            return !inside ? inner
+                : new Tree(tree.type, tree.children.slice(0, i).concat(inner), tree.positions.slice(0, i + 1), pos + inner.length);
+        }
+    }
+    return null;
+}
+function findStartInFragments(lang, fragments, startPos, editorState) {
+    for (let f of fragments) {
+        let from = f.from + (f.openStart ? 25 : 0), to = f.to - (f.openEnd ? 25 : 0);
+        let found = from <= startPos && to > startPos && findState(lang, f.tree, 0 - f.offset, startPos, to), tree;
+        if (found && (tree = cutTree(lang, f.tree, startPos + f.offset, found.pos + f.offset, false)))
+            return { state: found.state, tree };
+    }
+    return { state: lang.streamParser.startState(editorState ? getIndentUnit(editorState) : 4), tree: Tree.empty };
+}
+class Parse {
+    constructor(lang, input, fragments, ranges) {
+        this.lang = lang;
+        this.input = input;
+        this.fragments = fragments;
+        this.ranges = ranges;
+        this.stoppedAt = null;
+        this.chunks = [];
+        this.chunkPos = [];
+        this.chunk = [];
+        this.chunkReused = undefined;
+        this.rangeIndex = 0;
+        this.to = ranges[ranges.length - 1].to;
+        let context = ParseContext.get(), from = ranges[0].from;
+        let { state, tree } = findStartInFragments(lang, fragments, from, context === null || context === void 0 ? void 0 : context.state);
+        this.state = state;
+        this.parsedPos = this.chunkStart = from + tree.length;
+        for (let i = 0; i < tree.children.length; i++) {
+            this.chunks.push(tree.children[i]);
+            this.chunkPos.push(tree.positions[i]);
+        }
+        if (context && this.parsedPos < context.viewport.from - 100000 /* MaxDistanceBeforeViewport */) {
+            this.state = this.lang.streamParser.startState(getIndentUnit(context.state));
+            context.skipUntilInView(this.parsedPos, context.viewport.from);
+            this.parsedPos = context.viewport.from;
+        }
+        this.moveRangeIndex();
+    }
+    advance() {
+        let context = ParseContext.get();
+        let parseEnd = this.stoppedAt == null ? this.to : Math.min(this.to, this.stoppedAt);
+        let end = Math.min(parseEnd, this.chunkStart + 2048 /* ChunkSize */);
+        if (context)
+            end = Math.min(end, context.viewport.to);
+        while (this.parsedPos < end)
+            this.parseLine(context);
+        if (this.chunkStart < this.parsedPos)
+            this.finishChunk();
+        if (this.parsedPos >= parseEnd)
+            return this.finish();
+        if (context && this.parsedPos >= context.viewport.to) {
+            context.skipUntilInView(this.parsedPos, parseEnd);
+            return this.finish();
+        }
+        return null;
+    }
+    stopAt(pos) {
+        this.stoppedAt = pos;
+    }
+    lineAfter(pos) {
+        let chunk = this.input.chunk(pos);
+        if (!this.input.lineChunks) {
+            let eol = chunk.indexOf("\n");
+            if (eol > -1)
+                chunk = chunk.slice(0, eol);
+        }
+        else if (chunk == "\n") {
+            chunk = "";
+        }
+        return pos + chunk.length <= this.to ? chunk : chunk.slice(0, this.to - pos);
+    }
+    nextLine() {
+        let from = this.parsedPos, line = this.lineAfter(from), end = from + line.length;
+        for (let index = this.rangeIndex;;) {
+            let rangeEnd = this.ranges[index].to;
+            if (rangeEnd >= end)
+                break;
+            line = line.slice(0, rangeEnd - (end - line.length));
+            index++;
+            if (index == this.ranges.length)
+                break;
+            let rangeStart = this.ranges[index].from;
+            let after = this.lineAfter(rangeStart);
+            line += after;
+            end = rangeStart + after.length;
+        }
+        return { line, end };
+    }
+    skipGapsTo(pos, offset, side) {
+        for (;;) {
+            let end = this.ranges[this.rangeIndex].to, offPos = pos + offset;
+            if (side > 0 ? end > offPos : end >= offPos)
+                break;
+            let start = this.ranges[++this.rangeIndex].from;
+            offset += start - end;
+        }
+        return offset;
+    }
+    moveRangeIndex() {
+        while (this.ranges[this.rangeIndex].to < this.parsedPos)
+            this.rangeIndex++;
+    }
+    emitToken(id, from, to, size, offset) {
+        if (this.ranges.length > 1) {
+            offset = this.skipGapsTo(from, offset, 1);
+            from += offset;
+            let len0 = this.chunk.length;
+            offset = this.skipGapsTo(to, offset, -1);
+            to += offset;
+            size += this.chunk.length - len0;
+        }
+        this.chunk.push(id, from, to, size);
+        return offset;
+    }
+    parseLine(context) {
+        let { line, end } = this.nextLine(), offset = 0, { streamParser } = this.lang;
+        let stream = new StringStream(line, context ? context.state.tabSize : 4, context ? getIndentUnit(context.state) : 2);
+        if (stream.eol()) {
+            streamParser.blankLine(this.state, stream.indentUnit);
+        }
+        else {
+            while (!stream.eol()) {
+                let token = readToken(streamParser.token, stream, this.state);
+                if (token)
+                    offset = this.emitToken(this.lang.tokenTable.resolve(token), this.parsedPos + stream.start, this.parsedPos + stream.pos, 4, offset);
+                if (stream.start > 10000 /* MaxLineLength */)
+                    break;
+            }
+        }
+        this.parsedPos = end;
+        this.moveRangeIndex();
+        if (this.parsedPos < this.to)
+            this.parsedPos++;
+    }
+    finishChunk() {
+        let tree = Tree.build({
+            buffer: this.chunk,
+            start: this.chunkStart,
+            length: this.parsedPos - this.chunkStart,
+            nodeSet,
+            topID: 0,
+            maxBufferLength: 2048 /* ChunkSize */,
+            reused: this.chunkReused
+        });
+        tree = new Tree(tree.type, tree.children, tree.positions, tree.length, [[this.lang.stateAfter, this.lang.streamParser.copyState(this.state)]]);
+        this.chunks.push(tree);
+        this.chunkPos.push(this.chunkStart - this.ranges[0].from);
+        this.chunk = [];
+        this.chunkReused = undefined;
+        this.chunkStart = this.parsedPos;
+    }
+    finish() {
+        return new Tree(this.lang.topNode, this.chunks, this.chunkPos, this.parsedPos - this.ranges[0].from).balance();
+    }
+}
+function readToken(token, stream, state) {
+    stream.start = stream.pos;
+    for (let i = 0; i < 10; i++) {
+        let result = token(stream, state);
+        if (stream.pos > stream.start)
+            return result;
+    }
+    throw new Error("Stream parser failed to advance stream.");
+}
+const noTokens = /*@__PURE__*/Object.create(null);
+const typeArray = [dist_NodeType.none];
+const nodeSet = /*@__PURE__*/new NodeSet(typeArray);
+const warned = [];
+const defaultTable = /*@__PURE__*/Object.create(null);
+for (let [legacyName, name] of [
+    ["variable", "variableName"],
+    ["variable-2", "variableName.special"],
+    ["string-2", "string.special"],
+    ["def", "variableName.definition"],
+    ["tag", "typeName"],
+    ["attribute", "propertyName"],
+    ["type", "typeName"],
+    ["builtin", "variableName.standard"],
+    ["qualifier", "modifier"],
+    ["error", "invalid"],
+    ["header", "heading"],
+    ["property", "propertyName"]
+])
+    defaultTable[legacyName] = /*@__PURE__*/createTokenType(noTokens, name);
+class TokenTable {
+    constructor(extra) {
+        this.extra = extra;
+        this.table = Object.assign(Object.create(null), defaultTable);
+    }
+    resolve(tag) {
+        return !tag ? 0 : this.table[tag] || (this.table[tag] = createTokenType(this.extra, tag));
+    }
+}
+const defaultTokenTable = /*@__PURE__*/new TokenTable(noTokens);
+function warnForPart(part, msg) {
+    if (warned.indexOf(part) > -1)
+        return;
+    warned.push(part);
+    console.warn(msg);
+}
+function createTokenType(extra, tagStr) {
+    let tag = null;
+    for (let part of tagStr.split(".")) {
+        let value = (extra[part] || tags[part]);
+        if (!value) {
+            warnForPart(part, `Unknown highlighting tag ${part}`);
+        }
+        else if (typeof value == "function") {
+            if (!tag)
+                warnForPart(part, `Modifier ${part} used at start of tag`);
+            else
+                tag = value(tag);
+        }
+        else {
+            if (tag)
+                warnForPart(part, `Tag ${part} used as modifier`);
+            else
+                tag = value;
+        }
+    }
+    if (!tag)
+        return 0;
+    let name = tagStr.replace(/ /g, "_"), type = dist_NodeType.define({
+        id: typeArray.length,
+        name,
+        props: [styleTags({ [name]: tag })]
+    });
+    typeArray.push(type);
+    return type.id;
+}
+function docID(data) {
+    let type = NodeType.define({ id: typeArray.length, name: "Document", props: [languageDataProp.add(() => data)] });
+    typeArray.push(type);
+    return type;
+}
+
+
+
+;// CONCATENATED MODULE: ./node_modules/@codemirror/commands/dist/index.js
+
+
+
+
+
+/**
+Comment or uncomment the current selection. Will use line comments
+if available, otherwise falling back to block comments.
+*/
+const toggleComment = target => {
+    let config = getConfig(target.state);
+    return config.line ? toggleLineComment(target) : config.block ? toggleBlockCommentByLine(target) : false;
+};
+function command(f, option) {
+    return ({ state, dispatch }) => {
+        if (state.readOnly)
+            return false;
+        let tr = f(option, state);
+        if (!tr)
+            return false;
+        dispatch(state.update(tr));
+        return true;
+    };
+}
+/**
+Comment or uncomment the current selection using line comments.
+The line comment syntax is taken from the
+[`commentTokens`](https://codemirror.net/6/docs/ref/#commands.CommentTokens) [language
+data](https://codemirror.net/6/docs/ref/#state.EditorState.languageDataAt).
+*/
+const toggleLineComment = /*@__PURE__*/(/* unused pure expression or super */ null && (command(changeLineComment, 0 /* Toggle */)));
+/**
+Comment the current selection using line comments.
+*/
+const lineComment = /*@__PURE__*/(/* unused pure expression or super */ null && (command(changeLineComment, 1 /* Comment */)));
+/**
+Uncomment the current selection using line comments.
+*/
+const lineUncomment = /*@__PURE__*/(/* unused pure expression or super */ null && (command(changeLineComment, 2 /* Uncomment */)));
+/**
+Comment or uncomment the current selection using block comments.
+The block comment syntax is taken from the
+[`commentTokens`](https://codemirror.net/6/docs/ref/#commands.CommentTokens) [language
+data](https://codemirror.net/6/docs/ref/#state.EditorState.languageDataAt).
+*/
+const toggleBlockComment = /*@__PURE__*/(/* unused pure expression or super */ null && (command(changeBlockComment, 0 /* Toggle */)));
+/**
+Comment the current selection using block comments.
+*/
+const blockComment = /*@__PURE__*/(/* unused pure expression or super */ null && (command(changeBlockComment, 1 /* Comment */)));
+/**
+Uncomment the current selection using block comments.
+*/
+const blockUncomment = /*@__PURE__*/(/* unused pure expression or super */ null && (command(changeBlockComment, 2 /* Uncomment */)));
+/**
+Comment or uncomment the lines around the current selection using
+block comments.
+*/
+const toggleBlockCommentByLine = /*@__PURE__*/(/* unused pure expression or super */ null && (command((o, s) => changeBlockComment(o, s, selectedLineRanges(s)), 0 /* Toggle */)));
+function getConfig(state, pos = state.selection.main.head) {
+    let data = state.languageDataAt("commentTokens", pos);
+    return data.length ? data[0] : {};
+}
+const SearchMargin = 50;
+/**
+Determines if the given range is block-commented in the given
+state.
+*/
+function findBlockComment(state, { open, close }, from, to) {
+    let textBefore = state.sliceDoc(from - SearchMargin, from);
+    let textAfter = state.sliceDoc(to, to + SearchMargin);
+    let spaceBefore = /\s*$/.exec(textBefore)[0].length, spaceAfter = /^\s*/.exec(textAfter)[0].length;
+    let beforeOff = textBefore.length - spaceBefore;
+    if (textBefore.slice(beforeOff - open.length, beforeOff) == open &&
+        textAfter.slice(spaceAfter, spaceAfter + close.length) == close) {
+        return { open: { pos: from - spaceBefore, margin: spaceBefore && 1 },
+            close: { pos: to + spaceAfter, margin: spaceAfter && 1 } };
+    }
+    let startText, endText;
+    if (to - from <= 2 * SearchMargin) {
+        startText = endText = state.sliceDoc(from, to);
+    }
+    else {
+        startText = state.sliceDoc(from, from + SearchMargin);
+        endText = state.sliceDoc(to - SearchMargin, to);
+    }
+    let startSpace = /^\s*/.exec(startText)[0].length, endSpace = /\s*$/.exec(endText)[0].length;
+    let endOff = endText.length - endSpace - close.length;
+    if (startText.slice(startSpace, startSpace + open.length) == open &&
+        endText.slice(endOff, endOff + close.length) == close) {
+        return { open: { pos: from + startSpace + open.length,
+                margin: /\s/.test(startText.charAt(startSpace + open.length)) ? 1 : 0 },
+            close: { pos: to - endSpace - close.length,
+                margin: /\s/.test(endText.charAt(endOff - 1)) ? 1 : 0 } };
+    }
+    return null;
+}
+function selectedLineRanges(state) {
+    let ranges = [];
+    for (let r of state.selection.ranges) {
+        let fromLine = state.doc.lineAt(r.from);
+        let toLine = r.to <= fromLine.to ? fromLine : state.doc.lineAt(r.to);
+        let last = ranges.length - 1;
+        if (last >= 0 && ranges[last].to > fromLine.from)
+            ranges[last].to = toLine.to;
+        else
+            ranges.push({ from: fromLine.from, to: toLine.to });
+    }
+    return ranges;
+}
+// Performs toggle, comment and uncomment of block comments in
+// languages that support them.
+function changeBlockComment(option, state, ranges = state.selection.ranges) {
+    let tokens = ranges.map(r => getConfig(state, r.from).block);
+    if (!tokens.every(c => c))
+        return null;
+    let comments = ranges.map((r, i) => findBlockComment(state, tokens[i], r.from, r.to));
+    if (option != 2 /* Uncomment */ && !comments.every(c => c)) {
+        return { changes: state.changes(ranges.map((range, i) => {
+                if (comments[i])
+                    return [];
+                return [{ from: range.from, insert: tokens[i].open + " " }, { from: range.to, insert: " " + tokens[i].close }];
+            })) };
+    }
+    else if (option != 1 /* Comment */ && comments.some(c => c)) {
+        let changes = [];
+        for (let i = 0, comment; i < comments.length; i++)
+            if (comment = comments[i]) {
+                let token = tokens[i], { open, close } = comment;
+                changes.push({ from: open.pos - token.open.length, to: open.pos + open.margin }, { from: close.pos - close.margin, to: close.pos + token.close.length });
+            }
+        return { changes };
+    }
+    return null;
+}
+// Performs toggle, comment and uncomment of line comments.
+function changeLineComment(option, state, ranges = state.selection.ranges) {
+    let lines = [];
+    let prevLine = -1;
+    for (let { from, to } of ranges) {
+        let startI = lines.length, minIndent = 1e9;
+        for (let pos = from; pos <= to;) {
+            let line = state.doc.lineAt(pos);
+            if (line.from > prevLine && (from == to || to > line.from)) {
+                prevLine = line.from;
+                let token = getConfig(state, pos).line;
+                if (!token)
+                    continue;
+                let indent = /^\s*/.exec(line.text)[0].length;
+                let empty = indent == line.length;
+                let comment = line.text.slice(indent, indent + token.length) == token ? indent : -1;
+                if (indent < line.text.length && indent < minIndent)
+                    minIndent = indent;
+                lines.push({ line, comment, token, indent, empty, single: false });
+            }
+            pos = line.to + 1;
+        }
+        if (minIndent < 1e9)
+            for (let i = startI; i < lines.length; i++)
+                if (lines[i].indent < lines[i].line.text.length)
+                    lines[i].indent = minIndent;
+        if (lines.length == startI + 1)
+            lines[startI].single = true;
+    }
+    if (option != 2 /* Uncomment */ && lines.some(l => l.comment < 0 && (!l.empty || l.single))) {
+        let changes = [];
+        for (let { line, token, indent, empty, single } of lines)
+            if (single || !empty)
+                changes.push({ from: line.from + indent, insert: token + " " });
+        let changeSet = state.changes(changes);
+        return { changes: changeSet, selection: state.selection.map(changeSet, 1) };
+    }
+    else if (option != 1 /* Comment */ && lines.some(l => l.comment >= 0)) {
+        let changes = [];
+        for (let { line, comment, token } of lines)
+            if (comment >= 0) {
+                let from = line.from + comment, to = from + token.length;
+                if (line.text[to - line.from] == " ")
+                    to++;
+                changes.push({ from, to });
+            }
+        return { changes };
+    }
+    return null;
+}
+
+const fromHistory = /*@__PURE__*/state_.Annotation.define();
+/**
+Transaction annotation that will prevent that transaction from
+being combined with other transactions in the undo history. Given
+`"before"`, it'll prevent merging with previous transactions. With
+`"after"`, subsequent transactions won't be combined with this
+one. With `"full"`, the transaction is isolated on both sides.
+*/
+const isolateHistory = /*@__PURE__*/state_.Annotation.define();
+/**
+This facet provides a way to register functions that, given a
+transaction, provide a set of effects that the history should
+store when inverting the transaction. This can be used to
+integrate some kinds of effects in the history, so that they can
+be undone (and redone again).
+*/
+const invertedEffects = /*@__PURE__*/state_.Facet.define();
+const historyConfig = /*@__PURE__*/state_.Facet.define({
+    combine(configs) {
+        return (0,state_.combineConfig)(configs, {
+            minDepth: 100,
+            newGroupDelay: 500
+        }, { minDepth: Math.max, newGroupDelay: Math.min });
+    }
+});
+function changeEnd(changes) {
+    let end = 0;
+    changes.iterChangedRanges((_, to) => end = to);
+    return end;
+}
+const historyField_ = /*@__PURE__*/state_.StateField.define({
+    create() {
+        return HistoryState.empty;
+    },
+    update(state, tr) {
+        let config = tr.state.facet(historyConfig);
+        let fromHist = tr.annotation(fromHistory);
+        if (fromHist) {
+            let selection = tr.docChanged ? state_.EditorSelection.single(changeEnd(tr.changes)) : undefined;
+            let item = HistEvent.fromTransaction(tr, selection), from = fromHist.side;
+            let other = from == 0 /* Done */ ? state.undone : state.done;
+            if (item)
+                other = updateBranch(other, other.length, config.minDepth, item);
+            else
+                other = addSelection(other, tr.startState.selection);
+            return new HistoryState(from == 0 /* Done */ ? fromHist.rest : other, from == 0 /* Done */ ? other : fromHist.rest);
+        }
+        let isolate = tr.annotation(isolateHistory);
+        if (isolate == "full" || isolate == "before")
+            state = state.isolate();
+        if (tr.annotation(state_.Transaction.addToHistory) === false)
+            return !tr.changes.empty ? state.addMapping(tr.changes.desc) : state;
+        let event = HistEvent.fromTransaction(tr);
+        let time = tr.annotation(state_.Transaction.time), userEvent = tr.annotation(state_.Transaction.userEvent);
+        if (event)
+            state = state.addChanges(event, time, userEvent, config.newGroupDelay, config.minDepth);
+        else if (tr.selection)
+            state = state.addSelection(tr.startState.selection, time, userEvent, config.newGroupDelay);
+        if (isolate == "full" || isolate == "after")
+            state = state.isolate();
+        return state;
+    },
+    toJSON(value) {
+        return { done: value.done.map(e => e.toJSON()), undone: value.undone.map(e => e.toJSON()) };
+    },
+    fromJSON(json) {
+        return new HistoryState(json.done.map(HistEvent.fromJSON), json.undone.map(HistEvent.fromJSON));
+    }
+});
+/**
+Create a history extension with the given configuration.
+*/
+function dist_history(config = {}) {
+    return [
+        historyField_,
+        historyConfig.of(config),
+        EditorView.domEventHandlers({
+            beforeinput(e, view) {
+                let command = e.inputType == "historyUndo" ? undo : e.inputType == "historyRedo" ? redo : null;
+                if (!command)
+                    return false;
+                e.preventDefault();
+                return command(view);
+            }
+        })
+    ];
+}
+/**
+The state field used to store the history data. Should probably
+only be used when you want to
+[serialize](https://codemirror.net/6/docs/ref/#state.EditorState.toJSON) or
+[deserialize](https://codemirror.net/6/docs/ref/#state.EditorState^fromJSON) state objects in a way
+that preserves history.
+*/
+const historyField = (/* unused pure expression or super */ null && (historyField_));
+function cmd(side, selection) {
+    return function ({ state, dispatch }) {
+        if (!selection && state.readOnly)
+            return false;
+        let historyState = state.field(historyField_, false);
+        if (!historyState)
+            return false;
+        let tr = historyState.pop(side, state, selection);
+        if (!tr)
+            return false;
+        dispatch(tr);
+        return true;
+    };
+}
+/**
+Undo a single group of history events. Returns false if no group
+was available.
+*/
+const undo = /*@__PURE__*/cmd(0 /* Done */, false);
+/**
+Redo a group of history events. Returns false if no group was
+available.
+*/
+const redo = /*@__PURE__*/cmd(1 /* Undone */, false);
+/**
+Undo a change or selection change.
+*/
+const undoSelection = /*@__PURE__*/cmd(0 /* Done */, true);
+/**
+Redo a change or selection change.
+*/
+const redoSelection = /*@__PURE__*/cmd(1 /* Undone */, true);
+function depth(side) {
+    return function (state) {
+        let histState = state.field(historyField_, false);
+        if (!histState)
+            return 0;
+        let branch = side == 0 /* Done */ ? histState.done : histState.undone;
+        return branch.length - (branch.length && !branch[0].changes ? 1 : 0);
+    };
+}
+/**
+The amount of undoable change events available in a given state.
+*/
+const undoDepth = /*@__PURE__*/(/* unused pure expression or super */ null && (depth(0 /* Done */)));
+/**
+The amount of redoable change events available in a given state.
+*/
+const redoDepth = /*@__PURE__*/(/* unused pure expression or super */ null && (depth(1 /* Undone */)));
+// History events store groups of changes or effects that need to be
+// undone/redone together.
+class HistEvent {
+    constructor(
+    // The changes in this event. Normal events hold at least one
+    // change or effect. But it may be necessary to store selection
+    // events before the first change, in which case a special type of
+    // instance is created which doesn't hold any changes, with
+    // changes == startSelection == undefined
+    changes, 
+    // The effects associated with this event
+    effects, mapped, 
+    // The selection before this event
+    startSelection, 
+    // Stores selection changes after this event, to be used for
+    // selection undo/redo.
+    selectionsAfter) {
+        this.changes = changes;
+        this.effects = effects;
+        this.mapped = mapped;
+        this.startSelection = startSelection;
+        this.selectionsAfter = selectionsAfter;
+    }
+    setSelAfter(after) {
+        return new HistEvent(this.changes, this.effects, this.mapped, this.startSelection, after);
+    }
+    toJSON() {
+        var _a, _b, _c;
+        return {
+            changes: (_a = this.changes) === null || _a === void 0 ? void 0 : _a.toJSON(),
+            mapped: (_b = this.mapped) === null || _b === void 0 ? void 0 : _b.toJSON(),
+            startSelection: (_c = this.startSelection) === null || _c === void 0 ? void 0 : _c.toJSON(),
+            selectionsAfter: this.selectionsAfter.map(s => s.toJSON())
+        };
+    }
+    static fromJSON(json) {
+        return new HistEvent(json.changes && state_.ChangeSet.fromJSON(json.changes), [], json.mapped && state_.ChangeDesc.fromJSON(json.mapped), json.startSelection && state_.EditorSelection.fromJSON(json.startSelection), json.selectionsAfter.map(state_.EditorSelection.fromJSON));
+    }
+    // This does not check `addToHistory` and such, it assumes the
+    // transaction needs to be converted to an item. Returns null when
+    // there are no changes or effects in the transaction.
+    static fromTransaction(tr, selection) {
+        let effects = none;
+        for (let invert of tr.startState.facet(invertedEffects)) {
+            let result = invert(tr);
+            if (result.length)
+                effects = effects.concat(result);
+        }
+        if (!effects.length && tr.changes.empty)
+            return null;
+        return new HistEvent(tr.changes.invert(tr.startState.doc), effects, undefined, selection || tr.startState.selection, none);
+    }
+    static selection(selections) {
+        return new HistEvent(undefined, none, undefined, undefined, selections);
+    }
+}
+function updateBranch(branch, to, maxLen, newEvent) {
+    let start = to + 1 > maxLen + 20 ? to - maxLen - 1 : 0;
+    let newBranch = branch.slice(start, to);
+    newBranch.push(newEvent);
+    return newBranch;
+}
+function isAdjacent(a, b) {
+    let ranges = [], isAdjacent = false;
+    a.iterChangedRanges((f, t) => ranges.push(f, t));
+    b.iterChangedRanges((_f, _t, f, t) => {
+        for (let i = 0; i < ranges.length;) {
+            let from = ranges[i++], to = ranges[i++];
+            if (t >= from && f <= to)
+                isAdjacent = true;
+        }
+    });
+    return isAdjacent;
+}
+function eqSelectionShape(a, b) {
+    return a.ranges.length == b.ranges.length &&
+        a.ranges.filter((r, i) => r.empty != b.ranges[i].empty).length === 0;
+}
+function conc(a, b) {
+    return !a.length ? b : !b.length ? a : a.concat(b);
+}
+const none = [];
+const MaxSelectionsPerEvent = 200;
+function addSelection(branch, selection) {
+    if (!branch.length) {
+        return [HistEvent.selection([selection])];
+    }
+    else {
+        let lastEvent = branch[branch.length - 1];
+        let sels = lastEvent.selectionsAfter.slice(Math.max(0, lastEvent.selectionsAfter.length - MaxSelectionsPerEvent));
+        if (sels.length && sels[sels.length - 1].eq(selection))
+            return branch;
+        sels.push(selection);
+        return updateBranch(branch, branch.length - 1, 1e9, lastEvent.setSelAfter(sels));
+    }
+}
+// Assumes the top item has one or more selectionAfter values
+function popSelection(branch) {
+    let last = branch[branch.length - 1];
+    let newBranch = branch.slice();
+    newBranch[branch.length - 1] = last.setSelAfter(last.selectionsAfter.slice(0, last.selectionsAfter.length - 1));
+    return newBranch;
+}
+// Add a mapping to the top event in the given branch. If this maps
+// away all the changes and effects in that item, drop it and
+// propagate the mapping to the next item.
+function addMappingToBranch(branch, mapping) {
+    if (!branch.length)
+        return branch;
+    let length = branch.length, selections = none;
+    while (length) {
+        let event = mapEvent(branch[length - 1], mapping, selections);
+        if (event.changes && !event.changes.empty || event.effects.length) { // Event survived mapping
+            let result = branch.slice(0, length);
+            result[length - 1] = event;
+            return result;
+        }
+        else { // Drop this event, since there's no changes or effects left
+            mapping = event.mapped;
+            length--;
+            selections = event.selectionsAfter;
+        }
+    }
+    return selections.length ? [HistEvent.selection(selections)] : none;
+}
+function mapEvent(event, mapping, extraSelections) {
+    let selections = conc(event.selectionsAfter.length ? event.selectionsAfter.map(s => s.map(mapping)) : none, extraSelections);
+    // Change-less events don't store mappings (they are always the last event in a branch)
+    if (!event.changes)
+        return HistEvent.selection(selections);
+    let mappedChanges = event.changes.map(mapping), before = mapping.mapDesc(event.changes, true);
+    let fullMapping = event.mapped ? event.mapped.composeDesc(before) : before;
+    return new HistEvent(mappedChanges, state_.StateEffect.mapEffects(event.effects, mapping), fullMapping, event.startSelection.map(before), selections);
+}
+const joinableUserEvent = /^(input\.type|delete)($|\.)/;
+class HistoryState {
+    constructor(done, undone, prevTime = 0, prevUserEvent = undefined) {
+        this.done = done;
+        this.undone = undone;
+        this.prevTime = prevTime;
+        this.prevUserEvent = prevUserEvent;
+    }
+    isolate() {
+        return this.prevTime ? new HistoryState(this.done, this.undone) : this;
+    }
+    addChanges(event, time, userEvent, newGroupDelay, maxLen) {
+        let done = this.done, lastEvent = done[done.length - 1];
+        if (lastEvent && lastEvent.changes && !lastEvent.changes.empty && event.changes &&
+            (!userEvent || joinableUserEvent.test(userEvent)) &&
+            ((!lastEvent.selectionsAfter.length &&
+                time - this.prevTime < newGroupDelay &&
+                isAdjacent(lastEvent.changes, event.changes)) ||
+                // For compose (but not compose.start) events, always join with previous event
+                userEvent == "input.type.compose")) {
+            done = updateBranch(done, done.length - 1, maxLen, new HistEvent(event.changes.compose(lastEvent.changes), conc(event.effects, lastEvent.effects), lastEvent.mapped, lastEvent.startSelection, none));
+        }
+        else {
+            done = updateBranch(done, done.length, maxLen, event);
+        }
+        return new HistoryState(done, none, time, userEvent);
+    }
+    addSelection(selection, time, userEvent, newGroupDelay) {
+        let last = this.done.length ? this.done[this.done.length - 1].selectionsAfter : none;
+        if (last.length > 0 &&
+            time - this.prevTime < newGroupDelay &&
+            userEvent == this.prevUserEvent && userEvent && /^select($|\.)/.test(userEvent) &&
+            eqSelectionShape(last[last.length - 1], selection))
+            return this;
+        return new HistoryState(addSelection(this.done, selection), this.undone, time, userEvent);
+    }
+    addMapping(mapping) {
+        return new HistoryState(addMappingToBranch(this.done, mapping), addMappingToBranch(this.undone, mapping), this.prevTime, this.prevUserEvent);
+    }
+    pop(side, state, selection) {
+        let branch = side == 0 /* Done */ ? this.done : this.undone;
+        if (branch.length == 0)
+            return null;
+        let event = branch[branch.length - 1];
+        if (selection && event.selectionsAfter.length) {
+            return state.update({
+                selection: event.selectionsAfter[event.selectionsAfter.length - 1],
+                annotations: fromHistory.of({ side, rest: popSelection(branch) }),
+                userEvent: side == 0 /* Done */ ? "select.undo" : "select.redo",
+                scrollIntoView: true
+            });
+        }
+        else if (!event.changes) {
+            return null;
+        }
+        else {
+            let rest = branch.length == 1 ? none : branch.slice(0, branch.length - 1);
+            if (event.mapped)
+                rest = addMappingToBranch(rest, event.mapped);
+            return state.update({
+                changes: event.changes,
+                selection: event.startSelection,
+                effects: event.effects,
+                annotations: fromHistory.of({ side, rest }),
+                filter: false,
+                userEvent: side == 0 /* Done */ ? "undo" : "redo",
+                scrollIntoView: true
+            });
+        }
+    }
+}
+HistoryState.empty = /*@__PURE__*/new HistoryState(none, none);
+/**
+Default key bindings for the undo history.
+
+- Mod-z: [`undo`](https://codemirror.net/6/docs/ref/#commands.undo).
+- Mod-y (Mod-Shift-z on macOS): [`redo`](https://codemirror.net/6/docs/ref/#commands.redo).
+- Mod-u: [`undoSelection`](https://codemirror.net/6/docs/ref/#commands.undoSelection).
+- Alt-u (Mod-Shift-u on macOS): [`redoSelection`](https://codemirror.net/6/docs/ref/#commands.redoSelection).
+*/
+const historyKeymap = [
+    { key: "Mod-z", run: undo, preventDefault: true },
+    { key: "Mod-y", mac: "Mod-Shift-z", run: redo, preventDefault: true },
+    { key: "Mod-u", run: undoSelection, preventDefault: true },
+    { key: "Alt-u", mac: "Mod-Shift-u", run: redoSelection, preventDefault: true }
+];
+
+function updateSel(sel, by) {
+    return state_.EditorSelection.create(sel.ranges.map(by), sel.mainIndex);
+}
+function setSel(state, selection) {
+    return state.update({ selection, scrollIntoView: true, userEvent: "select" });
+}
+function moveSel({ state, dispatch }, how) {
+    let selection = updateSel(state.selection, how);
+    if (selection.eq(state.selection))
+        return false;
+    dispatch(setSel(state, selection));
+    return true;
+}
+function rangeEnd(range, forward) {
+    return state_.EditorSelection.cursor(forward ? range.to : range.from);
+}
+function cursorByChar(view, forward) {
+    return moveSel(view, range => range.empty ? view.moveByChar(range, forward) : rangeEnd(range, forward));
+}
+function ltrAtCursor(view) {
+    return view.textDirectionAt(view.state.selection.main.head) == view_.Direction.LTR;
+}
+/**
+Move the selection one character to the left (which is backward in
+left-to-right text, forward in right-to-left text).
+*/
+const cursorCharLeft = view => cursorByChar(view, !ltrAtCursor(view));
+/**
+Move the selection one character to the right.
+*/
+const cursorCharRight = view => cursorByChar(view, ltrAtCursor(view));
+/**
+Move the selection one character forward.
+*/
+const cursorCharForward = view => cursorByChar(view, true);
+/**
+Move the selection one character backward.
+*/
+const cursorCharBackward = view => cursorByChar(view, false);
+function cursorByGroup(view, forward) {
+    return moveSel(view, range => range.empty ? view.moveByGroup(range, forward) : rangeEnd(range, forward));
+}
+/**
+Move the selection to the left across one group of word or
+non-word (but also non-space) characters.
+*/
+const cursorGroupLeft = view => cursorByGroup(view, !ltrAtCursor(view));
+/**
+Move the selection one group to the right.
+*/
+const cursorGroupRight = view => cursorByGroup(view, ltrAtCursor(view));
+/**
+Move the selection one group forward.
+*/
+const cursorGroupForward = view => cursorByGroup(view, true);
+/**
+Move the selection one group backward.
+*/
+const cursorGroupBackward = view => cursorByGroup(view, false);
+function moveBySubword(view, range, forward) {
+    let categorize = view.state.charCategorizer(range.from);
+    return view.moveByChar(range, forward, start => {
+        let cat = CharCategory.Space, pos = range.from;
+        let done = false, sawUpper = false, sawLower = false;
+        let step = (next) => {
+            if (done)
+                return false;
+            pos += forward ? next.length : -next.length;
+            let nextCat = categorize(next), ahead;
+            if (cat == CharCategory.Space)
+                cat = nextCat;
+            if (cat != nextCat)
+                return false;
+            if (cat == CharCategory.Word) {
+                if (next.toLowerCase() == next) {
+                    if (!forward && sawUpper)
+                        return false;
+                    sawLower = true;
+                }
+                else if (sawLower) {
+                    if (forward)
+                        return false;
+                    done = true;
+                }
+                else {
+                    if (sawUpper && forward && categorize(ahead = view.state.sliceDoc(pos, pos + 1)) == CharCategory.Word &&
+                        ahead.toLowerCase() == ahead)
+                        return false;
+                    sawUpper = true;
+                }
+            }
+            return true;
+        };
+        step(start);
+        return step;
+    });
+}
+function cursorBySubword(view, forward) {
+    return moveSel(view, range => range.empty ? moveBySubword(view, range, forward) : rangeEnd(range, forward));
+}
+/**
+Move the selection one group or camel-case subword forward.
 */
 const cursorSubwordForward = view => cursorBySubword(view, true);
 /**
@@ -3782,11 +5716,11 @@ function moveBySyntax(state, start, forward) {
 /**
 Move the cursor over the next syntactic element to the left.
 */
-const cursorSyntaxLeft = view => moveSel(view, range => moveBySyntax(view.state, range, view.textDirection != Direction.LTR));
+const cursorSyntaxLeft = view => moveSel(view, range => moveBySyntax(view.state, range, !ltrAtCursor(view)));
 /**
 Move the cursor over the next syntactic element to the right.
 */
-const cursorSyntaxRight = view => moveSel(view, range => moveBySyntax(view.state, range, view.textDirection == Direction.LTR));
+const cursorSyntaxRight = view => moveSel(view, range => moveBySyntax(view.state, range, ltrAtCursor(view)));
 function cursorByLine(view, forward) {
     return moveSel(view, range => {
         if (!range.empty)
@@ -3805,17 +5739,18 @@ Move the selection one line down.
 const cursorLineDown = view => cursorByLine(view, true);
 function cursorByPage(view, forward) {
     let { state } = view, selection = updateSel(state.selection, range => {
-        return range.empty ? view.moveVertically(range, forward, view.dom.clientHeight) : rangeEnd(range, forward);
+        return range.empty ? view.moveVertically(range, forward, Math.min(view.dom.clientHeight, innerHeight))
+            : rangeEnd(range, forward);
     });
     if (selection.eq(state.selection))
         return false;
     let startPos = view.coordsAtPos(state.selection.main.head);
     let scrollRect = view.scrollDOM.getBoundingClientRect();
-    view.dispatch(setSel(state, selection), {
-        effects: startPos && startPos.top > scrollRect.top && startPos.bottom < scrollRect.bottom
-            ? view_.EditorView.scrollIntoView(selection.main.head, { y: "start", yMargin: startPos.top - scrollRect.top })
-            : undefined
-    });
+    let effect;
+    if (startPos && startPos.top > scrollRect.top && startPos.bottom < scrollRect.bottom &&
+        startPos.top - scrollRect.top <= view.scrollDOM.scrollHeight - view.scrollDOM.scrollTop - view.scrollDOM.clientHeight)
+        effect = view_.EditorView.scrollIntoView(selection.main.head, { y: "start", yMargin: startPos.top - scrollRect.top });
+    view.dispatch(setSel(state, selection), { effects: effect });
     return true;
 }
 /**
@@ -3901,11 +5836,11 @@ function selectByChar(view, forward) {
 Move the selection head one character to the left, while leaving
 the anchor in place.
 */
-const selectCharLeft = view => selectByChar(view, view.textDirection != view_.Direction.LTR);
+const selectCharLeft = view => selectByChar(view, !ltrAtCursor(view));
 /**
 Move the selection head one character to the right.
 */
-const selectCharRight = view => selectByChar(view, view.textDirection == view_.Direction.LTR);
+const selectCharRight = view => selectByChar(view, ltrAtCursor(view));
 /**
 Move the selection head one character forward.
 */
@@ -3921,11 +5856,11 @@ function selectByGroup(view, forward) {
 Move the selection head one [group](https://codemirror.net/6/docs/ref/#commands.cursorGroupLeft) to
 the left.
 */
-const selectGroupLeft = view => selectByGroup(view, view.textDirection != Direction.LTR);
+const selectGroupLeft = view => selectByGroup(view, !ltrAtCursor(view));
 /**
 Move the selection head one group to the right.
 */
-const selectGroupRight = view => selectByGroup(view, view.textDirection == Direction.LTR);
+const selectGroupRight = view => selectByGroup(view, ltrAtCursor(view));
 /**
 Move the selection head one group forward.
 */
@@ -3948,11 +5883,11 @@ const selectSubwordBackward = view => selectBySubword(view, false);
 /**
 Move the selection head over the next syntactic element to the left.
 */
-const selectSyntaxLeft = view => extendSel(view, range => moveBySyntax(view.state, range, view.textDirection != Direction.LTR));
+const selectSyntaxLeft = view => extendSel(view, range => moveBySyntax(view.state, range, !ltrAtCursor(view)));
 /**
 Move the selection head over the next syntactic element to the right.
 */
-const selectSyntaxRight = view => extendSel(view, range => moveBySyntax(view.state, range, view.textDirection == Direction.LTR));
+const selectSyntaxRight = view => extendSel(view, range => moveBySyntax(view.state, range, ltrAtCursor(view)));
 function selectByLine(view, forward) {
     return extendSel(view, range => view.moveVertically(range, forward));
 }
@@ -3965,7 +5900,7 @@ Move the selection head one line down.
 */
 const selectLineDown = view => selectByLine(view, true);
 function selectByPage(view, forward) {
-    return extendSel(view, range => view.moveVertically(range, forward, view.dom.clientHeight));
+    return extendSel(view, range => view.moveVertically(range, forward, Math.min(view.dom.clientHeight, innerHeight)));
 }
 /**
 Move the selection head one page up.
@@ -4093,7 +6028,7 @@ function deleteBy({ state, dispatch }, by) {
 }
 function skipAtomic(target, pos, forward) {
     if (target instanceof view_.EditorView)
-        for (let ranges of target.pluginField(view_.PluginField.atomicRanges))
+        for (let ranges of target.state.facet(view_.EditorView.atomicRanges).map(f => f(target)))
             ranges.between(pos, pos, (from, to) => {
                 if (from < pos && to > pos)
                     pos = forward ? to : from;
@@ -4106,13 +6041,13 @@ const deleteByChar = (target, forward) => deleteBy(target, pos => {
         !/[^ \t]/.test(before = line.text.slice(0, pos - line.from))) {
         if (before[before.length - 1] == "\t")
             return pos - 1;
-        let col = dist_countColumn(before, state.tabSize), drop = col % getIndentUnit(state) || getIndentUnit(state);
+        let col = (0,state_.countColumn)(before, state.tabSize), drop = col % getIndentUnit(state) || getIndentUnit(state);
         for (let i = 0; i < drop && before[before.length - 1 - i] == " "; i++)
             pos--;
         targetPos = pos;
     }
     else {
-        targetPos = findClusterBreak(line.text, pos - line.from, forward, forward) + line.from;
+        targetPos = (0,state_.findClusterBreak)(line.text, pos - line.from, forward, forward) + line.from;
         if (targetPos == pos && line.number != (forward ? state.doc.lines : 1))
             targetPos += forward ? 1 : -1;
     }
@@ -4136,7 +6071,7 @@ const deleteByGroup = (target, forward) => deleteBy(target, start => {
                 pos += forward ? 1 : -1;
             break;
         }
-        let next = findClusterBreak(line.text, pos - line.from, forward) + line.from;
+        let next = (0,state_.findClusterBreak)(line.text, pos - line.from, forward) + line.from;
         let nextChar = line.text.slice(Math.min(pos, next) - line.from, Math.max(pos, next) - line.from);
         let nextCat = categorize(nextChar);
         if (cat != null && nextCat != cat)
@@ -4211,7 +6146,7 @@ const splitLine = ({ state, dispatch }) => {
     if (state.readOnly)
         return false;
     let changes = state.changeByRange(range => {
-        return { changes: { from: range.from, to: range.to, insert: dist_Text.of(["", ""]) },
+        return { changes: { from: range.from, to: range.to, insert: state_.Text.of(["", ""]) },
             range: state_.EditorSelection.cursor(range.from) };
     });
     dispatch(state.update(changes, { scrollIntoView: true, userEvent: "input" }));
@@ -4227,8 +6162,8 @@ const transposeChars = ({ state, dispatch }) => {
         if (!range.empty || range.from == 0 || range.from == state.doc.length)
             return { range };
         let pos = range.from, line = state.doc.lineAt(pos);
-        let from = pos == line.from ? pos - 1 : findClusterBreak(line.text, pos - line.from, false) + line.from;
-        let to = pos == line.to ? pos + 1 : findClusterBreak(line.text, pos - line.from, true) + line.from;
+        let from = pos == line.from ? pos - 1 : (0,state_.findClusterBreak)(line.text, pos - line.from, false) + line.from;
+        let to = pos == line.to ? pos + 1 : (0,state_.findClusterBreak)(line.text, pos - line.from, true) + line.from;
         return { changes: { from, to, insert: state.doc.slice(pos, to).append(state.doc.slice(from, pos)) },
             range: state_.EditorSelection.cursor(to) };
     });
@@ -4460,7 +6395,7 @@ const indentLess = ({ state, dispatch }) => {
         let space = /^\s*/.exec(line.text)[0];
         if (!space)
             return;
-        let col = dist_countColumn(space, state.tabSize), keep = 0;
+        let col = (0,state_.countColumn)(space, state.tabSize), keep = 0;
         let insert = dist_indentString(state, Math.max(0, col - getIndentUnit(state)));
         while (keep < space.length && keep < insert.length && space.charCodeAt(keep) == insert.charCodeAt(keep))
             keep++;
@@ -4561,9 +6496,9 @@ const standardKeymap = /*@__PURE__*/(/* unused pure expression or super */ null
     { mac: "Ctrl-ArrowDown", run: cursorPageDown, shift: selectPageDown },
     { key: "PageUp", run: cursorPageUp, shift: selectPageUp },
     { key: "PageDown", run: cursorPageDown, shift: selectPageDown },
-    { key: "Home", run: cursorLineBoundaryBackward, shift: selectLineBoundaryBackward },
+    { key: "Home", run: cursorLineBoundaryBackward, shift: selectLineBoundaryBackward, preventDefault: true },
     { key: "Mod-Home", run: cursorDocStart, shift: selectDocStart },
-    { key: "End", run: cursorLineBoundaryForward, shift: selectLineBoundaryForward },
+    { key: "End", run: cursorLineBoundaryForward, shift: selectLineBoundaryForward, preventDefault: true },
     { key: "Mod-End", run: cursorDocEnd, shift: selectDocEnd },
     { key: "Enter", run: insertNewlineAndIndent },
     { key: "Mod-a", run: selectAll },
@@ -4593,6 +6528,8 @@ The default keymap. Includes all bindings from
 - Ctrl-Alt-\\ (Cmd-Alt-\\ on macOS): [`indentSelection`](https://codemirror.net/6/docs/ref/#commands.indentSelection)
 - Shift-Ctrl-k (Shift-Cmd-k on macOS): [`deleteLine`](https://codemirror.net/6/docs/ref/#commands.deleteLine)
 - Shift-Ctrl-\\ (Shift-Cmd-\\ on macOS): [`cursorMatchingBracket`](https://codemirror.net/6/docs/ref/#commands.cursorMatchingBracket)
+- Ctrl-/ (Cmd-/ on macOS): [`toggleComment`](https://codemirror.net/6/docs/ref/#commands.toggleComment).
+- Shift-Alt-a: [`toggleBlockComment`](https://codemirror.net/6/docs/ref/#commands.toggleBlockComment).
 */
 const defaultKeymap = /*@__PURE__*/(/* unused pure expression or super */ null && ([
     { key: "Alt-ArrowLeft", mac: "Ctrl-ArrowLeft", run: cursorSyntaxLeft, shift: selectSyntaxLeft },
@@ -4609,7 +6546,9 @@ const defaultKeymap = /*@__PURE__*/(/* unused pure expression or super */ null &
     { key: "Mod-]", run: indentMore },
     { key: "Mod-Alt-\\", run: indentSelection },
     { key: "Shift-Mod-k", run: deleteLine },
-    { key: "Shift-Mod-\\", run: cursorMatchingBracket }
+    { key: "Shift-Mod-\\", run: cursorMatchingBracket },
+    { key: "Mod-/", run: toggleComment },
+    { key: "Alt-A", run: toggleBlockComment }
 ].concat(standardKeymap)));
 /**
 A binding that binds Tab to [`indentMore`](https://codemirror.net/6/docs/ref/#commands.indentMore) and
@@ -4880,7 +6819,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _home_runner_work_react_codemirror_react_codemirror_node_modules_babel_runtime_helpers_esm_objectWithoutProperties_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(925);
 /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(787);
 /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var _useCodeMirror__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(497);
+/* harmony import */ var _useCodeMirror__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(963);
 /* harmony import */ var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(724);
 /* harmony import */ var _codemirror_view__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(105);
 /* harmony import */ var _codemirror_view__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_codemirror_view__WEBPACK_IMPORTED_MODULE_3__);