@sanity/runtime-cli 1.3.1 → 1.4.0

package/dist/server/static/vendor/vendor.bundle.d.ts

@@ -0,0 +1,1815 @@
+/**
+The editor state class is a persistent (immutable) data structure.
+To update a state, you [create](https://codemirror.net/6/docs/ref/#state.EditorState.update) a
+[transaction](https://codemirror.net/6/docs/ref/#state.Transaction), which produces a _new_ state
+instance, without modifying the original object.
+
+As such, _never_ mutate properties of a state directly. That'll
+just break things.
+*/
+export class EditorState {
+    /**
+    Deserialize a state from its JSON representation. When custom
+    fields should be deserialized, pass the same object you passed
+    to [`toJSON`](https://codemirror.net/6/docs/ref/#state.EditorState.toJSON) when serializing as
+    third argument.
+    */
+    static fromJSON(json: any, config: {} | undefined, fields: any): EditorState;
+    /**
+    Create a new state. You'll usually only need this when
+    initializing an editor—updated states are created by applying
+    transactions.
+    */
+    static create(config?: {}): EditorState;
+    constructor(config: any, doc: any, selection: any, values: any, computeSlot: any, tr: any);
+    config: any;
+    doc: any;
+    selection: any;
+    values: any;
+    status: any;
+    computeSlot: any;
+    field(field: any, require?: boolean): any;
+    /**
+    Create a [transaction](https://codemirror.net/6/docs/ref/#state.Transaction) that updates this
+    state. Any number of [transaction specs](https://codemirror.net/6/docs/ref/#state.TransactionSpec)
+    can be passed. Unless
+    [`sequential`](https://codemirror.net/6/docs/ref/#state.TransactionSpec.sequential) is set, the
+    [changes](https://codemirror.net/6/docs/ref/#state.TransactionSpec.changes) (if any) of each spec
+    are assumed to start in the _current_ document (not the document
+    produced by previous specs), and its
+    [selection](https://codemirror.net/6/docs/ref/#state.TransactionSpec.selection) and
+    [effects](https://codemirror.net/6/docs/ref/#state.TransactionSpec.effects) are assumed to refer
+    to the document created by its _own_ changes. The resulting
+    transaction contains the combined effect of all the different
+    specs. For [selection](https://codemirror.net/6/docs/ref/#state.TransactionSpec.selection), later
+    specs take precedence over earlier ones.
+    */
+    update(...specs: any[]): any;
+    /**
+    @internal
+    */
+    applyTransaction(tr: any): void;
+    /**
+    Create a [transaction spec](https://codemirror.net/6/docs/ref/#state.TransactionSpec) that
+    replaces every selection range with the given content.
+    */
+    replaceSelection(text: any): {
+        changes: (any[] & ChangeSet) | null;
+        selection: EditorSelection;
+        effects: any[];
+    };
+    /**
+    Create a set of changes and a new selection by running the given
+    function for each range in the active selection. The function
+    can return an optional set of changes (in the coordinate space
+    of the start document), plus an updated range (in the coordinate
+    space of the document produced by the call's own changes). This
+    method will merge all the changes and ranges into a single
+    changeset and selection, and return it as a [transaction
+    spec](https://codemirror.net/6/docs/ref/#state.TransactionSpec), which can be passed to
+    [`update`](https://codemirror.net/6/docs/ref/#state.EditorState.update).
+    */
+    changeByRange(f: any): {
+        changes: (any[] & ChangeSet) | null;
+        selection: EditorSelection;
+        effects: any[];
+    };
+    /**
+    Create a [change set](https://codemirror.net/6/docs/ref/#state.ChangeSet) from the given change
+    description, taking the state's document length and line
+    separator into account.
+    */
+    changes(spec?: any[]): (any[] & ChangeSet) | null;
+    /**
+    Using the state's [line
+    separator](https://codemirror.net/6/docs/ref/#state.EditorState^lineSeparator), create a
+    [`Text`](https://codemirror.net/6/docs/ref/#state.Text) instance from the given string.
+    */
+    toText(string: any): any;
+    /**
+    Return the given range of the document as a string.
+    */
+    sliceDoc(from?: number, to?: any): any;
+    /**
+    Get the value of a state [facet](https://codemirror.net/6/docs/ref/#state.Facet).
+    */
+    facet(facet: any): any;
+    /**
+    Convert this state to a JSON-serializable object. When custom
+    fields should be serialized, you can pass them in as an object
+    mapping property names (in the resulting object, which should
+    not use `doc` or `selection`) to fields.
+    */
+    toJSON(fields: any): {
+        doc: any;
+        selection: any;
+    };
+    /**
+    The size (in columns) of a tab in the document, determined by
+    the [`tabSize`](https://codemirror.net/6/docs/ref/#state.EditorState^tabSize) facet.
+    */
+    get tabSize(): any;
+    /**
+    Get the proper [line-break](https://codemirror.net/6/docs/ref/#state.EditorState^lineSeparator)
+    string for this state.
+    */
+    get lineBreak(): any;
+    /**
+    Returns true when the editor is
+    [configured](https://codemirror.net/6/docs/ref/#state.EditorState^readOnly) to be read-only.
+    */
+    get readOnly(): any;
+    /**
+    Look up a translation for the given phrase (via the
+    [`phrases`](https://codemirror.net/6/docs/ref/#state.EditorState^phrases) facet), or return the
+    original string if no translation is found.
+    
+    If additional arguments are passed, they will be inserted in
+    place of markers like `$1` (for the first value) and `$2`, etc.
+    A single `$` is equivalent to `$1`, and `$$` will produce a
+    literal dollar sign.
+    */
+    phrase(phrase: any, ...insert: any[]): any;
+    /**
+    Find the values for a given language data field, provided by the
+    the [`languageData`](https://codemirror.net/6/docs/ref/#state.EditorState^languageData) facet.
+    
+    Examples of language data fields are...
+    
+    - [`"commentTokens"`](https://codemirror.net/6/docs/ref/#commands.CommentTokens) for specifying
+      comment syntax.
+    - [`"autocomplete"`](https://codemirror.net/6/docs/ref/#autocomplete.autocompletion^config.override)
+      for providing language-specific completion sources.
+    - [`"wordChars"`](https://codemirror.net/6/docs/ref/#state.EditorState.charCategorizer) for adding
+      characters that should be considered part of words in this
+      language.
+    - [`"closeBrackets"`](https://codemirror.net/6/docs/ref/#autocomplete.CloseBracketConfig) controls
+      bracket closing behavior.
+    */
+    languageDataAt(name: any, pos: any, side?: number): any[];
+    /**
+    Return a function that can categorize strings (expected to
+    represent a single [grapheme cluster](https://codemirror.net/6/docs/ref/#state.findClusterBreak))
+    into one of:
+    
+     - Word (contains an alphanumeric character or a character
+       explicitly listed in the local language's `"wordChars"`
+       language data, which should be a string)
+     - Space (contains only whitespace)
+     - Other (anything else)
+    */
+    charCategorizer(at: any): (char: any) => any;
+    /**
+    Find the word at the given position, meaning the range
+    containing all [word](https://codemirror.net/6/docs/ref/#state.CharCategory.Word) characters
+    around it. If no word characters are adjacent to the position,
+    this returns null.
+    */
+    wordAt(pos: any): SelectionRange | null;
+}
+export namespace EditorState {
+    export { allowMultipleSelections };
+    export let tabSize: Facet;
+    export { lineSeparator };
+    export { readOnly };
+    export let phrases: Facet;
+    export { languageData };
+    export { changeFilter };
+    export { transactionFilter };
+    export { transactionExtender };
+}
+/**
+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.
+*/
+export class EditorView {
+    /**
+    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: any, options?: {}): StateEffect;
+    /**
+    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: any): ViewPlugin;
+    /**
+    Create an extension that registers DOM event observers. Contrary
+    to event [handlers](https://codemirror.net/6/docs/ref/#view.EditorView^domEventHandlers),
+    observers can't be prevented from running by a higher-precedence
+    handler returning true. They also don't prevent other handlers
+    and observers from running when they return true, and should not
+    call `preventDefault`.
+    */
+    static domEventObservers(observers: any): ViewPlugin;
+    /**
+    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: any, options: any): FacetProvider[];
+    /**
+    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: any): PrecExtension;
+    /**
+    Retrieve an editor view instance from the view's DOM
+    representation.
+    */
+    static findFromDOM(dom: any): any;
+    /**
+    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(config?: {});
+    /**
+    The current editor state.
+    */
+    get state(): any;
+    /**
+    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(): Viewport | undefined;
+    /**
+    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(): any[];
+    /**
+    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;
+    /**
+    The document or shadow root that the view lives in.
+    */
+    get root(): any;
+    /**
+    @internal
+    */
+    get win(): Window & typeof globalThis;
+    plugins: any;
+    pluginMap: Map<any, any>;
+    editorAttrs: {};
+    contentAttrs: {};
+    bidiCache: any[];
+    destroyed: boolean;
+    /**
+    @internal
+    */
+    updateState: number;
+    /**
+    @internal
+    */
+    measureScheduled: number;
+    /**
+    @internal
+    */
+    measureRequests: any[];
+    contentDOM: HTMLDivElement;
+    scrollDOM: HTMLDivElement;
+    announceDOM: HTMLDivElement;
+    dom: HTMLDivElement;
+    dispatchTransactions: any;
+    dispatch(...input: any[]): void;
+    _root: any;
+    viewState: ViewState;
+    observer: DOMObserver;
+    inputState: InputState;
+    docView: DocView;
+    /**
+    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: any): 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: any): void;
+    updatePlugins(update: any): void;
+    docViewUpdate(): void;
+    /**
+    @internal
+    */
+    measure(flush?: boolean): void;
+    /**
+    Get the CSS classes for the currently active editor themes.
+    */
+    get themeClasses(): string;
+    updateAttrs(): any;
+    showAnnouncements(trs: any): void;
+    mountStyles(): void;
+    styleModules: any;
+    readMeasured(): void;
+    /**
+    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(request: any): 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(plugin: any): any;
+    /**
+    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;
+    };
+    /**
+    If the editor is transformed with CSS, this provides the scale
+    along the X axis. Otherwise, it will just be 1. Note that
+    transforms other than translation and scaling are not supported.
+    */
+    get scaleX(): number;
+    /**
+    Provide the CSS transformed scale along the Y axis.
+    */
+    get scaleY(): 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: any): any;
+    /**
+    Find the line block (see
+    [`lineBlockAt`](https://codemirror.net/6/docs/ref/#view.EditorView.lineBlockAt) at the given
+    height, again interpreted relative to the [top of the
+    document](https://codemirror.net/6/docs/ref/#view.EditorView.documentTop).
+    */
+    lineBlockAtHeight(height: any): any;
+    /**
+    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(): any[] | undefined;
+    /**
+    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 break, 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: any): any;
+    /**
+    The editor's total content height.
+    */
+    get contentHeight(): any;
+    /**
+    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: any, forward: any, by: any): any;
+    /**
+    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: any, forward: any): any;
+    /**
+    Get the cursor position visually at the start or end of a line.
+    Note that this may differ from the _logical_ position at its
+    start or end (which is simply at `line.from`/`line.to`) if text
+    at the start or end goes against the line's base text direction.
+    */
+    visualLineSide(line: any, end: any): 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: any, forward: any, 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: any, forward: any, distance: any): any;
+    /**
+    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: any): any;
+    /**
+    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: any, offset?: number): any;
+    posAtCoords(coords: any, precise?: boolean): any;
+    /**
+    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: any, side?: number): any;
+    /**
+    Return the rectangle around a given character. If `pos` does not
+    point in front of a character that is in the viewport and
+    rendered (i.e. not replaced, not a line break), this will return
+    null. For space characters that are a line wrap point, this will
+    return the position before the line break.
+    */
+    coordsForChar(pos: any): any;
+    /**
+    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(): any;
+    /**
+    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: any): any;
+    /**
+    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(): any;
+    /**
+    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: any): any;
+    /**
+    Check whether the editor has focus.
+    */
+    get hasFocus(): boolean;
+    /**
+    Put focus on the editor.
+    */
+    focus(): void;
+    /**
+    Update the [root](https://codemirror.net/6/docs/ref/##view.EditorViewConfig.root) in which the editor lives. This is only
+    necessary when moving the editor's existing DOM to a new window or shadow root.
+    */
+    setRoot(root: any): 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;
+    /**
+    Return an effect that resets the editor to its current (at the
+    time this method was called) scroll position. Note that this
+    only affects the editor's own scrollable element, not parents.
+    See also
+    [`EditorViewConfig.scrollTo`](https://codemirror.net/6/docs/ref/#view.EditorViewConfig.scrollTo).
+    
+    The effect should be used with a document identical to the one
+    it was created for. Failing to do so is not an error, but may
+    not scroll to the expected position. You can
+    [map](https://codemirror.net/6/docs/ref/#state.StateEffect.map) the effect to account for changes.
+    */
+    scrollSnapshot(): StateEffect;
+    /**
+    Enable or disable tab-focus mode, which disables key bindings
+    for Tab and Shift-Tab, letting the browser's default
+    focus-changing behavior go through instead. This is useful to
+    prevent trapping keyboard users in your editor.
+    
+    Without argument, this toggles the mode. With a boolean, it
+    enables (true) or disables it (false). Given a number, it
+    temporarily enables the mode until that number of milliseconds
+    have passed or another non-Tab key is pressed.
+    */
+    setTabFocusMode(to: any): void;
+}
+export namespace EditorView {
+    export { styleModule };
+    export { inputHandler$1 as inputHandler };
+    export { clipboardInputFilter };
+    export { clipboardOutputFilter };
+    export { scrollHandler };
+    export { focusChangeEffect };
+    export { perLineTextDirection };
+    export { exceptionSink };
+    export { updateListener };
+    export { editable };
+    export { mouseSelectionStyle };
+    export { dragMovesSelection$1 as dragMovesSelection };
+    export { clickAddsSelectionRange };
+    export { decorations };
+    export { outerDecorations };
+    export { atomicRanges };
+    export { bidiIsolatedRanges };
+    export { scrollMargins };
+    export { darkTheme };
+    export let cspNonce: Facet;
+    export { contentAttributes };
+    export { editorAttributes };
+    export let lineWrapping: FacetProvider;
+    export let announce: StateEffectType;
+}
+export function Store(initialState: any): any;
+/**
+This is an extension value that just pulls together a number of
+extensions that you might want in a basic editor. It is meant as a
+convenient helper to quickly set up CodeMirror without installing
+and importing a lot of separate packages.
+
+Specifically, it includes...
+
+ - [the default command bindings](https://codemirror.net/6/docs/ref/#commands.defaultKeymap)
+ - [line numbers](https://codemirror.net/6/docs/ref/#view.lineNumbers)
+ - [special character highlighting](https://codemirror.net/6/docs/ref/#view.highlightSpecialChars)
+ - [the undo history](https://codemirror.net/6/docs/ref/#commands.history)
+ - [a fold gutter](https://codemirror.net/6/docs/ref/#language.foldGutter)
+ - [custom selection drawing](https://codemirror.net/6/docs/ref/#view.drawSelection)
+ - [drop cursor](https://codemirror.net/6/docs/ref/#view.dropCursor)
+ - [multiple selections](https://codemirror.net/6/docs/ref/#state.EditorState^allowMultipleSelections)
+ - [reindentation on input](https://codemirror.net/6/docs/ref/#language.indentOnInput)
+ - [the default highlight style](https://codemirror.net/6/docs/ref/#language.defaultHighlightStyle) (as fallback)
+ - [bracket matching](https://codemirror.net/6/docs/ref/#language.bracketMatching)
+ - [bracket closing](https://codemirror.net/6/docs/ref/#autocomplete.closeBrackets)
+ - [autocompletion](https://codemirror.net/6/docs/ref/#autocomplete.autocompletion)
+ - [rectangular selection](https://codemirror.net/6/docs/ref/#view.rectangularSelection) and [crosshair cursor](https://codemirror.net/6/docs/ref/#view.crosshairCursor)
+ - [active line highlighting](https://codemirror.net/6/docs/ref/#view.highlightActiveLine)
+ - [active line gutter highlighting](https://codemirror.net/6/docs/ref/#view.highlightActiveLineGutter)
+ - [selection match highlighting](https://codemirror.net/6/docs/ref/#search.highlightSelectionMatches)
+ - [search](https://codemirror.net/6/docs/ref/#search.searchKeymap)
+ - [linting](https://codemirror.net/6/docs/ref/#lint.lintKeymap)
+
+(You'll probably want to add some language package to your setup
+too.)
+
+This extension does not allow customization. The idea is that,
+once you decide you want to configure your editor more precisely,
+you take this package's source (which is just a bunch of imports
+and an array literal), copy it into your own code, and adjust it
+as desired.
+*/
+export const basicSetup: (any[] | FacetProvider | ViewPlugin)[];
+/**
+JSON language support.
+*/
+export function json(): LanguageSupport;
+export function prettyBytes(number: any, options: any): string;
+export function prettyMilliseconds(milliseconds: any, options: any): string;
+/**
+A change set represents a group of modifications to a document. It
+stores the document length, and can only be applied to documents
+with exactly that length.
+*/
+declare class ChangeSet extends ChangeDesc {
+    /**
+    Create a change set for the given changes, for a document of the
+    given length, using `lineSep` as line separator.
+    */
+    static of(changes: any, length: any, lineSep: any): null;
+    /**
+    Create an empty changeset of the given length.
+    */
+    static empty(length: any): ChangeSet;
+    /**
+    Create a changeset from its JSON representation (as produced by
+    [`toJSON`](https://codemirror.net/6/docs/ref/#state.ChangeSet.toJSON).
+    */
+    static fromJSON(json: any): ChangeSet;
+    /**
+    @internal
+    */
+    static createSet(sections: any, inserted: any): ChangeSet;
+    constructor(sections: any, inserted: any);
+    inserted: any;
+    /**
+    Apply the changes to a document, returning the modified
+    document.
+    */
+    apply(doc: any): any;
+    /**
+    Given the document as it existed _before_ the changes, return a
+    change set that represents the inverse of this set, which could
+    be used to go from the document created by the changes back to
+    the document as it existed before the changes.
+    */
+    invert(doc: any): ChangeSet;
+    /**
+    Combine two subsequent change sets into a single set. `other`
+    must start in the document produced by `this`. If `this` goes
+    `docA` → `docB` and `other` represents `docB` → `docC`, the
+    returned value will represent the change `docA` → `docC`.
+    */
+    compose(other: any): any;
+    /**
+    Given another change set starting in the same document, maps this
+    change set over the other, producing a new change set that can be
+    applied to the document produced by applying `other`. When
+    `before` is `true`, order changes as if `this` comes before
+    `other`, otherwise (the default) treat `other` as coming first.
+    
+    Given two changes `A` and `B`, `A.compose(B.map(A))` and
+    `B.compose(A.map(B, true))` will produce the same document. This
+    provides a basic form of [operational
+    transformation](https://en.wikipedia.org/wiki/Operational_transformation),
+    and can be used for collaborative editing.
+    */
+    map(other: any, before?: boolean): ChangeDesc;
+    /**
+    Iterate over the changed ranges in the document, calling `f` for
+    each, with the range in the original document (`fromA`-`toA`)
+    and the range that replaces it in the new document
+    (`fromB`-`toB`).
+    
+    When `individual` is true, adjacent changes are reported
+    separately.
+    */
+    iterChanges(f: any, individual?: boolean): void;
+    /**
+    Get a [change description](https://codemirror.net/6/docs/ref/#state.ChangeDesc) for this change
+    set.
+    */
+    get desc(): ChangeDesc;
+    /**
+    @internal
+    */
+    filter(ranges: any): {
+        changes: ChangeSet;
+        filtered: ChangeDesc;
+    };
+    /**
+    Serialize this change set to a JSON-representable value.
+    */
+    toJSON(): any[];
+}
+/**
+An editor selection holds one or more selection ranges.
+*/
+declare class EditorSelection {
+    /**
+    Create a selection from a JSON representation.
+    */
+    static fromJSON(json: any): EditorSelection;
+    /**
+    Create a selection holding a single range.
+    */
+    static single(anchor: any, head?: any): EditorSelection;
+    /**
+    Sort and merge the given set of ranges, creating a valid
+    selection.
+    */
+    static create(ranges: any, mainIndex?: number): EditorSelection;
+    /**
+    Create a cursor selection range at the given position. You can
+    safely ignore the optional arguments in most situations.
+    */
+    static cursor(pos: any, assoc: number | undefined, bidiLevel: any, goalColumn: any): SelectionRange;
+    /**
+    Create a selection range.
+    */
+    static range(anchor: any, head: any, goalColumn: any, bidiLevel: any): SelectionRange;
+    /**
+    @internal
+    */
+    static normalized(ranges: any, mainIndex?: number): EditorSelection;
+    constructor(ranges: any, mainIndex: any);
+    ranges: any;
+    mainIndex: any;
+    /**
+    Map a selection through a change. Used to adjust the selection
+    position for changes.
+    */
+    map(change: any, assoc?: number): EditorSelection;
+    /**
+    Compare this selection to another selection. By default, ranges
+    are compared only by position. When `includeAssoc` is true,
+    cursor ranges must also have the same
+    [`assoc`](https://codemirror.net/6/docs/ref/#state.SelectionRange.assoc) value.
+    */
+    eq(other: any, includeAssoc?: boolean): boolean;
+    /**
+    Get the primary selection range. Usually, you should make sure
+    your code applies to _all_ ranges, by using methods like
+    [`changeByRange`](https://codemirror.net/6/docs/ref/#state.EditorState.changeByRange).
+    */
+    get main(): any;
+    /**
+    Make sure the selection only has one range. Returns a selection
+    holding only the main range from this selection.
+    */
+    asSingle(): EditorSelection;
+    /**
+    Extend this selection with an extra range.
+    */
+    addRange(range: any, main?: boolean): EditorSelection;
+    /**
+    Replace a given range with another range, and then normalize the
+    selection to merge and sort ranges if necessary.
+    */
+    replaceRange(range: any, which?: any): EditorSelection;
+    /**
+    Convert this selection to an object that can be serialized to
+    JSON.
+    */
+    toJSON(): {
+        ranges: any;
+        main: any;
+    };
+}
+/**
+A single selection range. When
+[`allowMultipleSelections`](https://codemirror.net/6/docs/ref/#state.EditorState^allowMultipleSelections)
+is enabled, a [selection](https://codemirror.net/6/docs/ref/#state.EditorSelection) may hold
+multiple ranges. By default, selections hold exactly one range.
+*/
+declare class SelectionRange {
+    /**
+    Convert a JSON representation of a range to a `SelectionRange`
+    instance.
+    */
+    static fromJSON(json: any): SelectionRange;
+    /**
+    @internal
+    */
+    static create(from: any, to: any, flags: any): SelectionRange;
+    constructor(from: any, to: any, flags: any);
+    from: any;
+    to: any;
+    flags: any;
+    /**
+    The anchor of the range—the side that doesn't move when you
+    extend it.
+    */
+    get anchor(): any;
+    /**
+    The head of the range, which is moved when the range is
+    [extended](https://codemirror.net/6/docs/ref/#state.SelectionRange.extend).
+    */
+    get head(): any;
+    /**
+    True when `anchor` and `head` are at the same position.
+    */
+    get empty(): boolean;
+    /**
+    If this is a cursor that is explicitly associated with the
+    character on one of its sides, this returns the side. -1 means
+    the character before its position, 1 the character after, and 0
+    means no association.
+    */
+    get assoc(): 1 | 0 | -1;
+    /**
+    The bidirectional text level associated with this cursor, if
+    any.
+    */
+    get bidiLevel(): number | null;
+    /**
+    The goal column (stored vertical offset) associated with a
+    cursor. This is used to preserve the vertical position when
+    [moving](https://codemirror.net/6/docs/ref/#view.EditorView.moveVertically) across
+    lines of different length.
+    */
+    get goalColumn(): number | undefined;
+    /**
+    Map this range through a change, producing a valid range in the
+    updated document.
+    */
+    map(change: any, assoc?: number): SelectionRange;
+    /**
+    Extend this range to cover at least `from` to `to`.
+    */
+    extend(from: any, to?: any): SelectionRange;
+    /**
+    Compare this range to another range.
+    */
+    eq(other: any, includeAssoc?: boolean): boolean;
+    /**
+    Return a JSON-serializable object representing the range.
+    */
+    toJSON(): {
+        anchor: any;
+        head: any;
+    };
+}
+declare const allowMultipleSelections: Facet;
+/**
+A facet is a labeled value that is associated with an editor
+state. It takes inputs from any number of extensions, and combines
+those into a single output value.
+
+Examples of uses of facets are the [tab
+size](https://codemirror.net/6/docs/ref/#state.EditorState^tabSize), [editor
+attributes](https://codemirror.net/6/docs/ref/#view.EditorView^editorAttributes), and [update
+listeners](https://codemirror.net/6/docs/ref/#view.EditorView^updateListener).
+
+Note that `Facet` instances can be used anywhere where
+[`FacetReader`](https://codemirror.net/6/docs/ref/#state.FacetReader) is expected.
+*/
+declare class Facet {
+    /**
+    Define a new facet.
+    */
+    static define(config?: {}): Facet;
+    constructor(combine: any, compareInput: any, compare: any, isStatic: any, enables: any);
+    combine: any;
+    compareInput: any;
+    compare: any;
+    isStatic: any;
+    /**
+    @internal
+    */
+    id: number;
+    default: any;
+    extensions: any;
+    /**
+    Returns a facet reader for this facet, which can be used to
+    [read](https://codemirror.net/6/docs/ref/#state.EditorState.facet) it but not to define values for it.
+    */
+    get reader(): this;
+    /**
+    Returns an extension that adds the given value to this facet.
+    */
+    of(value: any): FacetProvider;
+    /**
+    Create an extension that computes a value for the facet from a
+    state. You must take care to declare the parts of the state that
+    this value depends on, since your function is only called again
+    for a new state when one of those parts changed.
+    
+    In cases where your value depends only on a single field, you'll
+    want to use the [`from`](https://codemirror.net/6/docs/ref/#state.Facet.from) method instead.
+    */
+    compute(deps: any, get: any): FacetProvider;
+    /**
+    Create an extension that computes zero or more values for this
+    facet from a state.
+    */
+    computeN(deps: any, get: any): FacetProvider;
+    from(field: any, get: any): FacetProvider;
+}
+declare const lineSeparator: Facet;
+declare const readOnly: Facet;
+declare const languageData: Facet;
+declare const changeFilter: Facet;
+declare const transactionFilter: Facet;
+declare const transactionExtender: Facet;
+declare class Viewport {
+    constructor(from: any, to: any);
+    from: any;
+    to: any;
+}
+declare class ViewState {
+    constructor(state: any);
+    state: any;
+    pixelViewport: {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+    };
+    inView: boolean;
+    paddingTop: number;
+    paddingBottom: number;
+    contentDOMWidth: number;
+    contentDOMHeight: number;
+    editorHeight: number;
+    editorWidth: number;
+    scrollTop: number;
+    scrolledToBottom: boolean;
+    scaleX: number;
+    scaleY: number;
+    scrollAnchorPos: number;
+    scrollAnchorHeight: number;
+    scaler: {
+        toDOM(n: any): any;
+        fromDOM(n: any): any;
+        scale: number;
+        eq(other: any): boolean;
+    };
+    scrollTarget: any;
+    printing: boolean;
+    mustMeasureContent: boolean;
+    defaultTextDirection: any;
+    visibleRanges: any[];
+    mustEnforceCursorAssoc: boolean;
+    heightOracle: HeightOracle;
+    stateDeco: any;
+    heightMap: any;
+    viewport: Viewport | undefined;
+    lineGaps: any[];
+    lineGapDeco: any;
+    updateForViewport(): 0 | 2;
+    viewports: (Viewport | undefined)[] | undefined;
+    updateScaler(): 0 | 2;
+    updateViewportLines(): void;
+    viewportLines: any[] | undefined;
+    update(update: any, scrollTarget?: null): void;
+    measure(view: any): number;
+    get visibleTop(): any;
+    get visibleBottom(): any;
+    getViewport(bias: any, scrollTarget: any): Viewport;
+    mapViewport(viewport: any, changes: any): Viewport;
+    viewportIsAppropriate({ from, to }: {
+        from: any;
+        to: any;
+    }, bias?: number): boolean;
+    mapLineGaps(gaps: any, changes: any): any;
+    ensureLineGaps(current: any, mayMeasure: any): any[];
+    gapSize(line: any, from: any, to: any, structure: any): number;
+    updateLineGaps(gaps: any): void;
+    computeVisibleRanges(changes: any): number;
+    lineBlockAt(pos: any): any;
+    lineBlockAtHeight(height: any): any;
+    scrollAnchorAt(scrollTop: any): any;
+    elementAtHeight(height: any): any;
+    get docHeight(): any;
+    get contentHeight(): any;
+}
+declare class DOMObserver {
+    constructor(view: any);
+    view: any;
+    active: boolean;
+    editContext: EditContextManager | null;
+    selectionRange: DOMSelectionState;
+    selectionChanged: boolean;
+    delayedFlush: number;
+    resizeTimeout: number;
+    queue: any[];
+    delayedAndroidKey: any;
+    flushingAndroidKey: number;
+    lastChange: number;
+    scrollTargets: any[];
+    intersection: IntersectionObserver | null;
+    resizeScroll: ResizeObserver | null;
+    intersecting: boolean;
+    gapIntersection: IntersectionObserver | null;
+    gaps: any[];
+    printQuery: MediaQueryList | null;
+    parentCheck: number;
+    dom: any;
+    observer: MutationObserver;
+    onCharData: ((event: any) => void) | undefined;
+    onSelectionChange(event: any): void;
+    onResize(): void;
+    onPrint(event: any): void;
+    onScroll(e: any): void;
+    win: any;
+    onScrollChanged(e: any): void;
+    updateGaps(gaps: any): void;
+    readSelectionRange(): boolean;
+    setSelectionRange(anchor: any, head: any): void;
+    clearSelectionRange(): void;
+    listenForScroll(): void;
+    ignore(f: any): any;
+    start(): void;
+    stop(): void;
+    clear(): void;
+    delayAndroidKey(key: any, keyCode: any): void;
+    clearDelayedAndroidKey(): void;
+    flushSoon(): void;
+    forceFlush(): void;
+    pendingRecords(): any[];
+    processRecords(): {
+        from: number;
+        to: number;
+        typeOver: boolean;
+    };
+    readChange(): DOMChange | null;
+    flush(readSelection?: boolean): boolean;
+    readMutation(rec: any): {
+        from: any;
+        to: any;
+        typeOver: boolean;
+    } | null;
+    setWindow(win: any): void;
+    addWindowListeners(win: any): void;
+    removeWindowListeners(win: any): void;
+    update(update: any): void;
+    destroy(): void;
+}
+declare class InputState {
+    constructor(view: any);
+    setSelectionOrigin(origin: any): void;
+    lastSelectionOrigin: any;
+    lastSelectionTime: number;
+    view: any;
+    lastKeyCode: number;
+    lastKeyTime: number;
+    lastTouchTime: number;
+    lastFocusTime: number;
+    lastScrollTop: number;
+    lastScrollLeft: number;
+    pendingIOSKey: any;
+    /**
+    When enabled (>-1), tab presses are not given to key handlers,
+    leaving the browser's default behavior. If >0, the mode expires
+    at that timestamp, and any other keypress clears it.
+    Esc enables temporary tab focus mode for two seconds when not
+    otherwise handled.
+    */
+    tabFocusMode: number;
+    lastContextMenu: number;
+    scrollHandlers: any[];
+    handlers: any;
+    composing: number;
+    compositionFirstChange: any;
+    compositionEndedAt: number;
+    compositionPendingKey: boolean;
+    compositionPendingChange: boolean;
+    mouseSelection: any;
+    draggedContent: any;
+    handleEvent(event: any): void;
+    notifiedFocused: any;
+    runHandlers(type: any, event: any): void;
+    ensureHandlers(plugins: any): void;
+    keydown(event: any): boolean;
+    flushIOSKey(change: any): boolean;
+    ignoreDuringComposition(event: any): boolean;
+    startMouseSelection(mouseSelection: any): void;
+    update(update: any): void;
+    destroy(): void;
+}
+declare class DocView extends ContentView {
+    constructor(view: any);
+    get length(): any;
+    view: any;
+    decorations: any[];
+    dynamicDecorationMap: boolean[];
+    domChanged: any;
+    hasComposition: {
+        from: any;
+        to: any;
+    } | null;
+    markedForComposition: Set<any>;
+    editContextFormatting: RangeSet;
+    lastCompositionAfterCursor: boolean;
+    minWidth: number;
+    minWidthFrom: number;
+    minWidthTo: number;
+    impreciseAnchor: DOMPos | null;
+    impreciseHead: DOMPos | null;
+    forceSelection: boolean;
+    lastUpdate: number;
+    children: LineView[];
+    update(update: any): boolean;
+    updateInner(changes: any, oldLength: any, composition: any): void;
+    updateChildren(changes: any, oldLength: any, composition: any): void;
+    updateEditContextFormatting(update: any): void;
+    compositionView(composition: any): LineView;
+    fixCompositionDOM(composition: any): void;
+    updateSelection(mustRead?: boolean, fromPointer?: boolean): void;
+    suppressWidgetCursorChange(sel: any, cursor: any): any;
+    enforceCursorAssoc(): void;
+    moveToLine(pos: any): any;
+    nearest(dom: any): any;
+    posFromDOM(node: any, offset: any): any;
+    domAtPos(pos: any): any;
+    coordsAt(pos: any, side: any): any;
+    coordsForChar(pos: any): any;
+    measureVisibleLineHeights(viewport: any): any[];
+    textDirectionAt(pos: any): any;
+    measureTextSize(): {
+        lineHeight: any;
+        charWidth: number;
+        textHeight: any;
+    } | {
+        lineHeight: undefined;
+        charWidth: undefined;
+        textHeight: undefined;
+    };
+    computeBlockGapDeco(): any;
+    updateDeco(): any[];
+    scrollIntoView(target: any): true | undefined;
+}
+/**
+State effects can be used to represent additional effects
+associated with a [transaction](https://codemirror.net/6/docs/ref/#state.Transaction.effects). They
+are often useful to model changes to custom [state
+fields](https://codemirror.net/6/docs/ref/#state.StateField), when those changes aren't implicit in
+document or selection changes.
+*/
+declare class StateEffect {
+    /**
+    Define a new effect type. The type parameter indicates the type
+    of values that his effect holds. It should be a type that
+    doesn't include `undefined`, since that is used in
+    [mapping](https://codemirror.net/6/docs/ref/#state.StateEffect.map) to indicate that an effect is
+    removed.
+    */
+    static define(spec?: {}): StateEffectType;
+    /**
+    Map an array of effects through a change set.
+    */
+    static mapEffects(effects: any, mapping: any): any;
+    /**
+    @internal
+    */
+    constructor(type: any, value: any);
+    type: any;
+    value: any;
+    /**
+    Map this effect through a position mapping. Will return
+    `undefined` when that ends up deleting the effect.
+    */
+    map(mapping: any): StateEffect | undefined;
+    /**
+    Tells you whether this effect object is of a given
+    [type](https://codemirror.net/6/docs/ref/#state.StateEffectType).
+    */
+    is(type: any): boolean;
+}
+declare namespace StateEffect {
+    let reconfigure: StateEffectType;
+    let appendConfig: StateEffectType;
+}
+/**
+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 {
+    /**
+    Define a plugin from a constructor function that creates the
+    plugin's value, given an editor view.
+    */
+    static define(create: any, spec: any): ViewPlugin;
+    /**
+    Create a plugin for a class whose constructor takes a single
+    editor view as argument.
+    */
+    static fromClass(cls: any, spec: any): ViewPlugin;
+    constructor(id: any, create: any, domEventHandlers: any, domEventObservers: any, buildExtensions: any);
+    id: any;
+    create: any;
+    domEventHandlers: any;
+    domEventObservers: any;
+    extension: any;
+}
+declare class FacetProvider {
+    constructor(dependencies: any, facet: any, type: any, value: any);
+    dependencies: any;
+    facet: any;
+    type: any;
+    value: any;
+    id: number;
+    dynamicSlot(addresses: any): {
+        create(state: any): number;
+        update(state: any, tr: any): 1 | 0;
+        reconfigure: (state: any, oldState: any) => 1 | 0;
+    };
+}
+declare class PrecExtension {
+    constructor(inner: any, prec: any);
+    inner: any;
+    prec: any;
+}
+declare const styleModule: Facet;
+declare const inputHandler$1: Facet;
+declare const clipboardInputFilter: Facet;
+declare const clipboardOutputFilter: Facet;
+declare const scrollHandler: Facet;
+declare const focusChangeEffect: Facet;
+declare const perLineTextDirection: Facet;
+declare const exceptionSink: Facet;
+declare const updateListener: Facet;
+declare const editable: Facet;
+declare const mouseSelectionStyle: Facet;
+declare const dragMovesSelection$1: Facet;
+declare const clickAddsSelectionRange: Facet;
+declare const decorations: Facet;
+declare const outerDecorations: Facet;
+declare const atomicRanges: Facet;
+declare const bidiIsolatedRanges: Facet;
+declare const scrollMargins: Facet;
+declare const darkTheme: Facet;
+declare const contentAttributes: Facet;
+declare const editorAttributes: Facet;
+/**
+Representation of a type of state effect. Defined with
+[`StateEffect.define`](https://codemirror.net/6/docs/ref/#state.StateEffect^define).
+*/
+declare class StateEffectType {
+    /**
+    @internal
+    */
+    constructor(map: any);
+    map: any;
+    /**
+    Create a [state effect](https://codemirror.net/6/docs/ref/#state.StateEffect) instance of this
+    type.
+    */
+    of(value: any): StateEffect;
+}
+/**
+This class bundles a [language](https://codemirror.net/6/docs/ref/#language.Language) with an
+optional set of supporting extensions. Language packages are
+encouraged to export a function that optionally takes a
+configuration object and returns a `LanguageSupport` instance, as
+the main way for client code to use the package.
+*/
+declare class LanguageSupport {
+    /**
+    Create a language support object.
+    */
+    constructor(language: any, support?: any[]);
+    language: any;
+    support: any[];
+    extension: any[];
+}
+/**
+A change description is a variant of [change set](https://codemirror.net/6/docs/ref/#state.ChangeSet)
+that doesn't store the inserted text. As such, it can't be
+applied, but is cheaper to store and manipulate.
+*/
+declare class ChangeDesc {
+    /**
+    Create a change desc from its JSON representation (as produced
+    by [`toJSON`](https://codemirror.net/6/docs/ref/#state.ChangeDesc.toJSON).
+    */
+    static fromJSON(json: any): ChangeDesc;
+    /**
+    @internal
+    */
+    static create(sections: any): ChangeDesc;
+    /**
+    @internal
+    */
+    constructor(sections: any);
+    sections: any;
+    /**
+    The length of the document before the change.
+    */
+    get length(): number;
+    /**
+    The length of the document after the change.
+    */
+    get newLength(): number;
+    /**
+    False when there are actual changes in this set.
+    */
+    get empty(): boolean;
+    /**
+    Iterate over the unchanged parts left by these changes. `posA`
+    provides the position of the range in the old document, `posB`
+    the new position in the changed document.
+    */
+    iterGaps(f: any): void;
+    /**
+    Iterate over the ranges changed by these changes. (See
+    [`ChangeSet.iterChanges`](https://codemirror.net/6/docs/ref/#state.ChangeSet.iterChanges) for a
+    variant that also provides you with the inserted text.)
+    `fromA`/`toA` provides the extent of the change in the starting
+    document, `fromB`/`toB` the extent of the replacement in the
+    changed document.
+    
+    When `individual` is true, adjacent changes (which are kept
+    separate for [position mapping](https://codemirror.net/6/docs/ref/#state.ChangeDesc.mapPos)) are
+    reported separately.
+    */
+    iterChangedRanges(f: any, individual?: boolean): void;
+    /**
+    Get a description of the inverted form of these changes.
+    */
+    get invertedDesc(): ChangeDesc;
+    /**
+    Compute the combined effect of applying another set of changes
+    after this one. The length of the document after this set should
+    match the length before `other`.
+    */
+    composeDesc(other: any): any;
+    /**
+    Map this description, which should start with the same document
+    as `other`, over another set of changes, so that it can be
+    applied after it. When `before` is true, map as if the changes
+    in `this` happened before the ones in `other`.
+    */
+    mapDesc(other: any, before?: boolean): ChangeDesc;
+    mapPos(pos: any, assoc?: number, mode?: any): any;
+    /**
+    Check whether these changes touch a given range. When one of the
+    changes entirely covers the range, the string `"cover"` is
+    returned.
+    */
+    touchesRange(from: any, to?: any): boolean | "cover";
+    /**
+    @internal
+    */
+    toString(): string;
+    /**
+    Serialize this change desc to a JSON-representable value.
+    */
+    toJSON(): any;
+}
+declare class HeightOracle {
+    constructor(lineWrapping: any);
+    lineWrapping: any;
+    doc: TextLeaf;
+    heightSamples: {};
+    lineHeight: number;
+    charWidth: number;
+    textHeight: number;
+    lineLength: number;
+    heightForGap(from: any, to: any): number;
+    heightForLine(length: any): number;
+    setDoc(doc: any): this;
+    mustRefreshForWrapping(whiteSpace: any): boolean;
+    mustRefreshForHeights(lineHeights: any): boolean;
+    refresh(whiteSpace: any, lineHeight: any, charWidth: any, textHeight: any, lineLength: any, knownHeights: any): boolean;
+}
+declare class EditContextManager {
+    constructor(view: any);
+    from: number;
+    to: number;
+    pendingContextChange: {
+        from: any;
+        to: any;
+        insert: any;
+    } | null;
+    handlers: any;
+    composing: any;
+    editContext: any;
+    measureReq: {
+        read: (view: any) => void;
+    };
+    applyEdits(update: any): boolean;
+    update(update: any): void;
+    resetRange(state: any): void;
+    reset(state: any): void;
+    revertPending(state: any): void;
+    setSelection(state: any): void;
+    rangeIsValid(state: any): boolean;
+    toEditorPos(contextPos: any, clipLen?: number): any;
+    toContextPos(editorPos: any): any;
+    destroy(): void;
+}
+declare class DOMSelectionState {
+    anchorNode: any;
+    anchorOffset: number;
+    focusNode: any;
+    focusOffset: number;
+    eq(domSel: any): boolean;
+    setRange(range: any): void;
+    set(anchorNode: any, anchorOffset: any, focusNode: any, focusOffset: any): void;
+}
+declare class DOMChange {
+    constructor(view: any, start: any, end: any, typeOver: any);
+    typeOver: any;
+    bounds: any;
+    text: string;
+    domChanged: boolean;
+    newSel: EditorSelection | null;
+}
+declare class ContentView {
+    static get(node: any): any;
+    parent: any;
+    dom: any;
+    flags: number;
+    get overrideDOMText(): null;
+    get posAtStart(): any;
+    get posAtEnd(): any;
+    posBefore(view: any): any;
+    posAfter(view: any): any;
+    sync(view: any, track: any): void;
+    reuseDOM(_dom: any): void;
+    localPosFromDOM(node: any, offset: any): any;
+    domBoundsAround(from: any, to: any, offset?: number): any;
+    markDirty(andParent?: boolean): void;
+    markParentsDirty(childList: any): void;
+    setParent(parent: any): void;
+    setDOM(dom: any): void;
+    get rootView(): this;
+    replaceChildren(from: any, to: any, children?: any[]): void;
+    children: any;
+    ignoreMutation(_rec: any): boolean;
+    ignoreEvent(_event: any): boolean;
+    childCursor(pos?: any): ChildCursor;
+    childPos(pos: any, bias?: number): ChildCursor;
+    toString(): string;
+    get isEditable(): boolean;
+    get isWidget(): boolean;
+    get isHidden(): boolean;
+    merge(from: any, to: any, source: any, hasStart: any, openStart: any, openEnd: any): boolean;
+    become(other: any): boolean;
+    canReuseDOM(other: any): boolean;
+    getSide(): number;
+    destroy(): void;
+    breakAfter: number;
+}
+/**
+A range set stores a collection of [ranges](https://codemirror.net/6/docs/ref/#state.Range) in a
+way that makes them efficient to [map](https://codemirror.net/6/docs/ref/#state.RangeSet.map) and
+[update](https://codemirror.net/6/docs/ref/#state.RangeSet.update). This is an immutable data
+structure.
+*/
+declare class RangeSet {
+    /**
+    @internal
+    */
+    static create(chunkPos: any, chunk: any, nextLayer: any, maxPoint: any): RangeSet;
+    /**
+    Iterate over the ranges in a collection of sets, in order,
+    starting from `from`.
+    */
+    static iter(sets: any, from?: number): LayerCursor | HeapCursor;
+    /**
+    Iterate over two groups of sets, calling methods on `comparator`
+    to notify it of possible differences.
+    */
+    static compare(oldSets: any, newSets: any, textDiff: any, comparator: any, minPointSize?: number): void;
+    /**
+    Compare the contents of two groups of range sets, returning true
+    if they are equivalent in the given range.
+    */
+    static eq(oldSets: any, newSets: any, from: number | undefined, to: any): boolean;
+    /**
+    Iterate over a group of range sets at the same time, notifying
+    the iterator about the ranges covering every given piece of
+    content. Returns the open count (see
+    [`SpanIterator.span`](https://codemirror.net/6/docs/ref/#state.SpanIterator.span)) at the end
+    of the iteration.
+    */
+    static spans(sets: any, from: any, to: any, iterator: any, minPointSize?: number): number;
+    /**
+    Create a range set for the given range or array of ranges. By
+    default, this expects the ranges to be _sorted_ (by start
+    position and, if two start at the same position,
+    `value.startSide`). You can pass `true` as second argument to
+    cause the method to sort them.
+    */
+    static of(ranges: any, sort?: boolean): any;
+    /**
+    Join an array of range sets into a single set.
+    */
+    static join(sets: any): any;
+    constructor(chunkPos: any, chunk: any, nextLayer: any, maxPoint: any);
+    chunkPos: any;
+    chunk: any;
+    nextLayer: any;
+    maxPoint: any;
+    /**
+    @internal
+    */
+    get length(): number;
+    /**
+    The number of ranges in the set.
+    */
+    get size(): any;
+    /**
+    @internal
+    */
+    chunkEnd(index: any): any;
+    /**
+    Update the range set, optionally adding new ranges or filtering
+    out existing ones.
+    
+    (Note: The type parameter is just there as a kludge to work
+    around TypeScript variance issues that prevented `RangeSet<X>`
+    from being a subtype of `RangeSet<Y>` when `X` is a subtype of
+    `Y`.)
+    */
+    update(updateSpec: any): any;
+    /**
+    Map this range set through a set of changes, return the new set.
+    */
+    map(changes: any): any;
+    /**
+    Iterate over the ranges that touch the region `from` to `to`,
+    calling `f` for each. There is no guarantee that the ranges will
+    be reported in any specific order. When the callback returns
+    `false`, iteration stops.
+    */
+    between(from: any, to: any, f: any): void;
+    /**
+    Iterate over the ranges in this set, in order, including all
+    ranges that end at or after `from`.
+    */
+    iter(from?: number): LayerCursor | HeapCursor;
+    /**
+    @internal
+    */
+    get isEmpty(): boolean;
+}
+declare namespace RangeSet {
+    let empty: RangeSet;
+}
+declare class DOMPos {
+    static before(dom: any, precise: any): DOMPos;
+    static after(dom: any, precise: any): DOMPos;
+    constructor(node: any, offset: any, precise?: boolean);
+    node: any;
+    offset: any;
+    precise: boolean;
+}
+declare class LineView extends ContentView {
+    static find(docView: any, pos: any): LineView | null;
+    constructor(...args: any[]);
+    children: any[];
+    length: number;
+    prevAttrs: any;
+    attrs: any;
+    split(at: any): LineView;
+    transferDOM(other: any): void;
+    setDeco(attrs: any): void;
+    append(child: any, openStart: any): void;
+    addLineDeco(deco: any): void;
+    domAtPos(pos: any): any;
+    measureTextSize(): {
+        lineHeight: any;
+        charWidth: number;
+        textHeight: any;
+    } | null;
+    coordsAt(pos: any, side: any): any;
+    covers(): boolean;
+}
+declare class TextLeaf extends Text {
+    static split(text: any, target: any): any;
+    constructor(text: any, length?: number);
+    text: any;
+    length: number;
+    get lines(): any;
+    get children(): null;
+    lineInner(target: any, isLine: any, line: any, offset: any): Line;
+    decompose(from: any, to: any, target: any, open: any): void;
+    sliceString(from: any, to?: number, lineSep?: string): string;
+    flatten(target: any): void;
+    scanIdentical(): number;
+}
+declare class ChildCursor {
+    constructor(children: any, pos: any, i: any);
+    children: any;
+    pos: any;
+    i: any;
+    off: number;
+    findPos(pos: any, bias?: number): this;
+}
+declare class LayerCursor {
+    constructor(layer: any, skip: any, minPoint: any, rank?: number);
+    layer: any;
+    skip: any;
+    minPoint: any;
+    rank: number;
+    get startSide(): any;
+    get endSide(): any;
+    goto(pos: any, side?: number): this;
+    chunkIndex: number | undefined;
+    rangeIndex: any;
+    gotoInner(pos: any, side: any, forward: any): void;
+    forward(pos: any, side: any): void;
+    next(): void;
+    from: any;
+    to: any;
+    value: any;
+    setRangeIndex(index: any): void;
+    nextChunk(): void;
+    compare(other: any): number;
+}
+declare class HeapCursor {
+    static from(sets: any, skip?: null, minPoint?: number): LayerCursor | HeapCursor;
+    constructor(heap: any);
+    heap: any;
+    get startSide(): any;
+    goto(pos: any, side?: number): this;
+    forward(pos: any, side: any): void;
+    next(): void;
+    from: any;
+    to: any;
+    value: any;
+    rank: any;
+}
+/**
+The data structure for documents. @nonabstract
+*/
+declare class Text {
+    /**
+    Create a `Text` instance for the given array of lines.
+    */
+    static of(text: any): any;
+    /**
+    Get the line description around the given position.
+    */
+    lineAt(pos: any): any;
+    /**
+    Get the description for the given (1-based) line number.
+    */
+    line(n: any): any;
+    /**
+    Replace a range of the text with the given content.
+    */
+    replace(from: any, to: any, text: any): any;
+    /**
+    Append another document to this one.
+    */
+    append(other: any): any;
+    /**
+    Retrieve the text between the given points.
+    */
+    slice(from: any, to?: any): any;
+    /**
+    Test whether this text is equal to another instance.
+    */
+    eq(other: any): boolean;
+    /**
+    Iterate over the text. When `dir` is `-1`, iteration happens
+    from end to start. This will return lines and the breaks between
+    them as separate strings.
+    */
+    iter(dir?: number): RawTextCursor;
+    /**
+    Iterate over a range of the text. When `from` > `to`, the
+    iterator will run in reverse.
+    */
+    iterRange(from: any, to?: any): PartialTextCursor;
+    /**
+    Return a cursor that iterates over the given range of lines,
+    _without_ returning the line breaks between, and yielding empty
+    strings for empty lines.
+    
+    When `from` and `to` are given, they should be 1-based line numbers.
+    */
+    iterLines(from: any, to: any): LineCursor;
+    /**
+    Return the document as a string, using newline characters to
+    separate lines.
+    */
+    toString(): any;
+    /**
+    Convert the document to an array of lines (which can be
+    deserialized again via [`Text.of`](https://codemirror.net/6/docs/ref/#state.Text^of)).
+    */
+    toJSON(): any[];
+}
+declare namespace Text {
+    let empty_1: TextLeaf;
+    export { empty_1 as empty };
+}
+/**
+This type describes a line in the document. It is created
+on-demand when lines are [queried](https://codemirror.net/6/docs/ref/#state.Text.lineAt).
+*/
+declare class Line {
+    /**
+    @internal
+    */
+    constructor(from: any, to: any, number: any, text: any);
+    from: any;
+    to: any;
+    number: any;
+    text: any;
+    /**
+    The length of the line (not including any line break after it).
+    */
+    get length(): number;
+}
+declare class RawTextCursor {
+    constructor(text: any, dir?: number);
+    dir: number;
+    done: boolean;
+    lineBreak: boolean;
+    value: string;
+    nodes: any[];
+    offsets: number[];
+    nextInner(skip: any, dir: any): this;
+    next(skip?: number): this;
+}
+declare class PartialTextCursor {
+    constructor(text: any, start: any, end: any);
+    value: string;
+    done: boolean;
+    cursor: RawTextCursor;
+    pos: any;
+    from: number;
+    to: number;
+    nextInner(skip: any, dir: any): this;
+    next(skip?: number): this;
+    get lineBreak(): boolean;
+}
+declare class LineCursor {
+    constructor(inner: any);
+    inner: any;
+    afterBreak: boolean;
+    value: string;
+    done: boolean;
+    next(skip?: number): this;
+    get lineBreak(): boolean;
+}
+export {};