chrome-devtools-frontend 1.0.945579 → 1.0.946920

package/front_end/third_party/codemirror.next/codemirror.next.d.ts

@@ -169,6 +169,7 @@ interface SyntaxNode {
     prevSibling: SyntaxNode | null;
     cursor: TreeCursor;
     resolve(pos: number, side?: -1 | 0 | 1): SyntaxNode;
+    resolveInner(pos: number, side?: -1 | 0 | 1): SyntaxNode;
     enterUnfinishedNodesBefore(pos: number): SyntaxNode;
     tree: Tree | null;
     toTree(): Tree;
@@ -1583,1932 +1584,1988 @@ declare type StateCommand = (target: {
 }) => boolean;
 
 /**
-A language object manages parsing and per-language
-[metadata](https://codemirror.net/6/docs/ref/#state.EditorState.languageDataAt). Parse data is
-managed as a [Lezer](https://lezer.codemirror.net) tree. You'll
-want to subclass this class for custom parsers, or use the
-[`LRLanguage`](https://codemirror.net/6/docs/ref/#language.LRLanguage) or
-[`StreamLanguage`](https://codemirror.net/6/docs/ref/#stream-parser.StreamLanguage) abstractions for
-[Lezer](https://lezer.codemirror.net/) or stream parsers.
+Each range is associated with a value, which must inherit from
+this class.
 */
-declare class Language {
-    /**
-    The [language data](https://codemirror.net/6/docs/ref/#state.EditorState.languageDataAt) data
-    facet used for this language.
-    */
-    readonly data: Facet<{
-        [name: string]: any;
-    }>;
+declare abstract class RangeValue {
     /**
-    The node type of the top node of trees produced by this parser.
+    Compare this value with another value. The default
+    implementation compares by identity.
     */
-    readonly topNode: NodeType;
+    eq(other: RangeValue): boolean;
     /**
-    The extension value to install this provider.
+    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.
     */
-    readonly extension: Extension;
+    startSide: number;
     /**
-    The parser object. Can be useful when using this as a [nested
-    parser](https://lezer.codemirror.net/docs/ref#common.Parser).
+    The bias value at the end of the range. Defaults to 0.
     */
-    parser: Parser;
+    endSide: number;
     /**
-    Construct a language object. You usually don't need to invoke
-    this directly. But when you do, make sure you use
-    [`defineLanguageFacet`](https://codemirror.net/6/docs/ref/#language.defineLanguageFacet) to create
-    the first argument.
+    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`.
     */
-    constructor(
+    mapMode: MapMode;
     /**
-    The [language data](https://codemirror.net/6/docs/ref/#state.EditorState.languageDataAt) data
-    facet used for this language.
+    Whether this value marks a point range, which is treated as
+    atomic and shadows the ranges contained in it.
     */
-    data: Facet<{
-        [name: string]: any;
-    }>, parser: Parser,
+    point: boolean;
     /**
-    The node type of the top node of trees produced by this parser.
+    Create a [range](https://codemirror.net/6/docs/ref/#rangeset.Range) with this value.
     */
-    topNode: NodeType, extraExtensions?: Extension[]);
+    range(from: number, to?: number): Range<this>;
+}
+/**
+A range associates a value with a range of positions.
+*/
+declare class Range<T extends RangeValue> {
     /**
-    Query whether this language is active at the given position.
+    The range's start position.
     */
-    isActiveAt(state: EditorState, pos: number, side?: -1 | 0 | 1): boolean;
+    readonly from: number;
     /**
-    Find the document regions that were parsed using this language.
-    The returned regions will _include_ any nested languages rooted
-    in this language, when those exist.
+    Its end position.
     */
-    findRegions(state: EditorState): {
-        from: number;
-        to: number;
-    }[];
+    readonly to: number;
     /**
-    Indicates whether this language allows nested languages. The
-    default implementation returns true.
+    The value associated with this range.
     */
-    get allowsNesting(): boolean;
+    readonly value: T;
 }
 /**
-A subclass of [`Language`](https://codemirror.net/6/docs/ref/#language.Language) for use with Lezer
-[LR parsers](https://lezer.codemirror.net/docs/ref#lr.LRParser)
-parsers.
+Collection of methods used when comparing range sets.
 */
-declare class LRLanguage extends Language {
-    readonly parser: LRParser;
-    private constructor();
+interface RangeComparator<T extends RangeValue> {
     /**
-    Define a language from a parser.
+    Notifies the comparator that the given range has the given set
+    of values associated with it.
     */
-    static define(spec: {
-        /**
-        The parser to use. Should already have added editor-relevant
-        node props (and optionally things like dialect and top rule)
-        configured.
-        */
-        parser: LRParser;
-        /**
-        [Language data](https://codemirror.net/6/docs/ref/#state.EditorState.languageDataAt)
-        to register for this language.
-        */
-        languageData?: {
-            [name: string]: any;
-        };
-    }): LRLanguage;
+    compareRange(from: number, to: number, activeA: T[], activeB: T[]): void;
     /**
-    Create a new instance of this language with a reconfigured
-    version of its parser.
+    Notification for a point range.
     */
-    configure(options: ParserConfig): LRLanguage;
-    get allowsNesting(): boolean;
+    comparePoint(from: number, to: number, byA: T | null, byB: T | null): void;
 }
 /**
-Get the syntax tree for a state, which is the current (possibly
-incomplete) parse tree of active [language](https://codemirror.net/6/docs/ref/#language.Language),
-or the empty tree if there is no language available.
-*/
-declare function syntaxTree(state: EditorState): Tree;
-/**
-Try to get a parse tree that spans at least up to `upto`. The
-method will do at most `timeout` milliseconds of work to parse
-up to that point if the tree isn't already available.
+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.
 */
-declare function ensureSyntaxTree(state: EditorState, upto: number, timeout?: number): Tree | null;
+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): void;
+}
 /**
-This class bundles a [language object](https://codemirror.net/6/docs/ref/#language.Language) with an
-optional set of supporting extensions. Language packages are
-encouraged to export a function that optionally takes a
-configuration object and returns a `LanguageSupport` instance, as
-the main way for client code to use the package.
+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).
 */
-declare class LanguageSupport {
+interface RangeCursor<T> {
     /**
-    The language object.
+    Move the iterator forward.
     */
-    readonly language: Language;
+    next: () => void;
     /**
-    An optional set of supporting extensions. When nesting a
-    language in another language, the outer language is encouraged
-    to include the supporting extensions for its inner languages
-    in its own set of support extensions.
+    The next range's value. Holds `null` when the cursor has reached
+    its end.
     */
-    readonly support: Extension;
+    value: T | null;
     /**
-    An extension including both the language and its support
-    extensions. (Allowing the object to be used as an extension
-    value itself.)
+    The next range's start position.
     */
-    extension: Extension;
+    from: number;
     /**
-    Create a support object.
+    The next end position.
     */
-    constructor(
+    to: number;
+}
+declare type RangeSetUpdate<T extends RangeValue> = {
     /**
-    The language object.
+    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/#rangeset.RangeSet.update^updateSpec.sort) is given as
+    `true`.
     */
-    language: Language,
+    add?: readonly Range<T>[];
     /**
-    An optional set of supporting extensions. When nesting a
-    language in another language, the outer language is encouraged
-    to include the supporting extensions for its inner languages
-    in its own set of support extensions.
+    Indicates whether the library should sort the ranges in `add`.
+    Defaults to `false`.
     */
-    support?: Extension);
-}
-/**
-Language descriptions are used to store metadata about languages
-and to dynamically load them. Their main role is finding the
-appropriate language for a filename or dynamically loading nested
-parsers.
-*/
-declare class LanguageDescription {
+    sort?: boolean;
     /**
-    The name of this language.
+    Filter the ranges already in the set. Only those for which this
+    function returns `true` are kept.
     */
-    readonly name: string;
+    filter?: (from: number, to: number, value: T) => boolean;
     /**
-    Alternative names for the mode (lowercased, includes `this.name`).
+    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.
     */
-    readonly alias: readonly string[];
+    filterFrom?: number;
     /**
-    File extensions associated with this language.
+    The end position to apply the filter to.
     */
-    readonly extensions: readonly string[];
+    filterTo?: number;
+};
+/**
+A range set stores a collection of [ranges](https://codemirror.net/6/docs/ref/#rangeset.Range) in a
+way that makes them efficient to [map](https://codemirror.net/6/docs/ref/#rangeset.RangeSet.map) and
+[update](https://codemirror.net/6/docs/ref/#rangeset.RangeSet.update). This is an immutable data
+structure.
+*/
+declare class RangeSet<T extends RangeValue> {
     /**
-    Optional filename pattern that should be associated with this
-    language.
+    The number of ranges in the set.
     */
-    readonly filename: RegExp | undefined;
-    private loadFunc;
+    get size(): number;
     /**
-    If the language has been loaded, this will hold its value.
+    Update the range set, optionally adding new ranges or filtering
+    out existing ones.
+
+    (The extra 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`.)
     */
-    support: LanguageSupport | undefined;
-    private loading;
-    private constructor();
+    update<U extends T>(updateSpec: RangeSetUpdate<U>): RangeSet<T>;
     /**
-    Start loading the the language. Will return a promise that
-    resolves to a [`LanguageSupport`](https://codemirror.net/6/docs/ref/#language.LanguageSupport)
-    object when the language successfully loads.
+    Map this range set through a set of changes, return the new set.
     */
-    load(): Promise<LanguageSupport>;
+    map(changes: ChangeDesc): RangeSet<T>;
     /**
-    Create a language description.
+    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.
     */
-    static of(spec: {
-        /**
-        The language's name.
-        */
-        name: string;
-        /**
-        An optional array of alternative names.
-        */
-        alias?: readonly string[];
-        /**
-        An optional array of extensions associated with this language.
-        */
-        extensions?: readonly string[];
-        /**
-        An optional filename pattern associated with this language.
-        */
-        filename?: RegExp;
-        /**
-        A function that will asynchronously load the language.
-        */
-        load: () => Promise<LanguageSupport>;
-    }): LanguageDescription;
+    between(from: number, to: number, f: (from: number, to: number, value: T) => void | false): void;
     /**
-    Look for a language in the given array of descriptions that
-    matches the filename. Will first match
-    [`filename`](https://codemirror.net/6/docs/ref/#language.LanguageDescription.filename) patterns,
-    and then [extensions](https://codemirror.net/6/docs/ref/#language.LanguageDescription.extensions),
-    and return the first language that matches.
+    Iterate over the ranges in this set, in order, including all
+    ranges that end at or after `from`.
     */
-    static matchFilename(descs: readonly LanguageDescription[], filename: string): LanguageDescription | null;
+    iter(from?: number): RangeCursor<T>;
     /**
-    Look for a language whose name or alias matches the the given
-    name (case-insensitively). If `fuzzy` is true, and no direct
-    matchs is found, this'll also search for a language whose name
-    or alias occurs in the string (for names shorter than three
-    characters, only when surrounded by non-word characters).
+    Iterate over the ranges in a collection of sets, in order,
+    starting from `from`.
     */
-    static matchLanguageName(descs: readonly LanguageDescription[], name: string, fuzzy?: boolean): LanguageDescription | null;
-}
-/**
-Facet for overriding the unit by which indentation happens.
-Should be a string consisting either entirely of spaces or
-entirely of tabs. When not set, this defaults to 2 spaces.
-*/
-declare const indentUnit: Facet<string, string>;
-/**
-Indentation contexts are used when calling [indentation
-services](https://codemirror.net/6/docs/ref/#language.indentService). They provide helper utilities
-useful in indentation logic, and can selectively override the
-indentation reported for some lines.
-*/
-declare class IndentContext {
+    static iter<T extends RangeValue>(sets: readonly RangeSet<T>[], from?: number): RangeCursor<T>;
     /**
-    The editor state.
+    Iterate over two groups of sets, calling methods on `comparator`
+    to notify it of possible differences.
     */
-    readonly state: EditorState;
+    static compare<T extends RangeValue>(oldSets: readonly RangeSet<T>[], newSets: readonly RangeSet<T>[],
     /**
-    The indent unit (number of columns per indentation level).
+    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.
     */
-    unit: number;
+    textDiff: ChangeDesc, comparator: RangeComparator<T>,
     /**
-    Create an indent context.
+    Can be used to ignore all non-point ranges, and points below
+    the given size. When -1, all ranges are compared.
     */
-    constructor(
+    minPointSize?: number): void;
     /**
-    The editor state.
+    Compare the contents of two groups of range sets, returning true
+    if they are equivalent in the given range.
     */
-    state: EditorState,
+    static eq<T extends RangeValue>(oldSets: readonly RangeSet<T>[], newSets: readonly RangeSet<T>[], from?: number, to?: number): boolean;
     /**
-    @internal
+    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/#rangeset.SpanIterator.span)) at the end
+    of the iteration.
     */
-    options?: {
-        /**
-        Override line indentations provided to the indentation
-        helper function, which is useful when implementing region
-        indentation, where indentation for later lines needs to refer
-        to previous lines, which may have been reindented compared to
-        the original start state. If given, this function should
-        return -1 for lines (given by start position) that didn't
-        change, and an updated indentation otherwise.
-        */
-        overrideIndentation?: (pos: number) => number;
-        /**
-        Make it look, to the indent logic, like a line break was
-        added at the given position (which is mostly just useful for
-        implementing something like
-        [`insertNewlineAndIndent`](https://codemirror.net/6/docs/ref/#commands.insertNewlineAndIndent)).
-        */
-        simulateBreak?: number;
-        /**
-        When `simulateBreak` is given, this can be used to make the
-        simulate break behave like a double line break.
-        */
-        simulateDoubleBreak?: boolean;
-    });
+    static spans<T extends RangeValue>(sets: readonly RangeSet<T>[], from: number, to: number, iterator: SpanIterator<T>,
     /**
-    Get a description of the line at the given position, taking
-    [simulated line
-    breaks](https://codemirror.net/6/docs/ref/#language.IndentContext.constructor^options.simulateBreak)
-    into account. If there is such a break at `pos`, the `bias`
-    argument determines whether the part of the line line before or
-    after the break is used.
+    When given and greater than -1, only points of at least this
+    size are taken into account.
     */
-    lineAt(pos: number, bias?: -1 | 1): {
-        text: string;
-        from: number;
-    };
+    minPointSize?: number): number;
     /**
-    Get the text directly after `pos`, either the entire line
-    or the next 100 characters, whichever is shorter.
+    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.
     */
-    textAfterPos(pos: number, bias?: -1 | 1): string;
+    static of<T extends RangeValue>(ranges: readonly Range<T>[] | Range<T>, sort?: boolean): RangeSet<T>;
     /**
-    Find the column for the given position.
+    The empty set of ranges.
     */
-    column(pos: number, bias?: -1 | 1): number;
+    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/#rangeset.RangeSet) directly, without first allocating
+an array of [`Range`](https://codemirror.net/6/docs/ref/#rangeset.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;
     /**
-    Find the column position (taking tabs into account) of the given
-    position in the given string.
+    Create an empty builder.
     */
-    countColumn(line: string, pos?: number): number;
+    constructor();
     /**
-    Find the indentation column of the line at the given point.
+    Add a range. Ranges should be added in sorted (by `from` and
+    `value.startSide`) order.
     */
-    lineIndent(pos: number, bias?: -1 | 1): number;
+    add(from: number, to: number, value: T): void;
     /**
-    Returns the [simulated line
-    break](https://codemirror.net/6/docs/ref/#language.IndentContext.constructor^options.simulateBreak)
-    for this context, if any.
+    Finish the range set. Returns the new set. The builder can't be
+    used anymore after this has been called.
     */
-    get simulatedBreak(): number | null;
+    finish(): RangeSet<T>;
 }
-/**
-Enables reindentation on input. When a language defines an
-`indentOnInput` field in its [language
-data](https://codemirror.net/6/docs/ref/#state.EditorState.languageDataAt), which must hold a regular
-expression, the line at the cursor will be reindented whenever new
-text is typed and the input from the start of the line up to the
-cursor matches that regexp.
 
-To avoid unneccesary reindents, it is recommended to start the
-regexp with `^` (usually followed by `\s*`), and end it with `$`.
-For example, `/^\s*\}$/` will reindent when a closing brace is
-added at the start of a line.
-*/
-declare function indentOnInput(): Extension;
+declare class StyleModule {
+  constructor(spec: {[selector: string]: StyleSpec}, options?: {
+    finish?(sel: string): string
+  })
+  getRules(): string
+  static mount(root: Document | ShadowRoot | DocumentOrShadowRoot, module: StyleModule | ReadonlyArray<StyleModule>): void
+  static newName(): string
+}
 
-/**
-Each range is associated with a value, which must inherit from
-this class.
-*/
-declare abstract class RangeValue {
+type StyleSpec = {
+  [propOrSelector: string]: string | number | StyleSpec | null
+}
+
+declare type Attrs = {
+    [name: string]: string;
+};
+
+interface MarkDecorationSpec {
     /**
-    Compare this value with another value. The default
-    implementation compares by identity.
+    Whether the mark covers its start and end position or not. This
+    influences whether content inserted at those positions becomes
+    part of the mark. Defaults to false.
     */
-    eq(other: RangeValue): boolean;
+    inclusive?: 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.
+    Specify whether the start position of the marked range should be
+    inclusive. Overrides `inclusive`, when both are present.
     */
-    startSide: number;
+    inclusiveStart?: boolean;
     /**
-    The bias value at the end of the range. Defaults to 0.
+    Whether the end should be inclusive.
     */
-    endSide: number;
+    inclusiveEnd?: boolean;
     /**
-    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`.
+    Add attributes to the DOM elements that hold the text in the
+    marked range.
     */
-    mapMode: MapMode;
+    attributes?: {
+        [key: string]: string;
+    };
     /**
-    Whether this value marks a point range, which is treated as
-    atomic and shadows the ranges contained in it.
+    Shorthand for `{attributes: {class: value}}`.
     */
-    point: boolean;
+    class?: string;
     /**
-    Create a [range](https://codemirror.net/6/docs/ref/#rangeset.Range) with this value.
+    Add a wrapping element around the text in the marked range. Note
+    that there will not be a single element covering the entire
+    range—content is split on mark starts and ends, and each piece
+    gets its own element.
     */
-    range(from: number, to?: number): Range<this>;
-}
-/**
-A range associates a value with a range of positions.
-*/
-declare class Range<T extends RangeValue> {
+    tagName?: string;
     /**
-    The range's start position.
+    Decoration specs allow extra properties, which can be retrieved
+    through the decoration's [`spec`](https://codemirror.net/6/docs/ref/#view.Decoration.spec)
+    property.
     */
-    readonly from: number;
+    [other: string]: any;
+}
+interface WidgetDecorationSpec {
     /**
-    Its end position.
+    The type of widget to draw here.
     */
-    readonly to: number;
+    widget: WidgetType;
     /**
-    The value associated with this range.
+    Which side of the given position the widget is on. When this is
+    positive, the widget will be drawn after the cursor if the
+    cursor is on the same position. Otherwise, it'll be drawn before
+    it. When multiple widgets sit at the same position, their `side`
+    values will determine their ordering—those with a lower value
+    come first. Defaults to 0.
     */
-    readonly value: T;
-}
-/**
-Collection of methods used when comparing range sets.
-*/
-interface RangeComparator<T extends RangeValue> {
+    side?: number;
     /**
-    Notifies the comparator that the given range has the given set
-    of values associated with it.
+    Determines whether this is a block widgets, which will be drawn
+    between lines, or an inline widget (the default) which is drawn
+    between the surrounding text.
+
+    Note that block-level decorations should not have vertical
+    margins, and if you dynamically change their height, you should
+    make sure to call
+    [`requestMeasure`](https://codemirror.net/6/docs/ref/#view.EditorView.requestMeasure), so that the
+    editor can update its information about its vertical layout.
     */
-    compareRange(from: number, to: number, activeA: T[], activeB: T[]): void;
+    block?: boolean;
     /**
-    Notification for a point range.
+    Other properties are allowed.
     */
-    comparePoint(from: number, to: number, byA: T | null, byB: T | null): void;
+    [other: string]: any;
 }
-/**
-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> {
+interface ReplaceDecorationSpec {
     /**
-    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.
+    An optional widget to drawn in the place of the replaced
+    content.
     */
-    span(from: number, to: number, active: readonly T[], openStart: number): void;
+    widget?: WidgetType;
     /**
-    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.
+    Whether this range covers the positions on its sides. This
+    influences whether new content becomes part of the range and
+    whether the cursor can be drawn on its sides. Defaults to false
+    for inline replacements, and true for block replacements.
     */
-    point(from: number, to: number, value: T, active: readonly T[], openStart: 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> {
+    inclusive?: boolean;
     /**
-    Move the iterator forward.
+    Set inclusivity at the start.
     */
-    next: () => void;
+    inclusiveStart?: boolean;
     /**
-    The next range's value. Holds `null` when the cursor has reached
-    its end.
+    Set inclusivity at the end.
     */
-    value: T | null;
+    inclusiveEnd?: boolean;
     /**
-    The next range's start position.
+    Whether this is a block-level decoration. Defaults to false.
     */
-    from: number;
+    block?: boolean;
     /**
-    The next end position.
+    Other properties are allowed.
     */
-    to: number;
+    [other: string]: any;
 }
-declare type RangeSetUpdate<T extends RangeValue> = {
+interface LineDecorationSpec {
     /**
-    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/#rangeset.RangeSet.update^updateSpec.sort) is given as
-    `true`.
+    DOM attributes to add to the element wrapping the line.
     */
-    add?: readonly Range<T>[];
+    attributes?: {
+        [key: string]: string;
+    };
     /**
-    Indicates whether the library should sort the ranges in `add`.
-    Defaults to `false`.
+    Shorthand for `{attributes: {class: value}}`.
     */
-    sort?: boolean;
+    class?: string;
     /**
-    Filter the ranges already in the set. Only those for which this
-    function returns `true` are kept.
+    Other properties are allowed.
     */
-    filter?: (from: number, to: number, value: T) => boolean;
+    [other: string]: any;
+}
+/**
+Widgets added to the content are described by subclasses of this
+class. Using a description object like that makes it possible to
+delay creating of the DOM structure for a widget until it is
+needed, and to avoid redrawing widgets even when the decorations
+that define them are recreated.
+*/
+declare abstract class WidgetType {
     /**
-    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.
+    Build the DOM structure for this widget instance.
     */
-    filterFrom?: number;
+    abstract toDOM(view: EditorView): HTMLElement;
     /**
-    The end position to apply the filter to.
+    Compare this instance to another instance of the same type.
+    (TypeScript can't express this, but only instances of the same
+    specific class will be passed to this method.) This is used to
+    avoid redrawing widgets when they are replaced by a new
+    decoration of the same type. The default implementation just
+    returns `false`, which will cause new instances of the widget to
+    always be redrawn.
     */
-    filterTo?: number;
-};
-/**
-A range set stores a collection of [ranges](https://codemirror.net/6/docs/ref/#rangeset.Range) in a
-way that makes them efficient to [map](https://codemirror.net/6/docs/ref/#rangeset.RangeSet.map) and
-[update](https://codemirror.net/6/docs/ref/#rangeset.RangeSet.update). This is an immutable data
-structure.
-*/
-declare class RangeSet<T extends RangeValue> {
+    eq(_widget: WidgetType): boolean;
     /**
-    The number of ranges in the set.
+    Update a DOM element created by a widget of the same type (but
+    different, non-`eq` content) to reflect this widget. May return
+    true to indicate that it could update, false to indicate it
+    couldn't (in which case the widget will be redrawn). The default
+    implementation just returns false.
     */
-    get size(): number;
+    updateDOM(_dom: HTMLElement): boolean;
     /**
-    Update the range set, optionally adding new ranges or filtering
-    out existing ones.
-
-    (The extra 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`.)
+    The estimated height this widget will have, to be used when
+    estimating the height of content that hasn't been drawn. May
+    return -1 to indicate you don't know. The default implementation
+    returns -1.
     */
-    update<U extends T>(updateSpec: RangeSetUpdate<U>): RangeSet<T>;
+    get estimatedHeight(): number;
     /**
-    Map this range set through a set of changes, return the new set.
+    Can be used to configure which kinds of events inside the widget
+    should be ignored by the editor. The default is to ignore all
+    events.
     */
-    map(changes: ChangeDesc): RangeSet<T>;
+    ignoreEvent(_event: Event): boolean;
+}
+/**
+A decoration set represents a collection of decorated ranges,
+organized for efficient access and mapping. See
+[`RangeSet`](https://codemirror.net/6/docs/ref/#rangeset.RangeSet) for its methods.
+*/
+declare type DecorationSet = RangeSet<Decoration>;
+/**
+The different types of blocks that can occur in an editor view.
+*/
+declare enum BlockType {
     /**
-    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.
+    A line of text.
     */
-    between(from: number, to: number, f: (from: number, to: number, value: T) => void | false): void;
+    Text = 0,
     /**
-    Iterate over the ranges in this set, in order, including all
-    ranges that end at or after `from`.
+    A block widget associated with the position after it.
     */
-    iter(from?: number): RangeCursor<T>;
+    WidgetBefore = 1,
     /**
-    Iterate over the ranges in a collection of sets, in order,
-    starting from `from`.
+    A block widget associated with the position before it.
     */
-    static iter<T extends RangeValue>(sets: readonly RangeSet<T>[], from?: number): RangeCursor<T>;
+    WidgetAfter = 2,
     /**
-    Iterate over two groups of sets, calling methods on `comparator`
-    to notify it of possible differences.
+    A block widget [replacing](https://codemirror.net/6/docs/ref/#view.Decoration^replace) a range of content.
     */
-    static compare<T extends RangeValue>(oldSets: readonly RangeSet<T>[], newSets: readonly RangeSet<T>[],
+    WidgetRange = 3
+}
+/**
+A decoration provides information on how to draw or style a piece
+of content. You'll usually use it wrapped in a
+[`Range`](https://codemirror.net/6/docs/ref/#rangeset.Range), which adds a start and end position.
+*/
+declare abstract class Decoration extends RangeValue {
     /**
-    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.
+    The config object used to create this decoration. You can
+    include additional properties in there to store metadata about
+    your decoration.
     */
-    textDiff: ChangeDesc, comparator: RangeComparator<T>,
+    readonly spec: any;
+    abstract eq(other: Decoration): boolean;
     /**
-    Can be used to ignore all non-point ranges, and points below
-    the given size. When -1, all ranges are compared.
+    Create a mark decoration, which influences the styling of the
+    content in its range. Nested mark decorations will cause nested
+    DOM elements to be created. Nesting order is determined by
+    precedence of the [facet](https://codemirror.net/6/docs/ref/#view.EditorView^decorations) or
+    (below the facet-provided decorations) [view
+    plugin](https://codemirror.net/6/docs/ref/#view.PluginSpec.decorations). Such elements are split
+    on line boundaries and on the boundaries of higher-precedence
+    decorations.
     */
-    minPointSize?: number): void;
+    static mark(spec: MarkDecorationSpec): Decoration;
     /**
-    Compare the contents of two groups of range sets, returning true
-    if they are equivalent in the given range.
+    Create a widget decoration, which adds an element at the given
+    position.
     */
-    static eq<T extends RangeValue>(oldSets: readonly RangeSet<T>[], newSets: readonly RangeSet<T>[], from?: number, to?: number): boolean;
+    static widget(spec: WidgetDecorationSpec): Decoration;
     /**
-    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/#rangeset.SpanIterator.span)) at the end
-    of the iteration.
+    Create a replace decoration which replaces the given range with
+    a widget, or simply hides it.
     */
-    static spans<T extends RangeValue>(sets: readonly RangeSet<T>[], from: number, to: number, iterator: SpanIterator<T>,
+    static replace(spec: ReplaceDecorationSpec): Decoration;
     /**
-    When given and greater than -1, only points of at least this
-    size are taken into account.
+    Create a line decoration, which can add DOM attributes to the
+    line starting at the given position.
     */
-    minPointSize?: number): number;
+    static line(spec: LineDecorationSpec): Decoration;
     /**
-    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.
+    Build a [`DecorationSet`](https://codemirror.net/6/docs/ref/#view.DecorationSet) from the given
+    decorated range or ranges. If the ranges aren't already sorted,
+    pass `true` for `sort` to make the library sort them for you.
     */
-    static of<T extends RangeValue>(ranges: readonly Range<T>[] | Range<T>, sort?: boolean): RangeSet<T>;
+    static set(of: Range<Decoration> | readonly Range<Decoration>[], sort?: boolean): DecorationSet;
     /**
-    The empty set of ranges.
+    The empty set of decorations.
     */
-    static empty: RangeSet<any>;
+    static none: DecorationSet;
 }
+
 /**
-A range set builder is a data structure that helps build up a
-[range set](https://codemirror.net/6/docs/ref/#rangeset.RangeSet) directly, without first allocating
-an array of [`Range`](https://codemirror.net/6/docs/ref/#rangeset.Range) objects.
+Basic rectangle type.
 */
-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();
+interface Rect {
+    readonly left: number;
+    readonly right: number;
+    readonly top: number;
+    readonly bottom: number;
+}
+
+/**
+Command functions are used in key bindings and other types of user
+actions. Given an editor view, they check whether their effect can
+apply to the editor, and if it can, perform it as a side effect
+(which usually means [dispatching](https://codemirror.net/6/docs/ref/#view.EditorView.dispatch) a
+transaction) and return `true`.
+*/
+declare type Command = (target: EditorView) => boolean;
+/**
+This is the interface plugin objects conform to.
+*/
+interface PluginValue {
     /**
-    Add a range. Ranges should be added in sorted (by `from` and
-    `value.startSide`) order.
+    Notifies the plugin of an update that happened in the view. This
+    is called _before_ the view updates its own DOM. It is
+    responsible for updating the plugin's internal state (including
+    any state that may be read by plugin fields) and _writing_ to
+    the DOM for the changes in the update. To avoid unnecessary
+    layout recomputations, it should _not_ read the DOM layout—use
+    [`requestMeasure`](https://codemirror.net/6/docs/ref/#view.EditorView.requestMeasure) to schedule
+    your code in a DOM reading phase if you need to.
     */
-    add(from: number, to: number, value: T): void;
+    update?(_update: ViewUpdate): void;
     /**
-    Finish the range set. Returns the new set. The builder can't be
-    used anymore after this has been called.
+    Called when the plugin is no longer going to be used. Should
+    revert any changes the plugin made to the DOM.
     */
-    finish(): RangeSet<T>;
-}
-
-declare class StyleModule {
-  constructor(spec: {[selector: string]: StyleSpec}, options?: {
-    finish?(sel: string): string
-  })
-  getRules(): string
-  static mount(root: Document | ShadowRoot | DocumentOrShadowRoot, module: StyleModule | ReadonlyArray<StyleModule>): void
-  static newName(): string
+    destroy?(): void;
 }
-
-type StyleSpec = {
-  [propOrSelector: string]: string | number | StyleSpec | null
+declare const isFieldProvider: unique symbol;
+/**
+Used to [declare](https://codemirror.net/6/docs/ref/#view.PluginSpec.provide) which
+[fields](https://codemirror.net/6/docs/ref/#view.PluginValue) a [view plugin](https://codemirror.net/6/docs/ref/#view.ViewPlugin)
+provides.
+*/
+declare class PluginFieldProvider<V> {
+    private [isFieldProvider];
 }
-
-declare type Attrs = {
-    [name: string]: string;
-};
-
-interface MarkDecorationSpec {
+/**
+Plugin fields are a mechanism for allowing plugins to provide
+values that can be retrieved through the
+[`pluginField`](https://codemirror.net/6/docs/ref/#view.EditorView.pluginField) view method.
+*/
+declare class PluginField<T> {
     /**
-    Whether the mark covers its start and end position or not. This
-    influences whether content inserted at those positions becomes
-    part of the mark. Defaults to false.
+    Create a [provider](https://codemirror.net/6/docs/ref/#view.PluginFieldProvider) for this field,
+    to use with a plugin's [provide](https://codemirror.net/6/docs/ref/#view.PluginSpec.provide)
+    option.
     */
-    inclusive?: boolean;
+    from<V extends PluginValue>(get: (value: V) => T): PluginFieldProvider<V>;
     /**
-    Specify whether the start position of the marked range should be
-    inclusive. Overrides `inclusive`, when both are present.
+    Define a new plugin field.
     */
-    inclusiveStart?: boolean;
+    static define<T>(): PluginField<T>;
     /**
-    Whether the end should be inclusive.
+    This field can be used by plugins to provide
+    [decorations](https://codemirror.net/6/docs/ref/#view.Decoration).
+
+    **Note**: For reasons of data flow (plugins are only updated
+    after the viewport is computed), decorations produced by plugins
+    are _not_ taken into account when predicting the vertical layout
+    structure of the editor. Thus, things like large widgets or big
+    replacements (i.e. code folding) should be provided through the
+    state-level [`decorations` facet](https://codemirror.net/6/docs/ref/#view.EditorView^decorations),
+    not this plugin field. Specifically, replacing decorations that
+    cross line boundaries will break if provided through a plugin.
     */
-    inclusiveEnd?: boolean;
+    static decorations: PluginField<DecorationSet>;
     /**
-    Add attributes to the DOM elements that hold the text in the
-    marked range.
+    Used to provide ranges that should be treated as atoms as far as
+    cursor motion is concerned. This causes methods like
+    [`moveByChar`](https://codemirror.net/6/docs/ref/#view.EditorView.moveByChar) and
+    [`moveVertically`](https://codemirror.net/6/docs/ref/#view.EditorView.moveVertically) (and the
+    commands built on top of them) to skip across such regions when
+    a selection endpoint would enter them. This does _not_ prevent
+    direct programmatic [selection
+    updates](https://codemirror.net/6/docs/ref/#state.TransactionSpec.selection) from moving into such
+    regions.
     */
-    attributes?: {
-        [key: string]: string;
-    };
+    static atomicRanges: PluginField<RangeSet<any>>;
     /**
-    Shorthand for `{attributes: {class: value}}`.
+    Plugins can provide additional scroll margins (space around the
+    sides of the scrolling element that should be considered
+    invisible) through this field. This can be useful when the
+    plugin introduces elements that cover part of that element (for
+    example a horizontally fixed gutter).
     */
-    class?: string;
+    static scrollMargins: PluginField<Partial<Rect> | null>;
+}
+/**
+Provides additional information when defining a [view
+plugin](https://codemirror.net/6/docs/ref/#view.ViewPlugin).
+*/
+interface PluginSpec<V extends PluginValue> {
     /**
-    Add a wrapping element around the text in the marked range. Note
-    that there will not be a single element covering the entire
-    range—content is split on mark starts and ends, and each piece
-    gets its own element.
+    Register the given [event
+    handlers](https://codemirror.net/6/docs/ref/#view.EditorView^domEventHandlers) for the plugin.
+    When called, these will have their `this` bound to the plugin
+    value.
     */
-    tagName?: string;
+    eventHandlers?: DOMEventHandlers<V>;
     /**
-    Decoration specs allow extra properties, which can be retrieved
-    through the decoration's [`spec`](https://codemirror.net/6/docs/ref/#view.Decoration.spec)
-    property.
+    Allow the plugin to provide decorations. When given, this should
+    a function that take the plugin value and return a [decoration
+    set](https://codemirror.net/6/docs/ref/#view.DecorationSet). See also the caveat about
+    [layout-changing decorations](https://codemirror.net/6/docs/ref/#view.PluginField^decorations)
+    from plugins.
     */
-    [other: string]: any;
-}
-interface WidgetDecorationSpec {
+    decorations?: (value: V) => DecorationSet;
     /**
-    The type of widget to draw here.
+    Specify that the plugin provides [plugin
+    field](https://codemirror.net/6/docs/ref/#view.PluginField) values. Use a field's
+    [`from`](https://codemirror.net/6/docs/ref/#view.PluginField.from) method to create these
+    providers.
     */
-    widget: WidgetType;
+    provide?: PluginFieldProvider<V> | readonly PluginFieldProvider<V>[];
+}
+/**
+View plugins associate stateful values with a view. They can
+influence the way the content is drawn, and are notified of things
+that happen in the view.
+*/
+declare class ViewPlugin<V extends PluginValue> {
     /**
-    Which side of the given position the widget is on. When this is
-    positive, the widget will be drawn after the cursor if the
-    cursor is on the same position. Otherwise, it'll be drawn before
-    it. When multiple widgets sit at the same position, their `side`
-    values will determine their ordering—those with a lower value
-    come first. Defaults to 0.
+    Instances of this class act as extensions.
     */
-    side?: number;
+    extension: Extension;
+    private constructor();
     /**
-    Determines whether this is a block widgets, which will be drawn
-    between lines, or an inline widget (the default) which is drawn
-    between the surrounding text.
-
-    Note that block-level decorations should not have vertical
-    margins, and if you dynamically change their height, you should
-    make sure to call
-    [`requestMeasure`](https://codemirror.net/6/docs/ref/#view.EditorView.requestMeasure), so that the
-    editor can update its information about its vertical layout.
+    Define a plugin from a constructor function that creates the
+    plugin's value, given an editor view.
     */
-    block?: boolean;
+    static define<V extends PluginValue>(create: (view: EditorView) => V, spec?: PluginSpec<V>): ViewPlugin<V>;
     /**
-    Other properties are allowed.
+    Create a plugin for a class whose constructor takes a single
+    editor view as argument.
     */
-    [other: string]: any;
+    static fromClass<V extends PluginValue>(cls: {
+        new (view: EditorView): V;
+    }, spec?: PluginSpec<V>): ViewPlugin<V>;
 }
-interface ReplaceDecorationSpec {
+interface MeasureRequest<T> {
     /**
-    An optional widget to drawn in the place of the replaced
-    content.
+    Called in a DOM read phase to gather information that requires
+    DOM layout. Should _not_ mutate the document.
     */
-    widget?: WidgetType;
+    read(view: EditorView): T;
     /**
-    Whether this range covers the positions on its sides. This
-    influences whether new content becomes part of the range and
-    whether the cursor can be drawn on its sides. Defaults to false
-    for inline replacements, and true for block replacements.
+    Called in a DOM write phase to update the document. Should _not_
+    do anything that triggers DOM layout.
     */
-    inclusive?: boolean;
+    write?(measure: T, view: EditorView): void;
     /**
-    Set inclusivity at the start.
+    When multiple requests with the same key are scheduled, only the
+    last one will actually be ran.
     */
-    inclusiveStart?: boolean;
+    key?: any;
+}
+/**
+View [plugins](https://codemirror.net/6/docs/ref/#view.ViewPlugin) are given instances of this
+class, which describe what happened, whenever the view is updated.
+*/
+declare class ViewUpdate {
     /**
-    Set inclusivity at the end.
+    The editor view that the update is associated with.
     */
-    inclusiveEnd?: boolean;
+    readonly view: EditorView;
     /**
-    Whether this is a block-level decoration. Defaults to false.
+    The new editor state.
     */
-    block?: boolean;
+    readonly state: EditorState;
     /**
-    Other properties are allowed.
+    The transactions involved in the update. May be empty.
     */
-    [other: string]: any;
-}
-interface LineDecorationSpec {
+    readonly transactions: readonly Transaction[];
     /**
-    DOM attributes to add to the element wrapping the line.
+    The changes made to the document by this update.
     */
-    attributes?: {
-        [key: string]: string;
-    };
+    readonly changes: ChangeSet;
     /**
-    Shorthand for `{attributes: {class: value}}`.
+    The previous editor state.
     */
-    class?: string;
+    readonly startState: EditorState;
     /**
-    Other properties are allowed.
+    Tells you whether the [viewport](https://codemirror.net/6/docs/ref/#view.EditorView.viewport) or
+    [visible ranges](https://codemirror.net/6/docs/ref/#view.EditorView.visibleRanges) changed in this
+    update.
     */
-    [other: string]: any;
-}
-/**
-Widgets added to the content are described by subclasses of this
-class. Using a description object like that makes it possible to
-delay creating of the DOM structure for a widget until it is
-needed, and to avoid redrawing widgets even when the decorations
-that define them are recreated.
-*/
-declare abstract class WidgetType {
+    get viewportChanged(): boolean;
     /**
-    Build the DOM structure for this widget instance.
+    Indicates whether the line height in the editor changed in this update.
     */
-    abstract toDOM(view: EditorView): HTMLElement;
+    get heightChanged(): boolean;
     /**
-    Compare this instance to another instance of the same type.
-    (TypeScript can't express this, but only instances of the same
-    specific class will be passed to this method.) This is used to
-    avoid redrawing widgets when they are replaced by a new
-    decoration of the same type. The default implementation just
-    returns `false`, which will cause new instances of the widget to
-    always be redrawn.
+    Returns true when the document changed or the size of the editor
+    or the lines or characters within it has changed.
     */
-    eq(_widget: WidgetType): boolean;
+    get geometryChanged(): boolean;
     /**
-    Update a DOM element created by a widget of the same type (but
-    different, non-`eq` content) to reflect this widget. May return
-    true to indicate that it could update, false to indicate it
-    couldn't (in which case the widget will be redrawn). The default
-    implementation just returns false.
+    True when this update indicates a focus change.
     */
-    updateDOM(_dom: HTMLElement): boolean;
+    get focusChanged(): boolean;
     /**
-    The estimated height this widget will have, to be used when
-    estimating the height of content that hasn't been drawn. May
-    return -1 to indicate you don't know. The default implementation
-    returns -1.
+    Whether the document changed in this update.
     */
-    get estimatedHeight(): number;
+    get docChanged(): boolean;
     /**
-    Can be used to configure which kinds of events inside the widget
-    should be ignored by the editor. The default is to ignore all
-    events.
+    Whether the selection was explicitly set in this update.
     */
-    ignoreEvent(_event: Event): boolean;
+    get selectionSet(): boolean;
 }
+
 /**
-A decoration set represents a collection of decorated ranges,
-organized for efficient access and mapping. See
-[`RangeSet`](https://codemirror.net/6/docs/ref/#rangeset.RangeSet) for its methods.
-*/
-declare type DecorationSet = RangeSet<Decoration>;
-/**
-The different types of blocks that can occur in an editor view.
+Interface that objects registered with
+[`EditorView.mouseSelectionStyle`](https://codemirror.net/6/docs/ref/#view.EditorView^mouseSelectionStyle)
+must conform to.
 */
-declare enum BlockType {
+interface MouseSelectionStyle {
     /**
-    A line of text.
+    Return a new selection for the mouse gesture that starts with
+    the event that was originally given to the constructor, and ends
+    with the event passed here. In case of a plain click, those may
+    both be the `mousedown` event, in case of a drag gesture, the
+    latest `mousemove` event will be passed.
+
+    When `extend` is true, that means the new selection should, if
+    possible, extend the start selection. If `multiple` is true, the
+    new selection should be added to the original selection.
     */
-    Text = 0,
+    get: (curEvent: MouseEvent, extend: boolean, multiple: boolean) => EditorSelection;
     /**
-    A block widget associated with the position after it.
+    Called when the view is updated while the gesture is in
+    progress. When the document changes, it may be necessary to map
+    some data (like the original selection or start position)
+    through the changes.
+
+    This may return `true` to indicate that the `get` method should
+    get queried again after the update, because something in the
+    update could change its result. Be wary of infinite loops when
+    using this (where `get` returns a new selection, which will
+    trigger `update`, which schedules another `get` in response).
     */
-    WidgetBefore = 1,
+    update: (update: ViewUpdate) => boolean | void;
+}
+declare type MakeSelectionStyle = (view: EditorView, event: MouseEvent) => MouseSelectionStyle | null;
+
+/**
+Used to indicate [text direction](https://codemirror.net/6/docs/ref/#view.EditorView.textDirection).
+*/
+declare enum Direction {
     /**
-    A block widget associated with the position before it.
+    Left-to-right.
     */
-    WidgetAfter = 2,
+    LTR = 0,
     /**
-    A block widget [replacing](https://codemirror.net/6/docs/ref/#view.Decoration^replace) a range of content.
+    Right-to-left.
     */
-    WidgetRange = 3
+    RTL = 1
 }
 /**
-A decoration provides information on how to draw or style a piece
-of content. You'll usually use it wrapped in a
-[`Range`](https://codemirror.net/6/docs/ref/#rangeset.Range), which adds a start and end position.
+Represents a contiguous range of text that has a single direction
+(as in left-to-right or right-to-left).
 */
-declare abstract class Decoration extends RangeValue {
+declare class BidiSpan {
     /**
-    The config object used to create this decoration. You can
-    include additional properties in there to store metadata about
-    your decoration.
+    The start of the span (relative to the start of the line).
     */
-    readonly spec: any;
-    abstract eq(other: Decoration): boolean;
+    readonly from: number;
     /**
-    Create a mark decoration, which influences the styling of the
-    content in its range. Nested mark decorations will cause nested
-    DOM elements to be created. Nesting order is determined by
-    precedence of the [facet](https://codemirror.net/6/docs/ref/#view.EditorView^decorations) or
-    (below the facet-provided decorations) [view
-    plugin](https://codemirror.net/6/docs/ref/#view.PluginSpec.decorations). Such elements are split
-    on line boundaries and on the boundaries of higher-precedence
-    decorations.
+    The end of the span.
     */
-    static mark(spec: MarkDecorationSpec): Decoration;
+    readonly to: number;
     /**
-    Create a widget decoration, which adds an element at the given
-    position.
+    The ["bidi
+    level"](https://unicode.org/reports/tr9/#Basic_Display_Algorithm)
+    of the span (in this context, 0 means
+    left-to-right, 1 means right-to-left, 2 means left-to-right
+    number inside right-to-left text).
     */
-    static widget(spec: WidgetDecorationSpec): Decoration;
+    readonly level: number;
     /**
-    Create a replace decoration which replaces the given range with
-    a widget, or simply hides it.
+    The direction of this span.
     */
-    static replace(spec: ReplaceDecorationSpec): Decoration;
+    get dir(): Direction;
+}
+
+/**
+Record used to represent information about a block-level element
+in the editor view.
+*/
+declare class BlockInfo {
     /**
-    Create a line decoration, which can add DOM attributes to the
-    line starting at the given position.
+    The start of the element in the document.
     */
-    static line(spec: LineDecorationSpec): Decoration;
+    readonly from: number;
     /**
-    Build a [`DecorationSet`](https://codemirror.net/6/docs/ref/#view.DecorationSet) from the given
-    decorated range or ranges. If the ranges aren't already sorted,
-    pass `true` for `sort` to make the library sort them for you.
+    The length of the element.
     */
-    static set(of: Range<Decoration> | readonly Range<Decoration>[], sort?: boolean): DecorationSet;
+    readonly length: number;
     /**
-    The empty set of decorations.
+    The top position of the element (relative to the top of the
+    document).
     */
-    static none: DecorationSet;
-}
-
-/**
-Basic rectangle type.
-*/
-interface Rect {
-    readonly left: number;
-    readonly right: number;
     readonly top: number;
-    readonly bottom: number;
-}
-
-/**
-Command functions are used in key bindings and other types of user
-actions. Given an editor view, they check whether their effect can
-apply to the editor, and if it can, perform it as a side effect
-(which usually means [dispatching](https://codemirror.net/6/docs/ref/#view.EditorView.dispatch) a
-transaction) and return `true`.
-*/
-declare type Command = (target: EditorView) => boolean;
-/**
-This is the interface plugin objects conform to.
-*/
-interface PluginValue {
     /**
-    Notifies the plugin of an update that happened in the view. This
-    is called _before_ the view updates its own DOM. It is
-    responsible for updating the plugin's internal state (including
-    any state that may be read by plugin fields) and _writing_ to
-    the DOM for the changes in the update. To avoid unnecessary
-    layout recomputations, it should _not_ read the DOM layout—use
-    [`requestMeasure`](https://codemirror.net/6/docs/ref/#view.EditorView.requestMeasure) to schedule
-    your code in a DOM reading phase if you need to.
+    Its height.
     */
-    update?(_update: ViewUpdate): void;
+    readonly height: number;
     /**
-    Called when the plugin is no longer going to be used. Should
-    revert any changes the plugin made to the DOM.
+    The type of element this is. When querying lines, this may be
+    an array of all the blocks that make up the line.
     */
-    destroy?(): void;
-}
-declare const isFieldProvider: unique symbol;
-/**
-Used to [declare](https://codemirror.net/6/docs/ref/#view.PluginSpec.provide) which
-[fields](https://codemirror.net/6/docs/ref/#view.PluginValue) a [view plugin](https://codemirror.net/6/docs/ref/#view.ViewPlugin)
-provides.
-*/
-declare class PluginFieldProvider<V> {
-    private [isFieldProvider];
+    readonly type: BlockType | readonly BlockInfo[];
+    /**
+    The end of the element as a document position.
+    */
+    get to(): number;
+    /**
+    The bottom position of the element.
+    */
+    get bottom(): number;
 }
-/**
-Plugin fields are a mechanism for allowing plugins to provide
-values that can be retrieved through the
-[`pluginField`](https://codemirror.net/6/docs/ref/#view.EditorView.pluginField) view method.
-*/
-declare class PluginField<T> {
+
+interface EditorConfig {
     /**
-    Create a [provider](https://codemirror.net/6/docs/ref/#view.PluginFieldProvider) for this field,
-    to use with a plugin's [provide](https://codemirror.net/6/docs/ref/#view.PluginSpec.provide)
-    option.
+    The view's initial state. Defaults to an extension-less state
+    with an empty document.
     */
-    from<V extends PluginValue>(get: (value: V) => T): PluginFieldProvider<V>;
+    state?: EditorState;
     /**
-    Define a new plugin field.
+    If the view is going to be mounted in a shadow root or document
+    other than the one held by the global variable `document` (the
+    default), you should pass it here. If you provide `parent`, but
+    not this option, the editor will automatically look up a root
+    from the parent.
     */
-    static define<T>(): PluginField<T>;
+    root?: Document | ShadowRoot;
     /**
-    This field can be used by plugins to provide
-    [decorations](https://codemirror.net/6/docs/ref/#view.Decoration).
-
-    **Note**: For reasons of data flow (plugins are only updated
-    after the viewport is computed), decorations produced by plugins
-    are _not_ taken into account when predicting the vertical layout
-    structure of the editor. Thus, things like large widgets or big
-    replacements (i.e. code folding) should be provided through the
-    state-level [`decorations` facet](https://codemirror.net/6/docs/ref/#view.EditorView^decorations),
-    not this plugin field. Specifically, replacing decorations that
-    cross line boundaries will break if provided through a plugin.
-    */
-    static decorations: PluginField<DecorationSet>;
-    /**
-    Used to provide ranges that should be treated as atoms as far as
-    cursor motion is concerned. This causes methods like
-    [`moveByChar`](https://codemirror.net/6/docs/ref/#view.EditorView.moveByChar) and
-    [`moveVertically`](https://codemirror.net/6/docs/ref/#view.EditorView.moveVertically) (and the
-    commands built on top of them) to skip across such regions when
-    a selection endpoint would enter them. This does _not_ prevent
-    direct programmatic [selection
-    updates](https://codemirror.net/6/docs/ref/#state.TransactionSpec.selection) from moving into such
-    regions.
+    Override the transaction [dispatch
+    function](https://codemirror.net/6/docs/ref/#view.EditorView.dispatch) for this editor view, which
+    is the way updates get routed to the view. Your implementation,
+    if provided, should probably call the view's [`update`
+    method](https://codemirror.net/6/docs/ref/#view.EditorView.update).
     */
-    static atomicRanges: PluginField<RangeSet<any>>;
+    dispatch?: (tr: Transaction) => void;
     /**
-    Plugins can provide additional scroll margins (space around the
-    sides of the scrolling element that should be considered
-    invisible) through this field. This can be useful when the
-    plugin introduces elements that cover part of that element (for
-    example a horizontally fixed gutter).
+    When given, the editor is immediately appended to the given
+    element on creation. (Otherwise, you'll have to place the view's
+    [`dom`](https://codemirror.net/6/docs/ref/#view.EditorView.dom) element in the document yourself.)
     */
-    static scrollMargins: PluginField<Partial<Rect> | null>;
+    parent?: Element | DocumentFragment;
 }
 /**
-Provides additional information when defining a [view
-plugin](https://codemirror.net/6/docs/ref/#view.ViewPlugin).
+An editor view represents the editor's user interface. It holds
+the editable DOM surface, and possibly other elements such as the
+line number gutter. It handles events and dispatches state
+transactions for editing actions.
 */
-interface PluginSpec<V extends PluginValue> {
+declare class EditorView {
     /**
-    Register the given [event
-    handlers](https://codemirror.net/6/docs/ref/#view.EditorView^domEventHandlers) for the plugin.
-    When called, these will have their `this` bound to the plugin
-    value.
+    The current editor state.
     */
-    eventHandlers?: DOMEventHandlers<V>;
+    get state(): EditorState;
     /**
-    Allow the plugin to provide decorations. When given, this should
-    a function that take the plugin value and return a [decoration
-    set](https://codemirror.net/6/docs/ref/#view.DecorationSet). See also the caveat about
-    [layout-changing decorations](https://codemirror.net/6/docs/ref/#view.PluginField^decorations)
-    from plugins.
+    To be able to display large documents without consuming too much
+    memory or overloading the browser, CodeMirror only draws the
+    code that is visible (plus a margin around it) to the DOM. This
+    property tells you the extent of the current drawn viewport, in
+    document positions.
     */
-    decorations?: (value: V) => DecorationSet;
+    get viewport(): {
+        from: number;
+        to: number;
+    };
     /**
-    Specify that the plugin provides [plugin
-    field](https://codemirror.net/6/docs/ref/#view.PluginField) values. Use a field's
-    [`from`](https://codemirror.net/6/docs/ref/#view.PluginField.from) method to create these
-    providers.
+    When there are, for example, large collapsed ranges in the
+    viewport, its size can be a lot bigger than the actual visible
+    content. Thus, if you are doing something like styling the
+    content in the viewport, it is preferable to only do so for
+    these ranges, which are the subset of the viewport that is
+    actually drawn.
     */
-    provide?: PluginFieldProvider<V> | readonly PluginFieldProvider<V>[];
-}
-/**
-View plugins associate stateful values with a view. They can
-influence the way the content is drawn, and are notified of things
-that happen in the view.
-*/
-declare class ViewPlugin<V extends PluginValue> {
+    get visibleRanges(): readonly {
+        from: number;
+        to: number;
+    }[];
     /**
-    Instances of this class act as extensions.
+    Returns false when the editor is entirely scrolled out of view
+    or otherwise hidden.
     */
-    extension: Extension;
-    private constructor();
+    get inView(): boolean;
     /**
-    Define a plugin from a constructor function that creates the
-    plugin's value, given an editor view.
+    Indicates whether the user is currently composing text via
+    [IME](https://en.wikipedia.org/wiki/Input_method).
     */
-    static define<V extends PluginValue>(create: (view: EditorView) => V, spec?: PluginSpec<V>): ViewPlugin<V>;
+    get composing(): boolean;
+    private _dispatch;
     /**
-    Create a plugin for a class whose constructor takes a single
-    editor view as argument.
+    The document or shadow root that the view lives in.
     */
-    static fromClass<V extends PluginValue>(cls: {
-        new (view: EditorView): V;
-    }, spec?: PluginSpec<V>): ViewPlugin<V>;
-}
-interface MeasureRequest<T> {
+    readonly root: DocumentOrShadowRoot;
     /**
-    Called in a DOM read phase to gather information that requires
-    DOM layout. Should _not_ mutate the document.
+    The DOM element that wraps the entire editor view.
     */
-    read(view: EditorView): T;
+    readonly dom: HTMLElement;
     /**
-    Called in a DOM write phase to update the document. Should _not_
-    do anything that triggers DOM layout.
+    The DOM element that can be styled to scroll. (Note that it may
+    not have been, so you can't assume this is scrollable.)
     */
-    write(measure: T, view: EditorView): void;
+    readonly scrollDOM: HTMLElement;
     /**
-    When multiple requests with the same key are scheduled, only the
-    last one will actually be ran.
+    The editable DOM element holding the editor content. You should
+    not, usually, interact with this content directly though the
+    DOM, since the editor will immediately undo most of the changes
+    you make. Instead, [dispatch](https://codemirror.net/6/docs/ref/#view.EditorView.dispatch)
+    [transactions](https://codemirror.net/6/docs/ref/#state.Transaction) to modify content, and
+    [decorations](https://codemirror.net/6/docs/ref/#view.Decoration) to style it.
     */
-    key?: any;
-}
-/**
-View [plugins](https://codemirror.net/6/docs/ref/#view.ViewPlugin) are given instances of this
-class, which describe what happened, whenever the view is updated.
-*/
-declare class ViewUpdate {
+    readonly contentDOM: HTMLElement;
+    private announceDOM;
+    private plugins;
+    private editorAttrs;
+    private contentAttrs;
+    private styleModules;
+    private bidiCache;
+    private destroyed;
     /**
-    The editor view that the update is associated with.
+    Construct a new view. You'll usually want to put `view.dom` into
+    your document after creating a view, so that the user can see
+    it.
     */
-    readonly view: EditorView;
+    constructor(
     /**
-    The new editor state.
+    Initialization options.
     */
-    readonly state: EditorState;
+    config?: EditorConfig);
     /**
-    The transactions involved in the update. May be empty.
+    All regular editor state updates should go through this. It
+    takes a transaction or transaction spec and updates the view to
+    show the new state produced by that transaction. Its
+    implementation can be overridden with an
+    [option](https://codemirror.net/6/docs/ref/#view.EditorView.constructor^config.dispatch). This
+    function is bound to the view instance, so it does not have to
+    be called as a method.
     */
-    readonly transactions: readonly Transaction[];
+    dispatch(tr: Transaction): void;
+    dispatch(...specs: TransactionSpec[]): void;
     /**
-    The changes made to the document by this update.
+    Update the view for the given array of transactions. This will
+    update the visible document and selection to match the state
+    produced by the transactions, and notify view plugins of the
+    change. You should usually call
+    [`dispatch`](https://codemirror.net/6/docs/ref/#view.EditorView.dispatch) instead, which uses this
+    as a primitive.
     */
-    readonly changes: ChangeSet;
+    update(transactions: readonly Transaction[]): void;
     /**
-    The previous editor state.
+    Reset the view to the given state. (This will cause the entire
+    document to be redrawn and all view plugins to be reinitialized,
+    so you should probably only use it when the new state isn't
+    derived from the old state. Otherwise, use
+    [`dispatch`](https://codemirror.net/6/docs/ref/#view.EditorView.dispatch) instead.)
     */
-    readonly startState: EditorState;
+    setState(newState: EditorState): void;
+    private updatePlugins;
     /**
-    Tells you whether the [viewport](https://codemirror.net/6/docs/ref/#view.EditorView.viewport) or
-    [visible ranges](https://codemirror.net/6/docs/ref/#view.EditorView.visibleRanges) changed in this
-    update.
+    Get the CSS classes for the currently active editor themes.
     */
-    get viewportChanged(): boolean;
+    get themeClasses(): string;
+    private updateAttrs;
+    private showAnnouncements;
+    private mountStyles;
+    private readMeasured;
     /**
-    Indicates whether the line height in the editor changed in this update.
+    Schedule a layout measurement, optionally providing callbacks to
+    do custom DOM measuring followed by a DOM write phase. Using
+    this is preferable reading DOM layout directly from, for
+    example, an event handler, because it'll make sure measuring and
+    drawing done by other components is synchronized, avoiding
+    unnecessary DOM layout computations.
     */
-    get heightChanged(): boolean;
+    requestMeasure<T>(request?: MeasureRequest<T>): void;
     /**
-    Returns true when the document changed or the size of the editor
-    or the lines or characters within it has changed.
+    Collect all values provided by the active plugins for a given
+    field.
     */
-    get geometryChanged(): boolean;
+    pluginField<T>(field: PluginField<T>): readonly T[];
     /**
-    True when this update indicates a focus change.
+    Get the value of a specific plugin, if present. Note that
+    plugins that crash can be dropped from a view, so even when you
+    know you registered a given plugin, it is recommended to check
+    the return value of this method.
     */
-    get focusChanged(): boolean;
+    plugin<T>(plugin: ViewPlugin<T>): T | null;
     /**
-    Whether the document changed in this update.
+    The top position of the document, in screen coordinates. This
+    may be negative when the editor is scrolled down. Points
+    directly to the top of the first line, not above the padding.
     */
-    get docChanged(): boolean;
+    get documentTop(): number;
     /**
-    Whether the selection was explicitly set in this update.
+    Reports the padding above and below the document.
     */
-    get selectionSet(): boolean;
-}
-
-/**
-Interface that objects registered with
-[`EditorView.mouseSelectionStyle`](https://codemirror.net/6/docs/ref/#view.EditorView^mouseSelectionStyle)
-must conform to.
-*/
-interface MouseSelectionStyle {
+    get documentPadding(): {
+        top: number;
+        bottom: number;
+    };
     /**
-    Return a new selection for the mouse gesture that starts with
-    the event that was originally given to the constructor, and ends
-    with the event passed here. In case of a plain click, those may
-    both be the `mousedown` event, in case of a drag gesture, the
-    latest `mousemove` event will be passed.
+    Find the line or block widget at the given vertical position.
 
-    When `extend` is true, that means the new selection should, if
-    possible, extend the start selection. If `multiple` is true, the
-    new selection should be added to the original selection.
+    By default, this position is interpreted as a screen position,
+    meaning `docTop` is set to the DOM top position of the editor
+    content (forcing a layout). You can pass a different `docTop`
+    value—for example 0 to interpret `height` as a document-relative
+    position, or a precomputed document top
+    (`view.contentDOM.getBoundingClientRect().top`) to limit layout
+    queries.
+
+    *Deprecated: use `blockAtHeight` instead.*
     */
-    get: (curEvent: MouseEvent, extend: boolean, multiple: boolean) => EditorSelection;
+    blockAtHeight(height: number, docTop?: number): BlockInfo;
     /**
-    Called when the view is updated while the gesture is in
-    progress. When the document changes, it may be necessary to map
-    some data (like the original selection or start position)
-    through the changes.
-
-    This may return `true` to indicate that the `get` method should
-    get queried again after the update, because something in the
-    update could change its result. Be wary of infinite loops when
-    using this (where `get` returns a new selection, which will
-    trigger `update`, which schedules another `get` in response).
+    Find the text line or block widget at the given vertical
+    position (which is interpreted as relative to the [top of the
+    document](https://codemirror.net/6/docs/ref/#view.EditorView.documentTop)
     */
-    update: (update: ViewUpdate) => boolean | void;
-}
-declare type MakeSelectionStyle = (view: EditorView, event: MouseEvent) => MouseSelectionStyle | null;
-
-/**
-Used to indicate [text direction](https://codemirror.net/6/docs/ref/#view.EditorView.textDirection).
-*/
-declare enum Direction {
+    elementAtHeight(height: number): BlockInfo;
     /**
-    Left-to-right.
+    Find information for the visual line (see
+    [`visualLineAt`](https://codemirror.net/6/docs/ref/#view.EditorView.visualLineAt)) at the given
+    vertical position. The resulting block info might hold another
+    array of block info structs in its `type` field if this line
+    consists of more than one block.
+
+    Defaults to treating `height` as a screen position. See
+    [`blockAtHeight`](https://codemirror.net/6/docs/ref/#view.EditorView.blockAtHeight) for the
+    interpretation of the `docTop` parameter.
+
+    *Deprecated: use `lineBlockAtHeight` instead.*
     */
-    LTR = 0,
+    visualLineAtHeight(height: number, docTop?: number): BlockInfo;
     /**
-    Right-to-left.
+    Find the line block (see
+    [`lineBlockAt`](https://codemirror.net/6/docs/ref/#view.EditorView.lineBlockAt) at the given
+    height.
     */
-    RTL = 1
-}
-/**
-Represents a contiguous range of text that has a single direction
-(as in left-to-right or right-to-left).
-*/
-declare class BidiSpan {
+    lineBlockAtHeight(height: number): BlockInfo;
     /**
-    The start of the span (relative to the start of the line).
+    Iterate over the height information of the visual lines in the
+    viewport. The heights of lines are reported relative to the
+    given document top, which defaults to the screen position of the
+    document (forcing a layout).
+
+    *Deprecated: use `viewportLineBlocks` instead.*
     */
-    readonly from: number;
+    viewportLines(f: (line: BlockInfo) => void, docTop?: number): void;
     /**
-    The end of the span.
+    Get the extent and vertical position of all [line
+    blocks](https://codemirror.net/6/docs/ref/#view.EditorView.lineBlockAt) in the viewport. Positions
+    are relative to the [top of the
+    document](https://codemirror.net/6/docs/ref/#view.EditorView.documentTop);
     */
-    readonly to: number;
+    get viewportLineBlocks(): BlockInfo[];
     /**
-    The ["bidi
-    level"](https://unicode.org/reports/tr9/#Basic_Display_Algorithm)
-    of the span (in this context, 0 means
-    left-to-right, 1 means right-to-left, 2 means left-to-right
-    number inside right-to-left text).
+    Find the extent and height of the visual line (a range delimited
+    on both sides by either non-[hidden](https://codemirror.net/6/docs/ref/#view.Decoration^range)
+    line breaks, or the start/end of the document) at the given position.
+
+    Vertical positions are computed relative to the `docTop`
+    argument, which defaults to 0 for this method. You can pass
+    `view.contentDOM.getBoundingClientRect().top` here to get screen
+    coordinates.
+
+    *Deprecated: use `lineBlockAt` instead.*
     */
-    readonly level: number;
+    visualLineAt(pos: number, docTop?: number): BlockInfo;
     /**
-    The direction of this span.
+    Find the line block around the given document position. A line
+    block is a range delimited on both sides by either a
+    non-[hidden](https://codemirror.net/6/docs/ref/#view.Decoration^range) line breaks, or the
+    start/end of the document. It will usually just hold a line of
+    text, but may be broken into multiple textblocks by block
+    widgets.
     */
-    get dir(): Direction;
-}
-
-/**
-Record used to represent information about a block-level element
-in the editor view.
-*/
-declare class BlockInfo {
+    lineBlockAt(pos: number): BlockInfo;
     /**
-    The start of the element in the document.
+    The editor's total content height.
     */
-    readonly from: number;
+    get contentHeight(): number;
     /**
-    The length of the element.
+    Move a cursor position by [grapheme
+    cluster](https://codemirror.net/6/docs/ref/#text.findClusterBreak). `forward` determines whether
+    the motion is away from the line start, or towards it. Motion in
+    bidirectional text is in visual order, in the editor's [text
+    direction](https://codemirror.net/6/docs/ref/#view.EditorView.textDirection). When the start
+    position was the last one on the line, the returned position
+    will be across the line break. If there is no further line, the
+    original position is returned.
+
+    By default, this method moves over a single cluster. The
+    optional `by` argument can be used to move across more. It will
+    be called with the first cluster as argument, and should return
+    a predicate that determines, for each subsequent cluster,
+    whether it should also be moved over.
     */
-    readonly length: number;
+    moveByChar(start: SelectionRange, forward: boolean, by?: (initial: string) => (next: string) => boolean): SelectionRange;
     /**
-    The top position of the element.
+    Move a cursor position across the next group of either
+    [letters](https://codemirror.net/6/docs/ref/#state.EditorState.charCategorizer) or non-letter
+    non-whitespace characters.
     */
-    readonly top: number;
+    moveByGroup(start: SelectionRange, forward: boolean): SelectionRange;
     /**
-    Its height.
+    Move to the next line boundary in the given direction. If
+    `includeWrap` is true, line wrapping is on, and there is a
+    further wrap point on the current line, the wrap point will be
+    returned. Otherwise this function will return the start or end
+    of the line.
     */
-    readonly height: number;
+    moveToLineBoundary(start: SelectionRange, forward: boolean, includeWrap?: boolean): SelectionRange;
     /**
-    The type of element this is. When querying lines, this may be
-    an array of all the blocks that make up the line.
+    Move a cursor position vertically. When `distance` isn't given,
+    it defaults to moving to the next line (including wrapped
+    lines). Otherwise, `distance` should provide a positive distance
+    in pixels.
+
+    When `start` has a
+    [`goalColumn`](https://codemirror.net/6/docs/ref/#state.SelectionRange.goalColumn), the vertical
+    motion will use that as a target horizontal position. Otherwise,
+    the cursor's own horizontal position is used. The returned
+    cursor will have its goal column set to whichever column was
+    used.
     */
-    readonly type: BlockType | readonly BlockInfo[];
+    moveVertically(start: SelectionRange, forward: boolean, distance?: number): SelectionRange;
+    scrollPosIntoView(pos: number): void;
     /**
-    The end of the element as a document position.
+    Find the DOM parent node and offset (child offset if `node` is
+    an element, character offset when it is a text node) at the
+    given document position.
     */
-    get to(): number;
+    domAtPos(pos: number): {
+        node: Node;
+        offset: number;
+    };
     /**
-    The bottom position of the element.
+    Find the document position at the given DOM node. Can be useful
+    for associating positions with DOM events. Will raise an error
+    when `node` isn't part of the editor content.
     */
-    get bottom(): number;
-}
-
-interface EditorConfig {
+    posAtDOM(node: Node, offset?: number): number;
     /**
-    The view's initial state. Defaults to an extension-less state
-    with an empty document.
+    Get the document position at the given screen coordinates.
+    Returns null if no valid position could be found.
     */
-    state?: EditorState;
+    posAtCoords(coords: {
+        x: number;
+        y: number;
+    }, precise: false): number;
+    posAtCoords(coords: {
+        x: number;
+        y: number;
+    }): number | null;
     /**
-    If the view is going to be mounted in a shadow root or document
-    other than the one held by the global variable `document` (the
-    default), you should pass it here. If you provide `parent`, but
-    not this option, the editor will automatically look up a root
-    from the parent.
+    Get the screen coordinates at the given document position.
+    `side` determines whether the coordinates are based on the
+    element before (-1) or after (1) the position (if no element is
+    available on the given side, the method will transparently use
+    another strategy to get reasonable coordinates).
     */
-    root?: Document | ShadowRoot;
+    coordsAtPos(pos: number, side?: -1 | 1): Rect | null;
     /**
-    Override the transaction [dispatch
-    function](https://codemirror.net/6/docs/ref/#view.EditorView.dispatch) for this editor view, which
-    is the way updates get routed to the view. Your implementation,
-    if provided, should probably call the view's [`update`
-    method](https://codemirror.net/6/docs/ref/#view.EditorView.update).
+    The default width of a character in the editor. May not
+    accurately reflect the width of all characters (given variable
+    width fonts or styling of invididual ranges).
     */
-    dispatch?: (tr: Transaction) => void;
+    get defaultCharacterWidth(): number;
     /**
-    When given, the editor is immediately appended to the given
-    element on creation. (Otherwise, you'll have to place the view's
-    [`dom`](https://codemirror.net/6/docs/ref/#view.EditorView.dom) element in the document yourself.)
+    The default height of a line in the editor. May not be accurate
+    for all lines.
     */
-    parent?: Element | DocumentFragment;
-}
-/**
-An editor view represents the editor's user interface. It holds
-the editable DOM surface, and possibly other elements such as the
-line number gutter. It handles events and dispatches state
-transactions for editing actions.
-*/
-declare class EditorView {
+    get defaultLineHeight(): number;
     /**
-    The current editor state.
+    The text direction
+    ([`direction`](https://developer.mozilla.org/en-US/docs/Web/CSS/direction)
+    CSS property) of the editor.
     */
-    get state(): EditorState;
+    get textDirection(): Direction;
     /**
-    To be able to display large documents without consuming too much
-    memory or overloading the browser, CodeMirror only draws the
-    code that is visible (plus a margin around it) to the DOM. This
-    property tells you the extent of the current drawn viewport, in
-    document positions.
+    Whether this editor [wraps lines](https://codemirror.net/6/docs/ref/#view.EditorView.lineWrapping)
+    (as determined by the
+    [`white-space`](https://developer.mozilla.org/en-US/docs/Web/CSS/white-space)
+    CSS property of its content element).
     */
-    get viewport(): {
-        from: number;
-        to: number;
-    };
+    get lineWrapping(): boolean;
     /**
-    When there are, for example, large collapsed ranges in the
-    viewport, its size can be a lot bigger than the actual visible
-    content. Thus, if you are doing something like styling the
-    content in the viewport, it is preferable to only do so for
-    these ranges, which are the subset of the viewport that is
-    actually drawn.
+    Returns the bidirectional text structure of the given line
+    (which should be in the current document) as an array of span
+    objects. The order of these spans matches the [text
+    direction](https://codemirror.net/6/docs/ref/#view.EditorView.textDirection)—if that is
+    left-to-right, the leftmost spans come first, otherwise the
+    rightmost spans come first.
     */
-    get visibleRanges(): readonly {
-        from: number;
-        to: number;
-    }[];
+    bidiSpans(line: Line$1): readonly BidiSpan[];
     /**
-    Returns false when the editor is entirely scrolled out of view
-    or otherwise hidden.
+    Check whether the editor has focus.
     */
-    get inView(): boolean;
+    get hasFocus(): boolean;
     /**
-    Indicates whether the user is currently composing text via
-    [IME](https://en.wikipedia.org/wiki/Input_method).
+    Put focus on the editor.
     */
-    get composing(): boolean;
-    private _dispatch;
+    focus(): void;
     /**
-    The document or shadow root that the view lives in.
+    Clean up this editor view, removing its element from the
+    document, unregistering event handlers, and notifying
+    plugins. The view instance can no longer be used after
+    calling this.
     */
-    readonly root: DocumentOrShadowRoot;
+    destroy(): void;
     /**
-    The DOM element that wraps the entire editor view.
+    Effect that can be [added](https://codemirror.net/6/docs/ref/#state.TransactionSpec.effects) to a
+    transaction to make it scroll the given range into view.
     */
-    readonly dom: HTMLElement;
+    static scrollTo: StateEffectType<SelectionRange>;
     /**
-    The DOM element that can be styled to scroll. (Note that it may
-    not have been, so you can't assume this is scrollable.)
+    Effect that makes the editor scroll the given range to the
+    center of the visible view.
     */
-    readonly scrollDOM: HTMLElement;
+    static centerOn: StateEffectType<SelectionRange>;
     /**
-    The editable DOM element holding the editor content. You should
-    not, usually, interact with this content directly though the
-    DOM, since the editor will immediately undo most of the changes
-    you make. Instead, [dispatch](https://codemirror.net/6/docs/ref/#view.EditorView.dispatch)
-    [transactions](https://codemirror.net/6/docs/ref/#state.Transaction) to modify content, and
-    [decorations](https://codemirror.net/6/docs/ref/#view.Decoration) to style it.
+    Facet to add a [style
+    module](https://github.com/marijnh/style-mod#documentation) to
+    an editor view. The view will ensure that the module is
+    mounted in its [document
+    root](https://codemirror.net/6/docs/ref/#view.EditorView.constructor^config.root).
     */
-    readonly contentDOM: HTMLElement;
-    private announceDOM;
-    private plugins;
-    private editorAttrs;
-    private contentAttrs;
-    private styleModules;
-    private bidiCache;
-    private destroyed;
+    static styleModule: Facet<StyleModule, readonly StyleModule[]>;
     /**
-    Construct a new view. You'll usually want to put `view.dom` into
-    your document after creating a view, so that the user can see
-    it.
+    Facet that can be used to add DOM event handlers. The value
+    should be an object mapping event names to handler functions. The
+    first such function to return true will be assumed to have handled
+    that event, and no other handlers or built-in behavior will be
+    activated for it.
+    These are registered on the [content
+    element](https://codemirror.net/6/docs/ref/#view.EditorView.contentDOM), except for `scroll`
+    handlers, which will be called any time the editor's [scroll
+    element](https://codemirror.net/6/docs/ref/#view.EditorView.scrollDOM) or one of its parent nodes
+    is scrolled.
     */
-    constructor(
+    static domEventHandlers(handlers: DOMEventHandlers<any>): Extension;
     /**
-    Initialization options.
+    An input handler can override the way changes to the editable
+    DOM content are handled. Handlers are passed the document
+    positions between which the change was found, and the new
+    content. When one returns true, no further input handlers are
+    called and the default behavior is prevented.
     */
-    config?: EditorConfig);
+    static inputHandler: Facet<(view: EditorView, from: number, to: number, text: string) => boolean, readonly ((view: EditorView, from: number, to: number, text: string) => boolean)[]>;
     /**
-    All regular editor state updates should go through this. It
-    takes a transaction or transaction spec and updates the view to
-    show the new state produced by that transaction. Its
-    implementation can be overridden with an
-    [option](https://codemirror.net/6/docs/ref/#view.EditorView.constructor^config.dispatch). This
-    function is bound to the view instance, so it does not have to
-    be called as a method.
+    Allows you to provide a function that should be called when the
+    library catches an exception from an extension (mostly from view
+    plugins, but may be used by other extensions to route exceptions
+    from user-code-provided callbacks). This is mostly useful for
+    debugging and logging. See [`logException`](https://codemirror.net/6/docs/ref/#view.logException).
     */
-    dispatch(tr: Transaction): void;
-    dispatch(...specs: TransactionSpec[]): void;
+    static exceptionSink: Facet<(exception: any) => void, readonly ((exception: any) => void)[]>;
     /**
-    Update the view for the given array of transactions. This will
-    update the visible document and selection to match the state
-    produced by the transactions, and notify view plugins of the
-    change. You should usually call
-    [`dispatch`](https://codemirror.net/6/docs/ref/#view.EditorView.dispatch) instead, which uses this
-    as a primitive.
+    A facet that can be used to register a function to be called
+    every time the view updates.
     */
-    update(transactions: readonly Transaction[]): void;
+    static updateListener: Facet<(update: ViewUpdate) => void, readonly ((update: ViewUpdate) => void)[]>;
     /**
-    Reset the view to the given state. (This will cause the entire
-    document to be redrawn and all view plugins to be reinitialized,
-    so you should probably only use it when the new state isn't
-    derived from the old state. Otherwise, use
-    [`dispatch`](https://codemirror.net/6/docs/ref/#view.EditorView.dispatch) instead.)
+    Facet that controls whether the editor content DOM is editable.
+    When its highest-precedence value is `false`, the element will
+    not longer have its `contenteditable` attribute set. (Note that
+    this doesn't affect API calls that change the editor content,
+    even when those are bound to keys or buttons. See the
+    [`readOnly`](https://codemirror.net/6/docs/ref/#state.EditorState.readOnly) facet for that.)
     */
-    setState(newState: EditorState): void;
-    private updatePlugins;
+    static editable: Facet<boolean, boolean>;
     /**
-    Get the CSS classes for the currently active editor themes.
+    Allows you to influence the way mouse selection happens. The
+    functions in this facet will be called for a `mousedown` event
+    on the editor, and can return an object that overrides the way a
+    selection is computed from that mouse click or drag.
     */
-    get themeClasses(): string;
-    private updateAttrs;
-    private showAnnouncements;
-    private mountStyles;
-    private readMeasured;
+    static mouseSelectionStyle: Facet<MakeSelectionStyle, readonly MakeSelectionStyle[]>;
     /**
-    Schedule a layout measurement, optionally providing callbacks to
-    do custom DOM measuring followed by a DOM write phase. Using
-    this is preferable reading DOM layout directly from, for
-    example, an event handler, because it'll make sure measuring and
-    drawing done by other components is synchronized, avoiding
-    unnecessary DOM layout computations.
+    Facet used to configure whether a given selection drag event
+    should move or copy the selection. The given predicate will be
+    called with the `mousedown` event, and can return `true` when
+    the drag should move the content.
     */
-    requestMeasure<T>(request?: MeasureRequest<T>): void;
+    static dragMovesSelection: Facet<(event: MouseEvent) => boolean, readonly ((event: MouseEvent) => boolean)[]>;
     /**
-    Collect all values provided by the active plugins for a given
-    field.
+    Facet used to configure whether a given selecting click adds
+    a new range to the existing selection or replaces it entirely.
     */
-    pluginField<T>(field: PluginField<T>): readonly T[];
+    static clickAddsSelectionRange: Facet<(event: MouseEvent) => boolean, readonly ((event: MouseEvent) => boolean)[]>;
     /**
-    Get the value of a specific plugin, if present. Note that
-    plugins that crash can be dropped from a view, so even when you
-    know you registered a given plugin, it is recommended to check
-    the return value of this method.
+    A facet that determines which [decorations](https://codemirror.net/6/docs/ref/#view.Decoration)
+    are shown in the view. See also [view
+    plugins](https://codemirror.net/6/docs/ref/#view.EditorView^decorations), which have a separate
+    mechanism for providing decorations.
     */
-    plugin<T>(plugin: ViewPlugin<T>): T | null;
+    static decorations: Facet<DecorationSet, readonly DecorationSet[]>;
     /**
-    Find the line or block widget at the given vertical position.
+    Create a theme extension. The first argument can be a
+    [`style-mod`](https://github.com/marijnh/style-mod#documentation)
+    style spec providing the styles for the theme. These will be
+    prefixed with a generated class for the style.
 
-    By default, this position is interpreted as a screen position,
-    meaning `docTop` is set to the DOM top position of the editor
-    content (forcing a layout). You can pass a different `docTop`
-    value—for example 0 to interpret `height` as a document-relative
-    position, or a precomputed document top
-    (`view.contentDOM.getBoundingClientRect().top`) to limit layout
-    queries.
-    */
-    blockAtHeight(height: number, docTop?: number): BlockInfo;
-    /**
-    Find information for the visual line (see
-    [`visualLineAt`](https://codemirror.net/6/docs/ref/#view.EditorView.visualLineAt)) at the given
-    vertical position. The resulting block info might hold another
-    array of block info structs in its `type` field if this line
-    consists of more than one block.
+    Because the selectors will be prefixed with a scope class, rule
+    that directly match the editor's [wrapper
+    element](https://codemirror.net/6/docs/ref/#view.EditorView.dom)—to which the scope class will be
+    added—need to be explicitly differentiated by adding an `&` to
+    the selector for that element—for example
+    `&.cm-focused`.
 
-    Defaults to treating `height` as a screen position. See
-    [`blockAtHeight`](https://codemirror.net/6/docs/ref/#view.EditorView.blockAtHeight) for the
-    interpretation of the `docTop` parameter.
-    */
-    visualLineAtHeight(height: number, docTop?: number): BlockInfo;
-    /**
-    Iterate over the height information of the visual lines in the
-    viewport. The heights of lines are reported relative to the
-    given document top, which defaults to the screen position of the
-    document (forcing a layout).
+    When `dark` is set to true, the theme will be marked as dark,
+    which will cause the `&dark` rules from [base
+    themes](https://codemirror.net/6/docs/ref/#view.EditorView^baseTheme) to be used (as opposed to
+    `&light` when a light theme is active).
     */
-    viewportLines(f: (line: BlockInfo) => void, docTop?: number): void;
+    static theme(spec: {
+        [selector: string]: StyleSpec;
+    }, options?: {
+        dark?: boolean;
+    }): Extension;
     /**
-    Find the extent and height of the visual line (a range delimited
-    on both sides by either non-[hidden](https://codemirror.net/6/docs/ref/#view.Decoration^range)
-    line breaks, or the start/end of the document) at the given position.
-
-    Vertical positions are computed relative to the `docTop`
-    argument, which defaults to 0 for this method. You can pass
-    `view.contentDOM.getBoundingClientRect().top` here to get screen
-    coordinates.
+    Create an extension that adds styles to the base theme. Like
+    with [`theme`](https://codemirror.net/6/docs/ref/#view.EditorView^theme), use `&` to indicate the
+    place of the editor wrapper element when directly targeting
+    that. You can also use `&dark` or `&light` instead to only
+    target editors with a dark or light theme.
     */
-    visualLineAt(pos: number, docTop?: number): BlockInfo;
+    static baseTheme(spec: {
+        [selector: string]: StyleSpec;
+    }): Extension;
     /**
-    The editor's total content height.
+    Facet that provides additional DOM attributes for the editor's
+    editable DOM element.
     */
-    get contentHeight(): number;
+    static contentAttributes: Facet<Attrs, Attrs>;
     /**
-    Move a cursor position by [grapheme
-    cluster](https://codemirror.net/6/docs/ref/#text.findClusterBreak). `forward` determines whether
-    the motion is away from the line start, or towards it. Motion in
-    bidirectional text is in visual order, in the editor's [text
-    direction](https://codemirror.net/6/docs/ref/#view.EditorView.textDirection). When the start
-    position was the last one on the line, the returned position
-    will be across the line break. If there is no further line, the
-    original position is returned.
-
-    By default, this method moves over a single cluster. The
-    optional `by` argument can be used to move across more. It will
-    be called with the first cluster as argument, and should return
-    a predicate that determines, for each subsequent cluster,
-    whether it should also be moved over.
+    Facet that provides DOM attributes for the editor's outer
+    element.
     */
-    moveByChar(start: SelectionRange, forward: boolean, by?: (initial: string) => (next: string) => boolean): SelectionRange;
+    static editorAttributes: Facet<Attrs, Attrs>;
     /**
-    Move a cursor position across the next group of either
-    [letters](https://codemirror.net/6/docs/ref/#state.EditorState.charCategorizer) or non-letter
-    non-whitespace characters.
+    An extension that enables line wrapping in the editor (by
+    setting CSS `white-space` to `pre-wrap` in the content).
     */
-    moveByGroup(start: SelectionRange, forward: boolean): SelectionRange;
+    static lineWrapping: Extension;
     /**
-    Move to the next line boundary in the given direction. If
-    `includeWrap` is true, line wrapping is on, and there is a
-    further wrap point on the current line, the wrap point will be
-    returned. Otherwise this function will return the start or end
-    of the line.
+    State effect used to include screen reader announcements in a
+    transaction. These will be added to the DOM in a visually hidden
+    element with `aria-live="polite"` set, and should be used to
+    describe effects that are visually obvious but may not be
+    noticed by screen reader users (such as moving to the next
+    search match).
     */
-    moveToLineBoundary(start: SelectionRange, forward: boolean, includeWrap?: boolean): SelectionRange;
-    /**
-    Move a cursor position vertically. When `distance` isn't given,
-    it defaults to moving to the next line (including wrapped
-    lines). Otherwise, `distance` should provide a positive distance
-    in pixels.
+    static announce: StateEffectType<string>;
+}
+/**
+Helper type that maps event names to event object types, or the
+`any` type for unknown events.
+*/
+interface DOMEventMap extends HTMLElementEventMap {
+    [other: string]: any;
+}
+/**
+Event handlers are specified with objects like this. For event
+types known by TypeScript, this will infer the event argument type
+to hold the appropriate event object type. For unknown events, it
+is inferred to `any`, and should be explicitly set if you want type
+checking.
+*/
+declare type DOMEventHandlers<This> = {
+    [event in keyof DOMEventMap]?: (this: This, event: DOMEventMap[event], view: EditorView) => boolean | void;
+};
 
-    When `start` has a
-    [`goalColumn`](https://codemirror.net/6/docs/ref/#state.SelectionRange.goalColumn), the vertical
-    motion will use that as a target horizontal position. Otherwise,
-    the cursor's own horizontal position is used. The returned
-    cursor will have its goal column set to whichever column was
-    used.
-    */
-    moveVertically(start: SelectionRange, forward: boolean, distance?: number): SelectionRange;
-    scrollPosIntoView(pos: number): void;
-    /**
-    Find the DOM parent node and offset (child offset if `node` is
-    an element, character offset when it is a text node) at the
-    given document position.
-    */
-    domAtPos(pos: number): {
-        node: Node;
-        offset: number;
-    };
-    /**
-    Find the document position at the given DOM node. Can be useful
-    for associating positions with DOM events. Will raise an error
-    when `node` isn't part of the editor content.
-    */
-    posAtDOM(node: Node, offset?: number): number;
+/**
+Key bindings associate key names with
+[command](https://codemirror.net/6/docs/ref/#view.Command)-style functions.
+
+Key names may be strings like `"Shift-Ctrl-Enter"`—a key identifier
+prefixed with zero or more modifiers. Key identifiers are based on
+the strings that can appear in
+[`KeyEvent.key`](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key).
+Use lowercase letters to refer to letter keys (or uppercase letters
+if you want shift to be held). You may use `"Space"` as an alias
+for the `" "` name.
+
+Modifiers can be given in any order. `Shift-` (or `s-`), `Alt-` (or
+`a-`), `Ctrl-` (or `c-` or `Control-`) and `Cmd-` (or `m-` or
+`Meta-`) are recognized.
+
+When a key binding contains multiple key names separated by
+spaces, it represents a multi-stroke binding, which will fire when
+the user presses the given keys after each other order.
+
+You can use `Mod-` as a shorthand for `Cmd-` on Mac and `Ctrl-` on
+other platforms. So `Mod-b` is `Ctrl-b` on Linux but `Cmd-b` on
+macOS.
+*/
+interface KeyBinding {
     /**
-    Get the document position at the given screen coordinates.
-    Returns null if no valid position could be found.
+    The key name to use for this binding. If the platform-specific
+    property (`mac`, `win`, or `linux`) for the current platform is
+    used as well in the binding, that one takes precedence. If `key`
+    isn't defined and the platform-specific binding isn't either,
+    a binding is ignored.
     */
-    posAtCoords(coords: {
-        x: number;
-        y: number;
-    }, precise: false): number;
-    posAtCoords(coords: {
-        x: number;
-        y: number;
-    }): number | null;
+    key?: string;
     /**
-    Get the screen coordinates at the given document position.
-    `side` determines whether the coordinates are based on the
-    element before (-1) or after (1) the position (if no element is
-    available on the given side, the method will transparently use
-    another strategy to get reasonable coordinates).
+    Key to use specifically on macOS.
     */
-    coordsAtPos(pos: number, side?: -1 | 1): Rect | null;
+    mac?: string;
     /**
-    The default width of a character in the editor. May not
-    accurately reflect the width of all characters (given variable
-    width fonts or styling of invididual ranges).
+    Key to use specifically on Windows.
     */
-    get defaultCharacterWidth(): number;
+    win?: string;
     /**
-    The default height of a line in the editor. May not be accurate
-    for all lines.
+    Key to use specifically on Linux.
     */
-    get defaultLineHeight(): number;
+    linux?: string;
     /**
-    The text direction
-    ([`direction`](https://developer.mozilla.org/en-US/docs/Web/CSS/direction)
-    CSS property) of the editor.
+    The command to execute when this binding is triggered. When the
+    command function returns `false`, further bindings will be tried
+    for the key.
     */
-    get textDirection(): Direction;
+    run: Command;
     /**
-    Whether this editor [wraps lines](https://codemirror.net/6/docs/ref/#view.EditorView.lineWrapping)
-    (as determined by the
-    [`white-space`](https://developer.mozilla.org/en-US/docs/Web/CSS/white-space)
-    CSS property of its content element).
+    When given, this defines a second binding, using the (possibly
+    platform-specific) key name prefixed with `Shift-` to activate
+    this command.
     */
-    get lineWrapping(): boolean;
+    shift?: Command;
     /**
-    Returns the bidirectional text structure of the given line
-    (which should be in the current document) as an array of span
-    objects. The order of these spans matches the [text
-    direction](https://codemirror.net/6/docs/ref/#view.EditorView.textDirection)—if that is
-    left-to-right, the leftmost spans come first, otherwise the
-    rightmost spans come first.
+    By default, key bindings apply when focus is on the editor
+    content (the `"editor"` scope). Some extensions, mostly those
+    that define their own panels, might want to allow you to
+    register bindings local to that panel. Such bindings should use
+    a custom scope name. You may also set multiple scope names,
+    separated by spaces.
     */
-    bidiSpans(line: Line$1): readonly BidiSpan[];
+    scope?: string;
     /**
-    Check whether the editor has focus.
+    When set to true (the default is false), this will always
+    prevent the further handling for the bound key, even if the
+    command(s) return false. This can be useful for cases where the
+    native behavior of the key is annoying or irrelevant but the
+    command doesn't always apply (such as, Mod-u for undo selection,
+    which would cause the browser to view source instead when no
+    selection can be undone).
     */
-    get hasFocus(): boolean;
+    preventDefault?: boolean;
+}
+/**
+Facet used for registering keymaps.
+
+You can add multiple keymaps to an editor. Their priorities
+determine their precedence (the ones specified early or with high
+priority get checked first). When a handler has returned `true`
+for a given key, no further handlers are called.
+*/
+declare const keymap: Facet<readonly KeyBinding[], readonly (readonly KeyBinding[])[]>;
+
+declare type SelectionConfig = {
     /**
-    Put focus on the editor.
+    The length of a full cursor blink cycle, in milliseconds.
+    Defaults to 1200. Can be set to 0 to disable blinking.
     */
-    focus(): void;
+    cursorBlinkRate?: number;
     /**
-    Clean up this editor view, removing its element from the
-    document, unregistering event handlers, and notifying
-    plugins. The view instance can no longer be used after
-    calling this.
+    Whether to show a cursor for non-empty ranges. Defaults to
+    true.
     */
-    destroy(): void;
+    drawRangeCursor?: boolean;
+};
+/**
+Returns an extension that hides the browser's native selection and
+cursor, replacing the selection with a background behind the text
+(with the `cm-selectionBackground` class), and the
+cursors with elements overlaid over the code (using
+`cm-cursor-primary` and `cm-cursor-secondary`).
+
+This allows the editor to display secondary selection ranges, and
+tends to produce a type of selection more in line with that users
+expect in a text editor (the native selection styling will often
+leave gaps between lines and won't fill the horizontal space after
+a line when the selection continues past it).
+
+It does have a performance cost, in that it requires an extra DOM
+layout cycle for many updates (the selection is drawn based on DOM
+layout information that's only available after laying out the
+content).
+*/
+declare function drawSelection(config?: SelectionConfig): Extension;
+
+interface SpecialCharConfig {
     /**
-    Effect that can be [added](https://codemirror.net/6/docs/ref/#state.TransactionSpec.effects) to a
-    transaction to make it scroll the given range into view.
+    An optional function that renders the placeholder elements.
+
+    The `description` argument will be text that clarifies what the
+    character is, which should be provided to screen readers (for
+    example with the
+    [`aria-label`](https://www.w3.org/TR/wai-aria/#aria-label)
+    attribute) and optionally shown to the user in other ways (such
+    as the
+    [`title`](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/title)
+    attribute).
+
+    The given placeholder string is a suggestion for how to display
+    the character visually.
     */
-    static scrollTo: StateEffectType<SelectionRange>;
+    render?: ((code: number, description: string | null, placeholder: string) => HTMLElement) | null;
     /**
-    Effect that makes the editor scroll the given range to the
-    center of the visible view.
+    Regular expression that matches the special characters to
+    highlight. Must have its 'g'/global flag set.
     */
-    static centerOn: StateEffectType<SelectionRange>;
+    specialChars?: RegExp;
     /**
-    Facet to add a [style
-    module](https://github.com/marijnh/style-mod#documentation) to
-    an editor view. The view will ensure that the module is
-    mounted in its [document
-    root](https://codemirror.net/6/docs/ref/#view.EditorView.constructor^config.root).
+    Regular expression that can be used to add characters to the
+    default set of characters to highlight.
     */
-    static styleModule: Facet<StyleModule, readonly StyleModule[]>;
+    addSpecialChars?: RegExp | null;
+}
+/**
+Returns an extension that installs highlighting of special
+characters.
+*/
+declare function highlightSpecialChars(
+/**
+Configuration options.
+*/
+config?: SpecialCharConfig): Extension;
+
+/**
+Returns a plugin that makes sure the content has a bottom margin
+equivalent to the height of the editor, minus one line height, so
+that every line in the document can be scrolled to the top of the
+editor.
+
+This is only meaningful when the editor is scrollable, and should
+not be enabled in editors that take the size of their content.
+*/
+declare function scrollPastEnd(): Extension;
+
+/**
+Extension that enables a placeholder—a piece of example content
+to show when the editor is empty.
+*/
+declare function placeholder(content: string | HTMLElement): Extension;
+
+/**
+Helper class used to make it easier to maintain decorations on
+visible code that matches a given regular expression. To be used
+in a [view plugin](https://codemirror.net/6/docs/ref/#view.ViewPlugin). Instances of this object
+represent a matching configuration.
+*/
+declare class MatchDecorator {
+    private regexp;
+    private getDeco;
+    private boundary;
     /**
-    Facet that can be used to add DOM event handlers. The value
-    should be an object mapping event names to handler functions. The
-    first such function to return true will be assumed to have handled
-    that event, and no other handlers or built-in behavior will be
-    activated for it.
-    These are registered on the [content
-    element](https://codemirror.net/6/docs/ref/#view.EditorView.contentDOM), except for `scroll`
-    handlers, which will be called any time the editor's [scroll
-    element](https://codemirror.net/6/docs/ref/#view.EditorView.scrollDOM) or one of its parent nodes
-    is scrolled.
+    Create a decorator.
     */
-    static domEventHandlers(handlers: DOMEventHandlers<any>): Extension;
+    constructor(config: {
+        /**
+        The regular expression to match against the content. Will only
+        be matched inside lines (not across them). Should have its 'g'
+        flag set.
+        */
+        regexp: RegExp;
+        /**
+        The decoration to apply to matches, either directly or as a
+        function of the match.
+        */
+        decoration: Decoration | ((match: RegExpExecArray, view: EditorView, pos: number) => Decoration);
+        /**
+        By default, changed lines are re-matched entirely. You can
+        provide a boundary expression, which should match single
+        character strings that can never occur in `regexp`, to reduce
+        the amount of re-matching.
+        */
+        boundary?: RegExp;
+    });
     /**
-    An input handler can override the way changes to the editable
-    DOM content are handled. Handlers are passed the document
-    positions between which the change was found, and the new
-    content. When one returns true, no further input handlers are
-    called and the default behavior is prevented.
+    Compute the full set of decorations for matches in the given
+    view's viewport. You'll want to call this when initializing your
+    plugin.
     */
-    static inputHandler: Facet<(view: EditorView, from: number, to: number, text: string) => boolean, readonly ((view: EditorView, from: number, to: number, text: string) => boolean)[]>;
+    createDeco(view: EditorView): RangeSet<Decoration>;
     /**
-    Allows you to provide a function that should be called when the
-    library catches an exception from an extension (mostly from view
-    plugins, but may be used by other extensions to route exceptions
-    from user-code-provided callbacks). This is mostly useful for
-    debugging and logging. See [`logException`](https://codemirror.net/6/docs/ref/#view.logException).
+    Update a set of decorations for a view update. `deco` _must_ be
+    the set of decorations produced by _this_ `MatchDecorator` for
+    the view state before the update.
     */
-    static exceptionSink: Facet<(exception: any) => void, readonly ((exception: any) => void)[]>;
+    updateDeco(update: ViewUpdate, deco: DecorationSet): DecorationSet;
+    private updateRange;
+}
+
+/**
+A language object manages parsing and per-language
+[metadata](https://codemirror.net/6/docs/ref/#state.EditorState.languageDataAt). Parse data is
+managed as a [Lezer](https://lezer.codemirror.net) tree. You'll
+want to subclass this class for custom parsers, or use the
+[`LRLanguage`](https://codemirror.net/6/docs/ref/#language.LRLanguage) or
+[`StreamLanguage`](https://codemirror.net/6/docs/ref/#stream-parser.StreamLanguage) abstractions for
+[Lezer](https://lezer.codemirror.net/) or stream parsers.
+*/
+declare class Language {
     /**
-    A facet that can be used to register a function to be called
-    every time the view updates.
+    The [language data](https://codemirror.net/6/docs/ref/#state.EditorState.languageDataAt) data
+    facet used for this language.
     */
-    static updateListener: Facet<(update: ViewUpdate) => void, readonly ((update: ViewUpdate) => void)[]>;
+    readonly data: Facet<{
+        [name: string]: any;
+    }>;
     /**
-    Facet that controls whether the editor content DOM is editable.
-    When its highest-precedence value is `false`, the element will
-    not longer have its `contenteditable` attribute set. (Note that
-    this doesn't affect API calls that change the editor content,
-    even when those are bound to keys or buttons. See the
-    [`readOnly`](https://codemirror.net/6/docs/ref/#state.EditorState.readOnly) facet for that.)
+    The node type of the top node of trees produced by this parser.
     */
-    static editable: Facet<boolean, boolean>;
+    readonly topNode: NodeType;
     /**
-    Allows you to influence the way mouse selection happens. The
-    functions in this facet will be called for a `mousedown` event
-    on the editor, and can return an object that overrides the way a
-    selection is computed from that mouse click or drag.
+    The extension value to install this provider.
     */
-    static mouseSelectionStyle: Facet<MakeSelectionStyle, readonly MakeSelectionStyle[]>;
+    readonly extension: Extension;
     /**
-    Facet used to configure whether a given selection drag event
-    should move or copy the selection. The given predicate will be
-    called with the `mousedown` event, and can return `true` when
-    the drag should move the content.
+    The parser object. Can be useful when using this as a [nested
+    parser](https://lezer.codemirror.net/docs/ref#common.Parser).
     */
-    static dragMovesSelection: Facet<(event: MouseEvent) => boolean, readonly ((event: MouseEvent) => boolean)[]>;
+    parser: Parser;
     /**
-    Facet used to configure whether a given selecting click adds
-    a new range to the existing selection or replaces it entirely.
+    Construct a language object. You usually don't need to invoke
+    this directly. But when you do, make sure you use
+    [`defineLanguageFacet`](https://codemirror.net/6/docs/ref/#language.defineLanguageFacet) to create
+    the first argument.
     */
-    static clickAddsSelectionRange: Facet<(event: MouseEvent) => boolean, readonly ((event: MouseEvent) => boolean)[]>;
+    constructor(
     /**
-    A facet that determines which [decorations](https://codemirror.net/6/docs/ref/#view.Decoration)
-    are shown in the view. See also [view
-    plugins](https://codemirror.net/6/docs/ref/#view.EditorView^decorations), which have a separate
-    mechanism for providing decorations.
+    The [language data](https://codemirror.net/6/docs/ref/#state.EditorState.languageDataAt) data
+    facet used for this language.
     */
-    static decorations: Facet<DecorationSet, readonly DecorationSet[]>;
+    data: Facet<{
+        [name: string]: any;
+    }>, parser: Parser,
     /**
-    Create a theme extension. The first argument can be a
-    [`style-mod`](https://github.com/marijnh/style-mod#documentation)
-    style spec providing the styles for the theme. These will be
-    prefixed with a generated class for the style.
-
-    Because the selectors will be prefixed with a scope class, rule
-    that directly match the editor's [wrapper
-    element](https://codemirror.net/6/docs/ref/#view.EditorView.dom)—to which the scope class will be
-    added—need to be explicitly differentiated by adding an `&` to
-    the selector for that element—for example
-    `&.cm-focused`.
-
-    When `dark` is set to true, the theme will be marked as dark,
-    which will cause the `&dark` rules from [base
-    themes](https://codemirror.net/6/docs/ref/#view.EditorView^baseTheme) to be used (as opposed to
-    `&light` when a light theme is active).
+    The node type of the top node of trees produced by this parser.
     */
-    static theme(spec: {
-        [selector: string]: StyleSpec;
-    }, options?: {
-        dark?: boolean;
-    }): Extension;
+    topNode: NodeType, extraExtensions?: Extension[]);
     /**
-    Create an extension that adds styles to the base theme. Like
-    with [`theme`](https://codemirror.net/6/docs/ref/#view.EditorView^theme), use `&` to indicate the
-    place of the editor wrapper element when directly targeting
-    that. You can also use `&dark` or `&light` instead to only
-    target editors with a dark or light theme.
+    Query whether this language is active at the given position.
     */
-    static baseTheme(spec: {
-        [selector: string]: StyleSpec;
-    }): Extension;
+    isActiveAt(state: EditorState, pos: number, side?: -1 | 0 | 1): boolean;
     /**
-    Facet that provides additional DOM attributes for the editor's
-    editable DOM element.
+    Find the document regions that were parsed using this language.
+    The returned regions will _include_ any nested languages rooted
+    in this language, when those exist.
     */
-    static contentAttributes: Facet<Attrs, Attrs>;
+    findRegions(state: EditorState): {
+        from: number;
+        to: number;
+    }[];
     /**
-    Facet that provides DOM attributes for the editor's outer
-    element.
+    Indicates whether this language allows nested languages. The
+    default implementation returns true.
     */
-    static editorAttributes: Facet<Attrs, Attrs>;
+    get allowsNesting(): boolean;
+}
+/**
+A subclass of [`Language`](https://codemirror.net/6/docs/ref/#language.Language) for use with Lezer
+[LR parsers](https://lezer.codemirror.net/docs/ref#lr.LRParser)
+parsers.
+*/
+declare class LRLanguage extends Language {
+    readonly parser: LRParser;
+    private constructor();
     /**
-    An extension that enables line wrapping in the editor (by
-    setting CSS `white-space` to `pre-wrap` in the content).
+    Define a language from a parser.
     */
-    static lineWrapping: Extension;
+    static define(spec: {
+        /**
+        The parser to use. Should already have added editor-relevant
+        node props (and optionally things like dialect and top rule)
+        configured.
+        */
+        parser: LRParser;
+        /**
+        [Language data](https://codemirror.net/6/docs/ref/#state.EditorState.languageDataAt)
+        to register for this language.
+        */
+        languageData?: {
+            [name: string]: any;
+        };
+    }): LRLanguage;
     /**
-    State effect used to include screen reader announcements in a
-    transaction. These will be added to the DOM in a visually hidden
-    element with `aria-live="polite"` set, and should be used to
-    describe effects that are visually obvious but may not be
-    noticed by screen reader users (such as moving to the next
-    search match).
+    Create a new instance of this language with a reconfigured
+    version of its parser.
     */
-    static announce: StateEffectType<string>;
+    configure(options: ParserConfig): LRLanguage;
+    get allowsNesting(): boolean;
 }
 /**
-Helper type that maps event names to event object types, or the
-`any` type for unknown events.
+Get the syntax tree for a state, which is the current (possibly
+incomplete) parse tree of active [language](https://codemirror.net/6/docs/ref/#language.Language),
+or the empty tree if there is no language available.
 */
-interface DOMEventMap extends HTMLElementEventMap {
-    [other: string]: any;
-}
+declare function syntaxTree(state: EditorState): Tree;
 /**
-Event handlers are specified with objects like this. For event
-types known by TypeScript, this will infer the event argument type
-to hold the appropriate event object type. For unknown events, it
-is inferred to `any`, and should be explicitly set if you want type
-checking.
+Try to get a parse tree that spans at least up to `upto`. The
+method will do at most `timeout` milliseconds of work to parse
+up to that point if the tree isn't already available.
 */
-declare type DOMEventHandlers<This> = {
-    [event in keyof DOMEventMap]?: (this: This, event: DOMEventMap[event], view: EditorView) => boolean | void;
-};
-
+declare function ensureSyntaxTree(state: EditorState, upto: number, timeout?: number): Tree | null;
 /**
-Key bindings associate key names with
-[command](https://codemirror.net/6/docs/ref/#view.Command)-style functions.
-
-Key names may be strings like `"Shift-Ctrl-Enter"`—a key identifier
-prefixed with zero or more modifiers. Key identifiers are based on
-the strings that can appear in
-[`KeyEvent.key`](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key).
-Use lowercase letters to refer to letter keys (or uppercase letters
-if you want shift to be held). You may use `"Space"` as an alias
-for the `" "` name.
-
-Modifiers can be given in any order. `Shift-` (or `s-`), `Alt-` (or
-`a-`), `Ctrl-` (or `c-` or `Control-`) and `Cmd-` (or `m-` or
-`Meta-`) are recognized.
-
-When a key binding contains multiple key names separated by
-spaces, it represents a multi-stroke binding, which will fire when
-the user presses the given keys after each other order.
-
-You can use `Mod-` as a shorthand for `Cmd-` on Mac and `Ctrl-` on
-other platforms. So `Mod-b` is `Ctrl-b` on Linux but `Cmd-b` on
-macOS.
+This class bundles a [language object](https://codemirror.net/6/docs/ref/#language.Language) with an
+optional set of supporting extensions. Language packages are
+encouraged to export a function that optionally takes a
+configuration object and returns a `LanguageSupport` instance, as
+the main way for client code to use the package.
 */
-interface KeyBinding {
+declare class LanguageSupport {
     /**
-    The key name to use for this binding. If the platform-specific
-    property (`mac`, `win`, or `linux`) for the current platform is
-    used as well in the binding, that one takes precedence. If `key`
-    isn't defined and the platform-specific binding isn't either,
-    a binding is ignored.
+    The language object.
     */
-    key?: string;
+    readonly language: Language;
     /**
-    Key to use specifically on macOS.
+    An optional set of supporting extensions. When nesting a
+    language in another language, the outer language is encouraged
+    to include the supporting extensions for its inner languages
+    in its own set of support extensions.
     */
-    mac?: string;
+    readonly support: Extension;
     /**
-    Key to use specifically on Windows.
+    An extension including both the language and its support
+    extensions. (Allowing the object to be used as an extension
+    value itself.)
     */
-    win?: string;
+    extension: Extension;
     /**
-    Key to use specifically on Linux.
+    Create a support object.
     */
-    linux?: string;
+    constructor(
     /**
-    The command to execute when this binding is triggered. When the
-    command function returns `false`, further bindings will be tried
-    for the key.
+    The language object.
     */
-    run: Command;
+    language: Language,
     /**
-    When given, this defines a second binding, using the (possibly
-    platform-specific) key name prefixed with `Shift-` to activate
-    this command.
+    An optional set of supporting extensions. When nesting a
+    language in another language, the outer language is encouraged
+    to include the supporting extensions for its inner languages
+    in its own set of support extensions.
     */
-    shift?: Command;
+    support?: Extension);
+}
+/**
+Language descriptions are used to store metadata about languages
+and to dynamically load them. Their main role is finding the
+appropriate language for a filename or dynamically loading nested
+parsers.
+*/
+declare class LanguageDescription {
     /**
-    By default, key bindings apply when focus is on the editor
-    content (the `"editor"` scope). Some extensions, mostly those
-    that define their own panels, might want to allow you to
-    register bindings local to that panel. Such bindings should use
-    a custom scope name. You may also set multiple scope names,
-    separated by spaces.
+    The name of this language.
     */
-    scope?: string;
+    readonly name: string;
     /**
-    When set to true (the default is false), this will always
-    prevent the further handling for the bound key, even if the
-    command(s) return false. This can be useful for cases where the
-    native behavior of the key is annoying or irrelevant but the
-    command doesn't always apply (such as, Mod-u for undo selection,
-    which would cause the browser to view source instead when no
-    selection can be undone).
+    Alternative names for the mode (lowercased, includes `this.name`).
+    */
+    readonly alias: readonly string[];
+    /**
+    File extensions associated with this language.
+    */
+    readonly extensions: readonly string[];
+    /**
+    Optional filename pattern that should be associated with this
+    language.
     */
-    preventDefault?: boolean;
-}
-/**
-Facet used for registering keymaps.
-
-You can add multiple keymaps to an editor. Their priorities
-determine their precedence (the ones specified early or with high
-priority get checked first). When a handler has returned `true`
-for a given key, no further handlers are called.
-*/
-declare const keymap: Facet<readonly KeyBinding[], readonly (readonly KeyBinding[])[]>;
-
-declare type SelectionConfig = {
+    readonly filename: RegExp | undefined;
+    private loadFunc;
     /**
-    The length of a full cursor blink cycle, in milliseconds.
-    Defaults to 1200. Can be set to 0 to disable blinking.
+    If the language has been loaded, this will hold its value.
     */
-    cursorBlinkRate?: number;
+    support: LanguageSupport | undefined;
+    private loading;
+    private constructor();
     /**
-    Whether to show a cursor for non-empty ranges. Defaults to
-    true.
+    Start loading the the language. Will return a promise that
+    resolves to a [`LanguageSupport`](https://codemirror.net/6/docs/ref/#language.LanguageSupport)
+    object when the language successfully loads.
     */
-    drawRangeCursor?: boolean;
-};
-/**
-Returns an extension that hides the browser's native selection and
-cursor, replacing the selection with a background behind the text
-(with the `cm-selectionBackground` class), and the
-cursors with elements overlaid over the code (using
-`cm-cursor-primary` and `cm-cursor-secondary`).
-
-This allows the editor to display secondary selection ranges, and
-tends to produce a type of selection more in line with that users
-expect in a text editor (the native selection styling will often
-leave gaps between lines and won't fill the horizontal space after
-a line when the selection continues past it).
-
-It does have a performance cost, in that it requires an extra DOM
-layout cycle for many updates (the selection is drawn based on DOM
-layout information that's only available after laying out the
-content).
-*/
-declare function drawSelection(config?: SelectionConfig): Extension;
-
-interface SpecialCharConfig {
+    load(): Promise<LanguageSupport>;
     /**
-    An optional function that renders the placeholder elements.
-
-    The `description` argument will be text that clarifies what the
-    character is, which should be provided to screen readers (for
-    example with the
-    [`aria-label`](https://www.w3.org/TR/wai-aria/#aria-label)
-    attribute) and optionally shown to the user in other ways (such
-    as the
-    [`title`](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/title)
-    attribute).
-
-    The given placeholder string is a suggestion for how to display
-    the character visually.
+    Create a language description.
     */
-    render?: ((code: number, description: string | null, placeholder: string) => HTMLElement) | null;
+    static of(spec: {
+        /**
+        The language's name.
+        */
+        name: string;
+        /**
+        An optional array of alternative names.
+        */
+        alias?: readonly string[];
+        /**
+        An optional array of filename extensions associated with this
+        language.
+        */
+        extensions?: readonly string[];
+        /**
+        An optional filename pattern associated with this language.
+        */
+        filename?: RegExp;
+        /**
+        A function that will asynchronously load the language.
+        */
+        load?: () => Promise<LanguageSupport>;
+        /**
+        Alternatively to `load`, you can provide an already loaded
+        support object. Either this or `load` should be provided.
+        */
+        support?: LanguageSupport;
+    }): LanguageDescription;
     /**
-    Regular expression that matches the special characters to
-    highlight. Must have its 'g'/global flag set.
+    Look for a language in the given array of descriptions that
+    matches the filename. Will first match
+    [`filename`](https://codemirror.net/6/docs/ref/#language.LanguageDescription.filename) patterns,
+    and then [extensions](https://codemirror.net/6/docs/ref/#language.LanguageDescription.extensions),
+    and return the first language that matches.
     */
-    specialChars?: RegExp;
+    static matchFilename(descs: readonly LanguageDescription[], filename: string): LanguageDescription | null;
     /**
-    Regular expression that can be used to add characters to the
-    default set of characters to highlight.
+    Look for a language whose name or alias matches the the given
+    name (case-insensitively). If `fuzzy` is true, and no direct
+    matchs is found, this'll also search for a language whose name
+    or alias occurs in the string (for names shorter than three
+    characters, only when surrounded by non-word characters).
     */
-    addSpecialChars?: RegExp | null;
+    static matchLanguageName(descs: readonly LanguageDescription[], name: string, fuzzy?: boolean): LanguageDescription | null;
 }
 /**
-Returns an extension that installs highlighting of special
-characters.
-*/
-declare function highlightSpecialChars(
-/**
-Configuration options.
-*/
-config?: SpecialCharConfig): Extension;
-
-/**
-Returns a plugin that makes sure the content has a bottom margin
-equivalent to the height of the editor, minus one line height, so
-that every line in the document can be scrolled to the top of the
-editor.
-
-This is only meaningful when the editor is scrollable, and should
-not be enabled in editors that take the size of their content.
-*/
-declare function scrollPastEnd(): Extension;
-
-/**
-Extension that enables a placeholder—a piece of example content
-to show when the editor is empty.
+Facet for overriding the unit by which indentation happens.
+Should be a string consisting either entirely of spaces or
+entirely of tabs. When not set, this defaults to 2 spaces.
 */
-declare function placeholder(content: string | HTMLElement): Extension;
-
+declare const indentUnit: Facet<string, string>;
 /**
-Helper class used to make it easier to maintain decorations on
-visible code that matches a given regular expression. To be used
-in a [view plugin](https://codemirror.net/6/docs/ref/#view.ViewPlugin). Instances of this object
-represent a matching configuration.
+Indentation contexts are used when calling [indentation
+services](https://codemirror.net/6/docs/ref/#language.indentService). They provide helper utilities
+useful in indentation logic, and can selectively override the
+indentation reported for some lines.
 */
-declare class MatchDecorator {
-    private regexp;
-    private getDeco;
-    private boundary;
+declare class IndentContext {
     /**
-    Create a decorator.
+    The editor state.
     */
-    constructor(config: {
+    readonly state: EditorState;
+    /**
+    The indent unit (number of columns per indentation level).
+    */
+    unit: number;
+    /**
+    Create an indent context.
+    */
+    constructor(
+    /**
+    The editor state.
+    */
+    state: EditorState,
+    /**
+    @internal
+    */
+    options?: {
         /**
-        The regular expression to match against the content. Will only
-        be matched inside lines (not across them). Should have its 'g'
-        flag set.
+        Override line indentations provided to the indentation
+        helper function, which is useful when implementing region
+        indentation, where indentation for later lines needs to refer
+        to previous lines, which may have been reindented compared to
+        the original start state. If given, this function should
+        return -1 for lines (given by start position) that didn't
+        change, and an updated indentation otherwise.
         */
-        regexp: RegExp;
+        overrideIndentation?: (pos: number) => number;
         /**
-        The decoration to apply to matches, either directly or as a
-        function of the match.
+        Make it look, to the indent logic, like a line break was
+        added at the given position (which is mostly just useful for
+        implementing something like
+        [`insertNewlineAndIndent`](https://codemirror.net/6/docs/ref/#commands.insertNewlineAndIndent)).
         */
-        decoration: Decoration | ((match: RegExpExecArray, view: EditorView, pos: number) => Decoration);
+        simulateBreak?: number;
         /**
-        By default, changed lines are re-matched entirely. You can
-        provide a boundary expression, which should match single
-        character strings that can never occur in `regexp`, to reduce
-        the amount of re-matching.
+        When `simulateBreak` is given, this can be used to make the
+        simulate break behave like a double line break.
         */
-        boundary?: RegExp;
+        simulateDoubleBreak?: boolean;
     });
     /**
-    Compute the full set of decorations for matches in the given
-    view's viewport. You'll want to call this when initializing your
-    plugin.
+    Get a description of the line at the given position, taking
+    [simulated line
+    breaks](https://codemirror.net/6/docs/ref/#language.IndentContext.constructor^options.simulateBreak)
+    into account. If there is such a break at `pos`, the `bias`
+    argument determines whether the part of the line line before or
+    after the break is used.
     */
-    createDeco(view: EditorView): RangeSet<Decoration>;
+    lineAt(pos: number, bias?: -1 | 1): {
+        text: string;
+        from: number;
+    };
     /**
-    Update a set of decorations for a view update. `deco` _must_ be
-    the set of decorations produced by _this_ `MatchDecorator` for
-    the view state before the update.
+    Get the text directly after `pos`, either the entire line
+    or the next 100 characters, whichever is shorter.
     */
-    updateDeco(update: ViewUpdate, deco: DecorationSet): DecorationSet;
-    private updateRange;
+    textAfterPos(pos: number, bias?: -1 | 1): string;
+    /**
+    Find the column for the given position.
+    */
+    column(pos: number, bias?: -1 | 1): number;
+    /**
+    Find the column position (taking tabs into account) of the given
+    position in the given string.
+    */
+    countColumn(line: string, pos?: number): number;
+    /**
+    Find the indentation column of the line at the given point.
+    */
+    lineIndent(pos: number, bias?: -1 | 1): number;
+    /**
+    Returns the [simulated line
+    break](https://codemirror.net/6/docs/ref/#language.IndentContext.constructor^options.simulateBreak)
+    for this context, if any.
+    */
+    get simulatedBreak(): number | null;
 }
+/**
+Enables reindentation on input. When a language defines an
+`indentOnInput` field in its [language
+data](https://codemirror.net/6/docs/ref/#state.EditorState.languageDataAt), which must hold a regular
+expression, the line at the cursor will be reindented whenever new
+text is typed and the input from the start of the line up to the
+cursor matches that regexp.
+
+To avoid unneccesary reindents, it is recommended to start the
+regexp with `^` (usually followed by `\s*`), and end it with `$`.
+For example, `/^\s*\}$/` will reindent when a closing brace is
+added at the start of a line.
+*/
+declare function indentOnInput(): Extension;
 
 interface CompletionConfig {
     /**
@@ -4604,6 +4661,12 @@ interface GutterConfig {
     */
     lineMarker?: (view: EditorView, line: BlockInfo, otherMarkers: readonly GutterMarker[]) => GutterMarker | null;
     /**
+    If line markers depend on additional state, and should be
+    updated when that changes, pass a predicate here that checks
+    whether a given view update might change the line markers.
+    */
+    lineMarkerChange?: null | ((update: ViewUpdate) => boolean);
+    /**
     Add a hidden spacer element that gives the gutter its base
     width.
     */