@codingame/monaco-vscode-api 1.79.0 → 1.79.2-next.0

package/dist/editorBrowser.d.ts

@@ -1,10 +1,23 @@
 import { S as ServiceIdentifier } from './instantiation.js';
-import { I as IDisposable, E as Event, a as IReference } from './event.js';
+import { a as IDisposable, E as Event, I as IReference, D as Disposable } from './event.js';
 import { a as UriComponents, U as URI } from './uri.js';
-import { I as IMarkdownString, e as IEditorModel$1 } from './editor.js';
 import * as monaco from 'monaco-editor';
 import { a as ThemeColor } from './themables.js';
 
+interface MarkdownStringTrustedOptions {
+    readonly enabledCommands: readonly string[];
+}
+interface IMarkdownString {
+    readonly value: string;
+    readonly isTrusted?: boolean | MarkdownStringTrustedOptions;
+    readonly supportThemeIcons?: boolean;
+    readonly supportHtml?: boolean;
+    readonly baseUri?: UriComponents;
+    uris?: {
+        [href: string]: UriComponents;
+    };
+}
+
 /**
  * A position in the editor. This interface is suitable for serialization.
  */
@@ -288,6 +301,7 @@ declare class Range {
  * A range of lines (1-based).
  */
 declare class LineRange {
+    static fromRange(range: Range): LineRange;
     /**
      * @param lineRanges An array of sorted line ranges.
      */
@@ -297,6 +311,7 @@ declare class LineRange {
      * @param lineRanges2 Must be sorted.
      */
     static join(lineRanges1: readonly LineRange[], lineRanges2: readonly LineRange[]): readonly LineRange[];
+    static ofLength(startLineNumber: number, length: number): LineRange;
     /**
      * The start line number.
      */
@@ -332,14 +347,18 @@ declare class LineRange {
      * If the ranges don't even touch, the result is undefined.
      */
     intersect(other: LineRange): LineRange | undefined;
+    intersectsStrict(other: LineRange): boolean;
     overlapOrTouch(other: LineRange): boolean;
     equals(b: LineRange): boolean;
+    toInclusiveRange(): Range | null;
+    toExclusiveRange(): Range;
 }
 
 /**
  * Maps a line range in the original text model to a line range in the modified text model.
  */
 declare class LineRangeMapping {
+    static inverse(mapping: LineRangeMapping[], originalLineCount: number, modifiedLineCount: number): LineRangeMapping[];
     /**
      * The line range in the original text model.
      */
@@ -1131,7 +1150,7 @@ interface IDocumentDiffProvider {
  */
 interface IDocumentDiffProviderOptions {
     /**
-     * When set to true, the diff should ignore whitespace changes.i
+     * When set to true, the diff should ignore whitespace changes.
      */
     ignoreTrimWhitespace: boolean;
     /**
@@ -1182,7 +1201,7 @@ declare const enum EditorAutoIndentStrategy {
 /**
  * Configuration options for the editor.
  */
-interface IEditorOptions {
+interface IEditorOptions$1 {
     /**
      * This editor is used inside a diff editor.
      */
@@ -1837,6 +1856,10 @@ interface IEditorOptions {
      * When enabled, this shows a preview of the drop location and triggers an `onDropIntoEditor` event.
      */
     dropIntoEditor?: IDropIntoEditorOptions;
+    /**
+     * Controls support for changing how content is pasted into the editor.
+     */
+    pasteAs?: IPasteAsOptions;
     /**
      * Controls whether the editor receives tabs or defers them to the workbench for navigation.
      */
@@ -1911,11 +1934,22 @@ interface IDiffEditorBaseOptions {
      * Whether the diff editor aria label should be verbose.
      */
     accessibilityVerbose?: boolean;
+    experimental?: {
+        /**
+         * Defaults to false.
+         */
+        collapseUnchangedRegions?: boolean;
+    };
 }
 /**
  * Configuration options for the diff editor.
  */
-interface IDiffEditorOptions extends IEditorOptions, IDiffEditorBaseOptions {
+interface IDiffEditorOptions extends IEditorOptions$1, IDiffEditorBaseOptions {
+    /**
+     * Is the diff editor inside another editor
+     * Defaults to false
+     */
+    isInEmbeddedEditor?: boolean;
 }
 /**
  * Configuration options for editor comments
@@ -2486,6 +2520,21 @@ interface IDropIntoEditorOptions {
      */
     showDropSelector?: 'afterDrop' | 'never';
 }
+/**
+ * Configuration options for editor pasting as into behavior
+ */
+interface IPasteAsOptions {
+    /**
+     * Enable paste as functionality in editors.
+     * Defaults to true.
+     */
+    enabled?: boolean;
+    /**
+     * Controls if a widget is shown after a drop.
+     * Defaults to 'afterPaste'.
+     */
+    showPasteSelector?: 'afterPaste' | 'never';
+}
 
 interface IDiffComputationResult {
     quitEarly: boolean;
@@ -2549,7 +2598,7 @@ interface IEditorAction {
     isSupported(): boolean;
     run(args?: unknown): Promise<void>;
 }
-type IEditorModel = ITextModel | IDiffEditorModel;
+type IEditorModel$1 = ITextModel | IDiffEditorModel;
 /**
  * A (serializable) state of the cursors.
  */
@@ -2620,7 +2669,7 @@ interface IEditor {
     /**
      * Update the editor's options after the editor has been created.
      */
-    updateOptions(newOptions: IEditorOptions): void;
+    updateOptions(newOptions: IEditorOptions$1): void;
     /**
      * Indicates that the editor becomes visible.
      * @internal
@@ -2803,7 +2852,7 @@ interface IEditor {
     /**
      * Gets the current model attached to this editor.
      */
-    getModel(): IEditorModel | null;
+    getModel(): IEditorModel$1 | null;
     /**
      * Sets the current model attached to this editor.
      * If the previous model was created by the editor via the value key in the options
@@ -2812,7 +2861,7 @@ interface IEditor {
      * will not be destroyed.
      * It is safe to call setModel(null) to simply detach the current model from the editor.
      */
-    setModel(model: IEditorModel | null): void;
+    setModel(model: IEditorModel$1 | null): void;
     /**
      * Create a collection of decorations. All decorations added through this collection
      * will get the ownerId of the editor (meaning they will not show up in other editors).
@@ -2979,6 +3028,310 @@ interface IDecorationRenderOptions extends IThemeDecorationRenderOptions {
     dark?: IThemeDecorationRenderOptions;
 }
 
+interface IEditorModel {
+    /**
+     * Emitted when the model is about to be disposed.
+     */
+    readonly onWillDispose: Event<void>;
+    /**
+     * Resolves the model.
+     */
+    resolve(): Promise<void>;
+    /**
+     * Find out if the editor model was resolved or not.
+     */
+    isResolved(): boolean;
+    /**
+     * Find out if this model has been disposed.
+     */
+    isDisposed(): boolean;
+    /**
+     * Dispose associated resources
+     */
+    dispose(): void;
+}
+interface IBaseUntypedEditorInput {
+    /**
+     * Optional options to use when opening the input.
+     */
+    options?: IEditorOptions;
+    /**
+     * Label to show for the input.
+     */
+    readonly label?: string;
+    /**
+     * Description to show for the input.
+     */
+    readonly description?: string;
+}
+interface IBaseResourceEditorInput extends IBaseUntypedEditorInput {
+    /**
+     * Hint to indicate that this input should be treated as a
+     * untitled file.
+     *
+     * Without this hint, the editor service will make a guess by
+     * looking at the scheme of the resource(s).
+     *
+     * Use `forceUntitled: true` when you pass in a `resource` that
+     * does not use the `untitled` scheme. The `resource` will then
+     * be used as associated path when saving the untitled file.
+     */
+    readonly forceUntitled?: boolean;
+}
+interface IBaseTextResourceEditorInput extends IBaseResourceEditorInput {
+    /**
+     * Optional options to use when opening the text input.
+     */
+    options?: ITextEditorOptions;
+    /**
+     * The contents of the text input if known. If provided,
+     * the input will not attempt to load the contents from
+     * disk and may appear dirty.
+     */
+    contents?: string;
+    /**
+     * The encoding of the text input if known.
+     */
+    encoding?: string;
+    /**
+     * The identifier of the language id of the text input
+     * if known to use when displaying the contents.
+     */
+    languageId?: string;
+}
+interface IResourceEditorInput extends IBaseResourceEditorInput {
+    /**
+     * The resource URI of the resource to open.
+     */
+    readonly resource: URI;
+}
+interface ITextResourceEditorInput extends IResourceEditorInput, IBaseTextResourceEditorInput {
+    /**
+     * Optional options to use when opening the text input.
+     */
+    options?: ITextEditorOptions;
+}
+/**
+ * This identifier allows to uniquely identify an editor with a
+ * resource, type and editor identifier.
+ */
+interface IResourceEditorInputIdentifier {
+    /**
+     * The type of the editor.
+     */
+    readonly typeId: string;
+    /**
+     * The identifier of the editor if provided.
+     */
+    readonly editorId: string | undefined;
+    /**
+     * The resource URI of the editor.
+     */
+    readonly resource: URI;
+}
+declare enum EditorActivation {
+    /**
+     * Activate the editor after it opened. This will automatically restore
+     * the editor if it is minimized.
+     */
+    ACTIVATE = 1,
+    /**
+     * Only restore the editor if it is minimized but do not activate it.
+     *
+     * Note: will only work in combination with the `preserveFocus: true` option.
+     * Otherwise, if focus moves into the editor, it will activate and restore
+     * automatically.
+     */
+    RESTORE = 2,
+    /**
+     * Preserve the current active editor.
+     *
+     * Note: will only work in combination with the `preserveFocus: true` option.
+     * Otherwise, if focus moves into the editor, it will activate and restore
+     * automatically.
+     */
+    PRESERVE = 3
+}
+declare enum EditorResolution {
+    /**
+     * Displays a picker and allows the user to decide which editor to use.
+     */
+    PICK = 0,
+    /**
+     * Only exclusive editors are considered.
+     */
+    EXCLUSIVE_ONLY = 1
+}
+declare enum EditorOpenSource {
+    /**
+     * Default: the editor is opening via a programmatic call
+     * to the editor service API.
+     */
+    API = 0,
+    /**
+     * Indicates that a user action triggered the opening, e.g.
+     * via mouse or keyboard use.
+     */
+    USER = 1
+}
+interface IEditorOptions {
+    /**
+     * Tells the editor to not receive keyboard focus when the editor is being opened.
+     *
+     * Will also not activate the group the editor opens in unless the group is already
+     * the active one. This behaviour can be overridden via the `activation` option.
+     */
+    preserveFocus?: boolean;
+    /**
+     * This option is only relevant if an editor is opened into a group that is not active
+     * already and allows to control if the inactive group should become active, restored
+     * or preserved.
+     *
+     * By default, the editor group will become active unless `preserveFocus` or `inactive`
+     * is specified.
+     */
+    activation?: EditorActivation;
+    /**
+     * Tells the editor to reload the editor input in the editor even if it is identical to the one
+     * already showing. By default, the editor will not reload the input if it is identical to the
+     * one showing.
+     */
+    forceReload?: boolean;
+    /**
+     * Will reveal the editor if it is already opened and visible in any of the opened editor groups.
+     *
+     * Note that this option is just a hint that might be ignored if the user wants to open an editor explicitly
+     * to the side of another one or into a specific editor group.
+     */
+    revealIfVisible?: boolean;
+    /**
+     * Will reveal the editor if it is already opened (even when not visible) in any of the opened editor groups.
+     *
+     * Note that this option is just a hint that might be ignored if the user wants to open an editor explicitly
+     * to the side of another one or into a specific editor group.
+     */
+    revealIfOpened?: boolean;
+    /**
+     * An editor that is pinned remains in the editor stack even when another editor is being opened.
+     * An editor that is not pinned will always get replaced by another editor that is not pinned.
+     */
+    pinned?: boolean;
+    /**
+     * An editor that is sticky moves to the beginning of the editors list within the group and will remain
+     * there unless explicitly closed. Operations such as "Close All" will not close sticky editors.
+     */
+    sticky?: boolean;
+    /**
+     * The index in the document stack where to insert the editor into when opening.
+     */
+    index?: number;
+    /**
+     * An active editor that is opened will show its contents directly. Set to true to open an editor
+     * in the background without loading its contents.
+     *
+     * Will also not activate the group the editor opens in unless the group is already
+     * the active one. This behaviour can be overridden via the `activation` option.
+     */
+    inactive?: boolean;
+    /**
+     * Will not show an error in case opening the editor fails and thus allows to show a custom error
+     * message as needed. By default, an error will be presented as notification if opening was not possible.
+     */
+    /**
+     * In case of an error opening the editor, will not present this error to the user (e.g. by showing
+     * a generic placeholder in the editor area). So it is up to the caller to provide error information
+     * in that case.
+     *
+     * By default, an error when opening an editor will result in a placeholder editor that shows the error.
+     * In certain cases a modal dialog may be presented to ask the user for further action.
+     */
+    ignoreError?: boolean;
+    /**
+     * Allows to override the editor that should be used to display the input:
+     * - `undefined`: let the editor decide for itself
+     * - `string`: specific override by id
+     * - `EditorResolution`: specific override handling
+     */
+    override?: string | EditorResolution;
+    /**
+     * A optional hint to signal in which context the editor opens.
+     *
+     * If configured to be `EditorOpenSource.USER`, this hint can be
+     * used in various places to control the experience. For example,
+     * if the editor to open fails with an error, a notification could
+     * inform about this in a modal dialog. If the editor opened through
+     * some background task, the notification would show in the background,
+     * not as a modal dialog.
+     */
+    source?: EditorOpenSource;
+    /**
+     * An optional property to signal that certain view state should be
+     * applied when opening the editor.
+     */
+    viewState?: object;
+}
+interface ITextEditorSelection {
+    readonly startLineNumber: number;
+    readonly startColumn: number;
+    readonly endLineNumber?: number;
+    readonly endColumn?: number;
+}
+declare const enum TextEditorSelectionRevealType {
+    /**
+     * Option to scroll vertically or horizontally as necessary and reveal a range centered vertically.
+     */
+    Center = 0,
+    /**
+     * Option to scroll vertically or horizontally as necessary and reveal a range centered vertically only if it lies outside the viewport.
+     */
+    CenterIfOutsideViewport = 1,
+    /**
+     * Option to scroll vertically or horizontally as necessary and reveal a range close to the top of the viewport, but not quite at the top.
+     */
+    NearTop = 2,
+    /**
+     * Option to scroll vertically or horizontally as necessary and reveal a range close to the top of the viewport, but not quite at the top.
+     * Only if it lies outside the viewport
+     */
+    NearTopIfOutsideViewport = 3
+}
+declare const enum TextEditorSelectionSource {
+    /**
+     * Programmatic source indicates a selection change that
+     * was not triggered by the user via keyboard or mouse
+     * but through text editor APIs.
+     */
+    PROGRAMMATIC = "api",
+    /**
+     * Navigation source indicates a selection change that
+     * was caused via some command or UI component such as
+     * an outline tree.
+     */
+    NAVIGATION = "code.navigation",
+    /**
+     * Jump source indicates a selection change that
+     * was caused from within the text editor to another
+     * location in the same or different text editor such
+     * as "Go to definition".
+     */
+    JUMP = "code.jump"
+}
+interface ITextEditorOptions extends IEditorOptions {
+    /**
+     * Text editor selection.
+     */
+    selection?: ITextEditorSelection;
+    /**
+     * Option to control the text editor selection reveal type.
+     * Defaults to TextEditorSelectionRevealType.Center
+     */
+    selectionRevealType?: TextEditorSelectionRevealType;
+    /**
+     * Source of the call that caused the selection.
+     */
+    selectionSource?: TextEditorSelectionSource | string;
+}
+
 declare const ITextModelService: ServiceIdentifier<ITextModelService>;
 interface ITextModelService {
     readonly _serviceBrand: undefined;
@@ -3002,7 +3355,7 @@ interface ITextModelContentProvider {
      */
     provideTextContent(resource: URI): Promise<ITextModel | null> | null;
 }
-interface ITextEditorModel extends IEditorModel$1 {
+interface ITextEditorModel extends IEditorModel {
     /**
      * Provides access to the underlying `ITextModel`.
      */
@@ -3028,6 +3381,227 @@ interface IResolvedTextEditorModel extends ITextEditorModel {
     readonly textEditorModel: ITextModel;
 }
 
+/**
+ * A vertical sash layout provider provides position and height for a sash.
+ */
+interface IVerticalSashLayoutProvider {
+    getVerticalSashLeft(sash: Sash): number;
+    getVerticalSashTop?(sash: Sash): number;
+    getVerticalSashHeight?(sash: Sash): number;
+}
+/**
+ * A vertical sash layout provider provides position and width for a sash.
+ */
+interface IHorizontalSashLayoutProvider {
+    getHorizontalSashTop(sash: Sash): number;
+    getHorizontalSashLeft?(sash: Sash): number;
+    getHorizontalSashWidth?(sash: Sash): number;
+}
+interface ISashEvent {
+    readonly startX: number;
+    readonly currentX: number;
+    readonly startY: number;
+    readonly currentY: number;
+    readonly altKey: boolean;
+}
+declare enum OrthogonalEdge {
+    North = "north",
+    South = "south",
+    East = "east",
+    West = "west"
+}
+interface IBoundarySashes {
+    readonly top?: Sash;
+    readonly right?: Sash;
+    readonly bottom?: Sash;
+    readonly left?: Sash;
+}
+interface ISashOptions {
+    /**
+     * Whether a sash is horizontal or vertical.
+     */
+    readonly orientation: Orientation;
+    /**
+     * The width or height of a vertical or horizontal sash, respectively.
+     */
+    readonly size?: number;
+    /**
+     * A reference to another sash, perpendicular to this one, which
+     * aligns at the start of this one. A corner sash will be created
+     * automatically at that location.
+     *
+     * The start of a horizontal sash is its left-most position.
+     * The start of a vertical sash is its top-most position.
+     */
+    readonly orthogonalStartSash?: Sash;
+    /**
+     * A reference to another sash, perpendicular to this one, which
+     * aligns at the end of this one. A corner sash will be created
+     * automatically at that location.
+     *
+     * The end of a horizontal sash is its right-most position.
+     * The end of a vertical sash is its bottom-most position.
+     */
+    readonly orthogonalEndSash?: Sash;
+    /**
+     * Provides a hint as to what mouse cursor to use whenever the user
+     * hovers over a corner sash provided by this and an orthogonal sash.
+     */
+    readonly orthogonalEdge?: OrthogonalEdge;
+}
+interface IVerticalSashOptions extends ISashOptions {
+    readonly orientation: Orientation.VERTICAL;
+}
+interface IHorizontalSashOptions extends ISashOptions {
+    readonly orientation: Orientation.HORIZONTAL;
+}
+declare const enum Orientation {
+    VERTICAL = 0,
+    HORIZONTAL = 1
+}
+declare const enum SashState {
+    /**
+     * Disable any UI interaction.
+     */
+    Disabled = 0,
+    /**
+     * Allow dragging down or to the right, depending on the sash orientation.
+     *
+     * Some OSs allow customizing the mouse cursor differently whenever
+     * some resizable component can't be any smaller, but can be larger.
+     */
+    AtMinimum = 1,
+    /**
+     * Allow dragging up or to the left, depending on the sash orientation.
+     *
+     * Some OSs allow customizing the mouse cursor differently whenever
+     * some resizable component can't be any larger, but can be smaller.
+     */
+    AtMaximum = 2,
+    /**
+     * Enable dragging.
+     */
+    Enabled = 3
+}
+/**
+ * The {@link Sash} is the UI component which allows the user to resize other
+ * components. It's usually an invisible horizontal or vertical line which, when
+ * hovered, becomes highlighted and can be dragged along the perpendicular dimension
+ * to its direction.
+ *
+ * Features:
+ * - Touch event handling
+ * - Corner sash support
+ * - Hover with different mouse cursor support
+ * - Configurable hover size
+ * - Linked sash support, for 2x2 corner sashes
+ */
+declare class Sash extends Disposable {
+    private el;
+    private layoutProvider;
+    private orientation;
+    private size;
+    private hoverDelay;
+    private hoverDelayer;
+    private _state;
+    private readonly onDidEnablementChange;
+    private readonly _onDidStart;
+    private readonly _onDidChange;
+    private readonly _onDidReset;
+    private readonly _onDidEnd;
+    private readonly orthogonalStartSashDisposables;
+    private _orthogonalStartSash;
+    private readonly orthogonalStartDragHandleDisposables;
+    private _orthogonalStartDragHandle;
+    private readonly orthogonalEndSashDisposables;
+    private _orthogonalEndSash;
+    private readonly orthogonalEndDragHandleDisposables;
+    private _orthogonalEndDragHandle;
+    get state(): SashState;
+    get orthogonalStartSash(): Sash | undefined;
+    get orthogonalEndSash(): Sash | undefined;
+    /**
+     * The state of a sash defines whether it can be interacted with by the user
+     * as well as what mouse cursor to use, when hovered.
+     */
+    set state(state: SashState);
+    /**
+     * An event which fires whenever the user starts dragging this sash.
+     */
+    readonly onDidStart: Event<ISashEvent>;
+    /**
+     * An event which fires whenever the user moves the mouse while
+     * dragging this sash.
+     */
+    readonly onDidChange: Event<ISashEvent>;
+    /**
+     * An event which fires whenever the user double clicks this sash.
+     */
+    readonly onDidReset: Event<void>;
+    /**
+     * An event which fires whenever the user stops dragging this sash.
+     */
+    readonly onDidEnd: Event<void>;
+    /**
+     * A linked sash will be forwarded the same user interactions and events
+     * so it moves exactly the same way as this sash.
+     *
+     * Useful in 2x2 grids. Not meant for widespread usage.
+     */
+    linkedSash: Sash | undefined;
+    /**
+     * A reference to another sash, perpendicular to this one, which
+     * aligns at the start of this one. A corner sash will be created
+     * automatically at that location.
+     *
+     * The start of a horizontal sash is its left-most position.
+     * The start of a vertical sash is its top-most position.
+     */
+    set orthogonalStartSash(sash: Sash | undefined);
+    /**
+     * A reference to another sash, perpendicular to this one, which
+     * aligns at the end of this one. A corner sash will be created
+     * automatically at that location.
+     *
+     * The end of a horizontal sash is its right-most position.
+     * The end of a vertical sash is its bottom-most position.
+     */
+    set orthogonalEndSash(sash: Sash | undefined);
+    /**
+     * Create a new vertical sash.
+     *
+     * @param container A DOM node to append the sash to.
+     * @param verticalLayoutProvider A vertical layout provider.
+     * @param options The options.
+     */
+    constructor(container: HTMLElement, verticalLayoutProvider: IVerticalSashLayoutProvider, options: IVerticalSashOptions);
+    /**
+     * Create a new horizontal sash.
+     *
+     * @param container A DOM node to append the sash to.
+     * @param horizontalLayoutProvider A horizontal layout provider.
+     * @param options The options.
+     */
+    constructor(container: HTMLElement, horizontalLayoutProvider: IHorizontalSashLayoutProvider, options: IHorizontalSashOptions);
+    private onPointerStart;
+    private onPointerDoublePress;
+    private static onMouseEnter;
+    private static onMouseLeave;
+    /**
+     * Forcefully stop any user interactions with this sash.
+     * Useful when hiding a parent component, while the user is still
+     * interacting with the sash.
+     */
+    clearSashHoverState(): void;
+    /**
+     * Layout the sash. The sash will size and position itself
+     * based on its provided {@link ISashLayoutProvider layout provider}.
+     */
+    layout(): void;
+    private getOrthogonalSash;
+    dispose(): void;
+}
+
 /**
  * A rich code editor.
  */
@@ -3123,6 +3697,18 @@ interface IDiffEditor extends IEditor {
      * Update the editor's options after the editor has been created.
      */
     updateOptions(newOptions: IDiffEditorOptions): void;
+    /**
+     * @internal
+     */
+    setBoundarySashes(sashes: IBoundarySashes): void;
+    /**
+     * @internal
+     */
+    goToDiff(target: 'next' | 'previous'): void;
+    /**
+     * @internal
+     */
+    revealFirstDiff(): unknown;
 }
 
-export { EndOfLineSequence as E, ITextBufferFactory as I, Position as P, Range as R, Selection as S, ITextModel as a, ITextModelCreationOptions as b, IEditor as c, IDiffEditor$1 as d, IRange as e, IPosition as f, IDocumentDiffProviderOptions as g, IDocumentDiff as h, IChange as i, ICodeEditor as j, IDiffEditor as k, IDecorationRenderOptions as l, IModelDecorationOptions as m, ITextModelContentProvider as n, ITextModelService as o, IResolvedTextEditorModel as p, IModelDecorationsChangeAccessor as q, IEditorContribution as r, ISingleEditOperation as s, EditorAutoIndentStrategy as t, IDimension as u, ITextEditorModel as v, ITextSnapshot as w };
+export { IChange as A, IBoundarySashes as B, IDiffEditor as C, IDecorationRenderOptions as D, EndOfLineSequence as E, ITextModelContentProvider as F, ITextModelService as G, IEditorOptions as I, MarkdownStringTrustedOptions as M, Orientation as O, Position as P, Range as R, Selection as S, IResolvedTextEditorModel as a, ICodeEditor as b, ITextModel as c, IModelDecorationOptions as d, IModelDecorationsChangeAccessor as e, IEditorContribution as f, IPosition as g, IRange as h, IMarkdownString as i, ISingleEditOperation as j, EditorAutoIndentStrategy as k, IEditorModel as l, IDimension as m, ITextEditorModel as n, ITextSnapshot as o, ITextBufferFactory as p, IDiffEditor$1 as q, IBaseTextResourceEditorInput as r, IBaseUntypedEditorInput as s, IResourceEditorInput as t, ITextResourceEditorInput as u, ITextModelCreationOptions as v, IEditor as w, IResourceEditorInputIdentifier as x, IDocumentDiffProviderOptions as y, IDocumentDiff as z };