https://engdarwish-universal-market-predictor-deluxe.hf.space/assets/Index-42090191.js

264// Nodes provide the tree structure of the `Text` type. They store a
265// number of other nodes or leaves, taking care to balance themselves
266// on changes. There are implied line breaks _between_ the children of
267// a node (but not before the first or after the last child).
268class TextNode extends Text {
269    constructor(children, length) {
270        super();
271        this.children = children;
272        this.length = length;
273        this.lines = 0;
274        for (let child of children)
275            this.lines += child.lines;
276    }
277    lineInner(target, isLine, line, offset) {
278        for (let i = 0;; i++) {
279            let child = this.children[i], end = offset + child.length, endLine = line + child.lines - 1;
280            if ((isLine ? endLine : end) >= target)
281                return child.lineInner(target, isLine, line, offset);
282            offset = end + 1;
283            line = endLine + 1;
284        }
285    }
286    decompose(from, to, target, open) {
287        for (let i = 0, pos = 0; pos <= to && i < this.children.length; i++) {
288            let child = this.children[i], end = pos + child.length;
289            if (from <= end && to >= pos) {
290                let childOpen = open & ((pos <= from ? 1 /* Open.From */ : 0) | (end >= to ? 2 /* Open.To */ : 0));
291                if (pos >= from && end <= to && !childOpen)
292                    target.push(child);
293                else
294                    child.decompose(from - pos, to - pos, target, childOpen);
295            }
296            pos = end + 1;
297        }
298    }
299    replace(from, to, text) {
300        if (text.lines < this.lines)
301            for (let i = 0, pos = 0; i < this.children.length; i++) {
302                let child = this.children[i], end = pos + child.length;
303                // Fast path: if the change only affects one child and the
304                // child's size remains in the acceptable range, only update
305                // that child
306                if (from >= pos && to <= end) {
307                    let updated = child.replace(from - pos, to - pos, text);
308                    let totalLines = this.lines - child.lines + updated.lines;
309                    if (updated.lines < (totalLines >> (5 /* Tree.BranchShift */ - 1)) &&
310                        updated.lines > (totalLines >> (5 /* Tree.BranchShift */ + 1))) {
311                        let copy = this.children.slice();
312                        copy[i] = updated;
313                        return new TextNode(copy, this.length - (to - from) + text.length);
314                    }
315                    return super.replace(pos, end, updated);
316                }
317                pos = end + 1;
318            }
319        return super.replace(from, to, text);
320    }
321    sliceString(from, to = this.length, lineSep = "\n") {

321
322        let result = "";
323        for (let i = 0, pos = 0; i < this.children.length && pos <= to; i++) {
324            let child = this.children[i], end = pos + child.length;
325            if (pos > from && i)
326                result += lineSep;
327            if (from < end && to > pos)
328                result += child.sliceString(from - pos, to - pos, lineSep);
329            pos = end + 1;
330        }
331        return result;
332    }
333    flatten(target) {
334        for (let child of this.children)
335            child.flatten(target);
336    }
337    scanIdentical(other, dir) {
338        if (!(other instanceof TextNode))
339            return 0;
340        let length = 0;
341        let [iA, iB, eA, eB] = dir > 0 ? [0, 0, this.children.length, other.children.length]
342            : [this.children.length - 1, other.children.length - 1, -1, -1];
343        for (;; iA += dir, iB += dir) {
344            if (iA == eA || iB == eB)
345                return length;
346            let chA = this.children[iA], chB = other.children[iB];
347            if (chA != chB)
348                return length + chA.scanIdentical(chB, dir);
349            length += chA.length + 1;
350        }
351    }
352    static from(children, length = children.reduce((l, ch) => l + ch.length + 1, -1)) {
353        let lines = 0;
354        for (let ch of children)
355            lines += ch.lines;
356        if (lines < 32 /* Tree.Branch */) {
357            let flat = [];
358            for (let ch of children)
359                ch.flatten(flat);
360            return new TextLeaf(flat, length);
361        }
362        let chunk = Math.max(32 /* Tree.Branch */, lines >> 5 /* Tree.BranchShift */), maxChunk = chunk << 1, minChunk = chunk >> 1;
363        let chunked = [], currentLines = 0, currentLen = -1, currentChunk = [];
364        function add(child) {
365            let last;
366            if (child.lines > maxChunk && child instanceof TextNode) {
367                for (let node of child.children)
368                    add(node);
369            }
370            else if (child.lines > minChunk && (currentLines > minChunk || !currentLines)) {
371                flush();
372                chunked.push(child);
373            }
374            else if (child instanceof TextLeaf && currentLines &&
375                (last = currentChunk[currentChunk.length - 1]) instanceof TextLeaf &&
376                child.lines + last.lines <= 32 /* Tree.Branch */) {
377                currentLines += child.lines;
378                currentLen += child.length + 1;
379                currentChunk[currentChunk.length - 1] = new TextLeaf(last.text.concat(child.text), last.length + 1 + child.length);
380            }
381            else {
382                if (currentLines + child.lines > chunk)
383                    flush();
384                currentLines += child.lines;
385                currentLen += child.length + 1;
386                currentChunk.push(child);
387            }
388        }
389        function flush() {
390            if (currentLines == 0)
391                return;
392            chunked.push(currentChunk.length == 1 ? currentChunk[0] : TextNode.from(currentChunk, currentLen));
393            currentLen = -1;
394            currentLines = currentChunk.length = 0;
395        }
396        for (let child of children)
397            add(child);
398        flush();
399        return chunked.length == 1 ? chunked[0] : new TextNode(chunked, length);
400    }
401}
402Text.empty = /*@__PURE__*/new TextLeaf([""], 0);
403function textLength(text) {
404    let length = -1;
405    for (let line of text)
406        length += line.length + 1;
407    return length;
408}
409function appendText(text, target, from = 0, to = 1e9) {
410    for (let pos = 0, i = 0, first = true; i < text.length && pos <= to; i++) {
411        let line = text[i], end = pos + line.length;
412        if (end >= from) {
413            if (end > to)
414                line = line.slice(0, to - pos);
415            if (pos < from)
416                line = line.slice(from - pos);
417            if (first) {
418                target[target.length - 1] += line;
419                first = false;
420            }
421            else
422                target.push(line);
423        }
424        pos = end + 1;
425    }
426    return target;
427}
428function sliceText(text, from, to) {
429    return appendText(text, [""], from, to);
430}
431class RawTextCursor {
432    constructor(text, dir = 1) {
433        this.dir = dir;
434        this.done = false;
435        this.lineBreak = false;
436        this.value = "";
437        this.nodes = [text];
438        this.offsets = [dir > 0 ? 1 : (text instanceof TextLeaf ? text.text.length : text.children.length) << 1];
439    }
440    nextInner(skip, dir) {
441        this.done = this.lineBreak = false;
442        for (;;) {
443            let last = this.nodes.length - 1;
444            let top = this.nodes[last], offsetValue = this.offsets[last], offset = offsetValue >> 1;
445            let size = top instanceof TextLeaf ? top.text.length : top.children.length;
446            if (offset == (dir > 0 ? size : 0)) {
447                if (last == 0) {
448                    this.done = true;
449                    this.value = "";
450                    return this;
451                }
452                if (dir > 0)
453                    this.offsets[last - 1]++;
454                this.nodes.pop();
455                this.offsets.pop();
456            }
457            else if ((offsetValue & 1) == (dir > 0 ? 0 : 1)) {
458                this.offsets[last] += dir;
459                if (skip == 0) {
460                    this.lineBreak = true;
461                    this.value = "\n";
462                    return this;
463                }
464                skip--;
465            }
466            else if (top instanceof TextLeaf) {
467                // Move to the next string
468                let next = top.text[offset + (dir < 0 ? -1 : 0)];
469                this.offsets[last] += dir;
470                if (next.length > Math.max(0, skip)) {
471                    this.value = skip == 0 ? next : dir > 0 ? next.slice(skip) : next.slice(0, next.length - skip);
472                    return this;
473                }
474                skip -= next.length;
475            }
476            else {
477                let next = top.children[offset + (dir < 0 ? -1 : 0)];
478                if (skip > next.length) {
479                    skip -= next.length;
480                    this.offsets[last] += dir;
481                }
482                else {
483                    if (dir < 0)
484                        this.offsets[last]--;
485                    this.nodes.push(next);
486                    this.offsets.push(dir > 0 ? 1 : (next instanceof TextLeaf ? next.text.length : next.children.length) << 1);
487                }
488            }
489        }
490    }
491    next(skip = 0) {
492        if (skip < 0) {
493            this.nextInner(-skip, (-this.dir));
494            skip = this.value.length;
495        }
496        return this.nextInner(skip, this.dir);
497    }
498}
499class PartialTextCursor {
500    constructor(text, start, end) {
501        this.value = "";
502        this.done = false;
503        this.cursor = new RawTextCursor(text, start > end ? -1 : 1);
504        this.pos = start > end ? text.length : 0;
505        this.from = Math.min(start, end);
506        this.to = Math.max(start, end);
507    }
508    nextInner(skip, dir) {
509        if (dir < 0 ? this.pos <= this.from : this.pos >= this.to) {
510            this.value = "";
511            this.done = true;
512            return this;
513        }
514        skip += Math.max(0, dir < 0 ? this.pos - this.to : this.from - this.pos);
515        let limit = dir < 0 ? this.pos - this.from : this.to - this.pos;
516        if (skip > limit)
517            skip = limit;
518        limit -= skip;
519        let { value } = this.cursor.next(skip);
520        this.pos += (value.length + skip) * dir;
521        this.value = value.length <= limit ? value : dir < 0 ? value.slice(value.length - limit) : value.slice(0, limit);
522        this.done = !this.value;
523        return this;
524    }
525    next(skip = 0) {
526        if (skip < 0)
527            skip = Math.max(skip, this.from - this.pos);
528        else if (skip > 0)
529            skip = Math.min(skip, this.to - this.pos);
530        return this.nextInner(skip, this.cursor.dir);
531    }
532    get lineBreak() { return this.cursor.lineBreak && this.value != ""; }
533}
534class LineCursor {
535    constructor(inner) {
536        this.inner = inner;
537        this.afterBreak = true;
538        this.value = "";
539        this.done = false;
540    }
541    next(skip = 0) {
542        let { done, lineBreak, value } = this.inner.next(skip);
543        if (done

685    let code0 = str.charCodeAt(pos);
686    if (!surrogateHigh(code0) || pos + 1 == str.length)
687        return code0;
688    let code1 = str.charCodeAt(pos + 1);
689    if (!surrogateLow(code1))
690        return code0;
691    return ((code0 - 0xd800) << 10) + (code1 - 0xdc00) + 0x10000;
692}
693/**
694Given a Unicode codepoint, return the JavaScript string that
695respresents it (like
696[`String.fromCodePoint`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCodePoint)).
697*/
698function fromCodePoint(code) {
699    if (code <= 0xffff)
700        return String.fromCharCode(code);
701    code -= 0x10000;
702    return String.fromCharCode((code >> 10) + 0xd800, (code & 1023) + 0xdc00);
703}
704/**
705The amount of positions a character takes up a JavaScript string.
706*/
707function codePointSize(code) { return code < 0x10000 ? 1 : 2; }
708
709const DefaultSplit = /\r\n?|\n/;
710/**
711Distinguishes different ways in which positions can be mapped.
712*/
713var MapMode = /*@__PURE__*/(function (MapMode) {
714    /**
715    Map a position to a valid new position, even when its context
716    was deleted.
717    */
718    MapMode[MapMode["Simple"] = 0] = "Simple";
719    /**
720    Return null if deletion happens across the position.
721    */
722    MapMode[MapMode["TrackDel"] = 1] = "TrackDel";
723    /**
724    Return null if the character _before_ the position is deleted.
725    */
726    MapMode[MapMode["TrackBefore"] = 2] = "TrackBefore";
727    /**
728    Return null if the character _after_ the position is deleted.
729    */
730    MapMode[MapMode["TrackAfter"] = 3] = "TrackAfter";
731return MapMode})(MapMode || (MapMode = {}));
732/**
733A change description is a variant of [change set](https://codemirror.net/6/docs/ref/#state.ChangeSet)
734that doesn't store the inserted text. As such, it can't be
735applied, but is cheaper to store and manipulate.
736*/
737class ChangeDesc {
738    // Sections are encoded as pairs of integers. The first is the
739    // length in the current document, and the second is -1 for
740    // unaffected sections, and the length of the replacement content
741    // otherwise. So an insertion would be (0, n>0), a deletion (n>0,
742    // 0), and a replacement two positive numbers.
743    /**
744    @internal
745    */
746    constructor(
747    /**
748    @internal
749    */
750    sections) {
751        this.sections = sections;
752    }
753    /**
754    The length of the document before the change.
755    */
756    get length() {
757        let result = 0;
758        for (let i = 0; i < this.sections.length; i += 2)
759            result += this.sections[i];
760        return result;
761    }
762    /**
763    The length of the document after the change.
764    */
765    get newLength() {
766        let result = 0;
767        for (let i = 0; i < this.sections.length; i += 2) {
768            let ins = this.sections[i + 1];
769            result += ins < 0 ? this.sections[i] : ins;
770        }
771        return result;
772    }
773    /**
774    False when there are actual changes in this set.
775    */
776    get empty() { return this.sections.length == 0 || this.sections.length == 2 && this.sections[1] < 0; }
777    /**
778    Iterate over the unchanged parts left by these changes. `posA`
779    provides the position of the range in the old document, `posB`
780    the new position in the changed document.
781    */
782    iterGaps(f) {
783        for (let i = 0, posA = 0, posB = 0; i < this.sections.length;) {
784            let len = this.sections[i++], ins = this.sections[i++];
785            if (ins < 0) {
786                f(posA, posB, len);
787                posB += len;
788            }
789            else {
790                posB += ins;
791            }
792            posA += len;
793        }
794    }
795    /**
796    Iterate over the ranges changed by these changes. (See
797    [`ChangeSet.iterChanges`](https://codemirror.net/6/docs/ref/#state.ChangeSet.iterChanges) for a
798    variant that also provides you with the inserted text.)
799    `fromA`/`toA` provides the extent of the change in the starting
800    document, `fromB`/`toB` the extent of the replacement in the
801    changed document.
802    
803    When `individual` is true, adjacent changes (which are kept
804    separate for [position mapping](https://codemirror.net/6/docs/ref/#state.ChangeDesc.mapPos)) are
805    reported separately.
806    */
807    iterChangedRanges(f, individual = false) {
808        iterChanges(this, f, individual);
809    }
810    /**
811    Get a description of the inverted form of these changes.
812    */
813    get invertedDesc() {
814        let sections = [];
815        for (let i = 0; i < this.sections.length;) {
816            let len = this.sections[i++], ins = this.sections[i++];
817            if (ins < 0)
818                sections.push(len, ins);
819            else
820                sections.push(ins, len);
821        }
822        return new ChangeDesc(sections);
823    }
824    /**
825    Compute the combined effect of applying another set of changes
826    after this one. The length of the document after this set should
827    match the length before `other`.
828    */
829    composeDesc(other) { return this.empty ? other : other.empty ? this 

834`.
835    */
836    mapDesc(other, before = false) { return other.empty ? this : mapSet(this, other, before); }
837    mapPos(pos, assoc = -1, mode = MapMode.Simple) {
838        let posA = 0, posB = 0;
839        for (let i = 0; i < this.sections.length;) {
840            let len = this.sections[i++], ins = this.sections[i++], endA = posA + len;
841            if (ins < 0) {
842                if (endA > pos)
843                    return posB + (pos - posA);
844                posB += len;
845            }
846            else {
847                if (mode != MapMode.Simple && endA >= pos &&
848                    (mode == MapMode.TrackDel && posA < pos && endA > pos ||
849                        mode == MapMode.TrackBefore && posA < pos ||
850                        mode == MapMode.TrackAfter && endA > pos))
851                    return null;
852                if (endA > pos || endA == pos && assoc < 0 && !len)
853                    return pos == posA || assoc < 0 ? posB : posB + ins;
854                posB += ins;
855            }
856            posA = endA;
857        }
858        if (pos > posA)
859            throw new RangeError(`Position ${pos} is out of range for changeset of length ${posA}`);
860        return posB;
861    }
862    /**
863    Check whether these changes touch a given range. When one of the
864    changes entirely covers the range, the string `"cover"` is
865    returned.
866    */
867    touchesRange(from, to = from) {
868        for (let i = 0, pos = 0; i < this.sections.length && pos <= to;) {
869            let len = this.sections[i++], ins = this.sections[i++], end = pos + len;
870            if (ins >= 0 && pos <= to && end >= from)
871                return pos < from && end > to ? "cover" : true;
872            pos = end;
873        }
874        return false;
875    }
876    /**
877    @internal
878    */
879    toString() {
880        let result = "";
881        for (let i = 0; i < this.sections.length;) {
882            let len = this.sections[i++], ins = this.sections[i++];
883            result += (result ? " " : "") + len + (ins >= 0 ? ":" + ins : "");
884        }
885        return result;
886    }
887    /**
888    Serialize this change desc to a JSON-representable value.
889    */
890    toJSON() { return this.sections; }
891    /**
892    Create a change desc from its JSON representation (as produced
893    by [`toJSON`](https://codemirror.net/6/docs/ref/#state.ChangeDesc.toJSON).
894    */
895    static fromJSON(json) {
896        if (!Array.isArray(json) || json.length % 2 || json.some(a => typeof a != "number"))
897            throw new RangeError("Invalid JSON representation of ChangeDesc");
898        return new ChangeDesc(json);
899    }
900    /**
901    @internal
902    */
903    static create(sections) { return new ChangeDesc(sections); }
904}
905/**
906A change set represents a group of modifications to a document. It
907stores the document length, and can only be applied to documents
908with exactly that length.
909*/
910class ChangeSet extends ChangeDesc {
911    constructor(sections, 
912    /**
913    @internal
914    */
915    inserted) {
916        super(sections);
917        this.inserted = inserted;
918    }
919    /**
920    Apply the changes to a document, returning the modified
921    document.
922    */
923    apply(doc) {
924        if (this.length != doc.length)
925            throw new RangeError("Applying change set to a document with the wrong length");
926        iterChanges(this, (fromA, toA, fromB, _toB, text) => doc = doc.replace(fromB, fromB + (toA - fromA), text), false);
927        return doc;
928    }
929    mapDesc(other, before = false) { return mapSet(this, other, before, true); }
930    /**
931    Given the document as it existed _before_ the changes, return a
932    change set that represents the inverse of this set, which could
933    be used to go from the document created by the changes back to
934    the document as it existed before the changes.
935    */
936    invert(doc) {
937        let sections = this.sections.slice(), inserted = [];
938        for (let i = 0, pos = 0; i < sections.length; i += 2) {
939            let len = sections[i], ins = sections[i + 1];
940            if (ins >= 0) {
941                sections[i] = ins;
942                sections[i + 1] = len;
943                let index = i >> 1;
944                while (inserted.length < index)
945                    inserted.push(Text.empty);
946                inserted.push(len ? doc.slice(pos, pos + len) : Text.empty);
947            }
948            pos += len;
949        }
950        return new ChangeSet(sections, inserted);
951    }
952    /**
953    Combine two subsequent change sets into a single set. `other`
954    must start in the document produced by `this`. If `this` goes
955    `docA` → `docB` and `other` represents `docB` → `docC`, the
956    returned value will represent the change `docA` → `docC`.
957    */
958    compose(other) { return this.empty ? other : other.empty ? this : composeSets(this, other, true); }
959    /**
960    Given another change set starting in the same document, maps this
961    change set over the other, producing a new change set that can be
962    applied to the document produced by applying `other`. When
963    `before` is `true`, order changes as if `this` comes before
964    `other`, otherwise (the default) treat `other` as coming first.
965    
966    Given two changes `A` and `B`, `A.compose(B.map(A))` and
967    `B.compose(A.map(B, true))` will produce the same document. This
968    provides a basic form of [operational
969    transformation](https://en.wikipedia.org/wiki/Operational_transformation),
970    and can be used for collaborative editing.
971    */
972    map(other, before = false) { return other.empty ? this : mapSet(this, other, before, true); }
973    /**
974    Iterate over the changed ranges in the document, calling `f` for
975    each, with the range in the original document (`fromA`-`toA`)
976    and the range that replaces it in the new document
977    (`fromB`-`toB`).
978    
979    When `individual` is true, adjacent changes are reported
980    separately.
981    */
982    iterChanges(f, individual = false) {
983        iterChanges(this, f, individual);
984    }
985    /**
986    Get a [change description](https://codemirror.net/6/docs/ref/#state.ChangeDesc) for this change
987    set.
988    */
989    get desc() { return ChangeDesc.create(this.sections); }
990    /**
991    @internal
992    */
993    filter(ranges) {
994        let resultSections = [], resultInserted = [], filteredSections = [];
995        let iter = new SectionIter(this);
996        done: for (let i = 0, pos = 0;;) {
997            let next = i == ranges.length ? 1e9 : ranges[i++];
998            while (pos < next || pos == next && iter.len == 0) {
999                if (iter.done)
1000                    break done;
1001                let len = Math.min(iter.len, next - pos);
1002                addSection(filteredSections, len, -1);
1003                let ins = iter.ins == -1 ? -1 : iter.off == 0 ? iter.ins : 0;
1004                addSection(resultSections, len, ins);
1005                if (ins > 0)
1006                    addInsert(resultInserted, resultSections, iter.text);
1007                iter.forward(len);
1008                pos += len;
1009            }
1010            let end = ranges[i++];
1011            while (pos < end) {
1012                if (iter.done)
1013                    break done;
1014                let len = Math.min(iter.len, end - pos);
1015                addSection(resultSections, len, -1);
1016                addSection(filteredSections, len, iter.ins == -1 ? -1 : iter.off == 0 ? iter.ins : 0);
1017                iter.forward(len);
1018                pos += len;
1019            }
1020        }
1021        return { changes: new ChangeSet(resultSections, resultInserted),
1022            filtered: ChangeDesc.create(filteredSections) };
1023    }
1024    /**
1025    Serialize this change set to a JSON-representable value.
1026    */
1027    toJSON() {
1028        let parts = [];
1029        for (let i = 0; i < this.sections.length; i += 2) {
1030            let len = this.sections[i], ins = this.sections[i + 1];
1031            if (ins < 0)
1032                parts.push(len);
1033            else if (ins == 0)
1034                parts.push([len]);
1035            else
1036                parts.push([len].concat(this.inserted[i >> 1].toJSON()));
1037        }
1038        return parts;
1039    }
1040    /**
1041    Create a change set for the given changes, for a document of the
1042    given length, using `lineSep` as line separator.
1043    */
1044    static of(changes, length, lineSep) {
1045        let sections = [], inserted = [], pos = 0;
1046        let total = null;
1047        function flush(force = false) {
1048            if (!force && !sections.length)
1049                return;
1050            if (pos < length)
1051                addSection(sections, length - pos, -1);
1052            let set = new ChangeSet(sections, inserted);
1053            total = total ? total.compose(set.map(total)) : set;
1054            sections = [];
1055            inserted = [];
1056            pos = 0;
1057        }
1058        function process(spec) {
1059            if (Array.isArray(spec)) {
1060                for (let sub of spec)
1061                    process(sub);
1062            }
1063            else if (spec instanceof ChangeSet) {
1064                if (spec.length != length)
1065                    throw new RangeError(`Mismatched change set length (got ${spec.length}, expected ${length})`);
1066                flush();
1067                total = total ? total.compose(spec.map(total)) : spec;
1068            }
1069            else {
1070                let { from, to = from, insert } = spec;
1071                if (from > to || from < 0 || to > length)
1072                    throw new RangeError(`Invalid change range ${from} to ${to} (in doc of length ${length})`);
1073                let insText = !insert ? Text.empty : typeof insert == "string" ? Text.of(insert.split(lineSep || DefaultSplit)) : insert;
1074                let insLen = insText.length;
1075                if (from == to && insLen == 0)
1076                    return;
1077                if (from < pos)
1078                    flush();
1079                if (from > pos)
1080                    addSection(sections, from - pos, -1);
1081                addSection(sections, to - from, insLen);
1082                addInsert(inserted, sections, insText);
1083                pos = to;
1084            }
1085        }
1086        process(changes);
1087        flush(!total);
1088        return total;
1089    }
1090    /**
1091    Create an empty changeset of the given length.
1092    */
1093    static empty(length) {
1094        return new ChangeSet(length ? [length, -1] : [], []);
1095    }
1096    /**
1097    Create a changeset from its JSON representation (as produced by
1098    [`toJSON`](https://codemirror.net/6/docs/ref/#state.ChangeSet.toJSON).
1099    */
1100    static fromJSON(json) {
1101        if (!Array.isArray(json))
1102            throw new RangeError("Invalid JSON representation of ChangeSet");
1103        let sections = [], inserted = [];
1104        for (let i = 0; i < json.length; i++) {
1105            let part = json[i];
1106            if (typeof part == "number") {
1107                sections.push(part, -1);
1108            }
1109            else if (!Array.isArray(part) || typeof part[0] != "number" || part.some((e, i) => i && typeof e != "string")) {
1110                throw new RangeError("Invalid JSON representation of ChangeSet");
1111            }
1112            else if (part.length == 1) {
1113                sections.push(part[0], 0);
1114            }
1115            else {
1116                while (inserted.length < i)
1117                    inserted.push(Text.empty);
1118                inserted[i] = Text.of(part.slice(1));
1119                sections.push(part[0], inserted[i].length);
1120            }
1121        }
1122        return new ChangeSet(sections, inserted);
1123    }
1124    /**
1125    @internal
1126    */
1127    static createSet(sections, inserted) {
1128        return new ChangeSet(sections, inserted);
1129    }
1130}
1131function addSection(sections, len, ins, forceJoin = false) {
1132    if (len == 0 && ins <= 0)
1133        return;
1134    let last = sections.length - 2;
1135    if (last >= 0 && ins <= 0 && ins == sections[last + 1])
1136        sections[last] += len;
1137    else if (l

1137en == 0 && sections[last] == 0)
1138        sections[last + 1] += ins;
1139    else if (forceJoin) {
1140        sections[last] += len;
1141        sections[last + 1] += ins;
1142    }
1143    else
1144        sections.push(len, ins);
1145}
1146function addInsert(values, sections, value) {
1147    if (value.length == 0)
1148        return;
1149    let index = (sections.length - 2) >> 1;
1150    if (index < values.length) {
1151        values[values.length - 1] = values[values.length - 1].append(value);
1152    }
1153    else {
1154        while (values.length < index)
1155            values.push(Text.empty);
1156        values.push(value);
1157    }
1158}
1159function iterChanges(desc, f, individual) {
1160    let inserted = desc.inserted;
1161    for (let posA = 0, posB = 0, i = 0; i < desc.sections.length;) {
1162        let len = desc.sections[i++], ins = desc.sections[i++];
1163        if (ins < 0) {
1164            posA += len;
1165            posB += len;
1166        }
1167        else {
1168            let endA = posA, endB = posB, text = Text.empty;
1169            for (;;) {
1170                endA += len;
1171                endB += ins;
1172                if (ins && inserted)
1173                    text = text.append(inserted[(i - 2) >> 1]);
1174                if (individual || i == desc.sections.length || desc.sections[i + 1] < 0)
1175                    break;
1176                len = desc.sections[i++];
1177                ins = desc.sections[i++];
1178            }
1179            f(posA, endA, posB, endB, text);
1180            posA = endA;
1181            posB = endB;
1182        }
1183    }
1184}
1185function mapSet(setA, setB, before, mkSet = false) {
1186    // Produce a copy of setA that applies to the document after setB
1187    // has been applied (assuming both start at the same document).
1188    let sections = [], insert = mkSet ? [] : null;
1189    let a = new SectionIter(setA), b = new SectionIter(setB);
1190    // Iterate over both sets in parallel. inserted tracks, for changes
1191    // in A that have to be processed piece-by-piece, whether their
1192    // content has been inserted already, and refers to the section
1193    // index.
1194    for (let inserted = -1;;) {
1195        if (a.ins == -1 && b.ins == -1) {
1196            // Move across ranges skipped by both sets.
1197            let len = Math.min(a.len, b.len);
1198            addSection(sections, len, -1);
1199            a.forward(len);
1200            b.forward(len);
1201        }
1202        else if (b.ins >= 0 && (a.ins < 0 || inserted == a.i || a.off == 0 && (b.len < a.len || b.len == a.len && !before))) {
1203            // If there's a change in B that comes before the next change in
1204            // A (ordered by start pos, then len, then before flag), skip
1205            // that (and process any changes in A it covers).
1206            let len = b.len;
1207            addSection(sections, b.ins, -1);
1208            while (len) {
1209                let piece = Math.min(a.len, len);
1210                if (a.ins >= 0 && inserted < a.i && a.len <= piece) {
1211                    addSection(sections, 0, a.ins);
1212                    if (insert)
1213                        addInsert(insert, sections, a.text);
1214                    inserted = a.i;
1215                }
1216                a.forward(piece);
1217                len -= piece;
1218            }
1219            b.next();
1220        }
1221        else if (a.ins >= 0) {
1222            // Process the part of a change in A up to the start of the next
1223            // non-deletion change in B (if overlapping).
1224            let len = 0, left = a.len;
1225            while (left) {
1226                if (b.ins == -1) {
1227                    let piece = Math.min(left, b.len);
1228                    len += piece;
1229                    left -= piece;
1230                    b.forward(piece);
1231                }
1232                else if (b.ins == 0 && b.len < left) {
1233                    left -= b.len;
1234                    b.next();
1235                }
1236                else {
1237                    break;
1238                }
1239            }
1240            addSection(sections, len, inserted < a.i ? a.ins : 0);
1241            if (insert && inserted < a.i)
1242                addInsert(insert, sections, a.text);
1243            inserted = a.i;
1244            a.forward(a.len - left);
1245        }
1246        else if (a.done && b.done) {
1247            return insert ? ChangeSet.createSet(sections, insert) : ChangeDesc.create(sections);
1248        }
1249        else {
1250            throw new Error("Mismatched change set lengths");
1251        }
1252    }
1253}
1254function composeSets(setA, setB, mkSet = false) {
1255    let sections = [];
1256    let insert = mkSet ? [] : null;
1257    let a = new SectionIter(setA), b = new SectionIter(setB);
1258    for (let open = false;;) {
1259        if (a.done && b.done) {
1260            return insert ? ChangeSet.createSet(sections, insert) : ChangeDesc.create(sections);
1261        }
1262        else if (a.ins == 0) { // Deletion in A
1263            addSection(sections, a.len, 0, open);
1264            a.next();
1265        }
1266        else if (b.len == 0 && !b.done) { // Insertion in B
1267            addSection(sections, 0, b.ins, open);
1268            if (insert)
1269                addInsert(insert, sections, b.text);
1270            b.next();
1271        }
1272        else if (a.done || b.done) {
1273            throw new Error("Mismatched change set lengths");
1274        }
1275        else {
1276            let len = Math.min(a.len2, b.len), sectionLen = sections.length;
1277            if (a.ins == -1) {
1278                let insB = b.ins == -1 ? -1 : b.off ? 0 : b.ins;
1279                addSection(sections, len, insB, open);
1280                if (insert && insB)
1281                    addInsert(insert, sections, b.text);
1282            }
1283            else if (b.ins == -1) {
1284                addSection(sections, a.off ? 0 : a.len, len, open);
1285                if (insert)
1286                    addInsert(insert, sections, a.textBit(len));
1287            }
1288            else {
1289                addSection(sections, a.off ? 0 : a.len, b.off ? 0 : b.ins, open);
1290                if (insert && !b.off)
1291                    addInsert(insert, sections, b.text);
1292            }
1293            open = (a.ins > len || b.ins >= 0 && b.len > len) && (open || sections.length > sectionLen);
1294            a.forward2(len);
1295            b.forward(len);
1296        }
1297    }
1298}
1299class SectionIter {
1300    constructor(set) {
1301        this.set = set;
1302        this.i = 0;
1303        this.next();
1304    }
1305    next() {
1306        let { sections } = this.set;
1307        if (this.i < sections.length) {
1308            this.len = sections[this.i++];
1309            this.ins = sections[this.i++];
1310        }
1311        else {
1312            this.len = 0;
1313            this.ins = -2;
1314        }
1315        this.off = 0;
1316    }
1317    get done() { return this.ins == -2; }
1318    get len2() { return this.ins < 0 ? this.len : this.ins; }
1319    get text() {
1320        let { inserted } = this.set, index = (this.i - 2) >> 1;
1321        return index >= inserted.length ? Text.empty : inserted[index];
1322    }
1323    textBit(len) {
1324        let { inserted } = this.set, index = (this.i - 2) >> 1;
1325        return index >= inserted.length && !len ? Text.empty
1326            : inserted[index].slice(this.off, len == null ? undefined : this.off + len);
1327    }
1328    forward(len) {
1329        if (len == this.len)
1330            this.next();
1331        else {
1332            this.len -= len;
1333            this.off += len;
1334        }
1335    }
1336    forward2(len) {
1337        if (this.ins == -1)
1338            this.forward(len);
1339        else if (len == this.ins)
1340            this.next();
1341        else {
1342            this.ins -= len;
1343            this.off += len;
1344        }
1345    }
1346}
1347
1348/**
1349A single selection range. When
1350[`allowMultipleSelections`](https://codemirror.net/6/docs/ref/#state.EditorState^allowMultipleSelections)
1351is enabled, a [selection](https://codemirror.net/6/docs/ref/#state.EditorSelection) may hold
1352multiple ranges. By default, selections hold exactly one range.
1353*/
1354class SelectionRange {
1355    constructor(
1356    /**
1357    The lower boundary of the range.
1358    */
1359    from, 

1360    /**
1361    The upper boundary of the range.
1362    */
1363    to, flags) {
1364        this.from = from;
1365        this.to = to;
1366        this.flags = flags;
1367    }
1368    /**
1369    The anchor of the range—the side that doesn't move when you
1370    extend it.
1371    */
1372    get anchor() { return this.flags & 16 /* RangeFlag.Inverted */ ? this.to : this.from; }
1373    /**
1374    The head of the range, which is moved when the range is
1375    [extended](https://codemirror.net/6/docs/ref/#state.SelectionRange.extend).
1376    */
1377    get head() { return this.flags & 16 /* RangeFlag.Inverted */ ? this.from : this.to; }
1378    /**
1379    True when `anchor` and `head` are at the same position.
1380    */
1381    get empty() { return this.from == this.to; }
1382    /**
1383    If this is a cursor that is explicitly associated with the
1384    character on one of its sides, this returns the side. -1 means
1385    the character before its position, 1 the character after, and 0
1386    means no association.
1387    */
1388    get assoc() { return this.flags & 4 /* RangeFlag.AssocBefore */ ? -1 : this.flags & 8 /* RangeFlag.AssocAfter */ ? 1 : 0; }
1389    /**
1390    The bidirectional text level associated with this cursor, if
1391    any.
1392    */
1393    get bidiLevel() {
1394        let level = this.flags & 3 /* RangeFlag.BidiLevelMask */;
1395        return level == 3 ? null : level;
1396    }
1397    /**
1398    The goal column (stored vertical offset) associated with a
1399    cursor. This is used to preserve the vertical position when
1400    [moving](https://codemirror.net/6/docs/ref/#view.EditorView.moveVertically) across
1401    lines of different length.
1402    */
1403    get goalColumn() {
1404        let value = this.flags >> 5 /* RangeFlag.GoalColumnOffset */;
1405        return value == 33554431 /* RangeFlag.NoGoalColumn */ ? undefined : value;
1406    }
1407    /**
1408    Map this range through a change, producing a valid range in the
1409    updated document.
1410    */
1411    map(change, assoc = -1) {
1412        let from, to;
1413        if (this.empty) {
1414            from = to = change.mapPos(this.from, assoc);
1415        }
1416        else {
1417            from = change.mapPos(this.from, 1);
1418            to = change.mapPos(this.to, -1);
1419        }
1420        return from == this.from && to == this.to ? this : new SelectionRange(from, to, this.flags);
1421    }
1422    /**
1423    Extend this range to cover at least `from` to `to`.
1424    */
1425    extend(from, to = from) {
1426        if (from <= this.anchor && to >= this.anchor)
1427            return EditorSelection.range(from, to);
1428        let head = Math.abs(from - this.anchor) > Math.abs(to - this.anchor) ? from : to;
1429        return EditorSelection.range(this.anchor, head);
1430    }
1431    /**
1432    Compare this range to another range.
1433    */
1434    eq(other) {
1435        return this.anchor == other.anchor && this.head == other.head;
1436    }
1437    /**
1438    Return a JSON-serializable object representing the range.
1439    */
1440    toJSON() { return { anchor: this.anchor, head: this.head }; }
1441    /**
1442    Convert a JSON representation of a range to a `SelectionRange`
1443    instance.
1444    */
1445    static fromJSON(json) {
1446        if (!json || typeof json.anchor != "number" || typeof json.head != "number")
1447            throw new RangeError("Invalid JSON representation for SelectionRange");
1448        return EditorSelection.range(json.anchor, json.head);
1449    }
1450    /**
1451    @internal
1452    */
1453    static create(from, to, flags) {
1454        return new SelectionRange(from, to, flags);
1455    }
1456}
1457/**
1458An editor selection holds one or more selection ranges.
1459*/
1460class EditorSelection {
1461    constructor(
1462    /**
1463    The ranges in the selection, sorted by position. Ranges cannot
1464    overlap (but they may touch, if they aren't empty).
1465    */
1466    ranges, 
1467    /**
1468    The index of the _main_ range in the selection (which is
1469    usually the range that was added last).
1470    */
1471    mainIndex) {
1472        this.ranges = ranges;
1473        this.mainIndex = mainIndex;
1474    }
1475    /**
1476    Map a selection through a change. Used to adjust the selection
1477    position for changes.
1478    */
1479    map(change, assoc = -1) {
1480        if (change.empty)
1481            return this;
1482        return EditorSelection.create(this.ranges.map(r => r.map(change, assoc)), this.mainIndex);
1483    }
1484    /**
1485    Compare this selection to another selection.
1486    */
1487    eq(other) {
1488        if (this.ranges.length != other.ranges.length ||
1489            this.mainIndex != other.mainIndex)
1490            return false;

1605state. It takes inputs from any number of extensions, and combines
1606those into a single output value.
1607
1608Examples of uses of facets are the [tab
1609size](https://codemirror.net/6/docs/ref/#state.EditorState^tabSize), [editor
1610attributes](https://codemirror.net/6/docs/ref/#view.EditorView^editorAttributes), and [update
1611listeners](https://codemirror.net/6/docs/ref/#view.EditorView^updateListener).
1612*/
1613class Facet {
1614    constructor(
1615    /**
1616    @internal
1617    */
1618    combine, 
1619    /**
1620    @internal
1621    */
1622    compareInput, 
1623    /**
1624    @internal
1625    */
1626    compare, isStatic, enables) {
1627        this.combine = combine;
1628        this.compareInput = compareInput;
1629        this.compare = compare;
1630        this.isStatic = isStatic;
1631        /**
1632        @internal
1633        */
1634        this.id = nextID++;
1635        this.default = combine([]);
1636        this.extensions = typeof enables == "function" ? enables(this) : enables;
1637    }
1638    /**
1639    Define a new facet.
1640    */
1641    static define(config = {}) {
1642        return new Facet(config.combine || ((a) => a), config.compareInput || ((a, b) => a === b), config.compare || (!config.combine ? sameArray$1 : (a, b) => a === b), !!config.static, config.enables);
1643    }
1644    /**
1645    Returns an extension that adds the given value to this facet.
1646    */
1647    of(value) {
1648        return new FacetProvider([], this, 0 /* Provider.Static */, value);
1649    }
1650    /**
1651    Create an extension that computes a value for the facet from a
1652    state. You must take care to declare the parts of the state that
1653    this value depends on, since your function is only called again
1654    for a new state when one of those parts changed.
1655    
1656    In cases where your value depends only on a single field, you'll
1657    want to use the [`from`](https://codemirror.net/6/docs/ref/#state.Facet.from) method instead.
1658    */
1659    compute(deps, get) {
1660        if (this.isStatic)
1661            throw new Error("Can't compute a static facet");
1662        return new FacetProvider(deps, this, 1 /* Provider.Single */, get);
1663    }
1664    /**
1665    Create an extension that computes zero or more values for this
1666    facet from a state.
1667    */
1668    computeN(deps, get) {
1669        if (this.isStatic)
1670            throw new Error("Can't compute a static facet");
1671        return new FacetProvider(deps, this, 2 /* Provider.Multi */, get);
1672    }
1673    from(field, get) {
1674        if (!get)
1675            get = x => x;
1676        return this.compute([field], state => get(state.field(field)));
1677    }
1678}
1679function sameArray$1(a, b) {
1680    return a == b || a.length == b.length && a.every((e, i) => e === b[i]);
1681}
1682class FacetProvider {
1683    constructor(dependencies, facet, type, value) {
1684        this.dependencies = dependencies;
1685        this.facet = facet;
1686        this.type = type;
1687        this.value = value;
1688        this.id = nextID++;
1689    }
1690    dynamicSlot(addresses) {
1691        var _a;
1692        let getter = this.value;
1693        let compare = this.facet.compareInput;
1694        let id = this.id, idx = addresses[id] >> 1, multi = this.type == 2 /* Provider.Multi */;
1695        let depDoc = false, depSel = false, depAddrs = [];
1696        for (let dep of this.dependencies) {
1697            if (dep == "doc")
1698                depDoc = true;
1699            else if (dep == "selection")
1700                depSel = true;
1701            else if ((((_a = addresses[dep.id]) !== null && _a !== void 0 ? _a : 1) & 1) == 0)
1702                depAddrs.push(addresses[dep.id]);
1703        }
1704        return {
1705            create(state) {
1706                state.values[idx] = getter(state);
1707                return 1 /* SlotStatus.Changed */;
1708            },
1709            update(state, tr) {
1710                if ((depDoc && tr.docChanged) || (depSel && (tr.docChanged || tr.selection)) || ensureAll(state, depAddrs)) {
1711                    let newVal = getter(state);
1712                    if (multi ? !compareArray(newVal, state.values[idx], compare) : !compare(newVal, state.values[idx])) {
1713                        state.values[idx] = newVal;
1714                        return 1 /* SlotStatus.Changed */;
1715                    }
1716                }
1717                return 0;
1718            },
1719            reconfigure: (state, oldState) => {
1720                let newVal = getter(state);
1721                let oldAddr = oldState.config.address[id];
1722                if (oldAddr != null) {
1723                    let oldVal = getAddr(oldState, oldAddr);
1724                    if (this.dependencies.every(dep => {
1725                        return dep instanceof Facet ? oldState.facet(dep) === state.facet(dep) :
1726                            dep instanceof StateField ? oldState.field(dep, false) == state.field(dep, false) : true;
1727                    }) || (multi ? compareArray(newVal, oldVal, compare) : compare(newVal, oldVal))) {
1728                        state.values[idx] = oldVal;
1729                        return 0;
1730                    }
1731                }
1732                state.values[idx] = newVal;
1733                return 1 /* SlotStatus.Changed */;
1734            }
1735        };
1736    }
1737}
1738function compareArray(a, b, compare) {
1739    if (a.length != b.length)
1740        return false;
1741    for (let i = 0; i < a.length; i++)
1742        if (!compare(a[i], b[i]))
1743            return false;
1744    return true;
1745}
1746function ensureAll(state, addrs) {
1747    let changed = false;
1748    for (let addr of addrs)
1749        if (ensureAddr(state, addr) & 1 /* SlotStatus.Changed */)
1750            changed = true;
1751    return changed;
1752}
1753function dynamicFacetSlot(addresses, facet, providers) {
1754    let providerAddrs = providers.map(p => addresses[p.id]);
1755    let providerTypes = providers.map(p => p.type);
1756    let dynamic = providerAddrs.filter(p => !(p & 1));
1757    let idx = addresses[facet.id] >> 1;
1758    function get(state) {
1759        let values = [];
1760        for (let i = 0; i < providerAddrs.length; i++) {
1761            let value = getAddr(state, providerAddrs[i]);
1762            if (providerTypes[i] == 2 /* Provider.Multi */)
1763                for (let val of value)
1764                    values.push(val);
1765            else
1766                values.push(value);
1767        }
1768        return facet.combine(values);
1769    }
1770    return {
1771        create(state) {
1772            for (let addr of providerAddrs)
1773                ensureAddr(state, addr);
1774            state.values[idx] = get(state);
1775            return 1 /* SlotStatus.Changed */;
1776        },
1777        update(state, tr) {
1778            if (!ensureAll(state, dynamic))
1779                return 0;
1780            let value = get(state);
1781            if (facet.compare(value, state.values[idx]))
1782                return 0;
1783            state.values[idx] = value;
1784            return 1 /* SlotStatus.Changed */;
1785        },
1786        reconfigure(state, oldState) {
1787            let depChanged = ensureAll(state, providerAddrs);
1788            let oldProviders = oldState.config.facets[facet.id], oldValue = oldState.facet(facet);
1789            if (oldProviders && !depChanged && sameArray$1(providers, oldProviders)) {
1790                state.values[idx] = oldValue;
1791                return 0;
1792            }
1793            let value = get(state);
1794            if (facet.compare(value, oldValue)) {
1795                state.values[idx] = oldValue;
1796                return 0;
1797            }
1798            state.values[idx] = value;
1799            return 1 /* SlotStatus.Changed */;
1800        }
1801    };
1802}
1803const initField = /*@__PURE__*/Facet.define({ static: true });
1804/**
1805Fields can store additional information in an editor state, and
1806keep it in sync with the rest of the state.
1807*/
1808class StateField {
1809    constructor(
1810    /**
1811    @internal
1812    */
1813    id, createF, updateF, compareF, 
1814    /**
1815    @internal
1816    */
1817    spec) {
1818        this.id = id;
1819        this.createF = createF;
1820        this.updateF = updateF;
1821        this.compareF = compareF;
1822        this.spec = spec;
1823        /**
1824        @internal
1825        */
1826        this.provides = undefined;
1827    }
1828    /**
1829    Define a state field.
1830    */
1831    static define(config) {
1832        let field = new StateField(nextID++, config.create, config.update, config.compare || ((a, b) => a === b), config);
1833        if (config.provide)
1834            field.provides = config.provide(field);
1835        return field;
1836    }
1837    create(state) {
1838        let init = state.facet(initField).find(i => i.field == this);
1839        return ((init === null || init === void 0 ? void 0 : init.create) || this.createF)(state);
1840    }
1841    /**
1842    @internal
1843    */
1844    slot(addresses) {
1845        let idx = addresses[this.id] >> 1;
1846        return {
1847            create: (state) => {
1848                state.values[idx] = this.create(state);
1849                return 1 /* SlotStatus.Changed */;
1850            },
1851            update: (state, tr) => {
1852                let oldVal = state.values[idx];
1853                let value = this.updateF(oldVal, tr);
1854                if (this.compareF(oldVal, value))
1855                    return 0;
1856                state.values[idx] = value;
1857                return 1 /* SlotStatus.Changed */;
1858            },
1859            reconfigure: (state, oldState) => {
1860                if (oldState.config.address[this.id] != null) {
1861                    state.values[idx] = oldState.field(this);
1862                    return 0;
1863                }
1864                state.values[idx] = this.create(state);
1865                return 1 /* SlotStatus.Changed */;
1866            }
1867        };
1868    }
1869    /**
1870    Returns an extension that enables this field and overrides the
1871    way it is initialized. Can be useful when you need to provide a
1872    non-default starting value for the field.
1873    */
1874    init(create) {
1875        return [this, initField.of({ field: this, create })];
1876    }
1877    /**
1878    State field instances can be used as
1879    [`Extension`](https://codemirror.net/6/docs/ref/#state.Extension) values to enable the field in a
1880    given state.
1881    */
1882    get extension() { return this; }
1883}
1884const Prec_ = { lowest: 4, low: 3, default: 2, high: 1, highest: 0 };
1885function prec(value) {
1886    return (ext) => new PrecExtension(ext, value);
1887}
1888/**
1889By default extensions are registered in the order they are found
1890in the flattened form of nested array that was provided.
1891Individual extension values can be assigned a precedence to
1892override this. Extensions that do not have a precedence set get
1893the precedence of the nearest parent with a precedence, or
1894[`default`](https://codemirror.net/6/docs/ref/#state.Prec.default) if there is no such parent. The
1895final ordering of extensions is determined by first sorting by
1896precedence and then by order within each precedence.
1897*/
1898const Prec = {
1899    /**
1900    The highest precedence level, for extensions that should end up
1901    near the start of the precedence ordering.
1902    */
1903    highest: /*@__PURE__*/prec(Prec_.highest),
1904    /**
1905    A higher-than-default precedence, for extensions that should
1906    come before those with default precedence.
1907    */
1908    high: /*@__PURE__*/prec(Prec_.high),
1909    /**
1910    The default precedence, which is also used for extensions
1911    without an explicit precedence.
1912    */
1913    default: /*@__PURE__*/prec(Prec_.default),
1914    /**
1915    A lower-than-default precedence.
1916    */
1917    low: /*@__PURE__*/prec(Prec_.low),
1918    /**
1919    The lowest precedence level. Meant for things that should end up
1920    near the end of the extension order.
1921    */
1922    lowest: /*@__PURE__*/prec(Prec_.lowest)
1923};
1924class PrecExtension {
1925    constructor(inner, prec) {
1926        this.inner = inner;
1927        this.prec = prec;
1928    }
1929}
1930/**
1931Extension compartments can be used to make a configuration
1932dynamic. By [wrapping](https://codemirror.net/6/docs/ref/#state.Compartment.of) part of your
1933configuration in a compartment, you can later
1934[replace](https://codemirror.net/6/docs/ref/#state.Compartment.reconfigure) that part through a
1935transaction.
1936*/
1937class Compartment {
1938    /**
1939    Create an instance of this compartment to add to your [state
1940    configuration](https://codemirror.net/6/docs/ref/#state.EditorStateConfig.extensions).
1941    */
1942    of(ext) { return new CompartmentInstance(this, ext); }
1943    /**
1944    Create an [effect](https://codemirror.net/6/docs/ref/#state.TransactionSpec.effects) that
1945    reconfigures this compartment.
1946    */
1947    reconfigure(content) {
1948        return Compartment.reconfigure.of({ compartment: this, extension: content });
1949    }
1950    /**
1951    Get the current content of the compartment in the state, or
1952    `undefined` if it isn't present.
1953    */
1954    get(state) {
1955        return state.config.compartments.get(this);
1956    }
1957}
1958class CompartmentInstance {
1959    constructor(compartment, inner) {
1960        this.compartment = compartment;
1961        this.inner = inner;
1962    }
1963}
1964class Configuration {
1965    constructor(base, compartments, dynamicSlots, address, staticValues, facets) {
1966        this.base = base;
1967        this.compartments = compartments;
1968        this.dynamicSlots = dynamicSlots;
1969        this.address = address;
1970        this.staticValues = staticValues;
1971        this.facets = facets;
1972        this.statusTemplate = [];
1973        while (this.statusTemplate.length < dynamicSlots.length)
1974            this.statusTemplate.push(0 /* SlotStatus.Unresolved */);
1975    }
1976    staticFacet(facet) {
1977        let addr = this.address[facet.id];
1978        return addr == null ? facet.default : this.staticValues[addr >> 1];
1979    }
1980    static resolve(base, compartments, oldState) {
1981        let fields = [];
1982        let facets = Object.create(null);
1983        let newCompartments = new Map();
1984        for (let ext of flatten(base, compartments, newCompartments)) {
1985            if (ext instanceof StateField)
1986                fields.push(ext);
1987            else
1988                (facets[ext.facet.id] || (facets[ext.facet.id] = [])).push(ext);
1989        }
1990        let address = Object.create(null);
1991        let staticValues = [];
1992        let dynamicSlots = [];
1993        for (let field of fields) {
1994            address[field.id] = dynamicSlots.length << 1;
1995            dynamicSlots.push(a => field.slot(a));
1996        }
1997        let oldFacets = oldState === null || oldState === void 0 ? void 0 : oldState.config.facets;
1998        for (let id in facets) {
1999            let providers = facets[id], facet = providers[0].facet;
2000            let oldProviders = oldFacets && oldFacets[id] || [];
2001            if (providers.every(p => p.type == 0 /* Provider.Static */)) {
2002                address[facet.id] = (staticValues.length << 1) | 1;
2003                if (sameArray$1(oldProviders, providers)) {
2004                    staticValues.push(oldState.facet(facet));
2005                }
2006                else {
2007                    let value = facet.combine(providers.map(p => p.value));
2008                    staticValues.push(oldState && facet.compare(value, oldState.facet(facet)) ? oldState.facet(facet) : value);
2009                }
2010            }
2011            else {
2012                for (let p of providers) {
2013                    if (p.type == 0 /* Provider.Static */) {
2014                        address[p.id] = (staticValues.length << 1) | 1;
2015                        staticValues.push(p.value);
2016                    }
2017                    else {
2018                        address[p.id] = dynamicSlots.length << 1;
2019                        dynamicSlots.push(a => p.dynamicSlot(a));
2020                    }
2021                }
2022                address[facet.id] = dynamicSlots.length << 1;
2023                dynamicSlots.push(a => dynamicFacetSlot(a, facet, providers));
2024            }
2025        }
2026        let dynamic = dynamicSlots.map(f => f(address));
2027        return new Configuration(base, newCompartments, dynamic, address, staticValues, facets);
2028    }
2029}
2030function flatten(extension, compartments, newCompartments) {
2031    let result = [[], [], [], [], []];
2032    let seen = new Map();
2033    function inner(ext, prec) {
2034        let known = seen.get(ext);
2035        if (known != null) {
2036            if (known <= prec)
2037                return;
2038            let found = result[known].indexOf(ext);
2039            if (found > -1)
2040                result[known].splice(found, 1);
2041            if (ext instanceof CompartmentInstance)
2042                newCompartments.delete(ext.compartment);
2043        }
2044        seen.set(ext, prec);
2045        if (Array.isArray(ext)) {
2046            for (let e of ext)
2047                inner(e, prec);
2048        }
2049        else if (ext instanceof CompartmentInstance) {
2050            if (newCompartments.has(ext.compartment))
2051                throw new RangeError(`Duplicate use of compartment in extensions`);
2052            let content = compartments.get(ext.compartment) || ext.inner;
2053            newCompartments.set(ext.compartment, content);
2054            inner(content, prec);
2055        }
2056        else if (ext instanceof PrecExtension) {
2057            inner(ext.inner, ext.prec);
2058        }
2059        else if (ext instanceof StateField) {
2060            result[prec].push(ext);
2061            if (ext.provides)
2062                inner(ext.provides, prec);
2063        }
2064        else if (ext instanceof FacetProvider) {
2065            result[prec].push(ext);
2066            if (ext.facet.extensions)
2067                inner(ext.facet.extensions, Prec_.default);
2068        }
2069        else {
2070            let content = ext.extension;
2071            if (!content)
2072                throw new Error(`Unrecognized extension value in extension set (${ext}). This sometimes happens because multiple instances of @codemirror/state are loaded, breaking instanceof checks.`);
2073            inner(content, prec);
2074        }
2075    }
2076    inner(extension, Prec_.default);
2077    return result.reduce((a, b) => a.concat(b));
2078}
2079function ensureAddr(state, addr) {
2080    if (addr & 1)
2081        return 2 /* SlotStatus.Computed */;
2082    let idx = addr >> 1;
2083    let status = state.status[idx];
2084    if (status == 4 /* SlotStatus.Computing */)
2085        throw new Error("Cyclic dependency between fields and/or facets");
2086    if (status & 2 /* SlotStatus.Computed */)
2087        return status;
2088    state.status[idx] = 4 /* SlotStatus.Computing */;
2089    let changed = state.computeSlot(state, state.config.dynamicSlots[idx]);
2090    return state.status[idx] = 2 /* SlotStatus.Computed */ | changed;
2091}
2092function getAddr(state, addr) {
2093    return addr & 1 ? state.config.staticValues[addr >> 1] : state.values[addr >> 1];
2094}
2095
2096const languageData = /*@__PURE__*/Facet.define();
2097const allowMultipleSelections = /*@__PURE__*/Facet.define({
2098    combine: values => values.some(v => v),
2099    static: true
2100});
2101const lineSeparator = /*@__PURE__*/Facet.define({
2102    combine: values => values.length ? values[0] : undefined,
2103    static: true
2104});
2105const changeFilter = /*@__PURE__*/Facet.define();
2106const transactionFilter = /*@__PURE__*/Facet.define();
2107const transactionExtender = /*@__PURE__*/Facet.define();
2108const readOnly = /*@__PURE__*/Facet.define({
2109    combine: values => values.length ? values[0] : false
2110});
2111
2112/**
2113Annotations are tagged values that are used to add metadata to
2114transactions in an extensible way. They should be used to model
2115things that effect the entire transaction (such as its [time
2116stamp](https://codemirror.net/6/docs/ref/#state.Transaction^time) or information about its
2117[origin](https://codemirror.net/6/docs/ref/#state.Transaction^userEvent)). For effects that happen
2118_alongside_ the other changes made by the transaction, [state

2214.
2215    */
2216    static define(spec = {}) {
2217        return new StateEffectType(spec.map || (v => v));
2218    }
2219    /**
2220    Map an array of effects through a change set.
2221    */
2222    static mapEffects(effects, mapping) {
2223        if (!effects.length)
2224            return effects;
2225        let result = [];
2226        for (let effect of effects) {
2227            let mapped = effect.map(mapping);
2228            if (mapped)
2229                result.push(mapped);
2230        }
2231        return result;
2232    }
2233}
2234/**
2235This effect can be used to reconfigure the root extensions of
2236the editor. Doing this will discard any extensions
2237[appended](https://codemirror.net/6/docs/ref/#state.StateEffect^appendConfig), but does not reset
2238the content of [reconfigured](https://codemirror.net/6/docs/ref/#state.Compartment.reconfigure)
2239compartments.
2240*/
2241StateEffect.reconfigure = /*@__PURE__*/StateEffect.define();
2242/**
2243Append extensions to the top-level configuration of the editor.
2244*/
2245StateEffect.appendConfig = /*@__PURE__*/StateEffect.define();
2246/**
2247Changes to the editor state are grouped into transactions.
2248Typically, a user action creates a single transaction, which may
2249contain any number of document changes, may change the selection,
2250or have other effects. Create a transaction by calling
2251[`EditorState.update`](https://codemirror.net/6/docs/ref/#state.EditorState.update), or immediately
2252dispatch one by calling
2253[`EditorView.dispatch`](https://codemirror.net/6/docs/ref/#view.EditorView.dispatch).
2254*/
2255class Transaction {
2256    constructor(
2257    /**
2258    The state from which the transaction starts.
2259    */
2260    startState, 
2261    /**
2262    The document changes made by this transaction.
2263    */
2264    changes, 
2265    /**
2266    The selection set by this transaction, or undefined if it
2267    doesn't explicitly set a selection.
2268    */
2269    selection, 
2270    /**
2271    The effects added to the transaction.
2272    */
2273    effects, 
2274    /**
2275    @internal
2276    */
2277    annotations, 
2278    /**
2279    Whether the selection should be scrolled into view after this
2280    transaction is dispatched.
2281    */
2282    scrollIntoView) {
2283        this.startState = startState;
2284        this.changes = changes;
2285        this.selection = selection;
2286        this.effects = effects;
2287        this.annotations = annotations;
2288        this.scrollIntoView = scrollIntoView;
2289        /**
2290        @internal
2291        */
2292        this._doc = null;
2293        /**
2294        @internal
2295        */
2296        this._state = null;
2297        if (selection)
2298            checkSelection(selection, changes.newLength);
2299        if (!annotations.some((a) => a.type == Transaction.time))
2300            this.annotations = annotations.concat(Transaction.time.of(Date.now()));
2301    }
2302    /**
2303    @internal
2304    */
2305    static create(startState, changes, selection, effects, annotations, scrollIntoView) {
2306        return new Transaction(startState, changes, selection, effects, annotations, scrollIntoView);
2307    }
2308    /**
2309    The new document produced by the transaction. Contrary to
2310    [`.state`](https://codemirror.net/6/docs/ref/#state.Transaction.state)`.doc`, accessing this won't
2311    force the entire new state to be computed right away, so it is
2312    recommended that [transaction
2313    filters](https://codemirror.net/6/docs/ref/#state.EditorState^transactionFilter) use this getter
2314    when they need to look at the new document.
2315    */
2316    get newDoc() {
2317        return this._doc || (this._doc = this.changes.apply(this.startState.doc));
2318    }
2319    /**
2320    The new selection produced by the transaction. If
2321    [`this.selection`](https://codemirror.net/6/docs/ref/#state.Transaction.selection) is undefined,
2322    this will [map](https://codemirror.net/6/docs/ref/#state.EditorSelection.map) the start state's
2323    current selection through the changes made by the transaction.
2324    */
2325    get newSelection() {
2326        return this.selection || this.startState.selection.map(this.changes);
2327    }
2328    /**
2329    The new state created by the transaction. Computed on demand
2330    (but retained for subsequent access), so it is recommended not to
2331    access it in [transaction
2332    filters](https://codemirror.net/6/docs/ref/#state.EditorState^transactionFilter) when possible.
2333    */
2334    get state() {
2335        if (!this._state)
2336            this.startState.applyTransaction(this);
2337        return this._state;
2338    }
2339    /**
2340    Get the value of the given annotation type, if any.
2341    */
2342    annotation(type) {
2343        for (let ann of this.annotations)
2344            if (ann.type == type)
2345                return ann.value;
2346        return undefined;
2347    }
2348    /**
2349    Indicates whether the transaction changed the document.
2350    */
2351    get docChanged() { return !this.changes.empty; }
2352    /**
2353    Indicates whether this transaction reconfigures the state
2354    (through a [configuration compartment](https://codemirror.net/6/docs/ref/#state.Compartment) or
2355    with a top-level configuration
2356    [effect](https://codemirror.net/6/docs/ref/#state.StateEffect^reconfigure).
2357    */
2358    get reconfigured() { return this.startState.config != this.state.config; }
2359    /**
2360    Returns true if the transaction has a [user
2361    event](https://codemirror.net/6/docs/ref/#state.Transaction^userEvent) annotation that is equal to
2362    or more specific than `event`. For example, if the transaction
2363    has `"select.pointer"` as user event, `"select"` and
2364    `"select.pointer"` will match it.
2365    */
2366    isUserEvent(event) {
2367        let e = this.annotation(Transaction.userEvent);
2368        return !!(e && (e == event || e.length > event.length && e.slice(0, event.length) == event && e[event.length] == "."));
2369    }
2370}
2371/**
2372Annotation used to store transaction timestamps. Automatically
2373added to every transaction, holding `Date.now()`.
2374*/
2375Transaction.time = /*@__PURE__*/Annotation.define();
2376/**
2377Annotation used to associate a transaction with a user interface
2378event. Holds a string identifying the event, using a
2379dot-separated format to support attaching more specific
2380information. The events used by the core libraries are:
2381
2382 - `"input"` when content is entered
2383   - `"input.type"` for typed input
2384     - `"input.type.compose"` for composition
2385   - `"input.paste"` for pasted input
2386   - `"input.drop"` when adding content with drag-and-drop
2387   - `"input.complete"` when autocompleting
2388 - `"delete"` when the user deletes content
2389   - `"delete.selection"` when deleting the selection
2390   - `"delete.forward"` when deleting forward from the selection
2391   - `"delete.backward"` when deleting backward from the selection
2392   - `"delete.cut"` when cutting to the clipboard
2393 - `"move"` when content is moved
2394   - `"move.drop"` when content is moved within the editor through drag-and-drop
2395 - `"select"` when explicitly changing the selection
2396   - `"select.pointer"` when selecting with a mouse or other pointing device
2397 - `"undo"` and `"redo"` for history actions
2398
2399Use [`isUserEvent`](https://codemirror.net/6/docs/ref/#state.Transaction.isUserEvent) to check
2400whether the annotation matches a given event.
2401*/
2402Transaction.userEvent = /*@__PURE__*/Annotation.define();
2403/**
2404Annotation indicating whether a transaction should be added to
2405the undo history or not.
2406*/
2407Transaction.addToHistory = /*@__PURE__*/Annotation.define();
2408/**
2409Annotation indicating (when present and true) that a transaction
2410represents a change made by some other actor, not the user. This
2411is used, for example, to tag other people's changes in
2412collaborative editing.
2413*/
2414Transaction.remote = /*@__PURE__*/Annotation.define();
2415function joinRanges(a, b) {
2416    let result = [];
2417    for (let iA = 0, iB = 0;;) {
2418        let from, to;
2419        if (iA < a.length && (iB == b.length || b[iB] >= a[iA])) {
2420            from = a[iA++];
2421            to = a[iA++];
2422        }
2423        else if (iB < b.length) {
2424            from = b[iB++];
2425            to = b[iB++];
2426        }
2427        else
2428            return result;
2429        if (!result.length || result[result.length - 1] < from)
2430            result.push(from, to);
2431        else if (result[result.length - 1] < to)
2432            result[result.length - 1] = to;
2433    }
2434}
2435function mergeTransaction(a, b, sequential) {
2436    var _a;
2437    let mapForA, mapForB, changes;
2438    if (sequential) {
2439        mapForA = b.changes;
2440        mapForB = ChangeSet.empty(b.changes.length);
2441        changes = a.changes.compose(b.changes);
2442    }
2443    else {
2444        mapForA = b.changes.map(a.changes);
2445        mapForB = a.changes.mapDesc(b.changes, true);
2446        changes = a.changes.compose(mapForA);
2447    }
2448    return {
2449        changes,
2450        selection: b.selection ? b.selection.map(mapForB) : (_a = a.selection) === null || _a === void 0 ? void 0 : _a.map(mapForA),
2451        effects: StateEffect.mapEffects(a.effects, mapForA).concat(StateEffect.mapEffects(b.effects, mapForB)),
2452        annotations: a.annotations.length ? a.annotations.concat(b.annotations) : b.annotations,
2453        scrollIntoView: a.scrollIntoView || b.scrollIntoView
2454    };
2455}
2456function resolveTransactionInner(state, spec, docSize) {
2457    let sel = spec.selection, annotations = asArray

2457$1(spec.annotations);
2458    if (spec.userEvent)
2459        annotations = annotations.concat(Transaction.userEvent.of(spec.userEvent));
2460    return {
2461        changes: spec.changes instanceof ChangeSet ? spec.changes
2462            : ChangeSet.of(spec.changes || [], docSize, state.facet(lineSeparator)),
2463        selection: sel && (sel instanceof EditorSelection ? sel : EditorSelection.single(sel.anchor, sel.head)),
2464        effects: asArray$1(spec.effects),
2465        annotations,
2466        scrollIntoView: !!spec.scrollIntoView
2467    };
2468}
2469function resolveTransaction(state, specs, filter) {
2470    let s = resolveTransactionInner(state, specs.length ? specs[0] : {}, state.doc.length);
2471    if (specs.length && specs[0].filter === false)
2472        filter = false;
2473    for (let i = 1; i < specs.length; i++) {
2474        if (specs[i].filter === false)
2475            filter = false;
2476        let seq = !!specs[i].sequential;
2477        s = mergeTransaction(s, resolveTransactionInner(state, specs[i], seq ? s.changes.newLength : state.doc.length), seq);
2478    }
2479    let tr = Transaction.create(state, s.changes, s.selection, s.effects, s.annotations, s.scrollIntoView);
2480    return extendTransaction(filter ? filterTransaction(tr) : tr);
2481}
2482// Finish a transaction by applying filters if necessary.
2483function filterTransaction(tr) {
2484    let state = tr.startState;
2485    // Change filters
2486    let result = true;
2487    for (let filter of state.facet(changeFilter)) {
2488        let value = filter(tr);
2489        if (value === false) {
2490            result = false;

2491            break;
2492        }
2493        if (Array.isArray(value))
2494            result = result === true ? value : joinRanges(result, value);
2495    }
2496    if (result !== true) {
2497        let changes, back;
2498        if (result === false) {
2499            back = tr.changes.invertedDesc;
2500            changes = ChangeSet.empty(state.doc.length);
2501        }
2502        else {
2503            let filtered = tr.changes.filter(result);
2504            changes = filtered.changes;
2505            back = filtered.filtered.mapDesc(filtered.changes).invertedDesc;
2506        }
2507        tr = Transaction.create(state, changes, tr.selection && tr.selection.map(back), StateEffect.mapEffects(tr.effects, back), tr.annotations, tr.scrollIntoView);
2508    }
2509    // Transaction filters
2510    let filters = state.facet(transactionFilter);
2511    for (let i = filters.length - 1; i >= 0; i--) {
2512        let filtered = filters[i](tr);
2513        if (filtered instanceof Transaction)
2514            tr = filtered;
2515        else if (Array.isArray(filtered) && filtered.length == 1 && filtered[0] instanceof Transaction)
2516            tr = filtered[0];
2517        else
2518            tr = resolveTransaction(state, asArray$1(filtered), false);
2519    }
2520    return tr;
2521}
2522function extendTransaction(tr) {
2523    let state = tr.startState, extenders = state.facet(transactionExtender), spec = tr;
2524    for (let i = extenders.length - 1; i >= 0; i--) {
2525        let extension = extenders[i](tr);
2526        if (extension && Object.keys(extension).length)
2527            spec = mergeTransaction(spec, resolveTransactionInner(state, extension, tr.changes.newLength), true);
2528    }
2529    return spec == tr ? tr : Transaction.create(state, tr.changes, tr.selection, spec.effects, spec.annotations, spec.scrollIntoView);
2530}
2531const none$2 = [];
2532function asArray$1(value) {
2533    return value == null ? none$2 : Array.isArray(value) ? value : [value];
2534}
2535
2536/**
2537The categories produced by a [character
2538categorizer](https://codemirror.net/6/docs/ref/#state.EditorState.charCategorizer). These are used
2539do things like selecting by word.
2540*/
2541var CharCategory = /*@__PURE__*/(function (CharCategory) {
2542    /**
2543    Word characters.
2544    */
2545    CharCategory[CharCategory["Word"] = 0] = "Word";
2546    /**
2547    Whitespace.
2548    */
2549    CharCategory[CharCategory["Space"] = 1] = "Space";
2550    /**
2551    Anything else.
2552    */
2553    CharCategory[CharCategory["Other"] = 2] = "Other";
2554return CharCategory})(CharCategory || (CharCategory = {}));
2555const nonASCIISingleCaseWordChar = /[\u00df\u0587\u0590-\u05f4\u0600-\u06ff\u3040-\u309f\u30a0-\u30ff\u3400-\u4db5\u4e00-\u9fcc\uac00-\ud7af]/;
2556let wordChar;
2557try {
2558    wordChar = /*@__PURE__*/new RegExp("[\\p{Alphabetic}\\p{Number}_]", "u");
2559}
2560catch (_) { }
2561function hasWordChar(str) {
2562    if (wordChar)
2563        return wordChar.test(str);
2564    for (let i = 0; i < str.length; i++) {
2565        let ch = str[i];
2566        if (/\w/.test(ch) || ch > "\x80" && (ch.toUpperCase() != ch.toLowerCase() || nonASCIISingleCaseWordChar.test(ch)))
2567            return true;
2568    }
2569    return false;
2570}
2571function makeCategorizer(wordChars) {
2572    return (char) => {
2573        if (!/\S/.test(char))
2574            return CharCategory.Space;
2575        if (hasWordChar(char))
2576            return CharCategory.Word;
2577        for (let i = 0; i < wordChars.length; i++)
2578            if (char.indexOf(wordChars[i]) > -1)
2579                return CharCategory.Word;
2580        return CharCategory.Other;
2581    };
2582}
2583
2584/**
2585The editor state class is a persistent (immutable) data structure.
2586To update a state, you [create](https://codemirror.net/6/docs/ref/#state.EditorState.update) a
2587[transaction](https://codemirror.net/6/docs/ref/#state.Transaction), which produces a _new_ state
2588instance, without modifying the original object.
2589
2590As such, _never_ mutate properties of a state directly. That'll
2591just break things.
2592*/
2593class EditorState {
2594    constructor(
2595    /**
2596    @internal
2597    */
2598    config, 
2599    /**
2600    The current document.
2601    */
2602    doc, 
2603    /**
2604    The current selection.
2605    */
2606    selection, 
2607    /**
2608    @internal
2609    */
2610    values, computeSlot, tr) {
2611        this.config = config;
2612        this.doc = doc;
2613        this.selection = selection;
2614        this.values = values;
2615        this.status = config.statusTemplate.slice();
2616        this.computeSlot = computeSlot;
2617        // Fill in the computed state immediately, so that further queries

2618        // for it made during the update return this state
2619        if (tr)
2620            tr._state = this;
2621        for (let i = 0; i < this.config.dynamicSlots.length; i++)
2622            ensureAddr(this, i << 1);
2623        this.computeSlot = null;
2624    }
2625    field(field, require = true) {
2626        let addr = this.config.address[field.id];
2627        if (addr == null) {
2628            if (require)
2629                throw new RangeError("Field is not present in this state");
2630            return undefined;
2631        }
2632        ensureAddr(this, addr);
2633        return getAddr(this, addr);
2634    }
2635    /**
2636    Create a [transaction](https://codemirror.net/6/docs/ref/#state.Transaction) that updates this
2637    state. Any number of [transaction specs](https://codemirror.net/6/docs/ref/#state.TransactionSpec)
2638    can be passed. Unless
2639    [`sequential`](https://codemirror.net/6/docs/ref/#state.TransactionSpec.sequential) is set, the
2640    [changes](https://codemirror.net/6/docs/ref/#state.TransactionSpec.changes) (if any) of each spec
2641    are assumed to start in the _current_ document (not the document
2642    produced by previous specs), and its
2643    [selection](https://codemirror.net/6/docs/ref/#state.TransactionSpec.selection) and
2644    [effects](https://codemirror.net/6/docs/ref/#state.TransactionSpec.effects) are assumed to refer
2645    to the document created by its _own_ changes. The resulting
2646    transaction contains the combined effect of all the different
2647    specs. For [selection](https://codemirror.net/6/docs/ref/#state.TransactionSpec.selection), later
2648    specs take precedence over earlier ones.
2649    */
2650    update(...specs) {
2651        return resolveTransaction(this, specs, true);
2652    }
2653    /**
2654    @internal
2655    */
2656    applyTransaction(tr) {
2657        let conf = this.config, { base, compartments } = conf;
2658        for (let effect of tr.effects) {
2659            if (effect.is(Compartment.reconfigure)) {
2660                if (conf) {
2661                    compartments = new Map;
2662                    conf.compartments.forEach((val, key) => compartments.set(key, val));
2663                    conf = null;
2664                }
2665                compartments.set(effect.value.compartment, effect.value.extension);
2666            }
2667            else if (effect.is(StateEffect.reconfigure)) {
2668                conf = null;
2669                base = effect.value;
2670            }
2671            else if (effect.is(StateEffect.appendConfig)) {
2672                conf = null;
2673                base = asArray$1(base).concat(effect.value);
2674            }
2675        }
2676        let startValues;
2677        if (!conf) {
2678            conf = Configuration.resolve(base, compartments, this);
2679            let intermediateState = new EditorState(conf, this.doc, this.selection, conf.dynamicSlots.map(() => null), (state, slot) => slot.reconfigure(state, this), null);
2680            startValues = intermediateState.values;
2681        }
2682        else {
2683            startValues = tr.startState.values.slice();
2684        }
2685        new EditorState(conf, tr.newDoc, tr.newSelection, startValues, (state, slot) => slot.update(state, tr), tr);
2686    }
2687    /**
2688    Create a [transaction spec](https://codemirror.net/6/docs/ref/#state.TransactionSpec) that
2689    replaces every selection range with the given content.
2690    */
2691    replaceSelection(text) {
2692        if (typeof text == "string")
2693            text = this.toText(text);
2694        return this.changeByRange(range => ({ changes: { from: range.from, to: range.to, insert: text },
2695            range: EditorSelection.cursor(range.from + text.length) }));
2696    }
2697    /**
2698    Create a set of changes and a new selection by running the given
2699    function for each range in the active selection. The function
2700    can return an optional set of changes (in the coordinate space
2701    of the start document), plus an updated range (in the coordinate
2702    space of the document produced by the call's own changes). This
2703    method will merge all the changes and ranges into a single
2704    changeset and selection, and return it as a [transaction
2705    spec](https://codemirror.net/6/docs/ref/#state.TransactionSpec), which can be passed to
2706    [`update`](https://codemirror.net/6/docs/ref/#state.EditorState.update).
2707    */
2708    changeByRange(f) {
2709        let sel = this.selection;
2710        let result1 = f(sel.ranges[0]);
2711        let changes = this.changes(result1.changes), ranges = [result1.range];
2712        let effects = asArray$1(result1.effects);
2713        for (let i = 1; i < sel.ranges.length; i++) {
2714            let result = f(sel.ranges[i]);
2715            let newChanges = this.changes(result.changes), newMapped = newChanges.map(changes);
2716            for (let j = 0; j < i; j++)
2717                ranges[j] = ranges[j].map(newMapped);
2718            let mapBy = changes.mapDesc(newChanges, true);
2719            ranges.push(result.range.map(mapBy));
2720            changes = changes.compose(newMapped);