@codemirror/view 0.19.48 → 0.20.2

package/dist/index.d.ts

@@ -1,9 +1,5 @@
-import * as _codemirror_rangeset from '@codemirror/rangeset';
-import { RangeSet, RangeValue, Range } from '@codemirror/rangeset';
-export { Range } from '@codemirror/rangeset';
 import * as _codemirror_state from '@codemirror/state';
-import { EditorState, Extension, Transaction, ChangeSet, EditorSelection, TransactionSpec, SelectionRange, StateEffect, Facet } from '@codemirror/state';
-import { Line } from '@codemirror/text';
+import { RangeSet, RangeValue, Range, EditorState, Extension, Transaction, ChangeSet, EditorSelection, TransactionSpec, SelectionRange, Line, StateEffect, Facet } from '@codemirror/state';
 import { StyleModule, StyleSpec } from 'style-mod';
 
 declare type Attrs = {
@@ -39,9 +35,10 @@ interface MarkDecorationSpec {
     class?: string;
     /**
     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.
+    that there will not necessarily be a single element covering the
+    entire range—other decorations with lower precedence might split
+    this one if they partially overlap it, and line breaks always
+    end decoration elements.
     */
     tagName?: string;
     /**
@@ -132,7 +129,7 @@ interface LineDecorationSpec {
 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
+needed, and to avoid redrawing widgets even if the decorations
 that define them are recreated.
 */
 declare abstract class WidgetType {
@@ -149,7 +146,7 @@ declare abstract class WidgetType {
     returns `false`, which will cause new instances of the widget to
     always be redrawn.
     */
-    eq(_widget: WidgetType): boolean;
+    eq(widget: WidgetType): boolean;
     /**
     Update a DOM element created by a widget of the same type (but
     different, non-`eq` content) to reflect this widget. May return
@@ -157,7 +154,7 @@ declare abstract class WidgetType {
     couldn't (in which case the widget will be redrawn). The default
     implementation just returns false.
     */
-    updateDOM(_dom: HTMLElement): boolean;
+    updateDOM(dom: HTMLElement): boolean;
     /**
     The estimated height this widget will have, to be used when
     estimating the height of content that hasn't been drawn. May
@@ -170,17 +167,17 @@ declare abstract class WidgetType {
     should be ignored by the editor. The default is to ignore all
     events.
     */
-    ignoreEvent(_event: Event): boolean;
+    ignoreEvent(event: Event): boolean;
     /**
     This is called when the an instance of the widget is removed
     from the editor view.
     */
-    destroy(_dom: HTMLElement): void;
+    destroy(dom: HTMLElement): void;
 }
 /**
 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.
+[`RangeSet`](https://codemirror.net/6/docs/ref/#state.RangeSet) for its methods.
 */
 declare type DecorationSet = RangeSet<Decoration>;
 /**
@@ -207,7 +204,8 @@ declare enum BlockType {
 /**
 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.
+[`Range`](https://codemirror.net/6/docs/ref/#state.Range), which adds a start and end position.
+@nonabstract
 */
 declare abstract class Decoration extends RangeValue {
     /**
@@ -221,16 +219,15 @@ declare abstract class Decoration extends RangeValue {
     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.
+    precedence of the [facet](https://codemirror.net/6/docs/ref/#view.EditorView^decorations), with
+    the higher-precedence decorations creating the inner DOM nodes.
+    Such elements are split on line boundaries and on the boundaries
+    of lower-precedence decorations.
     */
     static mark(spec: MarkDecorationSpec): Decoration;
     /**
-    Create a widget decoration, which adds an element at the given
-    position.
+    Create a widget decoration, which displays a DOM element at the
+    given position.
     */
     static widget(spec: WidgetDecorationSpec): Decoration;
     /**
@@ -290,7 +287,7 @@ declare function logException(state: EditorState, exception: any, context?: stri
 /**
 This is the interface plugin objects conform to.
 */
-interface PluginValue {
+interface PluginValue extends Object {
     /**
     Notifies the plugin of an update that happened in the view. This
     is called _before_ the view updates its own DOM. It is
@@ -301,75 +298,13 @@ interface PluginValue {
     [`requestMeasure`](https://codemirror.net/6/docs/ref/#view.EditorView.requestMeasure) to schedule
     your code in a DOM reading phase if you need to.
     */
-    update?(_update: ViewUpdate): void;
+    update?(update: ViewUpdate): void;
     /**
     Called when the plugin is no longer going to be used. Should
     revert any changes the plugin made to the DOM.
     */
     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];
-}
-/**
-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> {
-    /**
-    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.
-    */
-    from<V extends PluginValue>(get: (value: V) => T): PluginFieldProvider<V>;
-    /**
-    Define a new plugin field.
-    */
-    static define<T>(): PluginField<T>;
-    /**
-    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. They **must not** introduce block
-    widgets (that will raise an error) or replacing decorations that
-    cover line breaks (these will be ignored if they occur). Such
-    decorations, or others that cause a large amount of vertical
-    size shift compared to the undecorated content, should be
-    provided through the state-level [`decorations`
-    facet](https://codemirror.net/6/docs/ref/#view.EditorView^decorations) instead.
-    */
-    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.
-    */
-    static atomicRanges: PluginField<RangeSet<any>>;
-    /**
-    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).
-    */
-    static scrollMargins: PluginField<Partial<Rect> | null>;
-}
 /**
 Provides additional information when defining a [view
 plugin](https://codemirror.net/6/docs/ref/#view.ViewPlugin).
@@ -383,20 +318,18 @@ interface PluginSpec<V extends PluginValue> {
     */
     eventHandlers?: DOMEventHandlers<V>;
     /**
+    Specify that the plugin provides additional extensions when
+    added to an editor configuration.
+    */
+    provide?: (plugin: ViewPlugin<V>) => Extension;
+    /**
     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.
+    [layout-changing decorations](https://codemirror.net/6/docs/ref/#view.EditorView^decorations)
+    that depend on the view.
     */
     decorations?: (value: V) => DecorationSet;
-    /**
-    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.
-    */
-    provide?: PluginFieldProvider<V> | readonly PluginFieldProvider<V>[];
 }
 /**
 View plugins associate stateful values with a view. They can
@@ -413,12 +346,12 @@ declare class ViewPlugin<V extends PluginValue> {
     Define a plugin from a constructor function that creates the
     plugin's value, given an editor view.
     */
-    static define<V extends PluginValue & object>(create: (view: EditorView) => V, spec?: PluginSpec<V>): ViewPlugin<V>;
+    static define<V extends PluginValue>(create: (view: EditorView) => V, spec?: PluginSpec<V>): ViewPlugin<V>;
     /**
     Create a plugin for a class whose constructor takes a single
     editor view as argument.
     */
-    static fromClass<V extends PluginValue & object>(cls: {
+    static fromClass<V extends PluginValue>(cls: {
         new (view: EditorView): V;
     }, spec?: PluginSpec<V>): ViewPlugin<V>;
 }
@@ -472,8 +405,8 @@ declare class ViewUpdate {
     */
     get viewportChanged(): boolean;
     /**
-    Indicates whether the height of an element in the editor changed
-    in this update.
+    Indicates whether the height of a block element in the editor
+    changed in this update.
     */
     get heightChanged(): boolean;
     /**
@@ -529,6 +462,43 @@ interface MouseSelectionStyle {
 }
 declare type MakeSelectionStyle = (view: EditorView, event: MouseEvent) => MouseSelectionStyle | null;
 
+/**
+Record used to represent information about a block-level element
+in the editor view.
+*/
+declare class BlockInfo {
+    /**
+    The start of the element in the document.
+    */
+    readonly from: number;
+    /**
+    The length of the element.
+    */
+    readonly length: number;
+    /**
+    The top position of the element (relative to the top of the
+    document).
+    */
+    readonly top: number;
+    /**
+    Its height.
+    */
+    readonly height: number;
+    /**
+    The type of element this is. When querying lines, this may be
+    an array of all the blocks that make up the line.
+    */
+    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;
+}
+
 /**
 Used to indicate [text direction](https://codemirror.net/6/docs/ref/#view.EditorView.textDirection).
 */
@@ -569,43 +539,6 @@ declare class BidiSpan {
     get dir(): Direction;
 }
 
-/**
-Record used to represent information about a block-level element
-in the editor view.
-*/
-declare class BlockInfo {
-    /**
-    The start of the element in the document.
-    */
-    readonly from: number;
-    /**
-    The length of the element.
-    */
-    readonly length: number;
-    /**
-    The top position of the element (relative to the top of the
-    document).
-    */
-    readonly top: number;
-    /**
-    Its height.
-    */
-    readonly height: number;
-    /**
-    The type of element this is. When querying lines, this may be
-    an array of all the blocks that make up the line.
-    */
-    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;
-}
-
 interface EditorConfig {
     /**
     The view's initial state. Defaults to an extension-less state
@@ -613,6 +546,12 @@ interface EditorConfig {
     */
     state?: EditorState;
     /**
+    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.)
+    */
+    parent?: Element | DocumentFragment;
+    /**
     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
@@ -628,12 +567,6 @@ interface EditorConfig {
     method](https://codemirror.net/6/docs/ref/#view.EditorView.update).
     */
     dispatch?: (tr: Transaction) => void;
-    /**
-    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.)
-    */
-    parent?: Element | DocumentFragment;
 }
 /**
 An editor view represents the editor's user interface. It holds
@@ -719,9 +652,9 @@ declare class EditorView {
     private bidiCache;
     private destroyed;
     /**
-    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.
+    Construct a new view. You'll want to either provide a `parent`
+    option, or put `view.dom` into your document after creating a
+    view, so that the user can see the editor.
     */
     constructor(
     /**
@@ -775,11 +708,6 @@ declare class EditorView {
     */
     requestMeasure<T>(request?: MeasureRequest<T>): void;
     /**
-    Collect all values provided by the active plugins for a given
-    field.
-    */
-    pluginField<T>(field: PluginField<T>): readonly T[];
-    /**
     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
@@ -800,55 +728,18 @@ declare class EditorView {
         bottom: number;
     };
     /**
-    Find the line or block widget at the given vertical position.
-    
-    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 `elementAtHeight` instead.*
-    */
-    blockAtHeight(height: number, docTop?: number): BlockInfo;
-    /**
     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)
     */
     elementAtHeight(height: 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.
-    
-    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.*
-    */
-    visualLineAtHeight(height: number, docTop?: number): BlockInfo;
-    /**
     Find the line block (see
     [`lineBlockAt`](https://codemirror.net/6/docs/ref/#view.EditorView.lineBlockAt) at the given
     height.
     */
     lineBlockAtHeight(height: 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).
-    
-    *Deprecated: use `viewportLineBlocks` instead.*
-    */
-    viewportLines(f: (line: BlockInfo) => void, docTop?: number): void;
-    /**
     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
@@ -856,22 +747,9 @@ declare class EditorView {
     */
     get viewportLineBlocks(): BlockInfo[];
     /**
-    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.*
-    */
-    visualLineAt(pos: number, docTop?: number): BlockInfo;
-    /**
     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
+    non-[hidden](https://codemirror.net/6/docs/ref/#view.Decoration^replace) 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.
@@ -883,13 +761,13 @@ declare class EditorView {
     get contentHeight(): number;
     /**
     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.
+    cluster](https://codemirror.net/6/docs/ref/#state.findClusterBreak). `forward` determines whether
+    the motion is away from the line start, or towards it. In
+    bidirectional text, the line is traversed in visual order, using
+    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
@@ -926,7 +804,6 @@ declare class EditorView {
     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
@@ -984,10 +861,20 @@ declare class EditorView {
     /**
     The text direction
     ([`direction`](https://developer.mozilla.org/en-US/docs/Web/CSS/direction)
-    CSS property) of the editor.
+    CSS property) of the editor's content element.
     */
     get textDirection(): Direction;
     /**
+    Find the text direction of the block at the given position, as
+    assigned by CSS. If
+    [`perLineTextDirection`](https://codemirror.net/6/docs/ref/#view.EditorView^perLineTextDirection)
+    isn't enabled, or the given position is outside of the viewport,
+    this will always return the same as
+    [`textDirection`](https://codemirror.net/6/docs/ref/#view.EditorView.textDirection). Note that
+    this may trigger a DOM layout.
+    */
+    textDirectionAt(pos: number): Direction;
+    /**
     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)
@@ -1019,20 +906,6 @@ declare class EditorView {
     */
     destroy(): void;
     /**
-    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.
-    
-    *Deprecated*. Use [`scrollIntoView`](https://codemirror.net/6/docs/ref/#view.EditorView^scrollIntoView) instead.
-    */
-    static scrollTo: _codemirror_state.StateEffectType<SelectionRange>;
-    /**
-    Effect that makes the editor scroll the given range to the
-    center of the visible view.
-    
-    *Deprecated*. Use [`scrollIntoView`](https://codemirror.net/6/docs/ref/#view.EditorView^scrollIntoView) instead.
-    */
-    static centerOn: _codemirror_state.StateEffectType<SelectionRange>;
-    /**
     Returns an effect that can be
     [added](https://codemirror.net/6/docs/ref/#state.TransactionSpec.effects) to a transaction to
     cause it to scroll the given position or range into view.
@@ -1072,16 +945,16 @@ declare class EditorView {
     */
     static styleModule: Facet<StyleModule, readonly StyleModule[]>;
     /**
-    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.
+    Returns an extension that can be used to add DOM event handlers.
+    The value should be an object mapping event names to handler
+    functions. For any given event, such functions are ordered by
+    extension precedence, and the first handler 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.
     */
     static domEventHandlers(handlers: DOMEventHandlers<any>): Extension;
     /**
@@ -1093,6 +966,13 @@ declare class EditorView {
     */
     static inputHandler: Facet<(view: EditorView, from: number, to: number, text: string) => boolean, readonly ((view: EditorView, from: number, to: number, text: string) => boolean)[]>;
     /**
+    By default, the editor assumes all its content has the same
+    [text direction](https://codemirror.net/6/docs/ref/#view.Direction). Configure this with a `true`
+    value to make it read and store the text direction of every
+    (rendered) line separately.
+    */
+    static perLineTextDirection: Facet<boolean, boolean>;
+    /**
     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
@@ -1108,9 +988,9 @@ declare class EditorView {
     /**
     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
+    not 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.)
     */
     static editable: Facet<boolean, boolean>;
@@ -1129,17 +1009,44 @@ declare class EditorView {
     */
     static dragMovesSelection: Facet<(event: MouseEvent) => boolean, readonly ((event: MouseEvent) => boolean)[]>;
     /**
-    Facet used to configure whether a given selecting click adds
-    a new range to the existing selection or replaces it entirely.
+    Facet used to configure whether a given selecting click adds a
+    new range to the existing selection or replaces it entirely. The
+    default behavior is to check `event.metaKey` on macOS, and
+    `event.ctrlKey` elsewhere.
     */
     static clickAddsSelectionRange: Facet<(event: MouseEvent) => boolean, readonly ((event: MouseEvent) => boolean)[]>;
     /**
     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.
+    are shown in the view. Decorations can be provided in two
+    ways—directly, or via a function that takes an editor view.
+    
+    Only decoration sets provided directly are allowed to influence
+    the editor's vertical layout structure. The ones provided as
+    functions are called _after_ the new viewport has been computed,
+    and thus **must not** introduce block widgets or replacing
+    decorations that cover line breaks.
+    */
+    static decorations: Facet<DecorationSet | ((view: EditorView) => DecorationSet), readonly (DecorationSet | ((view: EditorView) => 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.
     */
-    static decorations: Facet<DecorationSet, readonly DecorationSet[]>;
+    static atomicRanges: Facet<(view: EditorView) => _codemirror_state.RangeSet<any>, readonly ((view: EditorView) => _codemirror_state.RangeSet<any>)[]>;
+    /**
+    Facet that allows extensions to provide additional scroll
+    margins (space around the sides of the scrolling element that
+    should be considered invisible). This can be useful when the
+    plugin introduces elements that cover part of that element (for
+    example a horizontally fixed gutter).
+    */
+    static scrollMargins: Facet<(view: EditorView) => Partial<Rect> | null, readonly ((view: EditorView) => Partial<Rect> | null)[]>;
     /**
     Create a theme extension. The first argument can be a
     [`style-mod`](https://github.com/marijnh/style-mod#documentation)
@@ -1241,7 +1148,7 @@ Modifiers can be given in any order. `Shift-` (or `s-`), `Alt-` (or
 
 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.
+the user presses the given keys after each other.
 
 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
@@ -1285,8 +1192,8 @@ interface KeyBinding {
     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.
+    a custom scope name. You may also assign multiple scope names to
+    a binding, separating them by spaces.
     */
     scope?: string;
     /**
@@ -1311,7 +1218,7 @@ for a given key, no further handlers are called.
 declare const keymap: Facet<readonly KeyBinding[], readonly (readonly KeyBinding[])[]>;
 /**
 Run the key handlers registered for a given scope. The event
-object should be `"keydown"` event. Returns true if any of the
+object should be a `"keydown"` event. Returns true if any of the
 handlers handled it.
 */
 declare function runScopeHandlers(view: EditorView, event: KeyboardEvent, scope: string): boolean;
@@ -1462,7 +1369,7 @@ declare class MatchDecorator {
     view's viewport. You'll want to call this when initializing your
     plugin.
     */
-    createDeco(view: EditorView): _codemirror_rangeset.RangeSet<Decoration>;
+    createDeco(view: EditorView): _codemirror_state.RangeSet<Decoration>;
     /**
     Update a set of decorations for a view update. `deco` _must_ be
     the set of decorations produced by _this_ `MatchDecorator` for
@@ -1472,4 +1379,388 @@ declare class MatchDecorator {
     private updateRange;
 }
 
-export { BidiSpan, BlockInfo, BlockType, Command, DOMEventHandlers, DOMEventMap, Decoration, DecorationSet, Direction, EditorView, KeyBinding, MatchDecorator, MouseSelectionStyle, PluginField, PluginFieldProvider, PluginSpec, PluginValue, Rect, ViewPlugin, ViewUpdate, WidgetType, drawSelection, dropCursor, highlightActiveLine, highlightSpecialChars, keymap, logException, placeholder, runScopeHandlers, scrollPastEnd };
+/**
+Create an extension that enables rectangular selections. By
+default, it will react to left mouse drag with the Alt key held
+down. When such a selection occurs, the text within the rectangle
+that was dragged over will be selected, as one selection
+[range](https://codemirror.net/6/docs/ref/#state.SelectionRange) per line.
+*/
+declare function rectangularSelection(options?: {
+    /**
+    A custom predicate function, which takes a `mousedown` event and
+    returns true if it should be used for rectangular selection.
+    */
+    eventFilter?: (event: MouseEvent) => boolean;
+}): Extension;
+/**
+Returns an extension that turns the pointer cursor into a
+crosshair when a given modifier key, defaulting to Alt, is held
+down. Can serve as a visual hint that rectangular selection is
+going to happen when paired with
+[`rectangularSelection`](https://codemirror.net/6/docs/ref/#view.rectangularSelection).
+*/
+declare function crosshairCursor(options?: {
+    key?: "Alt" | "Control" | "Shift" | "Meta";
+}): Extension;
+
+/**
+Creates an extension that configures tooltip behavior.
+*/
+declare function tooltips(config?: {
+    /**
+    By default, tooltips use `"fixed"`
+    [positioning](https://developer.mozilla.org/en-US/docs/Web/CSS/position),
+    which has the advantage that tooltips don't get cut off by
+    scrollable parent elements. However, CSS rules like `contain:
+    layout` can break fixed positioning in child nodes, which can be
+    worked about by using `"absolute"` here.
+    
+    On iOS, which at the time of writing still doesn't properly
+    support fixed positioning, the library always uses absolute
+    positioning.
+    */
+    position?: "fixed" | "absolute";
+    /**
+    The element to put the tooltips into. By default, they are put
+    in the editor (`cm-editor`) element, and that is usually what
+    you want. But in some layouts that can lead to positioning
+    issues, and you need to use a different parent to work around
+    those.
+    */
+    parent?: HTMLElement;
+    /**
+    By default, when figuring out whether there is room for a
+    tooltip at a given position, the extension considers the entire
+    space between 0,0 and `innerWidth`,`innerHeight` to be available
+    for showing tooltips. You can provide a function here that
+    returns an alternative rectangle.
+    */
+    tooltipSpace?: (view: EditorView) => {
+        top: number;
+        left: number;
+        bottom: number;
+        right: number;
+    };
+}): Extension;
+/**
+Describes a tooltip. Values of this type, when provided through
+the [`showTooltip`](https://codemirror.net/6/docs/ref/#view.showTooltip) facet, control the
+individual tooltips on the editor.
+*/
+interface Tooltip {
+    /**
+    The document position at which to show the tooltip.
+    */
+    pos: number;
+    /**
+    The end of the range annotated by this tooltip, if different
+    from `pos`.
+    */
+    end?: number;
+    /**
+    A constructor function that creates the tooltip's [DOM
+    representation](https://codemirror.net/6/docs/ref/#view.TooltipView).
+    */
+    create(view: EditorView): TooltipView;
+    /**
+    Whether the tooltip should be shown above or below the target
+    position. Not guaranteed to be respected for hover tooltips
+    since all hover tooltips for the same range are always
+    positioned together. Defaults to false.
+    */
+    above?: boolean;
+    /**
+    Whether the `above` option should be honored when there isn't
+    enough space on that side to show the tooltip inside the
+    viewport. Defaults to false.
+    */
+    strictSide?: boolean;
+    /**
+    When set to true, show a triangle connecting the tooltip element
+    to position `pos`.
+    */
+    arrow?: boolean;
+}
+/**
+Describes the way a tooltip is displayed.
+*/
+interface TooltipView {
+    /**
+    The DOM element to position over the editor.
+    */
+    dom: HTMLElement;
+    /**
+    Adjust the position of the tooltip relative to its anchor
+    position. A positive `x` value will move the tooltip
+    horizontally along with the text direction (so right in
+    left-to-right context, left in right-to-left). A positive `y`
+    will move the tooltip up when it is above its anchor, and down
+    otherwise.
+    */
+    offset?: {
+        x: number;
+        y: number;
+    };
+    /**
+    By default, a tooltip's screen position will be based on the
+    text position of its `pos` property. This method can be provided
+    to make the tooltip view itself responsible for finding its
+    screen position.
+    */
+    getCoords?: (pos: number) => Rect;
+    /**
+    By default, tooltips are moved when they overlap with other
+    tooltips. Set this to `true` to disable that behavior for this
+    tooltip.
+    */
+    overlap?: boolean;
+    /**
+    Called after the tooltip is added to the DOM for the first time.
+    */
+    mount?(view: EditorView): void;
+    /**
+    Update the DOM element for a change in the view's state.
+    */
+    update?(update: ViewUpdate): void;
+    /**
+    Called when the tooltip has been (re)positioned.
+    */
+    positioned?(): void;
+}
+/**
+Facet to which an extension can add a value to show a tooltip.
+*/
+declare const showTooltip: Facet<Tooltip | null, readonly (Tooltip | null)[]>;
+/**
+Set up a hover tooltip, which shows up when the pointer hovers
+over ranges of text. The callback is called when the mouse hovers
+over the document text. It should, if there is a tooltip
+associated with position `pos`, return the tooltip description
+(either directly or in a promise). The `side` argument indicates
+on which side of the position the pointer is—it will be -1 if the
+pointer is before the position, 1 if after the position.
+
+Note that all hover tooltips are hosted within a single tooltip
+container element. This allows multiple tooltips over the same
+range to be "merged" together without overlapping.
+*/
+declare function hoverTooltip(source: (view: EditorView, pos: number, side: -1 | 1) => Tooltip | null | Promise<Tooltip | null>, options?: {
+    /**
+    Controls whether a transaction hides the tooltip. The default
+    is to not hide.
+    */
+    hideOn?: (tr: Transaction, tooltip: Tooltip) => boolean;
+    /**
+    When enabled (this defaults to false), close the tooltip
+    whenever the document changes or the selection is set.
+    */
+    hideOnChange?: boolean | "touch";
+    /**
+    Hover time after which the tooltip should appear, in
+    milliseconds. Defaults to 300ms.
+    */
+    hoverTime?: number;
+}): Extension;
+/**
+Get the active tooltip view for a given tooltip, if available.
+*/
+declare function getTooltip(view: EditorView, tooltip: Tooltip): TooltipView | null;
+/**
+Returns true if any hover tooltips are currently active.
+*/
+declare function hasHoverTooltips(state: EditorState): boolean;
+/**
+Transaction effect that closes all hover tooltips.
+*/
+declare const closeHoverTooltips: StateEffect<null>;
+/**
+Tell the tooltip extension to recompute the position of the active
+tooltips. This can be useful when something happens (such as a
+re-positioning or CSS change affecting the editor) that could
+invalidate the existing tooltip positions.
+*/
+declare function repositionTooltips(view: EditorView): void;
+
+declare type PanelConfig = {
+    /**
+    By default, panels will be placed inside the editor's DOM
+    structure. You can use this option to override where panels with
+    `top: true` are placed.
+    */
+    topContainer?: HTMLElement;
+    /**
+    Override where panels with `top: false` are placed.
+    */
+    bottomContainer?: HTMLElement;
+};
+/**
+Configures the panel-managing extension.
+*/
+declare function panels(config?: PanelConfig): Extension;
+/**
+Object that describes an active panel.
+*/
+interface Panel {
+    /**
+    The element representing this panel. The library will add the
+    `"cm-panel"` DOM class to this.
+    */
+    dom: HTMLElement;
+    /**
+    Optionally called after the panel has been added to the editor.
+    */
+    mount?(): void;
+    /**
+    Update the DOM for a given view update.
+    */
+    update?(update: ViewUpdate): void;
+    /**
+    Called when the panel is removed from the editor or the editor
+    is destroyed.
+    */
+    destroy?(): void;
+    /**
+    Whether the panel should be at the top or bottom of the editor.
+    Defaults to false.
+    */
+    top?: boolean;
+}
+/**
+Get the active panel created by the given constructor, if any.
+This can be useful when you need access to your panels' DOM
+structure.
+*/
+declare function getPanel(view: EditorView, panel: PanelConstructor): Panel | null;
+/**
+A function that initializes a panel. Used in
+[`showPanel`](https://codemirror.net/6/docs/ref/#view.showPanel).
+*/
+declare type PanelConstructor = (view: EditorView) => Panel;
+/**
+Opening a panel is done by providing a constructor function for
+the panel through this facet. (The panel is closed again when its
+constructor is no longer provided.) Values of `null` are ignored.
+*/
+declare const showPanel: Facet<PanelConstructor | null, readonly (PanelConstructor | null)[]>;
+
+/**
+A gutter marker represents a bit of information attached to a line
+in a specific gutter. Your own custom markers have to extend this
+class.
+*/
+declare abstract class GutterMarker extends RangeValue {
+    /**
+    Compare this marker to another marker of the same type.
+    */
+    eq(other: GutterMarker): boolean;
+    /**
+    Render the DOM node for this marker, if any.
+    */
+    toDOM?(view: EditorView): Node;
+    /**
+    This property can be used to add CSS classes to the gutter
+    element that contains this marker.
+    */
+    elementClass: string;
+    /**
+    Called if the marker has a `toDOM` method and its representation
+    was removed from a gutter.
+    */
+    destroy(dom: Node): void;
+}
+/**
+Facet used to add a class to all gutter elements for a given line.
+Markers given to this facet should _only_ define an
+[`elementclass`](https://codemirror.net/6/docs/ref/#view.GutterMarker.elementClass), not a
+[`toDOM`](https://codemirror.net/6/docs/ref/#view.GutterMarker.toDOM) (or the marker will appear
+in all gutters for the line).
+*/
+declare const gutterLineClass: Facet<RangeSet<GutterMarker>, readonly RangeSet<GutterMarker>[]>;
+declare type Handlers = {
+    [event: string]: (view: EditorView, line: BlockInfo, event: Event) => boolean;
+};
+interface GutterConfig {
+    /**
+    An extra CSS class to be added to the wrapper (`cm-gutter`)
+    element.
+    */
+    class?: string;
+    /**
+    Controls whether empty gutter elements should be rendered.
+    Defaults to false.
+    */
+    renderEmptyElements?: boolean;
+    /**
+    Retrieve a set of markers to use in this gutter.
+    */
+    markers?: (view: EditorView) => (RangeSet<GutterMarker> | readonly RangeSet<GutterMarker>[]);
+    /**
+    Can be used to optionally add a single marker to every line.
+    */
+    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.
+    */
+    initialSpacer?: null | ((view: EditorView) => GutterMarker);
+    /**
+    Update the spacer element when the view is updated.
+    */
+    updateSpacer?: null | ((spacer: GutterMarker, update: ViewUpdate) => GutterMarker);
+    /**
+    Supply event handlers for DOM events on this gutter.
+    */
+    domEventHandlers?: Handlers;
+}
+/**
+Define an editor gutter. The order in which the gutters appear is
+determined by their extension priority.
+*/
+declare function gutter(config: GutterConfig): Extension;
+/**
+The gutter-drawing plugin is automatically enabled when you add a
+gutter, but you can use this function to explicitly configure it.
+
+Unless `fixed` is explicitly set to `false`, the gutters are
+fixed, meaning they don't scroll along with the content
+horizontally (except on Internet Explorer, which doesn't support
+CSS [`position:
+sticky`](https://developer.mozilla.org/en-US/docs/Web/CSS/position#sticky)).
+*/
+declare function gutters(config?: {
+    fixed?: boolean;
+}): Extension;
+interface LineNumberConfig {
+    /**
+    How to display line numbers. Defaults to simply converting them
+    to string.
+    */
+    formatNumber?: (lineNo: number, state: EditorState) => string;
+    /**
+    Supply event handlers for DOM events on this gutter.
+    */
+    domEventHandlers?: Handlers;
+}
+/**
+Facet used to provide markers to the line number gutter.
+*/
+declare const lineNumberMarkers: Facet<RangeSet<GutterMarker>, readonly RangeSet<GutterMarker>[]>;
+/**
+Create a line number gutter extension.
+*/
+declare function lineNumbers(config?: LineNumberConfig): Extension;
+/**
+Returns an extension that adds a `cm-activeLineGutter` class to
+all gutter elements on the [active
+line](https://codemirror.net/6/docs/ref/#view.highlightActiveLine).
+*/
+declare function highlightActiveLineGutter(): Extension;
+
+export { BidiSpan, BlockInfo, BlockType, Command, DOMEventHandlers, DOMEventMap, Decoration, DecorationSet, Direction, EditorView, GutterMarker, KeyBinding, MatchDecorator, MouseSelectionStyle, Panel, PanelConstructor, PluginSpec, PluginValue, Rect, Tooltip, TooltipView, ViewPlugin, ViewUpdate, WidgetType, closeHoverTooltips, crosshairCursor, drawSelection, dropCursor, getPanel, getTooltip, gutter, gutterLineClass, gutters, hasHoverTooltips, highlightActiveLine, highlightActiveLineGutter, highlightSpecialChars, hoverTooltip, keymap, lineNumberMarkers, lineNumbers, logException, panels, placeholder, rectangularSelection, repositionTooltips, runScopeHandlers, scrollPastEnd, showPanel, showTooltip, tooltips };