@codemirror/state 0.19.9 → 0.20.0

package/dist/index.js

@@ -1,5 +1,655 @@
-import { Text, findClusterBreak } from '@codemirror/text';
-export { Text } from '@codemirror/text';
+/**
+The data structure for documents. @nonabstract
+*/
+class 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.
+    */
+    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/#state.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 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 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 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);
+    }
+}
+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") {
+    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/#state.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; }
+}
+
+// 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; }
 
 const DefaultSplit = /\r\n?|\n/;
 /**
@@ -70,7 +720,9 @@ class ChangeDesc {
     */
     get empty() { return this.sections.length == 0 || this.sections.length == 2 && this.sections[1] < 0; }
     /**
-    Iterate over the unchanged parts left by these changes.
+    Iterate over the unchanged parts left by these changes. `posA`
+    provides the position of the range in the old document, `posB`
+    the new position in the changed document.
     */
     iterGaps(f) {
         for (let i = 0, posA = 0, posB = 0; i < this.sections.length;) {
@@ -89,6 +741,9 @@ class ChangeDesc {
     Iterate over the ranges changed by these changes. (See
     [`ChangeSet.iterChanges`](https://codemirror.net/6/docs/ref/#state.ChangeSet.iterChanges) for a
     variant that also provides you with the inserted text.)
+    `fromA`/`toA` provides the extent of the change in the starting
+    document, `fromB`/`toB` the extent of the replacement in the
+    changed document.
     
     When `individual` is true, adjacent changes (which are kept
     separate for [position mapping](https://codemirror.net/6/docs/ref/#state.ChangeDesc.mapPos)) are
@@ -871,10 +1526,10 @@ A facet is a labeled value that is associated with an editor
 state. It takes inputs from any number of extensions, and combines
 those into a single output value.
 
-Examples of facets are the [theme](https://codemirror.net/6/docs/ref/#view.EditorView^theme) styles
-associated with an editor or the [tab
-size](https://codemirror.net/6/docs/ref/#state.EditorState^tabSize) (which is reduced to a single
-value, using the input with the hightest precedence).
+Examples of uses of facets are the [tab
+size](https://codemirror.net/6/docs/ref/#state.EditorState^tabSize), [editor
+attributes](https://codemirror.net/6/docs/ref/#view.EditorView^editorAttributes), and [update
+listeners](https://codemirror.net/6/docs/ref/#view.EditorView^updateListener).
 */
 class Facet {
     constructor(
@@ -912,7 +1567,7 @@ class Facet {
         return new Facet(config.combine || ((a) => a), config.compareInput || ((a, b) => a === b), config.compare || (!config.combine ? sameArray : (a, b) => a === b), !!config.static, config.enables);
     }
     /**
-    Returns an extension that adds the given value for this facet.
+    Returns an extension that adds the given value to this facet.
     */
     of(value) {
         return new FacetProvider([], this, 0 /* Static */, value);
@@ -923,9 +1578,8 @@ class Facet {
     this value depends on, since your function is only called again
     for a new state when one of those parts changed.
     
-    In most cases, you'll want to use the
-    [`provide`](https://codemirror.net/6/docs/ref/#state.StateField^define^config.provide) option when
-    defining a field instead.
+    In cases where your value depends only on a single field, you'll
+    want to use the [`from`](https://codemirror.net/6/docs/ref/#state.Facet.from) method instead.
     */
     compute(deps, get) {
         if (this.isStatic)
@@ -978,8 +1632,7 @@ class FacetProvider {
                 return 1 /* Changed */;
             },
             update(state, tr) {
-                if ((depDoc && tr.docChanged) || (depSel && (tr.docChanged || tr.selection)) ||
-                    depAddrs.some(addr => (ensureAddr(state, addr) & 1 /* Changed */) > 0)) {
+                if ((depDoc && tr.docChanged) || (depSel && (tr.docChanged || tr.selection)) || ensureAll(state, depAddrs)) {
                     let newVal = getter(state);
                     if (multi ? !compareArray(newVal, state.values[idx], compare) : !compare(newVal, state.values[idx])) {
                         state.values[idx] = newVal;
@@ -988,12 +1641,15 @@ class FacetProvider {
                 }
                 return 0;
             },
-            reconfigure(state, oldState) {
+            reconfigure: (state, oldState) => {
                 let newVal = getter(state);
                 let oldAddr = oldState.config.address[id];
                 if (oldAddr != null) {
                     let oldVal = getAddr(oldState, oldAddr);
-                    if (multi ? compareArray(newVal, oldVal, compare) : compare(newVal, oldVal)) {
+                    if (this.dependencies.every(dep => {
+                        return dep instanceof Facet ? oldState.facet(dep) === state.facet(dep) :
+                            dep instanceof StateField ? oldState.field(dep, false) == state.field(dep, false) : true;
+                    }) || (multi ? compareArray(newVal, oldVal, compare) : compare(newVal, oldVal))) {
                         state.values[idx] = oldVal;
                         return 0;
                     }
@@ -1012,6 +1668,13 @@ function compareArray(a, b, compare) {
             return false;
     return true;
 }
+function ensureAll(state, addrs) {
+    let changed = false;
+    for (let addr of addrs)
+        if (ensureAddr(state, addr) & 1 /* Changed */)
+            changed = true;
+    return changed;
+}
 function dynamicFacetSlot(addresses, facet, providers) {
     let providerAddrs = providers.map(p => addresses[p.id]);
     let providerTypes = providers.map(p => p.type);
@@ -1037,7 +1700,7 @@ function dynamicFacetSlot(addresses, facet, providers) {
             return 1 /* Changed */;
         },
         update(state, tr) {
-            if (!dynamic.some(dynAddr => ensureAddr(state, dynAddr) & 1 /* Changed */))
+            if (!ensureAll(state, dynamic))
                 return 0;
             let value = get(state);
             if (facet.compare(value, state.values[idx]))
@@ -1046,7 +1709,7 @@ function dynamicFacetSlot(addresses, facet, providers) {
             return 1 /* Changed */;
         },
         reconfigure(state, oldState) {
-            let depChanged = providerAddrs.some(addr => ensureAddr(state, addr) & 1 /* Changed */);
+            let depChanged = ensureAll(state, providerAddrs);
             let oldProviders = oldState.config.facets[facet.id], oldValue = oldState.facet(facet);
             if (oldProviders && !depChanged && sameArray(providers, oldProviders)) {
                 state.values[idx] = oldValue;
@@ -1159,42 +1822,29 @@ precedence and then by order within each precedence.
 */
 const Prec = {
     /**
-    The lowest precedence level. Meant for things that should end up
-    near the end of the extension order.
-    */
-    lowest: /*@__PURE__*/prec(Prec_.lowest),
-    /**
-    A lower-than-default precedence, for extensions.
-    */
-    low: /*@__PURE__*/prec(Prec_.low),
-    /**
-    The default precedence, which is also used for extensions
-    without an explicit precedence.
+    The highest precedence level, for extensions that should end up
+    near the start of the precedence ordering.
     */
-    default: /*@__PURE__*/prec(Prec_.default),
+    highest: /*@__PURE__*/prec(Prec_.highest),
     /**
     A higher-than-default precedence, for extensions that should
     come before those with default precedence.
     */
     high: /*@__PURE__*/prec(Prec_.high),
     /**
-    The highest precedence level, for extensions that should end up
-    near the start of the precedence ordering.
-    */
-    highest: /*@__PURE__*/prec(Prec_.highest),
-    // FIXME Drop these in some future breaking version
-    /**
-    Backwards-compatible synonym for `Prec.lowest`.
+    The default precedence, which is also used for extensions
+    without an explicit precedence.
     */
-    fallback: /*@__PURE__*/prec(Prec_.lowest),
+    default: /*@__PURE__*/prec(Prec_.default),
     /**
-    Backwards-compatible synonym for `Prec.high`.
+    A lower-than-default precedence.
     */
-    extend: /*@__PURE__*/prec(Prec_.high),
+    low: /*@__PURE__*/prec(Prec_.low),
     /**
-    Backwards-compatible synonym for `Prec.highest`.
+    The lowest precedence level. Meant for things that should end up
+    near the end of the extension order.
     */
-    override: /*@__PURE__*/prec(Prec_.highest)
+    lowest: /*@__PURE__*/prec(Prec_.lowest)
 };
 class PrecExtension {
     constructor(inner, prec) {
@@ -1308,7 +1958,7 @@ function flatten(extension, compartments, newCompartments) {
     function inner(ext, prec) {
         let known = seen.get(ext);
         if (known != null) {
-            if (known >= prec)
+            if (known <= prec)
                 return;
             let found = result[known].indexOf(ext);
             if (found > -1)
@@ -1523,7 +2173,9 @@ Changes to the editor state are grouped into transactions.
 Typically, a user action creates a single transaction, which may
 contain any number of document changes, may change the selection,
 or have other effects. Create a transaction by calling
-[`EditorState.update`](https://codemirror.net/6/docs/ref/#state.EditorState.update).
+[`EditorState.update`](https://codemirror.net/6/docs/ref/#state.EditorState.update), or immediately
+dispatch one by calling
+[`EditorView.dispatch`](https://codemirror.net/6/docs/ref/#view.EditorView.dispatch).
 */
 class Transaction {
     /**
@@ -1597,7 +2249,7 @@ class Transaction {
     }
     /**
     The new state created by the transaction. Computed on demand
-    (but retained for subsequent access), so itis recommended not to
+    (but retained for subsequent access), so it is recommended not to
     access it in [transaction
     filters](https://codemirror.net/6/docs/ref/#state.EditorState^transactionFilter) when possible.
     */
@@ -1639,7 +2291,8 @@ class Transaction {
     }
 }
 /**
-Annotation used to store transaction timestamps.
+Annotation used to store transaction timestamps. Automatically
+added to every transaction, holding `Date.now()`.
 */
 Transaction.time = /*@__PURE__*/Annotation.define();
 /**
@@ -2011,7 +2664,7 @@ class EditorState {
     /**
     Using the state's [line
     separator](https://codemirror.net/6/docs/ref/#state.EditorState^lineSeparator), create a
-    [`Text`](https://codemirror.net/6/docs/ref/#text.Text) instance from the given string.
+    [`Text`](https://codemirror.net/6/docs/ref/#state.Text) instance from the given string.
     */
     toText(string) {
         return Text.of(string.split(this.facet(EditorState.lineSeparator) || DefaultSplit));
@@ -2131,7 +2784,7 @@ class EditorState {
     }
     /**
     Return a function that can categorize strings (expected to
-    represent a single [grapheme cluster](https://codemirror.net/6/docs/ref/#text.findClusterBreak))
+    represent a single [grapheme cluster](https://codemirror.net/6/docs/ref/#state.findClusterBreak))
     into one of:
     
      - Word (contains an alphanumeric character or a character
@@ -2215,7 +2868,12 @@ Registers translation phrases. The
 all objects registered with this facet to find translations for
 its argument.
 */
-EditorState.phrases = /*@__PURE__*/Facet.define();
+EditorState.phrases = /*@__PURE__*/Facet.define({
+    compare(a, b) {
+        let kA = Object.keys(a), kB = Object.keys(b);
+        return kA.length == kB.length && kA.every(k => a[k] == b[k]);
+    }
+});
 /**
 A facet used to register [language
 data](https://codemirror.net/6/docs/ref/#state.EditorState.languageDataAt) providers.
@@ -2231,7 +2889,7 @@ Such a function can return `true` to indicate that it doesn't
 want to do anything, `false` to completely stop the changes in
 the transaction, or a set of ranges in which changes should be
 suppressed. Such ranges are represented as an array of numbers,
-with each pair of two number indicating the start and end of a
+with each pair of two numbers indicating the start and end of a
 range. So for example `[10, 20, 100, 110]` suppresses changes
 between 10 and 20, and between 100 and 110.
 */
@@ -2262,19 +2920,22 @@ This is a more limited form of
 which can only add
 [annotations](https://codemirror.net/6/docs/ref/#state.TransactionSpec.annotations) and
 [effects](https://codemirror.net/6/docs/ref/#state.TransactionSpec.effects). _But_, this type
-of filter runs even the transaction has disabled regular
+of filter runs even if the transaction has disabled regular
 [filtering](https://codemirror.net/6/docs/ref/#state.TransactionSpec.filter), making it suitable
 for effects that don't need to touch the changes or selection,
 but do want to process every transaction.
 
-Extenders run _after_ filters, when both are applied.
+Extenders run _after_ filters, when both are present.
 */
 EditorState.transactionExtender = transactionExtender;
 Compartment.reconfigure = /*@__PURE__*/StateEffect.define();
 
 /**
 Utility function for combining behaviors to fill in a config
-object from an array of provided configs. Will, by default, error
+object from an array of provided configs. `defaults` should hold
+default values for all optional fields in `Config`.
+
+The function will, by default, error
 when a field gets two values that aren't `===`-equal, but you can
 provide combine functions per field to do something else.
 */
@@ -2298,4 +2959,871 @@ combine = {}) {
     return result;
 }
 
-export { Annotation, AnnotationType, ChangeDesc, ChangeSet, CharCategory, Compartment, EditorSelection, EditorState, Facet, MapMode, Prec, SelectionRange, StateEffect, StateEffectType, StateField, Transaction, combineConfig };
+/**
+Each range is associated with a value, which must inherit from
+this class.
+*/
+class RangeValue {
+    /**
+    Compare this value with another value. Used when comparing
+    rangesets. The default implementation compares by identity.
+    Unless you are only creating a fixed number of unique instances
+    of your value type, it is a good idea to implement this
+    properly.
+    */
+    eq(other) { return this == other; }
+    /**
+    Create a [range](https://codemirror.net/6/docs/ref/#state.Range) with this value.
+    */
+    range(from, to = from) { return new Range(from, to, this); }
+}
+RangeValue.prototype.startSide = RangeValue.prototype.endSide = 0;
+RangeValue.prototype.point = false;
+RangeValue.prototype.mapMode = MapMode.TrackDel;
+/**
+A range associates a value with a range of positions.
+*/
+class Range {
+    /**
+    @internal
+    */
+    constructor(
+    /**
+    The range's start position.
+    */
+    from, 
+    /**
+    Its end position.
+    */
+    to, 
+    /**
+    The value associated with this range.
+    */
+    value) {
+        this.from = from;
+        this.to = to;
+        this.value = value;
+    }
+}
+function cmpRange(a, b) {
+    return a.from - b.from || a.value.startSide - b.value.startSide;
+}
+class Chunk {
+    constructor(from, to, value, 
+    // Chunks are marked with the largest point that occurs
+    // in them (or -1 for no points), so that scans that are
+    // only interested in points (such as the
+    // heightmap-related logic) can skip range-only chunks.
+    maxPoint) {
+        this.from = from;
+        this.to = to;
+        this.value = value;
+        this.maxPoint = maxPoint;
+    }
+    get length() { return this.to[this.to.length - 1]; }
+    // Find the index of the given position and side. Use the ranges'
+    // `from` pos when `end == false`, `to` when `end == true`.
+    findIndex(pos, side, end, startAt = 0) {
+        let arr = end ? this.to : this.from;
+        for (let lo = startAt, hi = arr.length;;) {
+            if (lo == hi)
+                return lo;
+            let mid = (lo + hi) >> 1;
+            let diff = arr[mid] - pos || (end ? this.value[mid].endSide : this.value[mid].startSide) - side;
+            if (mid == lo)
+                return diff >= 0 ? lo : hi;
+            if (diff >= 0)
+                hi = mid;
+            else
+                lo = mid + 1;
+        }
+    }
+    between(offset, from, to, f) {
+        for (let i = this.findIndex(from, -1000000000 /* Far */, true), e = this.findIndex(to, 1000000000 /* Far */, false, i); i < e; i++)
+            if (f(this.from[i] + offset, this.to[i] + offset, this.value[i]) === false)
+                return false;
+    }
+    map(offset, changes) {
+        let value = [], from = [], to = [], newPos = -1, maxPoint = -1;
+        for (let i = 0; i < this.value.length; i++) {
+            let val = this.value[i], curFrom = this.from[i] + offset, curTo = this.to[i] + offset, newFrom, newTo;
+            if (curFrom == curTo) {
+                let mapped = changes.mapPos(curFrom, val.startSide, val.mapMode);
+                if (mapped == null)
+                    continue;
+                newFrom = newTo = mapped;
+                if (val.startSide != val.endSide) {
+                    newTo = changes.mapPos(curFrom, val.endSide);
+                    if (newTo < newFrom)
+                        continue;
+                }
+            }
+            else {
+                newFrom = changes.mapPos(curFrom, val.startSide);
+                newTo = changes.mapPos(curTo, val.endSide);
+                if (newFrom > newTo || newFrom == newTo && val.startSide > 0 && val.endSide <= 0)
+                    continue;
+            }
+            if ((newTo - newFrom || val.endSide - val.startSide) < 0)
+                continue;
+            if (newPos < 0)
+                newPos = newFrom;
+            if (val.point)
+                maxPoint = Math.max(maxPoint, newTo - newFrom);
+            value.push(val);
+            from.push(newFrom - newPos);
+            to.push(newTo - newPos);
+        }
+        return { mapped: value.length ? new Chunk(from, to, value, maxPoint) : null, pos: newPos };
+    }
+}
+/**
+A range set stores a collection of [ranges](https://codemirror.net/6/docs/ref/#state.Range) in a
+way that makes them efficient to [map](https://codemirror.net/6/docs/ref/#state.RangeSet.map) and
+[update](https://codemirror.net/6/docs/ref/#state.RangeSet.update). This is an immutable data
+structure.
+*/
+class RangeSet {
+    /**
+    @internal
+    */
+    constructor(
+    /**
+    @internal
+    */
+    chunkPos, 
+    /**
+    @internal
+    */
+    chunk, 
+    /**
+    @internal
+    */
+    nextLayer = RangeSet.empty, 
+    /**
+    @internal
+    */
+    maxPoint) {
+        this.chunkPos = chunkPos;
+        this.chunk = chunk;
+        this.nextLayer = nextLayer;
+        this.maxPoint = maxPoint;
+    }
+    /**
+    @internal
+    */
+    get length() {
+        let last = this.chunk.length - 1;
+        return last < 0 ? 0 : Math.max(this.chunkEnd(last), this.nextLayer.length);
+    }
+    /**
+    The number of ranges in the set.
+    */
+    get size() {
+        if (this.isEmpty)
+            return 0;
+        let size = this.nextLayer.size;
+        for (let chunk of this.chunk)
+            size += chunk.value.length;
+        return size;
+    }
+    /**
+    @internal
+    */
+    chunkEnd(index) {
+        return this.chunkPos[index] + this.chunk[index].length;
+    }
+    /**
+    Update the range set, optionally adding new ranges or filtering
+    out existing ones.
+    
+    (Note: The type parameter is just there as a kludge to work
+    around TypeScript variance issues that prevented `RangeSet<X>`
+    from being a subtype of `RangeSet<Y>` when `X` is a subtype of
+    `Y`.)
+    */
+    update(updateSpec) {
+        let { add = [], sort = false, filterFrom = 0, filterTo = this.length } = updateSpec;
+        let filter = updateSpec.filter;
+        if (add.length == 0 && !filter)
+            return this;
+        if (sort)
+            add = add.slice().sort(cmpRange);
+        if (this.isEmpty)
+            return add.length ? RangeSet.of(add) : this;
+        let cur = new LayerCursor(this, null, -1).goto(0), i = 0, spill = [];
+        let builder = new RangeSetBuilder();
+        while (cur.value || i < add.length) {
+            if (i < add.length && (cur.from - add[i].from || cur.startSide - add[i].value.startSide) >= 0) {
+                let range = add[i++];
+                if (!builder.addInner(range.from, range.to, range.value))
+                    spill.push(range);
+            }
+            else if (cur.rangeIndex == 1 && cur.chunkIndex < this.chunk.length &&
+                (i == add.length || this.chunkEnd(cur.chunkIndex) < add[i].from) &&
+                (!filter || filterFrom > this.chunkEnd(cur.chunkIndex) || filterTo < this.chunkPos[cur.chunkIndex]) &&
+                builder.addChunk(this.chunkPos[cur.chunkIndex], this.chunk[cur.chunkIndex])) {
+                cur.nextChunk();
+            }
+            else {
+                if (!filter || filterFrom > cur.to || filterTo < cur.from || filter(cur.from, cur.to, cur.value)) {
+                    if (!builder.addInner(cur.from, cur.to, cur.value))
+                        spill.push(new Range(cur.from, cur.to, cur.value));
+                }
+                cur.next();
+            }
+        }
+        return builder.finishInner(this.nextLayer.isEmpty && !spill.length ? RangeSet.empty
+            : this.nextLayer.update({ add: spill, filter, filterFrom, filterTo }));
+    }
+    /**
+    Map this range set through a set of changes, return the new set.
+    */
+    map(changes) {
+        if (changes.empty || this.isEmpty)
+            return this;
+        let chunks = [], chunkPos = [], maxPoint = -1;
+        for (let i = 0; i < this.chunk.length; i++) {
+            let start = this.chunkPos[i], chunk = this.chunk[i];
+            let touch = changes.touchesRange(start, start + chunk.length);
+            if (touch === false) {
+                maxPoint = Math.max(maxPoint, chunk.maxPoint);
+                chunks.push(chunk);
+                chunkPos.push(changes.mapPos(start));
+            }
+            else if (touch === true) {
+                let { mapped, pos } = chunk.map(start, changes);
+                if (mapped) {
+                    maxPoint = Math.max(maxPoint, mapped.maxPoint);
+                    chunks.push(mapped);
+                    chunkPos.push(pos);
+                }
+            }
+        }
+        let next = this.nextLayer.map(changes);
+        return chunks.length == 0 ? next : new RangeSet(chunkPos, chunks, next, maxPoint);
+    }
+    /**
+    Iterate over the ranges that touch the region `from` to `to`,
+    calling `f` for each. There is no guarantee that the ranges will
+    be reported in any specific order. When the callback returns
+    `false`, iteration stops.
+    */
+    between(from, to, f) {
+        if (this.isEmpty)
+            return;
+        for (let i = 0; i < this.chunk.length; i++) {
+            let start = this.chunkPos[i], chunk = this.chunk[i];
+            if (to >= start && from <= start + chunk.length &&
+                chunk.between(start, from - start, to - start, f) === false)
+                return;
+        }
+        this.nextLayer.between(from, to, f);
+    }
+    /**
+    Iterate over the ranges in this set, in order, including all
+    ranges that end at or after `from`.
+    */
+    iter(from = 0) {
+        return HeapCursor.from([this]).goto(from);
+    }
+    /**
+    @internal
+    */
+    get isEmpty() { return this.nextLayer == this; }
+    /**
+    Iterate over the ranges in a collection of sets, in order,
+    starting from `from`.
+    */
+    static iter(sets, from = 0) {
+        return HeapCursor.from(sets).goto(from);
+    }
+    /**
+    Iterate over two groups of sets, calling methods on `comparator`
+    to notify it of possible differences.
+    */
+    static compare(oldSets, newSets, 
+    /**
+    This indicates how the underlying data changed between these
+    ranges, and is needed to synchronize the iteration. `from` and
+    `to` are coordinates in the _new_ space, after these changes.
+    */
+    textDiff, comparator, 
+    /**
+    Can be used to ignore all non-point ranges, and points below
+    the given size. When -1, all ranges are compared.
+    */
+    minPointSize = -1) {
+        let a = oldSets.filter(set => set.maxPoint > 0 || !set.isEmpty && set.maxPoint >= minPointSize);
+        let b = newSets.filter(set => set.maxPoint > 0 || !set.isEmpty && set.maxPoint >= minPointSize);
+        let sharedChunks = findSharedChunks(a, b, textDiff);
+        let sideA = new SpanCursor(a, sharedChunks, minPointSize);
+        let sideB = new SpanCursor(b, sharedChunks, minPointSize);
+        textDiff.iterGaps((fromA, fromB, length) => compare(sideA, fromA, sideB, fromB, length, comparator));
+        if (textDiff.empty && textDiff.length == 0)
+            compare(sideA, 0, sideB, 0, 0, comparator);
+    }
+    /**
+    Compare the contents of two groups of range sets, returning true
+    if they are equivalent in the given range.
+    */
+    static eq(oldSets, newSets, from = 0, to) {
+        if (to == null)
+            to = 1000000000 /* Far */;
+        let a = oldSets.filter(set => !set.isEmpty && newSets.indexOf(set) < 0);
+        let b = newSets.filter(set => !set.isEmpty && oldSets.indexOf(set) < 0);
+        if (a.length != b.length)
+            return false;
+        if (!a.length)
+            return true;
+        let sharedChunks = findSharedChunks(a, b);
+        let sideA = new SpanCursor(a, sharedChunks, 0).goto(from), sideB = new SpanCursor(b, sharedChunks, 0).goto(from);
+        for (;;) {
+            if (sideA.to != sideB.to ||
+                !sameValues(sideA.active, sideB.active) ||
+                sideA.point && (!sideB.point || !sideA.point.eq(sideB.point)))
+                return false;
+            if (sideA.to > to)
+                return true;
+            sideA.next();
+            sideB.next();
+        }
+    }
+    /**
+    Iterate over a group of range sets at the same time, notifying
+    the iterator about the ranges covering every given piece of
+    content. Returns the open count (see
+    [`SpanIterator.span`](https://codemirror.net/6/docs/ref/#state.SpanIterator.span)) at the end
+    of the iteration.
+    */
+    static spans(sets, from, to, iterator, 
+    /**
+    When given and greater than -1, only points of at least this
+    size are taken into account.
+    */
+    minPointSize = -1) {
+        let cursor = new SpanCursor(sets, null, minPointSize).goto(from), pos = from;
+        let open = cursor.openStart;
+        for (;;) {
+            let curTo = Math.min(cursor.to, to);
+            if (cursor.point) {
+                iterator.point(pos, curTo, cursor.point, cursor.activeForPoint(cursor.to), open, cursor.pointRank);
+                open = cursor.openEnd(curTo) + (cursor.to > curTo ? 1 : 0);
+            }
+            else if (curTo > pos) {
+                iterator.span(pos, curTo, cursor.active, open);
+                open = cursor.openEnd(curTo);
+            }
+            if (cursor.to > to)
+                break;
+            pos = cursor.to;
+            cursor.next();
+        }
+        return open;
+    }
+    /**
+    Create a range set for the given range or array of ranges. By
+    default, this expects the ranges to be _sorted_ (by start
+    position and, if two start at the same position,
+    `value.startSide`). You can pass `true` as second argument to
+    cause the method to sort them.
+    */
+    static of(ranges, sort = false) {
+        let build = new RangeSetBuilder();
+        for (let range of ranges instanceof Range ? [ranges] : sort ? lazySort(ranges) : ranges)
+            build.add(range.from, range.to, range.value);
+        return build.finish();
+    }
+}
+/**
+The empty set of ranges.
+*/
+RangeSet.empty = /*@__PURE__*/new RangeSet([], [], null, -1);
+function lazySort(ranges) {
+    if (ranges.length > 1)
+        for (let prev = ranges[0], i = 1; i < ranges.length; i++) {
+            let cur = ranges[i];
+            if (cmpRange(prev, cur) > 0)
+                return ranges.slice().sort(cmpRange);
+            prev = cur;
+        }
+    return ranges;
+}
+RangeSet.empty.nextLayer = RangeSet.empty;
+/**
+A range set builder is a data structure that helps build up a
+[range set](https://codemirror.net/6/docs/ref/#state.RangeSet) directly, without first allocating
+an array of [`Range`](https://codemirror.net/6/docs/ref/#state.Range) objects.
+*/
+class RangeSetBuilder {
+    /**
+    Create an empty builder.
+    */
+    constructor() {
+        this.chunks = [];
+        this.chunkPos = [];
+        this.chunkStart = -1;
+        this.last = null;
+        this.lastFrom = -1000000000 /* Far */;
+        this.lastTo = -1000000000 /* Far */;
+        this.from = [];
+        this.to = [];
+        this.value = [];
+        this.maxPoint = -1;
+        this.setMaxPoint = -1;
+        this.nextLayer = null;
+    }
+    finishChunk(newArrays) {
+        this.chunks.push(new Chunk(this.from, this.to, this.value, this.maxPoint));
+        this.chunkPos.push(this.chunkStart);
+        this.chunkStart = -1;
+        this.setMaxPoint = Math.max(this.setMaxPoint, this.maxPoint);
+        this.maxPoint = -1;
+        if (newArrays) {
+            this.from = [];
+            this.to = [];
+            this.value = [];
+        }
+    }
+    /**
+    Add a range. Ranges should be added in sorted (by `from` and
+    `value.startSide`) order.
+    */
+    add(from, to, value) {
+        if (!this.addInner(from, to, value))
+            (this.nextLayer || (this.nextLayer = new RangeSetBuilder)).add(from, to, value);
+    }
+    /**
+    @internal
+    */
+    addInner(from, to, value) {
+        let diff = from - this.lastTo || value.startSide - this.last.endSide;
+        if (diff <= 0 && (from - this.lastFrom || value.startSide - this.last.startSide) < 0)
+            throw new Error("Ranges must be added sorted by `from` position and `startSide`");
+        if (diff < 0)
+            return false;
+        if (this.from.length == 250 /* ChunkSize */)
+            this.finishChunk(true);
+        if (this.chunkStart < 0)
+            this.chunkStart = from;
+        this.from.push(from - this.chunkStart);
+        this.to.push(to - this.chunkStart);
+        this.last = value;
+        this.lastFrom = from;
+        this.lastTo = to;
+        this.value.push(value);
+        if (value.point)
+            this.maxPoint = Math.max(this.maxPoint, to - from);
+        return true;
+    }
+    /**
+    @internal
+    */
+    addChunk(from, chunk) {
+        if ((from - this.lastTo || chunk.value[0].startSide - this.last.endSide) < 0)
+            return false;
+        if (this.from.length)
+            this.finishChunk(true);
+        this.setMaxPoint = Math.max(this.setMaxPoint, chunk.maxPoint);
+        this.chunks.push(chunk);
+        this.chunkPos.push(from);
+        let last = chunk.value.length - 1;
+        this.last = chunk.value[last];
+        this.lastFrom = chunk.from[last] + from;
+        this.lastTo = chunk.to[last] + from;
+        return true;
+    }
+    /**
+    Finish the range set. Returns the new set. The builder can't be
+    used anymore after this has been called.
+    */
+    finish() { return this.finishInner(RangeSet.empty); }
+    /**
+    @internal
+    */
+    finishInner(next) {
+        if (this.from.length)
+            this.finishChunk(false);
+        if (this.chunks.length == 0)
+            return next;
+        let result = new RangeSet(this.chunkPos, this.chunks, this.nextLayer ? this.nextLayer.finishInner(next) : next, this.setMaxPoint);
+        this.from = null; // Make sure further `add` calls produce errors
+        return result;
+    }
+}
+function findSharedChunks(a, b, textDiff) {
+    let inA = new Map();
+    for (let set of a)
+        for (let i = 0; i < set.chunk.length; i++)
+            if (set.chunk[i].maxPoint <= 0)
+                inA.set(set.chunk[i], set.chunkPos[i]);
+    let shared = new Set();
+    for (let set of b)
+        for (let i = 0; i < set.chunk.length; i++) {
+            let known = inA.get(set.chunk[i]);
+            if (known != null && (textDiff ? textDiff.mapPos(known) : known) == set.chunkPos[i] &&
+                !(textDiff === null || textDiff === void 0 ? void 0 : textDiff.touchesRange(known, known + set.chunk[i].length)))
+                shared.add(set.chunk[i]);
+        }
+    return shared;
+}
+class LayerCursor {
+    constructor(layer, skip, minPoint, rank = 0) {
+        this.layer = layer;
+        this.skip = skip;
+        this.minPoint = minPoint;
+        this.rank = rank;
+    }
+    get startSide() { return this.value ? this.value.startSide : 0; }
+    get endSide() { return this.value ? this.value.endSide : 0; }
+    goto(pos, side = -1000000000 /* Far */) {
+        this.chunkIndex = this.rangeIndex = 0;
+        this.gotoInner(pos, side, false);
+        return this;
+    }
+    gotoInner(pos, side, forward) {
+        while (this.chunkIndex < this.layer.chunk.length) {
+            let next = this.layer.chunk[this.chunkIndex];
+            if (!(this.skip && this.skip.has(next) ||
+                this.layer.chunkEnd(this.chunkIndex) < pos ||
+                next.maxPoint < this.minPoint))
+                break;
+            this.chunkIndex++;
+            forward = false;
+        }
+        if (this.chunkIndex < this.layer.chunk.length) {
+            let rangeIndex = this.layer.chunk[this.chunkIndex].findIndex(pos - this.layer.chunkPos[this.chunkIndex], side, true);
+            if (!forward || this.rangeIndex < rangeIndex)
+                this.setRangeIndex(rangeIndex);
+        }
+        this.next();
+    }
+    forward(pos, side) {
+        if ((this.to - pos || this.endSide - side) < 0)
+            this.gotoInner(pos, side, true);
+    }
+    next() {
+        for (;;) {
+            if (this.chunkIndex == this.layer.chunk.length) {
+                this.from = this.to = 1000000000 /* Far */;
+                this.value = null;
+                break;
+            }
+            else {
+                let chunkPos = this.layer.chunkPos[this.chunkIndex], chunk = this.layer.chunk[this.chunkIndex];
+                let from = chunkPos + chunk.from[this.rangeIndex];
+                this.from = from;
+                this.to = chunkPos + chunk.to[this.rangeIndex];
+                this.value = chunk.value[this.rangeIndex];
+                this.setRangeIndex(this.rangeIndex + 1);
+                if (this.minPoint < 0 || this.value.point && this.to - this.from >= this.minPoint)
+                    break;
+            }
+        }
+    }
+    setRangeIndex(index) {
+        if (index == this.layer.chunk[this.chunkIndex].value.length) {
+            this.chunkIndex++;
+            if (this.skip) {
+                while (this.chunkIndex < this.layer.chunk.length && this.skip.has(this.layer.chunk[this.chunkIndex]))
+                    this.chunkIndex++;
+            }
+            this.rangeIndex = 0;
+        }
+        else {
+            this.rangeIndex = index;
+        }
+    }
+    nextChunk() {
+        this.chunkIndex++;
+        this.rangeIndex = 0;
+        this.next();
+    }
+    compare(other) {
+        return this.from - other.from || this.startSide - other.startSide || this.rank - other.rank ||
+            this.to - other.to || this.endSide - other.endSide;
+    }
+}
+class HeapCursor {
+    constructor(heap) {
+        this.heap = heap;
+    }
+    static from(sets, skip = null, minPoint = -1) {
+        let heap = [];
+        for (let i = 0; i < sets.length; i++) {
+            for (let cur = sets[i]; !cur.isEmpty; cur = cur.nextLayer) {
+                if (cur.maxPoint >= minPoint)
+                    heap.push(new LayerCursor(cur, skip, minPoint, i));
+            }
+        }
+        return heap.length == 1 ? heap[0] : new HeapCursor(heap);
+    }
+    get startSide() { return this.value ? this.value.startSide : 0; }
+    goto(pos, side = -1000000000 /* Far */) {
+        for (let cur of this.heap)
+            cur.goto(pos, side);
+        for (let i = this.heap.length >> 1; i >= 0; i--)
+            heapBubble(this.heap, i);
+        this.next();
+        return this;
+    }
+    forward(pos, side) {
+        for (let cur of this.heap)
+            cur.forward(pos, side);
+        for (let i = this.heap.length >> 1; i >= 0; i--)
+            heapBubble(this.heap, i);
+        if ((this.to - pos || this.value.endSide - side) < 0)
+            this.next();
+    }
+    next() {
+        if (this.heap.length == 0) {
+            this.from = this.to = 1000000000 /* Far */;
+            this.value = null;
+            this.rank = -1;
+        }
+        else {
+            let top = this.heap[0];
+            this.from = top.from;
+            this.to = top.to;
+            this.value = top.value;
+            this.rank = top.rank;
+            if (top.value)
+                top.next();
+            heapBubble(this.heap, 0);
+        }
+    }
+}
+function heapBubble(heap, index) {
+    for (let cur = heap[index];;) {
+        let childIndex = (index << 1) + 1;
+        if (childIndex >= heap.length)
+            break;
+        let child = heap[childIndex];
+        if (childIndex + 1 < heap.length && child.compare(heap[childIndex + 1]) >= 0) {
+            child = heap[childIndex + 1];
+            childIndex++;
+        }
+        if (cur.compare(child) < 0)
+            break;
+        heap[childIndex] = cur;
+        heap[index] = child;
+        index = childIndex;
+    }
+}
+class SpanCursor {
+    constructor(sets, skip, minPoint) {
+        this.minPoint = minPoint;
+        this.active = [];
+        this.activeTo = [];
+        this.activeRank = [];
+        this.minActive = -1;
+        // A currently active point range, if any
+        this.point = null;
+        this.pointFrom = 0;
+        this.pointRank = 0;
+        this.to = -1000000000 /* Far */;
+        this.endSide = 0;
+        this.openStart = -1;
+        this.cursor = HeapCursor.from(sets, skip, minPoint);
+    }
+    goto(pos, side = -1000000000 /* Far */) {
+        this.cursor.goto(pos, side);
+        this.active.length = this.activeTo.length = this.activeRank.length = 0;
+        this.minActive = -1;
+        this.to = pos;
+        this.endSide = side;
+        this.openStart = -1;
+        this.next();
+        return this;
+    }
+    forward(pos, side) {
+        while (this.minActive > -1 && (this.activeTo[this.minActive] - pos || this.active[this.minActive].endSide - side) < 0)
+            this.removeActive(this.minActive);
+        this.cursor.forward(pos, side);
+    }
+    removeActive(index) {
+        remove(this.active, index);
+        remove(this.activeTo, index);
+        remove(this.activeRank, index);
+        this.minActive = findMinIndex(this.active, this.activeTo);
+    }
+    addActive(trackOpen) {
+        let i = 0, { value, to, rank } = this.cursor;
+        while (i < this.activeRank.length && this.activeRank[i] <= rank)
+            i++;
+        insert(this.active, i, value);
+        insert(this.activeTo, i, to);
+        insert(this.activeRank, i, rank);
+        if (trackOpen)
+            insert(trackOpen, i, this.cursor.from);
+        this.minActive = findMinIndex(this.active, this.activeTo);
+    }
+    // After calling this, if `this.point` != null, the next range is a
+    // point. Otherwise, it's a regular range, covered by `this.active`.
+    next() {
+        let from = this.to, wasPoint = this.point;
+        this.point = null;
+        let trackOpen = this.openStart < 0 ? [] : null, trackExtra = 0;
+        for (;;) {
+            let a = this.minActive;
+            if (a > -1 && (this.activeTo[a] - this.cursor.from || this.active[a].endSide - this.cursor.startSide) < 0) {
+                if (this.activeTo[a] > from) {
+                    this.to = this.activeTo[a];
+                    this.endSide = this.active[a].endSide;
+                    break;
+                }
+                this.removeActive(a);
+                if (trackOpen)
+                    remove(trackOpen, a);
+            }
+            else if (!this.cursor.value) {
+                this.to = this.endSide = 1000000000 /* Far */;
+                break;
+            }
+            else if (this.cursor.from > from) {
+                this.to = this.cursor.from;
+                this.endSide = this.cursor.startSide;
+                break;
+            }
+            else {
+                let nextVal = this.cursor.value;
+                if (!nextVal.point) { // Opening a range
+                    this.addActive(trackOpen);
+                    this.cursor.next();
+                }
+                else if (wasPoint && this.cursor.to == this.to && this.cursor.from < this.cursor.to) {
+                    // Ignore any non-empty points that end precisely at the end of the prev point
+                    this.cursor.next();
+                }
+                else { // New point
+                    this.point = nextVal;
+                    this.pointFrom = this.cursor.from;
+                    this.pointRank = this.cursor.rank;
+                    this.to = this.cursor.to;
+                    this.endSide = nextVal.endSide;
+                    if (this.cursor.from < from)
+                        trackExtra = 1;
+                    this.cursor.next();
+                    this.forward(this.to, this.endSide);
+                    break;
+                }
+            }
+        }
+        if (trackOpen) {
+            let openStart = 0;
+            while (openStart < trackOpen.length && trackOpen[openStart] < from)
+                openStart++;
+            this.openStart = openStart + trackExtra;
+        }
+    }
+    activeForPoint(to) {
+        if (!this.active.length)
+            return this.active;
+        let active = [];
+        for (let i = this.active.length - 1; i >= 0; i--) {
+            if (this.activeRank[i] < this.pointRank)
+                break;
+            if (this.activeTo[i] > to || this.activeTo[i] == to && this.active[i].endSide >= this.point.endSide)
+                active.push(this.active[i]);
+        }
+        return active.reverse();
+    }
+    openEnd(to) {
+        let open = 0;
+        for (let i = this.activeTo.length - 1; i >= 0 && this.activeTo[i] > to; i--)
+            open++;
+        return open;
+    }
+}
+function compare(a, startA, b, startB, length, comparator) {
+    a.goto(startA);
+    b.goto(startB);
+    let endB = startB + length;
+    let pos = startB, dPos = startB - startA;
+    for (;;) {
+        let diff = (a.to + dPos) - b.to || a.endSide - b.endSide;
+        let end = diff < 0 ? a.to + dPos : b.to, clipEnd = Math.min(end, endB);
+        if (a.point || b.point) {
+            if (!(a.point && b.point && (a.point == b.point || a.point.eq(b.point)) &&
+                sameValues(a.activeForPoint(a.to + dPos), b.activeForPoint(b.to))))
+                comparator.comparePoint(pos, clipEnd, a.point, b.point);
+        }
+        else {
+            if (clipEnd > pos && !sameValues(a.active, b.active))
+                comparator.compareRange(pos, clipEnd, a.active, b.active);
+        }
+        if (end > endB)
+            break;
+        pos = end;
+        if (diff <= 0)
+            a.next();
+        if (diff >= 0)
+            b.next();
+    }
+}
+function sameValues(a, b) {
+    if (a.length != b.length)
+        return false;
+    for (let i = 0; i < a.length; i++)
+        if (a[i] != b[i] && !a[i].eq(b[i]))
+            return false;
+    return true;
+}
+function remove(array, index) {
+    for (let i = index, e = array.length - 1; i < e; i++)
+        array[i] = array[i + 1];
+    array.pop();
+}
+function insert(array, index, value) {
+    for (let i = array.length - 1; i >= index; i--)
+        array[i + 1] = array[i];
+    array[index] = value;
+}
+function findMinIndex(value, array) {
+    let found = -1, foundPos = 1000000000 /* Far */;
+    for (let i = 0; i < array.length; i++)
+        if ((array[i] - foundPos || value[i].endSide - value[found].endSide) < 0) {
+            found = i;
+            foundPos = array[i];
+        }
+    return found;
+}
+
+/**
+Count the column position at the given offset into the string,
+taking extending characters and tab size into account.
+*/
+function 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;
+}
+
+export { Annotation, AnnotationType, ChangeDesc, ChangeSet, CharCategory, Compartment, EditorSelection, EditorState, Facet, Line, MapMode, Prec, Range, RangeSet, RangeSetBuilder, RangeValue, SelectionRange, StateEffect, StateEffectType, StateField, Text, Transaction, codePointAt, codePointSize, combineConfig, countColumn, findClusterBreak, findColumn, fromCodePoint };