chrome-devtools-frontend 1.0.1030457 → 1.0.1030946

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

@@ -1877,11 +1877,11 @@ type StyleSpec = {
   [propOrSelector: string]: string | number | StyleSpec | null
 }
 
-declare type Attrs = {
+declare type Attrs$1 = {
     [name: string]: string;
 };
 
-interface MarkDecorationSpec {
+interface MarkDecorationSpec$1 {
     /**
     Whether the mark covers its start and end position or not. This
     influences whether content inserted at those positions becomes
@@ -1923,11 +1923,11 @@ interface MarkDecorationSpec {
     */
     [other: string]: any;
 }
-interface WidgetDecorationSpec {
+interface WidgetDecorationSpec$1 {
     /**
     The type of widget to draw here.
     */
-    widget: WidgetType;
+    widget: WidgetType$1;
     /**
     Which side of the given position the widget is on. When this is
     positive, the widget will be drawn after the cursor if the
@@ -1954,12 +1954,12 @@ interface WidgetDecorationSpec {
     */
     [other: string]: any;
 }
-interface ReplaceDecorationSpec {
+interface ReplaceDecorationSpec$1 {
     /**
     An optional widget to drawn in the place of the replaced
     content.
     */
-    widget?: WidgetType;
+    widget?: WidgetType$1;
     /**
     Whether this range covers the positions on its sides. This
     influences whether new content becomes part of the range and
@@ -1984,7 +1984,7 @@ interface ReplaceDecorationSpec {
     */
     [other: string]: any;
 }
-interface LineDecorationSpec {
+interface LineDecorationSpec$1 {
     /**
     DOM attributes to add to the element wrapping the line.
     */
@@ -2007,11 +2007,11 @@ delay creating of the DOM structure for a widget until it is
 needed, and to avoid redrawing widgets even if the decorations
 that define them are recreated.
 */
-declare abstract class WidgetType {
+declare abstract class WidgetType$1 {
     /**
     Build the DOM structure for this widget instance.
     */
-    abstract toDOM(view: EditorView): HTMLElement;
+    abstract toDOM(view: EditorView$1): HTMLElement;
     /**
     Compare this instance to another instance of the same type.
     (TypeScript can't express this, but only instances of the same
@@ -2021,7 +2021,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$1): boolean;
     /**
     Update a DOM element created by a widget of the same type (but
     different, non-`eq` content) to reflect this widget. May return
@@ -2054,11 +2054,11 @@ A decoration set represents a collection of decorated ranges,
 organized for efficient access and mapping. See
 [`RangeSet`](https://codemirror.net/6/docs/ref/#state.RangeSet) for its methods.
 */
-declare type DecorationSet = RangeSet<Decoration>;
+declare type DecorationSet$1 = RangeSet<Decoration$1>;
 /**
 The different types of blocks that can occur in an editor view.
 */
-declare enum BlockType {
+declare enum BlockType$1 {
     /**
     A line of text.
     */
@@ -2082,14 +2082,14 @@ of content. You'll usually use it wrapped in a
 [`Range`](https://codemirror.net/6/docs/ref/#state.Range), which adds a start and end position.
 @nonabstract
 */
-declare abstract class Decoration extends RangeValue {
+declare abstract class Decoration$1 extends RangeValue {
     /**
     The config object used to create this decoration. You can
     include additional properties in there to store metadata about
     your decoration.
     */
     readonly spec: any;
-    abstract eq(other: Decoration): boolean;
+    abstract eq(other: Decoration$1): boolean;
     /**
     Create a mark decoration, which influences the styling of the
     content in its range. Nested mark decorations will cause nested
@@ -2099,44 +2099,44 @@ declare abstract class Decoration extends RangeValue {
     Such elements are split on line boundaries and on the boundaries
     of lower-precedence decorations.
     */
-    static mark(spec: MarkDecorationSpec): Decoration;
+    static mark(spec: MarkDecorationSpec$1): Decoration$1;
     /**
     Create a widget decoration, which displays a DOM element at the
     given position.
     */
-    static widget(spec: WidgetDecorationSpec): Decoration;
+    static widget(spec: WidgetDecorationSpec$1): Decoration$1;
     /**
     Create a replace decoration which replaces the given range with
     a widget, or simply hides it.
     */
-    static replace(spec: ReplaceDecorationSpec): Decoration;
+    static replace(spec: ReplaceDecorationSpec$1): Decoration$1;
     /**
     Create a line decoration, which can add DOM attributes to the
     line starting at the given position.
     */
-    static line(spec: LineDecorationSpec): Decoration;
+    static line(spec: LineDecorationSpec$1): Decoration$1;
     /**
     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 set(of: Range<Decoration> | readonly Range<Decoration>[], sort?: boolean): DecorationSet;
+    static set(of: Range<Decoration$1> | readonly Range<Decoration$1>[], sort?: boolean): DecorationSet$1;
     /**
     The empty set of decorations.
     */
-    static none: DecorationSet;
+    static none: DecorationSet$1;
 }
 
 /**
 Basic rectangle type.
 */
-interface Rect {
+interface Rect$1 {
     readonly left: number;
     readonly right: number;
     readonly top: number;
     readonly bottom: number;
 }
-declare type ScrollStrategy = "nearest" | "start" | "end" | "center";
+declare type ScrollStrategy$1 = "nearest" | "start" | "end" | "center";
 
 /**
 Command functions are used in key bindings and other types of user
@@ -2145,11 +2145,11 @@ 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;
+declare type Command = (target: EditorView$1) => boolean;
 /**
 This is the interface plugin objects conform to.
 */
-interface PluginValue extends Object {
+interface PluginValue$1 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
@@ -2160,7 +2160,7 @@ interface PluginValue extends Object {
     [`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$1): void;
     /**
     Called when the plugin is no longer going to be used. Should
     revert any changes the plugin made to the DOM.
@@ -2171,19 +2171,19 @@ interface PluginValue extends Object {
 Provides additional information when defining a [view
 plugin](https://codemirror.net/6/docs/ref/#view.ViewPlugin).
 */
-interface PluginSpec<V extends PluginValue> {
+interface PluginSpec$1<V extends PluginValue$1> {
     /**
     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.
     */
-    eventHandlers?: DOMEventHandlers<V>;
+    eventHandlers?: DOMEventHandlers$1<V>;
     /**
     Specify that the plugin provides additional extensions when
     added to an editor configuration.
     */
-    provide?: (plugin: ViewPlugin<V>) => Extension;
+    provide?: (plugin: ViewPlugin$1<V>) => Extension;
     /**
     Allow the plugin to provide decorations. When given, this should
     a function that take the plugin value and return a [decoration
@@ -2191,14 +2191,14 @@ interface PluginSpec<V extends PluginValue> {
     [layout-changing decorations](https://codemirror.net/6/docs/ref/#view.EditorView^decorations)
     that depend on the view.
     */
-    decorations?: (value: V) => DecorationSet;
+    decorations?: (value: V) => DecorationSet$1;
 }
 /**
 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> {
+declare class ViewPlugin$1<V extends PluginValue$1> {
     /**
     Instances of this class act as extensions.
     */
@@ -2208,42 +2208,42 @@ 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>(create: (view: EditorView) => V, spec?: PluginSpec<V>): ViewPlugin<V>;
+    static define<V extends PluginValue$1>(create: (view: EditorView$1) => V, spec?: PluginSpec$1<V>): ViewPlugin$1<V>;
     /**
     Create a plugin for a class whose constructor takes a single
     editor view as argument.
     */
-    static fromClass<V extends PluginValue>(cls: {
-        new (view: EditorView): V;
-    }, spec?: PluginSpec<V>): ViewPlugin<V>;
+    static fromClass<V extends PluginValue$1>(cls: {
+        new (view: EditorView$1): V;
+    }, spec?: PluginSpec$1<V>): ViewPlugin$1<V>;
 }
-interface MeasureRequest<T> {
+interface MeasureRequest$1<T> {
     /**
     Called in a DOM read phase to gather information that requires
     DOM layout. Should _not_ mutate the document.
     */
-    read(view: EditorView): T;
+    read(view: EditorView$1): T;
     /**
     Called in a DOM write phase to update the document. Should _not_
     do anything that triggers DOM layout.
     */
-    write?(measure: T, view: EditorView): void;
+    write?(measure: T, view: EditorView$1): void;
     /**
     When multiple requests with the same key are scheduled, only the
     last one will actually be ran.
     */
     key?: any;
 }
-declare type AttrSource = Attrs | ((view: EditorView) => Attrs | null);
+declare type AttrSource$1 = Attrs$1 | ((view: EditorView$1) => Attrs$1 | null);
 /**
 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 {
+declare class ViewUpdate$1 {
     /**
     The editor view that the update is associated with.
     */
-    readonly view: EditorView;
+    readonly view: EditorView$1;
     /**
     The new editor state.
     */
@@ -2295,7 +2295,7 @@ Interface that objects registered with
 [`EditorView.mouseSelectionStyle`](https://codemirror.net/6/docs/ref/#view.EditorView^mouseSelectionStyle)
 must conform to.
 */
-interface MouseSelectionStyle {
+interface MouseSelectionStyle$1 {
     /**
     Return a new selection for the mouse gesture that starts with
     the event that was originally given to the constructor, and ends
@@ -2320,15 +2320,15 @@ interface MouseSelectionStyle {
     using this (where `get` returns a new selection, which will
     trigger `update`, which schedules another `get` in response).
     */
-    update: (update: ViewUpdate) => boolean | void;
+    update: (update: ViewUpdate$1) => boolean | void;
 }
-declare type MakeSelectionStyle = (view: EditorView, event: MouseEvent) => MouseSelectionStyle | null;
+declare type MakeSelectionStyle$1 = (view: EditorView$1, event: MouseEvent) => MouseSelectionStyle$1 | null;
 
 /**
 Record used to represent information about a block-level element
 in the editor view.
 */
-declare class BlockInfo {
+declare class BlockInfo$1 {
     /**
     The start of the element in the document.
     */
@@ -2350,7 +2350,7 @@ declare class BlockInfo {
     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[];
+    readonly type: BlockType$1 | readonly BlockInfo$1[];
     /**
     The end of the element as a document position.
     */
@@ -2364,7 +2364,7 @@ declare class BlockInfo {
 /**
 Used to indicate [text direction](https://codemirror.net/6/docs/ref/#view.EditorView.textDirection).
 */
-declare enum Direction {
+declare enum Direction$1 {
     /**
     Left-to-right.
     */
@@ -2378,7 +2378,7 @@ declare enum Direction {
 Represents a contiguous range of text that has a single direction
 (as in left-to-right or right-to-left).
 */
-declare class BidiSpan {
+declare class BidiSpan$1 {
     /**
     The start of the span (relative to the start of the line).
     */
@@ -2398,10 +2398,10 @@ declare class BidiSpan {
     /**
     The direction of this span.
     */
-    get dir(): Direction;
+    get dir(): Direction$1;
 }
 
-interface EditorConfig {
+interface EditorConfig$1 {
     /**
     The view's initial state. Defaults to an extension-less state
     with an empty document.
@@ -2436,7 +2436,7 @@ 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 {
+declare class EditorView$1 {
     /**
     The current editor state.
     */
@@ -2522,7 +2522,7 @@ declare class EditorView {
     /**
     Initialization options.
     */
-    config?: EditorConfig);
+    config?: EditorConfig$1);
     /**
     All regular editor state updates should go through this. It
     takes a transaction or transaction spec and updates the view to
@@ -2568,14 +2568,14 @@ declare class EditorView {
     drawing done by other components is synchronized, avoiding
     unnecessary DOM layout computations.
     */
-    requestMeasure<T>(request?: MeasureRequest<T>): void;
+    requestMeasure<T>(request?: MeasureRequest$1<T>): void;
     /**
     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.
     */
-    plugin<T>(plugin: ViewPlugin<T>): T | null;
+    plugin<T>(plugin: ViewPlugin$1<T>): T | null;
     /**
     The top position of the document, in screen coordinates. This
     may be negative when the editor is scrolled down. Points
@@ -2594,20 +2594,20 @@ declare class EditorView {
     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;
+    elementAtHeight(height: number): BlockInfo$1;
     /**
     Find the line block (see
     [`lineBlockAt`](https://codemirror.net/6/docs/ref/#view.EditorView.lineBlockAt) at the given
     height.
     */
-    lineBlockAtHeight(height: number): BlockInfo;
+    lineBlockAtHeight(height: number): BlockInfo$1;
     /**
     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);
     */
-    get viewportLineBlocks(): BlockInfo[];
+    get viewportLineBlocks(): BlockInfo$1[];
     /**
     Find the line block around the given document position. A line
     block is a range delimited on both sides by either a
@@ -2616,7 +2616,7 @@ declare class EditorView {
     text, but may be broken into multiple textblocks by block
     widgets.
     */
-    lineBlockAt(pos: number): BlockInfo;
+    lineBlockAt(pos: number): BlockInfo$1;
     /**
     The editor's total content height.
     */
@@ -2708,7 +2708,7 @@ declare class EditorView {
     available on the given side, the method will transparently use
     another strategy to get reasonable coordinates).
     */
-    coordsAtPos(pos: number, side?: -1 | 1): Rect | null;
+    coordsAtPos(pos: number, side?: -1 | 1): Rect$1 | null;
     /**
     The default width of a character in the editor. May not
     accurately reflect the width of all characters (given variable
@@ -2725,7 +2725,7 @@ declare class EditorView {
     ([`direction`](https://developer.mozilla.org/en-US/docs/Web/CSS/direction)
     CSS property) of the editor's content element.
     */
-    get textDirection(): Direction;
+    get textDirection(): Direction$1;
     /**
     Find the text direction of the block at the given position, as
     assigned by CSS. If
@@ -2735,7 +2735,7 @@ declare class EditorView {
     [`textDirection`](https://codemirror.net/6/docs/ref/#view.EditorView.textDirection). Note that
     this may trigger a DOM layout.
     */
-    textDirectionAt(pos: number): Direction;
+    textDirectionAt(pos: number): Direction$1;
     /**
     Whether this editor [wraps lines](https://codemirror.net/6/docs/ref/#view.EditorView.lineWrapping)
     (as determined by the
@@ -2751,7 +2751,7 @@ declare class EditorView {
     left-to-right, the leftmost spans come first, otherwise the
     rightmost spans come first.
     */
-    bidiSpans(line: Line$1): readonly BidiSpan[];
+    bidiSpans(line: Line$1): readonly BidiSpan$1[];
     /**
     Check whether the editor has focus.
     */
@@ -2780,13 +2780,13 @@ declare class EditorView {
         to the top of the view, `"end"` to move it to the bottom, or
         `"center"` to move it to the center.
         */
-        y?: ScrollStrategy;
+        y?: ScrollStrategy$1;
         /**
         Effect similar to
         [`y`](https://codemirror.net/6/docs/ref/#view.EditorView^scrollIntoView^options.y), but for the
         horizontal scroll position.
         */
-        x?: ScrollStrategy;
+        x?: ScrollStrategy$1;
         /**
         Extra vertical distance to add when moving something into
         view. Not used with the `"center"` strategy. Defaults to 5.
@@ -2818,7 +2818,7 @@ declare class EditorView {
     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;
+    static domEventHandlers(handlers: DOMEventHandlers$1<any>): Extension;
     /**
     An input handler can override the way changes to the editable
     DOM content are handled. Handlers are passed the document
@@ -2826,7 +2826,7 @@ declare class EditorView {
     content. When one returns true, no further input handlers are
     called and the default behavior is prevented.
     */
-    static inputHandler: Facet<(view: EditorView, from: number, to: number, text: string) => boolean, readonly ((view: EditorView, from: number, to: number, text: string) => boolean)[]>;
+    static inputHandler: Facet<(view: EditorView$1, from: number, to: number, text: string) => boolean, readonly ((view: EditorView$1, 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`
@@ -2846,7 +2846,7 @@ declare class EditorView {
     A facet that can be used to register a function to be called
     every time the view updates.
     */
-    static updateListener: Facet<(update: ViewUpdate) => void, readonly ((update: ViewUpdate) => void)[]>;
+    static updateListener: Facet<(update: ViewUpdate$1) => void, readonly ((update: ViewUpdate$1) => void)[]>;
     /**
     Facet that controls whether the editor content DOM is editable.
     When its highest-precedence value is `false`, the element will
@@ -2862,7 +2862,7 @@ declare class EditorView {
     on the editor, and can return an object that overrides the way a
     selection is computed from that mouse click or drag.
     */
-    static mouseSelectionStyle: Facet<MakeSelectionStyle, readonly MakeSelectionStyle[]>;
+    static mouseSelectionStyle: Facet<MakeSelectionStyle$1, readonly MakeSelectionStyle$1[]>;
     /**
     Facet used to configure whether a given selection drag event
     should move or copy the selection. The given predicate will be
@@ -2888,7 +2888,7 @@ declare class EditorView {
     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))[]>;
+    static decorations: Facet<DecorationSet$1 | ((view: EditorView$1) => DecorationSet$1), readonly (DecorationSet$1 | ((view: EditorView$1) => DecorationSet$1))[]>;
     /**
     Used to provide ranges that should be treated as atoms as far as
     cursor motion is concerned. This causes methods like
@@ -2900,7 +2900,7 @@ declare class EditorView {
     updates](https://codemirror.net/6/docs/ref/#state.TransactionSpec.selection) from moving into such
     regions.
     */
-    static atomicRanges: Facet<(view: EditorView) => RangeSet<any>, readonly ((view: EditorView) => RangeSet<any>)[]>;
+    static atomicRanges: Facet<(view: EditorView$1) => RangeSet<any>, readonly ((view: EditorView$1) => RangeSet<any>)[]>;
     /**
     Facet that allows extensions to provide additional scroll
     margins (space around the sides of the scrolling element that
@@ -2908,7 +2908,7 @@ declare class EditorView {
     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)[]>;
+    static scrollMargins: Facet<(view: EditorView$1) => Partial<Rect$1> | null, readonly ((view: EditorView$1) => Partial<Rect$1> | null)[]>;
     /**
     Create a theme extension. The first argument can be a
     [`style-mod`](https://github.com/marijnh/style-mod#documentation)
@@ -2953,12 +2953,12 @@ declare class EditorView {
     Facet that provides additional DOM attributes for the editor's
     editable DOM element.
     */
-    static contentAttributes: Facet<AttrSource, readonly AttrSource[]>;
+    static contentAttributes: Facet<AttrSource$1, readonly AttrSource$1[]>;
     /**
     Facet that provides DOM attributes for the editor's outer
     element.
     */
-    static editorAttributes: Facet<AttrSource, readonly AttrSource[]>;
+    static editorAttributes: Facet<AttrSource$1, readonly AttrSource$1[]>;
     /**
     An extension that enables line wrapping in the editor (by
     setting CSS `white-space` to `pre-wrap` in the content).
@@ -2978,7 +2978,7 @@ declare class EditorView {
 Helper type that maps event names to event object types, or the
 `any` type for unknown events.
 */
-interface DOMEventMap extends HTMLElementEventMap {
+interface DOMEventMap$1 extends HTMLElementEventMap {
     [other: string]: any;
 }
 /**
@@ -2988,8 +2988,8 @@ 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;
+declare type DOMEventHandlers$1<This> = {
+    [event in keyof DOMEventMap$1]?: (this: This, event: DOMEventMap$1[event], view: EditorView$1) => boolean | void;
 };
 
 /**
@@ -3191,7 +3191,7 @@ declare class MatchDecorator {
         The decoration to apply to matches, either directly or as a
         function of the match.
         */
-        decoration: Decoration | ((match: RegExpExecArray, view: EditorView, pos: number) => Decoration);
+        decoration: Decoration$1 | ((match: RegExpExecArray, view: EditorView$1, pos: number) => Decoration$1);
         /**
         By default, changed lines are re-matched entirely. You can
         provide a boundary expression, which should match single
@@ -3213,13 +3213,13 @@ declare class MatchDecorator {
     view's viewport. You'll want to call this when initializing your
     plugin.
     */
-    createDeco(view: EditorView): RangeSet<Decoration>;
+    createDeco(view: EditorView$1): RangeSet<Decoration$1>;
     /**
     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.
     */
-    updateDeco(update: ViewUpdate, deco: DecorationSet): DecorationSet;
+    updateDeco(update: ViewUpdate$1, deco: DecorationSet$1): DecorationSet$1;
     private updateRange;
 }
 
@@ -3255,7 +3255,7 @@ declare function tooltips(config?: {
     for showing tooltips. You can provide a function here that
     returns an alternative rectangle.
     */
-    tooltipSpace?: (view: EditorView) => {
+    tooltipSpace?: (view: EditorView$1) => {
         top: number;
         left: number;
         bottom: number;
@@ -3281,7 +3281,7 @@ interface Tooltip {
     A constructor function that creates the tooltip's [DOM
     representation](https://codemirror.net/6/docs/ref/#view.TooltipView).
     */
-    create(view: EditorView): TooltipView;
+    create(view: EditorView$1): TooltipView;
     /**
     Whether the tooltip should be shown above or below the target
     position. Not guaranteed to be respected for hover tooltips
@@ -3327,7 +3327,7 @@ interface TooltipView {
     to make the tooltip view itself responsible for finding its
     screen position.
     */
-    getCoords?: (pos: number) => Rect;
+    getCoords?: (pos: number) => Rect$1;
     /**
     By default, tooltips are moved when they overlap with other
     tooltips. Set this to `true` to disable that behavior for this
@@ -3337,11 +3337,11 @@ interface TooltipView {
     /**
     Called after the tooltip is added to the DOM for the first time.
     */
-    mount?(view: EditorView): void;
+    mount?(view: EditorView$1): void;
     /**
     Update the DOM element for a change in the view's state.
     */
-    update?(update: ViewUpdate): void;
+    update?(update: ViewUpdate$1): void;
     /**
     Called when the tooltip has been (re)positioned.
     */
@@ -3357,7 +3357,7 @@ 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 function repositionTooltips(view: EditorView$1): void;
 /**
 Object that describes an active panel.
 */
@@ -3374,7 +3374,7 @@ interface Panel {
     /**
     Update the DOM for a given view update.
     */
-    update?(update: ViewUpdate): void;
+    update?(update: ViewUpdate$1): void;
     /**
     Called when the panel is removed from the editor or the editor
     is destroyed.
@@ -3390,7 +3390,7 @@ interface Panel {
 A function that initializes a panel. Used in
 [`showPanel`](https://codemirror.net/6/docs/ref/#view.showPanel).
 */
-declare type PanelConstructor = (view: EditorView) => Panel;
+declare type PanelConstructor = (view: EditorView$1) => Panel;
 /**
 Opening a panel is done by providing a constructor function for
 the panel through this facet. (The panel is closed again when its
@@ -3411,7 +3411,7 @@ declare abstract class GutterMarker extends RangeValue {
     /**
     Render the DOM node for this marker, if any.
     */
-    toDOM?(view: EditorView): Node;
+    toDOM?(view: EditorView$1): Node;
     /**
     This property can be used to add CSS classes to the gutter
     element that contains this marker.
@@ -3424,7 +3424,7 @@ declare abstract class GutterMarker extends RangeValue {
     destroy(dom: Node): void;
 }
 declare type Handlers$1 = {
-    [event: string]: (view: EditorView, line: BlockInfo, event: Event) => boolean;
+    [event: string]: (view: EditorView$1, line: BlockInfo$1, event: Event) => boolean;
 };
 interface GutterConfig {
     /**
@@ -3440,26 +3440,26 @@ interface GutterConfig {
     /**
     Retrieve a set of markers to use in this gutter.
     */
-    markers?: (view: EditorView) => (RangeSet<GutterMarker> | readonly RangeSet<GutterMarker>[]);
+    markers?: (view: EditorView$1) => (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;
+    lineMarker?: (view: EditorView$1, line: BlockInfo$1, 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);
+    lineMarkerChange?: null | ((update: ViewUpdate$1) => boolean);
     /**
     Add a hidden spacer element that gives the gutter its base
     width.
     */
-    initialSpacer?: null | ((view: EditorView) => GutterMarker);
+    initialSpacer?: null | ((view: EditorView$1) => GutterMarker);
     /**
     Update the spacer element when the view is updated.
     */
-    updateSpacer?: null | ((spacer: GutterMarker, update: ViewUpdate) => GutterMarker);
+    updateSpacer?: null | ((spacer: GutterMarker, update: ViewUpdate$1) => GutterMarker);
     /**
     Supply event handlers for DOM events on this gutter.
     */
@@ -3959,7 +3959,7 @@ interface FoldConfig {
     When this option isn't given, the `placeholderText` option will
     be used to create the placeholder element.
     */
-    placeholderDOM?: ((view: EditorView, onclick: (event: Event) => void) => HTMLElement) | null;
+    placeholderDOM?: ((view: EditorView$1, onclick: (event: Event) => void) => HTMLElement) | null;
     /**
     Text to use as placeholder for folded text. Defaults to `"…"`.
     Will be styled with the `"cm-foldPlaceholder"` class.
@@ -3971,7 +3971,7 @@ Create an extension that configures code folding.
 */
 declare function codeFolding(config?: FoldConfig): Extension;
 declare type Handlers = {
-    [event: string]: (view: EditorView, line: BlockInfo, event: Event) => boolean;
+    [event: string]: (view: EditorView$1, line: BlockInfo$1, event: Event) => boolean;
 };
 interface FoldGutterConfig {
     /**
@@ -4120,7 +4120,7 @@ interface Config {
     `cm-matchingBracket` class for matching pairs, and
     `cm-nonmatchingBracket` for mismatched pairs or single brackets.
     */
-    renderMatch?: (match: MatchResult, state: EditorState) => readonly Range<Decoration>[];
+    renderMatch?: (match: MatchResult, state: EditorState) => readonly Range<Decoration$1>[];
 }
 /**
 Create an extension that enables bracket matching. Whenever the
@@ -4408,7 +4408,7 @@ interface Completion {
     adding the [`pickedCompletion`](https://codemirror.net/6/docs/ref/#autocomplete.pickedCompletion)
     annotation to it.
     */
-    apply?: string | ((view: EditorView, completion: Completion, from: number, to: number) => void);
+    apply?: string | ((view: EditorView$1, completion: Completion, from: number, to: number) => void);
     /**
     The type of the completion. This is used to pick an icon to show
     for the completion. Icons are styled with a CSS class created by
@@ -4975,34 +4975,1165 @@ declare namespace _codemirror_lang_markdown {
   };
 }
 
+declare type Attrs = {
+    [name: string]: string;
+};
+
+interface MarkDecorationSpec {
+    /**
+    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.
+    */
+    inclusive?: boolean;
+    /**
+    Specify whether the start position of the marked range should be
+    inclusive. Overrides `inclusive`, when both are present.
+    */
+    inclusiveStart?: boolean;
+    /**
+    Whether the end should be inclusive.
+    */
+    inclusiveEnd?: boolean;
+    /**
+    Add attributes to the DOM elements that hold the text in the
+    marked range.
+    */
+    attributes?: {
+        [key: string]: string;
+    };
+    /**
+    Shorthand for `{attributes: {class: value}}`.
+    */
+    class?: string;
+    /**
+    Add a wrapping element around the text in the marked range. Note
+    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;
+    /**
+    Decoration specs allow extra properties, which can be retrieved
+    through the decoration's [`spec`](https://codemirror.net/6/docs/ref/#view.Decoration.spec)
+    property.
+    */
+    [other: string]: any;
+}
+interface WidgetDecorationSpec {
+    /**
+    The type of widget to draw here.
+    */
+    widget: WidgetType;
+    /**
+    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.
+    */
+    side?: number;
+    /**
+    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.
+    */
+    block?: boolean;
+    /**
+    Other properties are allowed.
+    */
+    [other: string]: any;
+}
+interface ReplaceDecorationSpec {
+    /**
+    An optional widget to drawn in the place of the replaced
+    content.
+    */
+    widget?: WidgetType;
+    /**
+    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.
+    */
+    inclusive?: boolean;
+    /**
+    Set inclusivity at the start.
+    */
+    inclusiveStart?: boolean;
+    /**
+    Set inclusivity at the end.
+    */
+    inclusiveEnd?: boolean;
+    /**
+    Whether this is a block-level decoration. Defaults to false.
+    */
+    block?: boolean;
+    /**
+    Other properties are allowed.
+    */
+    [other: string]: any;
+}
+interface LineDecorationSpec {
+    /**
+    DOM attributes to add to the element wrapping the line.
+    */
+    attributes?: {
+        [key: string]: string;
+    };
+    /**
+    Shorthand for `{attributes: {class: value}}`.
+    */
+    class?: string;
+    /**
+    Other properties are allowed.
+    */
+    [other: string]: any;
+}
 /**
-Describes a problem or hint for a piece of code.
+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 if the decorations
+that define them are recreated.
 */
-interface Diagnostic {
+declare abstract class WidgetType {
     /**
-    The start position of the relevant text.
+    Build the DOM structure for this widget instance.
     */
-    from: number;
+    abstract toDOM(view: EditorView): HTMLElement;
     /**
-    The end position. May be equal to `from`, though actually
-    covering text is preferable.
+    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.
     */
-    to: number;
+    eq(widget: WidgetType): boolean;
     /**
-    The severity of the problem. This will influence how it is
-    displayed.
+    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.
     */
-    severity: "info" | "warning" | "error";
+    updateDOM(dom: HTMLElement): boolean;
     /**
-    An optional source string indicating where the diagnostic is
-    coming from. You can put the name of your linter here, if
-    applicable.
+    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.
     */
-    source?: string;
+    get estimatedHeight(): number;
     /**
-    The message associated with this diagnostic.
+    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.
     */
-    message: string;
+    ignoreEvent(event: Event): boolean;
+    /**
+    This is called when the an instance of the widget is removed
+    from the editor view.
+    */
+    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/#state.RangeSet) for its methods.
+*/
+declare type DecorationSet = RangeSet<Decoration>;
+/**
+The different types of blocks that can occur in an editor view.
+*/
+declare enum BlockType {
+    /**
+    A line of text.
+    */
+    Text = 0,
+    /**
+    A block widget associated with the position after it.
+    */
+    WidgetBefore = 1,
+    /**
+    A block widget associated with the position before it.
+    */
+    WidgetAfter = 2,
+    /**
+    A block widget [replacing](https://codemirror.net/6/docs/ref/#view.Decoration^replace) a range of content.
+    */
+    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/#state.Range), which adds a start and end position.
+@nonabstract
+*/
+declare abstract class Decoration extends RangeValue {
+    /**
+    The config object used to create this decoration. You can
+    include additional properties in there to store metadata about
+    your decoration.
+    */
+    readonly spec: any;
+    protected constructor(
+    /**
+    @internal
+    */
+    startSide: number,
+    /**
+    @internal
+    */
+    endSide: number,
+    /**
+    @internal
+    */
+    widget: WidgetType | null,
+    /**
+    The config object used to create this decoration. You can
+    include additional properties in there to store metadata about
+    your decoration.
+    */
+    spec: any);
+    abstract eq(other: Decoration): boolean;
+    /**
+    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), 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 displays a DOM element at the
+    given position.
+    */
+    static widget(spec: WidgetDecorationSpec): Decoration;
+    /**
+    Create a replace decoration which replaces the given range with
+    a widget, or simply hides it.
+    */
+    static replace(spec: ReplaceDecorationSpec): Decoration;
+    /**
+    Create a line decoration, which can add DOM attributes to the
+    line starting at the given position.
+    */
+    static line(spec: LineDecorationSpec): Decoration;
+    /**
+    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 set(of: Range<Decoration> | readonly Range<Decoration>[], sort?: boolean): DecorationSet;
+    /**
+    The empty set of decorations.
+    */
+    static none: DecorationSet;
+}
+
+/**
+Basic rectangle type.
+*/
+interface Rect {
+    readonly left: number;
+    readonly right: number;
+    readonly top: number;
+    readonly bottom: number;
+}
+declare type ScrollStrategy = "nearest" | "start" | "end" | "center";
+/**
+This is the interface plugin objects conform to.
+*/
+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
+    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.
+    */
+    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;
+}
+/**
+Provides additional information when defining a [view
+plugin](https://codemirror.net/6/docs/ref/#view.ViewPlugin).
+*/
+interface PluginSpec<V extends PluginValue> {
+    /**
+    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.
+    */
+    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
+    be 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.EditorView^decorations) that
+    depend on the view.
+    */
+    decorations?: (value: V) => DecorationSet;
+}
+/**
+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> {
+    /**
+    Instances of this class act as extensions.
+    */
+    extension: Extension;
+    private constructor();
+    /**
+    Define a plugin from a constructor function that creates the
+    plugin's value, given an editor view.
+    */
+    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>(cls: {
+        new (view: EditorView): V;
+    }, spec?: PluginSpec<V>): ViewPlugin<V>;
+}
+interface MeasureRequest<T> {
+    /**
+    Called in a DOM read phase to gather information that requires
+    DOM layout. Should _not_ mutate the document.
+    */
+    read(view: EditorView): T;
+    /**
+    Called in a DOM write phase to update the document. Should _not_
+    do anything that triggers DOM layout.
+    */
+    write?(measure: T, view: EditorView): void;
+    /**
+    When multiple requests with the same key are scheduled, only the
+    last one will actually be ran.
+    */
+    key?: any;
+}
+declare type AttrSource = Attrs | ((view: EditorView) => Attrs | null);
+/**
+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 {
+    /**
+    The editor view that the update is associated with.
+    */
+    readonly view: EditorView;
+    /**
+    The new editor state.
+    */
+    readonly state: EditorState;
+    /**
+    The transactions involved in the update. May be empty.
+    */
+    readonly transactions: readonly Transaction[];
+    /**
+    The changes made to the document by this update.
+    */
+    readonly changes: ChangeSet;
+    /**
+    The previous editor state.
+    */
+    readonly startState: EditorState;
+    private constructor();
+    /**
+    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 viewportChanged(): boolean;
+    /**
+    Indicates whether the height of a block element in the editor
+    changed in this update.
+    */
+    get heightChanged(): boolean;
+    /**
+    Returns true when the document was modified or the size of the
+    editor, or elements within the editor, changed.
+    */
+    get geometryChanged(): boolean;
+    /**
+    True when this update indicates a focus change.
+    */
+    get focusChanged(): boolean;
+    /**
+    Whether the document changed in this update.
+    */
+    get docChanged(): boolean;
+    /**
+    Whether the selection was explicitly set in this update.
+    */
+    get selectionSet(): boolean;
+}
+
+/**
+Interface that objects registered with
+[`EditorView.mouseSelectionStyle`](https://codemirror.net/6/docs/ref/#view.EditorView^mouseSelectionStyle)
+must conform to.
+*/
+interface MouseSelectionStyle {
+    /**
+    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.
+    */
+    get: (curEvent: MouseEvent, extend: boolean, multiple: boolean) => EditorSelection;
+    /**
+    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).
+    */
+    update: (update: ViewUpdate) => boolean | void;
+}
+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).
+*/
+declare enum Direction {
+    /**
+    Left-to-right.
+    */
+    LTR = 0,
+    /**
+    Right-to-left.
+    */
+    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 {
+    /**
+    The start of the span (relative to the start of the line).
+    */
+    readonly from: number;
+    /**
+    The end of the span.
+    */
+    readonly to: number;
+    /**
+    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).
+    */
+    readonly level: number;
+    /**
+    The direction of this span.
+    */
+    get dir(): Direction;
+}
+
+interface EditorConfig {
+    /**
+    The view's initial state. Defaults to an extension-less state
+    with an empty document.
+    */
+    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
+    not this option, the editor will automatically look up a root
+    from the parent.
+    */
+    root?: Document | ShadowRoot;
+    /**
+    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).
+    */
+    dispatch?: (tr: Transaction) => void;
+}
+/**
+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 {
+    /**
+    The current editor state.
+    */
+    get state(): EditorState;
+    /**
+    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.
+    */
+    get viewport(): {
+        from: number;
+        to: number;
+    };
+    /**
+    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.
+    */
+    get visibleRanges(): readonly {
+        from: number;
+        to: number;
+    }[];
+    /**
+    Returns false when the editor is entirely scrolled out of view
+    or otherwise hidden.
+    */
+    get inView(): boolean;
+    /**
+    Indicates whether the user is currently composing text via
+    [IME](https://en.wikipedia.org/wiki/Input_method), and at least
+    one change has been made in the current composition.
+    */
+    get composing(): boolean;
+    /**
+    Indicates whether the user is currently in composing state. Note
+    that on some platforms, like Android, this will be the case a
+    lot, since just putting the cursor on a word starts a
+    composition there.
+    */
+    get compositionStarted(): boolean;
+    private _dispatch;
+    /**
+    The document or shadow root that the view lives in.
+    */
+    readonly root: DocumentOrShadowRoot;
+    /**
+    The DOM element that wraps the entire editor view.
+    */
+    readonly dom: HTMLElement;
+    /**
+    The DOM element that can be styled to scroll. (Note that it may
+    not have been, so you can't assume this is scrollable.)
+    */
+    readonly scrollDOM: HTMLElement;
+    /**
+    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.
+    */
+    readonly contentDOM: HTMLElement;
+    private announceDOM;
+    private plugins;
+    private pluginMap;
+    private editorAttrs;
+    private contentAttrs;
+    private styleModules;
+    private bidiCache;
+    private destroyed;
+    /**
+    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(
+    /**
+    Initialization options.
+    */
+    config?: EditorConfig);
+    /**
+    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.
+    */
+    dispatch(tr: Transaction): void;
+    dispatch(...specs: TransactionSpec[]): 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.
+    */
+    update(transactions: readonly Transaction[]): 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.)
+    */
+    setState(newState: EditorState): void;
+    private updatePlugins;
+    /**
+    Get the CSS classes for the currently active editor themes.
+    */
+    get themeClasses(): string;
+    private updateAttrs;
+    private showAnnouncements;
+    private mountStyles;
+    private readMeasured;
+    /**
+    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.
+    */
+    requestMeasure<T>(request?: MeasureRequest<T>): void;
+    /**
+    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.
+    */
+    plugin<T>(plugin: ViewPlugin<T>): T | null;
+    /**
+    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 documentTop(): number;
+    /**
+    Reports the padding above and below the document.
+    */
+    get documentPadding(): {
+        top: number;
+        bottom: number;
+    };
+    /**
+    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 the line block (see
+    [`lineBlockAt`](https://codemirror.net/6/docs/ref/#view.EditorView.lineBlockAt) at the given
+    height.
+    */
+    lineBlockAtHeight(height: number): BlockInfo;
+    /**
+    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);
+    */
+    get viewportLineBlocks(): 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^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.
+    */
+    lineBlockAt(pos: number): BlockInfo;
+    /**
+    The editor's total content height.
+    */
+    get contentHeight(): number;
+    /**
+    Move a cursor position by [grapheme
+    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
+    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.
+    */
+    moveByChar(start: SelectionRange, forward: boolean, by?: (initial: string) => (next: string) => boolean): SelectionRange;
+    /**
+    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.
+    */
+    moveByGroup(start: SelectionRange, forward: boolean): SelectionRange;
+    /**
+    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.
+    */
+    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.
+
+    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;
+    /**
+    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.
+
+    Note that for positions that aren't currently in
+    `visibleRanges`, the resulting DOM position isn't necessarily
+    meaningful (it may just point before or after a placeholder
+    element).
+    */
+    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;
+    /**
+    Get the document position at the given screen coordinates. For
+    positions not covered by the visible viewport's DOM structure,
+    this will return null, unless `false` is passed as second
+    argument, in which case it'll return an estimated position that
+    would be near the coordinates if it were rendered.
+    */
+    posAtCoords(coords: {
+        x: number;
+        y: number;
+    }, precise: false): number;
+    posAtCoords(coords: {
+        x: number;
+        y: number;
+    }): number | null;
+    /**
+    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).
+    */
+    coordsAtPos(pos: number, side?: -1 | 1): Rect | null;
+    /**
+    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).
+    */
+    get defaultCharacterWidth(): number;
+    /**
+    The default height of a line in the editor. May not be accurate
+    for all lines.
+    */
+    get defaultLineHeight(): number;
+    /**
+    The text direction
+    ([`direction`](https://developer.mozilla.org/en-US/docs/Web/CSS/direction)
+    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)
+    CSS property of its content element).
+    */
+    get lineWrapping(): boolean;
+    /**
+    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.
+    */
+    bidiSpans(line: Line$1): readonly BidiSpan[];
+    /**
+    Check whether the editor has focus.
+    */
+    get hasFocus(): boolean;
+    /**
+    Put focus on the editor.
+    */
+    focus(): void;
+    /**
+    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.
+    */
+    destroy(): void;
+    /**
+    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.
+    */
+    static scrollIntoView(pos: number | SelectionRange, options?: {
+        /**
+        By default (`"nearest"`) the position will be vertically
+        scrolled only the minimal amount required to move the given
+        position into view. You can set this to `"start"` to move it
+        to the top of the view, `"end"` to move it to the bottom, or
+        `"center"` to move it to the center.
+        */
+        y?: ScrollStrategy;
+        /**
+        Effect similar to
+        [`y`](https://codemirror.net/6/docs/ref/#view.EditorView^scrollIntoView^options.y), but for the
+        horizontal scroll position.
+        */
+        x?: ScrollStrategy;
+        /**
+        Extra vertical distance to add when moving something into
+        view. Not used with the `"center"` strategy. Defaults to 5.
+        */
+        yMargin?: number;
+        /**
+        Extra horizontal distance to add. Not used with the `"center"`
+        strategy. Defaults to 5.
+        */
+        xMargin?: number;
+    }): StateEffect<unknown>;
+    /**
+    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).
+    */
+    static styleModule: Facet<StyleModule, readonly StyleModule[]>;
+    /**
+    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;
+    /**
+    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.
+    */
+    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 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
+    from user-code-provided callbacks). This is mostly useful for
+    debugging and logging. See [`logException`](https://codemirror.net/6/docs/ref/#view.logException).
+    */
+    static exceptionSink: Facet<(exception: any) => void, readonly ((exception: any) => void)[]>;
+    /**
+    A facet that can be used to register a function to be called
+    every time the view updates.
+    */
+    static updateListener: Facet<(update: ViewUpdate) => void, readonly ((update: ViewUpdate) => void)[]>;
+    /**
+    Facet that controls whether the editor content DOM is editable.
+    When its highest-precedence value is `false`, the element will
+    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>;
+    /**
+    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.
+    */
+    static mouseSelectionStyle: Facet<MakeSelectionStyle, readonly MakeSelectionStyle[]>;
+    /**
+    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.
+    */
+    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. 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. 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 atomicRanges: Facet<(view: EditorView) => RangeSet<any>, readonly ((view: EditorView) => 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)
+    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).
+    */
+    static theme(spec: {
+        [selector: string]: StyleSpec;
+    }, options?: {
+        dark?: boolean;
+    }): Extension;
+    /**
+    This facet records whether a dark theme is active. The extension
+    returned by [`theme`](https://codemirror.net/6/docs/ref/#view.EditorView^theme) automatically
+    includes an instance of this when the `dark` option is set to
+    true.
+    */
+    static darkTheme: Facet<boolean, boolean>;
+    /**
+    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.
+    */
+    static baseTheme(spec: {
+        [selector: string]: StyleSpec;
+    }): Extension;
+    /**
+    Facet that provides additional DOM attributes for the editor's
+    editable DOM element.
+    */
+    static contentAttributes: Facet<AttrSource, readonly AttrSource[]>;
+    /**
+    Facet that provides DOM attributes for the editor's outer
+    element.
+    */
+    static editorAttributes: Facet<AttrSource, readonly AttrSource[]>;
+    /**
+    An extension that enables line wrapping in the editor (by
+    setting CSS `white-space` to `pre-wrap` in the content).
+    */
+    static lineWrapping: Extension;
+    /**
+    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).
+    */
+    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;
+};
+
+/**
+Describes a problem or hint for a piece of code.
+*/
+interface Diagnostic {
+    /**
+    The start position of the relevant text.
+    */
+    from: number;
+    /**
+    The end position. May be equal to `from`, though actually
+    covering text is preferable.
+    */
+    to: number;
+    /**
+    The severity of the problem. This will influence how it is
+    displayed.
+    */
+    severity: "info" | "warning" | "error";
+    /**
+    An optional source string indicating where the diagnostic is
+    coming from. You can put the name of your linter here, if
+    applicable.
+    */
+    source?: string;
+    /**
+    The message associated with this diagnostic.
+    */
+    message: string;
+    /**
+    An optional custom rendering function that displays the message
+    as a DOM node.
+    */
+    renderMessage?: () => Node;
     /**
     An optional array of actions that can be taken on this
     diagnostic.
@@ -5031,7 +6162,7 @@ Calls
 on the document and, if that throws an error, reports it as a
 single diagnostic.
 */
-declare const jsonParseLinter: () => (view: EditorView) => Diagnostic[];
+declare const jsonParseLinter: () => (view: EditorView$1) => Diagnostic[];
 
 /**
 A language provider that provides JSON parsing.
@@ -5345,7 +6476,7 @@ and
 [eslint4b-prebuilt](https://github.com/marijnh/eslint4b-prebuilt/)
 packages may help with that.
 */
-declare function esLint(eslint: any, config?: any): (view: EditorView) => Diagnostic[];
+declare function esLint(eslint: any, config?: any): (view: EditorView$1) => Diagnostic[];
 
 declare const index_d_autoCloseTags: typeof autoCloseTags;
 declare const index_d_esLint: typeof esLint;
@@ -5415,4 +6546,4 @@ declare function cssStreamParser(): Promise<any>;
 declare function wast(): Promise<typeof _codemirror_lang_wast>;
 declare function xml(): Promise<typeof _codemirror_lang_xml>;
 
-export { Annotation, AnnotationType, ChangeDesc, ChangeSet, ChangeSpec, Command, Compartment, Completion, CompletionContext, CompletionResult, CompletionSource, Decoration, DecorationSet, EditorSelection, EditorState, EditorStateConfig, EditorView, Extension, Facet, GutterMarker, HighlightStyle, KeyBinding, LRParser, Language, LanguageSupport, Line$1 as Line, MapMode, MatchDecorator, NodeProp, NodeSet, NodeType, Panel, Parser, Prec, Range, RangeSet, RangeSetBuilder, SelectionRange, StateEffect, StateEffectType, StateField, StreamLanguage, StreamParser, StringStream, StyleModule, SyntaxNode, Tag, TagStyle, Text, TextIterator, Tooltip, TooltipView, Transaction, TransactionSpec, Tree, TreeCursor, ViewPlugin, ViewUpdate, WidgetType, acceptCompletion, autocompletion, bracketMatching, clojure, closeBrackets, closeBracketsKeymap, closeCompletion, codeFolding, coffeescript, completeAnyWord, cpp, index_d$2 as css, cssStreamParser, currentCompletions, cursorMatchingBracket, cursorSubwordBackward, cursorSubwordForward, drawSelection, ensureSyntaxTree, foldGutter, foldKeymap, gutter, gutters, highlightSelectionMatches, highlightSpecialChars, highlightTree, history, historyKeymap, index_d$1 as html, ifNotIn, indentLess, indentMore, indentOnInput, indentUnit, insertNewlineAndIndent, java, index_d as javascript, json, keymap, lineNumberMarkers, lineNumbers, markdown, php, placeholder, python, redo, redoSelection, repositionTooltips, scrollPastEnd, selectMatchingBracket, selectNextOccurrence, selectSubwordBackward, selectSubwordForward, selectedCompletion, shell, showPanel, showTooltip, standardKeymap, startCompletion, syntaxHighlighting, syntaxTree, tags, toggleComment, tooltips, undo, undoSelection, wast, xml };
+export { Annotation, AnnotationType, ChangeDesc, ChangeSet, ChangeSpec, Command, Compartment, Completion, CompletionContext, CompletionResult, CompletionSource, Decoration$1 as Decoration, DecorationSet$1 as DecorationSet, EditorSelection, EditorState, EditorStateConfig, EditorView$1 as EditorView, Extension, Facet, GutterMarker, HighlightStyle, KeyBinding, LRParser, Language, LanguageSupport, Line$1 as Line, MapMode, MatchDecorator, NodeProp, NodeSet, NodeType, Panel, Parser, Prec, Range, RangeSet, RangeSetBuilder, SelectionRange, StateEffect, StateEffectType, StateField, StreamLanguage, StreamParser, StringStream, StyleModule, SyntaxNode, Tag, TagStyle, Text, TextIterator, Tooltip, TooltipView, Transaction, TransactionSpec, Tree, TreeCursor, ViewPlugin$1 as ViewPlugin, ViewUpdate$1 as ViewUpdate, WidgetType$1 as WidgetType, acceptCompletion, autocompletion, bracketMatching, clojure, closeBrackets, closeBracketsKeymap, closeCompletion, codeFolding, coffeescript, completeAnyWord, cpp, index_d$2 as css, cssStreamParser, currentCompletions, cursorMatchingBracket, cursorSubwordBackward, cursorSubwordForward, drawSelection, ensureSyntaxTree, foldGutter, foldKeymap, gutter, gutters, highlightSelectionMatches, highlightSpecialChars, highlightTree, history, historyKeymap, index_d$1 as html, ifNotIn, indentLess, indentMore, indentOnInput, indentUnit, insertNewlineAndIndent, java, index_d as javascript, json, keymap, lineNumberMarkers, lineNumbers, markdown, php, placeholder, python, redo, redoSelection, repositionTooltips, scrollPastEnd, selectMatchingBracket, selectNextOccurrence, selectSubwordBackward, selectSubwordForward, selectedCompletion, shell, showPanel, showTooltip, standardKeymap, startCompletion, syntaxHighlighting, syntaxTree, tags, toggleComment, tooltips, undo, undoSelection, wast, xml };