@codemirror/state 0.19.8 → 0.20.1

package/dist/index.d.ts

@@ -1,5 +1,136 @@
-import { Text } from '@codemirror/text';
-export { Text } from '@codemirror/text';
+/**
+A text iterator iterates over a sequence of strings. When
+iterating over a [`Text`](https://codemirror.net/6/docs/ref/#state.Text) document, result values will
+either be lines or line breaks.
+*/
+interface TextIterator extends Iterator<string>, Iterable<string> {
+    /**
+    Retrieve the next string. Optionally skip a given number of
+    positions after the current position. Always returns the object
+    itself.
+    */
+    next(skip?: number): this;
+    /**
+    The current string. Will be the empty string when the cursor is
+    at its end or `next` hasn't been called on it yet.
+    */
+    value: string;
+    /**
+    Whether the end of the iteration has been reached. You should
+    probably check this right after calling `next`.
+    */
+    done: boolean;
+    /**
+    Whether the current string represents a line break.
+    */
+    lineBreak: boolean;
+}
+/**
+The data structure for documents. @nonabstract
+*/
+declare abstract class Text implements Iterable<string> {
+    /**
+    The length of the string.
+    */
+    abstract readonly length: number;
+    /**
+    The number of lines in the string (always >= 1).
+    */
+    abstract readonly lines: number;
+    /**
+    Get the line description around the given position.
+    */
+    lineAt(pos: number): Line;
+    /**
+    Get the description for the given (1-based) line number.
+    */
+    line(n: number): Line;
+    /**
+    Replace a range of the text with the given content.
+    */
+    replace(from: number, to: number, text: Text): Text;
+    /**
+    Append another document to this one.
+    */
+    append(other: Text): Text;
+    /**
+    Retrieve the text between the given points.
+    */
+    slice(from: number, to?: number): Text;
+    /**
+    Retrieve a part of the document as a string
+    */
+    abstract sliceString(from: number, to?: number, lineSep?: string): string;
+    /**
+    Test whether this text is equal to another instance.
+    */
+    eq(other: Text): boolean;
+    /**
+    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 | -1): TextIterator;
+    /**
+    Iterate over a range of the text. When `from` > `to`, the
+    iterator will run in reverse.
+    */
+    iterRange(from: number, to?: number): TextIterator;
+    /**
+    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?: number, to?: number): TextIterator;
+    /**
+    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(): string[];
+    /**
+    If this is a branch node, `children` will hold the `Text`
+    objects that it is made up of. For leaf nodes, this holds null.
+    */
+    abstract readonly children: readonly Text[] | null;
+    [Symbol.iterator]: () => Iterator<string>;
+    /**
+    Create a `Text` instance for the given array of lines.
+    */
+    static of(text: readonly string[]): Text;
+    /**
+    The empty document.
+    */
+    static empty: Text;
+}
+/**
+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).
+*/
+declare class Line {
+    /**
+    The position of the start of the line.
+    */
+    readonly from: number;
+    /**
+    The position at the end of the line (_before_ the line break,
+    or at the end of document for the last line).
+    */
+    readonly to: number;
+    /**
+    This line's line number (1-based).
+    */
+    readonly number: number;
+    /**
+    The line's content.
+    */
+    readonly text: string;
+    /**
+    The length of the line (not including any line break after it).
+    */
+    get length(): number;
+}
 
 /**
 Distinguishes different ways in which positions can be mapped.
@@ -29,6 +160,11 @@ that doesn't store the inserted text. As such, it can't be
 applied, but is cheaper to store and manipulate.
 */
 declare class ChangeDesc {
+    protected constructor(
+    /**
+    @internal
+    */
+    sections: readonly number[]);
     /**
     The length of the document before the change.
     */
@@ -42,13 +178,18 @@ declare class ChangeDesc {
     */
     get empty(): boolean;
     /**
-    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: (posA: number, posB: number, length: number) => void): void;
     /**
     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
@@ -127,6 +268,7 @@ stores the document length, and can only be applied to documents
 with exactly that length.
 */
 declare class ChangeSet extends ChangeDesc {
+    private constructor();
     /**
     Apply the changes to a document, returning the modified
     document.
@@ -212,6 +354,7 @@ declare class SelectionRange {
     */
     readonly to: number;
     private flags;
+    private constructor();
     /**
     The anchor of the range—the side that doesn't move when you
     extend it.
@@ -282,6 +425,7 @@ declare class EditorSelection {
     usually the range that was added last).
     */
     readonly mainIndex: number;
+    private constructor();
     /**
     Map a selection through a change. Used to adjust the selection
     position for changes.
@@ -344,9 +488,9 @@ declare type FacetConfig<Input, Output> = {
     /**
     How to combine the input values into a single output value. When
     not given, the array of input values becomes the output. This
-    will immediately be called on creating the facet, with an empty
-    array, to compute the facet's default value when no inputs are
-    present.
+    function will immediately be called on creating the facet, with
+    an empty array, to compute the facet's default value when no
+    inputs are present.
     */
     combine?: (value: readonly Input[]) => Output;
     /**
@@ -362,7 +506,7 @@ declare type FacetConfig<Input, Output> = {
     */
     compareInput?: (a: Input, b: Input) => boolean;
     /**
-    Static facets can not contain dynamic inputs.
+    Forbids dynamic inputs to this facet.
     */
     static?: boolean;
     /**
@@ -379,10 +523,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).
 */
 declare class Facet<Input, Output = readonly Input[]> {
     private isStatic;
@@ -392,7 +536,7 @@ declare class Facet<Input, Output = readonly Input[]> {
     */
     static define<Input, Output = readonly Input[]>(config?: FacetConfig<Input, Output>): Facet<Input, Output>;
     /**
-    Returns an extension that adds the given value for this facet.
+    Returns an extension that adds the given value to this facet.
     */
     of(value: Input): Extension;
     /**
@@ -401,9 +545,8 @@ declare class Facet<Input, Output = readonly Input[]> {
     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: readonly Slot<any>[], get: (state: EditorState) => Input): Extension;
     /**
@@ -417,7 +560,7 @@ declare class Facet<Input, Output = readonly Input[]> {
     input type, the getter function can be omitted. If given, it
     will be used to retrieve the input from the field value.
     */
-    from(field: StateField<Input>): Extension;
+    from<T extends Input>(field: StateField<T>): Extension;
     from<T>(field: StateField<T>, get: (value: T) => Input): Extension;
 }
 declare type Slot<T> = Facet<any, T> | StateField<T> | "doc" | "selection";
@@ -439,12 +582,12 @@ declare type StateFieldSpec<Value> = {
     */
     compare?: (a: Value, b: Value) => boolean;
     /**
-    Provide values for facets based on the value of this field. The
-    given function will be called once with the initialized field. It
-    will usually want to call some facet's
-    [`from`](https://codemirror.net/6/docs/ref/#state.Facet.from) method to create facet inputs from
-    this field, but can also return other extensions that should be
-    enabled by this field.
+    Provide extensions based on this field. The given function will
+    be called once with the initialized field. It will usually want
+    to call some facet's [`from`](https://codemirror.net/6/docs/ref/#state.Facet.from) method to
+    create facet inputs from this field, but can also return other
+    extensions that should be enabled when the field is present in a
+    configuration.
     */
     provide?: (field: StateField<Value>) => Extension;
     /**
@@ -511,41 +654,29 @@ precedence and then by order within each precedence.
 */
 declare const Prec: {
     /**
-    The lowest precedence level. Meant for things that should end up
-    near the end of the extension order.
-    */
-    lowest: (ext: Extension) => Extension;
-    /**
-    A lower-than-default precedence, for extensions.
-    */
-    low: (ext: Extension) => Extension;
-    /**
-    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: (ext: Extension) => Extension;
+    highest: (ext: Extension) => Extension;
     /**
     A higher-than-default precedence, for extensions that should
     come before those with default precedence.
     */
     high: (ext: Extension) => Extension;
     /**
-    The highest precedence level, for extensions that should end up
-    near the start of the precedence ordering.
-    */
-    highest: (ext: Extension) => Extension;
-    /**
-    Backwards-compatible synonym for `Prec.lowest`.
+    The default precedence, which is also used for extensions
+    without an explicit precedence.
     */
-    fallback: (ext: Extension) => Extension;
+    default: (ext: Extension) => Extension;
     /**
-    Backwards-compatible synonym for `Prec.high`.
+    A lower-than-default precedence.
     */
-    extend: (ext: Extension) => Extension;
+    low: (ext: Extension) => Extension;
     /**
-    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: (ext: Extension) => Extension;
+    lowest: (ext: Extension) => Extension;
 };
 /**
 Extension compartments can be used to make a configuration
@@ -703,7 +834,7 @@ interface TransactionSpec {
     */
     annotations?: Annotation<any> | readonly Annotation<any>[];
     /**
-    Shorthand for `annotations: `[`Transaction.userEvent`](https://codemirror.net/6/docs/ref/#state.Transaction^userEvent)[`.of(...)`.
+    Shorthand for `annotations:` [`Transaction.userEvent`](https://codemirror.net/6/docs/ref/#state.Transaction^userEvent)`.of(...)`.
     */
     userEvent?: string;
     /**
@@ -715,7 +846,9 @@ interface TransactionSpec {
     By default, transactions can be modified by [change
     filters](https://codemirror.net/6/docs/ref/#state.EditorState^changeFilter) and [transaction
     filters](https://codemirror.net/6/docs/ref/#state.EditorState^transactionFilter). You can set this
-    to `false` to disable that.
+    to `false` to disable that. This can be necessary for
+    transactions that, for example, include annotations that must be
+    kept consistent with their changes.
     */
     filter?: boolean;
     /**
@@ -733,7 +866,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).
 */
 declare class Transaction {
     /**
@@ -758,6 +893,7 @@ declare class Transaction {
     transaction is dispatched.
     */
     readonly scrollIntoView: boolean;
+    private constructor();
     /**
     The new document produced by the transaction. Contrary to
     [`.state`](https://codemirror.net/6/docs/ref/#state.Transaction.state)`.doc`, accessing this won't
@@ -776,7 +912,7 @@ declare class Transaction {
     get newSelection(): EditorSelection;
     /**
     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.
     */
@@ -805,7 +941,8 @@ declare class Transaction {
     */
     isUserEvent(event: string): boolean;
     /**
-    Annotation used to store transaction timestamps.
+    Annotation used to store transaction timestamps. Automatically
+    added to every transaction, holding `Date.now()`.
     */
     static time: AnnotationType<number>;
     /**
@@ -879,7 +1016,7 @@ interface EditorStateConfig {
     provided either as a plain string (which will be split into
     lines according to the value of the [`lineSeparator`
     facet](https://codemirror.net/6/docs/ref/#state.EditorState^lineSeparator)), or an instance of
-    the [`Text`](https://codemirror.net/6/docs/ref/#text.Text) class (which is what the state will use
+    the [`Text`](https://codemirror.net/6/docs/ref/#state.Text) class (which is what the state will use
     to represent the document).
     */
     doc?: string | Text;
@@ -914,6 +1051,7 @@ declare class EditorState {
     The current selection.
     */
     readonly selection: EditorSelection;
+    private constructor();
     /**
     Retrieve the value of a [state field](https://codemirror.net/6/docs/ref/#state.StateField). Throws
     an error when the state doesn't have that field, unless you pass
@@ -941,11 +1079,7 @@ declare class EditorState {
     Create a [transaction spec](https://codemirror.net/6/docs/ref/#state.TransactionSpec) that
     replaces every selection range with the given content.
     */
-    replaceSelection(text: string | Text): {
-        changes: ChangeSet;
-        selection: EditorSelection;
-        effects: readonly StateEffect<any>[];
-    };
+    replaceSelection(text: string | Text): TransactionSpec;
     /**
     Create a set of changes and a new selection by running the given
     function for each range in the active selection. The function
@@ -975,7 +1109,7 @@ declare 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: string): Text;
     /**
@@ -1079,8 +1213,13 @@ declare class EditorState {
     Look up a translation for the given phrase (via the
     [`phrases`](https://codemirror.net/6/docs/ref/#state.EditorState^phrases) facet), or return the
     original string if no translation is found.
+    
+    If additional arguments are passed, they will be inserted in
+    place of markers like `$1` (for the first value) and `$2`, etc.
+    A single `$` is equivalent to `$1`, and `$$` will produce a
+    literal dollar sign.
     */
-    phrase(phrase: string): string;
+    phrase(phrase: string, ...insert: any[]): string;
     /**
     A facet used to register [language
     data](https://codemirror.net/6/docs/ref/#state.EditorState.languageDataAt) providers.
@@ -1097,7 +1236,7 @@ declare class EditorState {
     languageDataAt<T>(name: string, pos: number, side?: -1 | 0 | 1): readonly T[];
     /**
     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
@@ -1124,7 +1263,7 @@ declare class EditorState {
     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.
     */
@@ -1155,12 +1294,12 @@ declare class EditorState {
     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.
     */
     static transactionExtender: Facet<(tr: Transaction) => Pick<TransactionSpec, "effects" | "annotations"> | null, readonly ((tr: Transaction) => Pick<TransactionSpec, "effects" | "annotations"> | null)[]>;
 }
@@ -1177,13 +1316,336 @@ declare type StateCommand = (target: {
 
 /**
 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.
 */
-declare function combineConfig<Config>(configs: readonly Partial<Config>[], defaults: Partial<Config>, // Should hold only the optional properties of Config, but I haven't managed to express that
+declare function combineConfig<Config extends object>(configs: readonly Partial<Config>[], defaults: Partial<Config>, // Should hold only the optional properties of Config, but I haven't managed to express that
 combine?: {
     [P in keyof Config]?: (first: Config[P], second: Config[P]) => Config[P];
 }): Config;
 
-export { Annotation, AnnotationType, ChangeDesc, ChangeSet, ChangeSpec, CharCategory, Compartment, EditorSelection, EditorState, EditorStateConfig, Extension, Facet, MapMode, Prec, SelectionRange, StateCommand, StateEffect, StateEffectType, StateField, Transaction, TransactionSpec, combineConfig };
+/**
+Each range is associated with a value, which must inherit from
+this class.
+*/
+declare abstract 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: RangeValue): boolean;
+    /**
+    The bias value at the start of the range. Determines how the
+    range is positioned relative to other ranges starting at this
+    position. Defaults to 0.
+    */
+    startSide: number;
+    /**
+    The bias value at the end of the range. Defaults to 0.
+    */
+    endSide: number;
+    /**
+    The mode with which the location of the range should be mapped
+    when its `from` and `to` are the same, to decide whether a
+    change deletes the range. Defaults to `MapMode.TrackDel`.
+    */
+    mapMode: MapMode;
+    /**
+    Determines whether this value marks a point range. Regular
+    ranges affect the part of the document they cover, and are
+    meaningless when empty. Point ranges have a meaning on their
+    own. When non-empty, a point range is treated as atomic and
+    shadows any ranges contained in it.
+    */
+    point: boolean;
+    /**
+    Create a [range](https://codemirror.net/6/docs/ref/#state.Range) with this value.
+    */
+    range(from: number, to?: number): Range<this>;
+}
+/**
+A range associates a value with a range of positions.
+*/
+declare class Range<T extends RangeValue> {
+    /**
+    The range's start position.
+    */
+    readonly from: number;
+    /**
+    Its end position.
+    */
+    readonly to: number;
+    /**
+    The value associated with this range.
+    */
+    readonly value: T;
+    private constructor();
+}
+/**
+Collection of methods used when comparing range sets.
+*/
+interface RangeComparator<T extends RangeValue> {
+    /**
+    Notifies the comparator that a range (in positions in the new
+    document) has the given sets of values associated with it, which
+    are different in the old (A) and new (B) sets.
+    */
+    compareRange(from: number, to: number, activeA: T[], activeB: T[]): void;
+    /**
+    Notification for a changed (or inserted, or deleted) point range.
+    */
+    comparePoint(from: number, to: number, pointA: T | null, pointB: T | null): void;
+}
+/**
+Methods used when iterating over the spans created by a set of
+ranges. The entire iterated range will be covered with either
+`span` or `point` calls.
+*/
+interface SpanIterator<T extends RangeValue> {
+    /**
+    Called for any ranges not covered by point decorations. `active`
+    holds the values that the range is marked with (and may be
+    empty). `openStart` indicates how many of those ranges are open
+    (continued) at the start of the span.
+    */
+    span(from: number, to: number, active: readonly T[], openStart: number): void;
+    /**
+    Called when going over a point decoration. The active range
+    decorations that cover the point and have a higher precedence
+    are provided in `active`. The open count in `openStart` counts
+    the number of those ranges that started before the point and. If
+    the point started before the iterated range, `openStart` will be
+    `active.length + 1` to signal this.
+    */
+    point(from: number, to: number, value: T, active: readonly T[], openStart: number, index: number): void;
+}
+/**
+A range cursor is an object that moves to the next range every
+time you call `next` on it. Note that, unlike ES6 iterators, these
+start out pointing at the first element, so you should call `next`
+only after reading the first range (if any).
+*/
+interface RangeCursor<T> {
+    /**
+    Move the iterator forward.
+    */
+    next: () => void;
+    /**
+    The next range's value. Holds `null` when the cursor has reached
+    its end.
+    */
+    value: T | null;
+    /**
+    The next range's start position.
+    */
+    from: number;
+    /**
+    The next end position.
+    */
+    to: number;
+}
+declare type RangeSetUpdate<T extends RangeValue> = {
+    /**
+    An array of ranges to add. If given, this should be sorted by
+    `from` position and `startSide` unless
+    [`sort`](https://codemirror.net/6/docs/ref/#state.RangeSet.update^updateSpec.sort) is given as
+    `true`.
+    */
+    add?: readonly Range<T>[];
+    /**
+    Indicates whether the library should sort the ranges in `add`.
+    Defaults to `false`.
+    */
+    sort?: boolean;
+    /**
+    Filter the ranges already in the set. Only those for which this
+    function returns `true` are kept.
+    */
+    filter?: (from: number, to: number, value: T) => boolean;
+    /**
+    Can be used to limit the range on which the filter is
+    applied. Filtering only a small range, as opposed to the entire
+    set, can make updates cheaper.
+    */
+    filterFrom?: number;
+    /**
+    The end position to apply the filter to.
+    */
+    filterTo?: number;
+};
+/**
+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.
+*/
+declare class RangeSet<T extends RangeValue> {
+    private constructor();
+    /**
+    The number of ranges in the set.
+    */
+    get size(): number;
+    /**
+    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<U extends T>(updateSpec: RangeSetUpdate<U>): RangeSet<T>;
+    /**
+    Map this range set through a set of changes, return the new set.
+    */
+    map(changes: ChangeDesc): RangeSet<T>;
+    /**
+    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: number, to: number, f: (from: number, to: number, value: T) => void | false): void;
+    /**
+    Iterate over the ranges in this set, in order, including all
+    ranges that end at or after `from`.
+    */
+    iter(from?: number): RangeCursor<T>;
+    /**
+    Iterate over the ranges in a collection of sets, in order,
+    starting from `from`.
+    */
+    static iter<T extends RangeValue>(sets: readonly RangeSet<T>[], from?: number): RangeCursor<T>;
+    /**
+    Iterate over two groups of sets, calling methods on `comparator`
+    to notify it of possible differences.
+    */
+    static compare<T extends RangeValue>(oldSets: readonly RangeSet<T>[], newSets: readonly RangeSet<T>[], 
+    /**
+    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: ChangeDesc, comparator: RangeComparator<T>, 
+    /**
+    Can be used to ignore all non-point ranges, and points below
+    the given size. When -1, all ranges are compared.
+    */
+    minPointSize?: number): void;
+    /**
+    Compare the contents of two groups of range sets, returning true
+    if they are equivalent in the given range.
+    */
+    static eq<T extends RangeValue>(oldSets: readonly RangeSet<T>[], newSets: readonly RangeSet<T>[], from?: number, to?: number): boolean;
+    /**
+    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<T extends RangeValue>(sets: readonly RangeSet<T>[], from: number, to: number, iterator: SpanIterator<T>, 
+    /**
+    When given and greater than -1, only points of at least this
+    size are taken into account.
+    */
+    minPointSize?: number): number;
+    /**
+    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<T extends RangeValue>(ranges: readonly Range<T>[] | Range<T>, sort?: boolean): RangeSet<T>;
+    /**
+    The empty set of ranges.
+    */
+    static empty: RangeSet<any>;
+}
+/**
+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.
+*/
+declare class RangeSetBuilder<T extends RangeValue> {
+    private chunks;
+    private chunkPos;
+    private chunkStart;
+    private last;
+    private lastFrom;
+    private lastTo;
+    private from;
+    private to;
+    private value;
+    private maxPoint;
+    private setMaxPoint;
+    private nextLayer;
+    private finishChunk;
+    /**
+    Create an empty builder.
+    */
+    constructor();
+    /**
+    Add a range. Ranges should be added in sorted (by `from` and
+    `value.startSide`) order.
+    */
+    add(from: number, to: number, value: T): void;
+    /**
+    Finish the range set. Returns the new set. The builder can't be
+    used anymore after this has been called.
+    */
+    finish(): RangeSet<T>;
+}
+
+/**
+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.
+*/
+declare function findClusterBreak(str: string, pos: number, forward?: boolean, includeExtending?: boolean): number;
+/**
+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).
+*/
+declare function codePointAt(str: string, pos: number): number;
+/**
+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)).
+*/
+declare function fromCodePoint(code: number): string;
+/**
+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.
+*/
+declare function codePointSize(code: number): 1 | 2;
+
+/**
+Count the column position at the given offset into the string,
+taking extending characters and tab size into account.
+*/
+declare function countColumn(string: string, tabSize: number, to?: number): number;
+/**
+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.
+*/
+declare function findColumn(string: string, col: number, tabSize: number, strict?: boolean): number;
+
+export { Annotation, AnnotationType, ChangeDesc, ChangeSet, ChangeSpec, CharCategory, Compartment, EditorSelection, EditorState, EditorStateConfig, Extension, Facet, Line, MapMode, Prec, Range, RangeComparator, RangeCursor, RangeSet, RangeSetBuilder, RangeValue, SelectionRange, SpanIterator, StateCommand, StateEffect, StateEffectType, StateField, Text, TextIterator, Transaction, TransactionSpec, codePointAt, codePointSize, combineConfig, countColumn, findClusterBreak, findColumn, fromCodePoint };