@codingame/monaco-vscode-api 1.78.4-next.3 → 1.78.5-next.0

package/dist/vscode/vs/workbench/browser/parts/editor/sideBySideEditor.js

@@ -0,0 +1,387 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import "../../../../../../assets/sidebysideeditor.css";
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { Dimension, $, multibyteAwareBtoa, clearNode } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { SIDE_BY_SIDE_EDITOR_ID, SideBySideEditor as SideBySideEditor$1, EditorExtensions, isEditorPaneWithSelection } from '../../../common/editor.js';
+import { SideBySideEditorInput } from '../../../common/editor/sideBySideEditorInput.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
+import { SplitView, Sizing } from 'monaco-editor/esm/vs/base/browser/ui/splitview/splitview.js';
+import { Emitter, Relay, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { DEFAULT_EDITOR_MIN_DIMENSIONS } from './editor.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { SIDE_BY_SIDE_EDITOR_VERTICAL_BORDER, SIDE_BY_SIDE_EDITOR_HORIZONTAL_BORDER } from '../../../common/theme.js';
+import { AbstractEditorWithViewState } from './editorWithViewState.js';
+import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+function isSideBySideEditorViewState(thing) {
+    const candidate = thing;
+    return typeof candidate?.primary === 'object' && typeof candidate.secondary === 'object';
+}
+let SideBySideEditor = class SideBySideEditor extends AbstractEditorWithViewState {
+    get minimumPrimaryWidth() { return this.primaryEditorPane ? this.primaryEditorPane.minimumWidth : 0; }
+    get maximumPrimaryWidth() { return this.primaryEditorPane ? this.primaryEditorPane.maximumWidth : Number.POSITIVE_INFINITY; }
+    get minimumPrimaryHeight() { return this.primaryEditorPane ? this.primaryEditorPane.minimumHeight : 0; }
+    get maximumPrimaryHeight() { return this.primaryEditorPane ? this.primaryEditorPane.maximumHeight : Number.POSITIVE_INFINITY; }
+    get minimumSecondaryWidth() { return this.secondaryEditorPane ? this.secondaryEditorPane.minimumWidth : 0; }
+    get maximumSecondaryWidth() { return this.secondaryEditorPane ? this.secondaryEditorPane.maximumWidth : Number.POSITIVE_INFINITY; }
+    get minimumSecondaryHeight() { return this.secondaryEditorPane ? this.secondaryEditorPane.minimumHeight : 0; }
+    get maximumSecondaryHeight() { return this.secondaryEditorPane ? this.secondaryEditorPane.maximumHeight : Number.POSITIVE_INFINITY; }
+    set minimumWidth(value) { }
+    set maximumWidth(value) { }
+    set minimumHeight(value) { }
+    set maximumHeight(value) { }
+    get minimumWidth() { return this.minimumPrimaryWidth + this.minimumSecondaryWidth; }
+    get maximumWidth() { return this.maximumPrimaryWidth + this.maximumSecondaryWidth; }
+    get minimumHeight() { return this.minimumPrimaryHeight + this.minimumSecondaryHeight; }
+    get maximumHeight() { return this.maximumPrimaryHeight + this.maximumSecondaryHeight; }
+    constructor(telemetryService, instantiationService, themeService, storageService, configurationService, textResourceConfigurationService, editorService, editorGroupService) {
+        super(SideBySideEditor.ID, SideBySideEditor.VIEW_STATE_PREFERENCE_KEY, telemetryService, instantiationService, storageService, textResourceConfigurationService, themeService, editorService, editorGroupService);
+        this.configurationService = configurationService;
+        this.onDidCreateEditors = this._register(( (new Emitter())));
+        this._onDidChangeSizeConstraints = this._register(( (new Relay())));
+        this.onDidChangeSizeConstraints = Event.any(this.onDidCreateEditors.event, this._onDidChangeSizeConstraints.event);
+        this._onDidChangeSelection = this._register(( (new Emitter())));
+        this.onDidChangeSelection = this._onDidChangeSelection.event;
+        this.primaryEditorPane = undefined;
+        this.secondaryEditorPane = undefined;
+        this.splitviewDisposables = this._register(( (new DisposableStore())));
+        this.editorDisposables = this._register(( (new DisposableStore())));
+        this.orientation = this.configurationService.getValue(SideBySideEditor.SIDE_BY_SIDE_LAYOUT_SETTING) === 'vertical' ? 0  : 1 ;
+        this.dimension = ( (new Dimension(0, 0)));
+        this.lastFocusedSide = undefined;
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.configurationService.onDidChangeConfiguration(e => this.onConfigurationUpdated(e)));
+    }
+    onConfigurationUpdated(event) {
+        if (event.affectsConfiguration(SideBySideEditor.SIDE_BY_SIDE_LAYOUT_SETTING)) {
+            this.orientation = this.configurationService.getValue(SideBySideEditor.SIDE_BY_SIDE_LAYOUT_SETTING) === 'vertical' ? 0  : 1 ;
+            if (this.splitview) {
+                this.recreateSplitview();
+            }
+        }
+    }
+    recreateSplitview() {
+        const container = assertIsDefined(this.getContainer());
+        const ratio = this.getSplitViewRatio();
+        if (this.splitview) {
+            container.removeChild(this.splitview.el);
+            this.splitviewDisposables.clear();
+        }
+        this.createSplitView(container, ratio);
+        this.layout(this.dimension);
+    }
+    getSplitViewRatio() {
+        let ratio = undefined;
+        if (this.splitview) {
+            const leftViewSize = this.splitview.getViewSize(0);
+            const rightViewSize = this.splitview.getViewSize(1);
+            if (Math.abs(leftViewSize - rightViewSize) > 1) {
+                const totalSize = this.splitview.orientation === 1  ? this.dimension.width : this.dimension.height;
+                ratio = leftViewSize / totalSize;
+            }
+        }
+        return ratio;
+    }
+    createEditor(parent) {
+        parent.classList.add('side-by-side-editor');
+        this.secondaryEditorContainer = $('.side-by-side-editor-container.editor-instance');
+        this.primaryEditorContainer = $('.side-by-side-editor-container.editor-instance');
+        this.createSplitView(parent);
+    }
+    createSplitView(parent, ratio) {
+        this.splitview = this.splitviewDisposables.add(( (new SplitView(parent, { orientation: this.orientation }))));
+        this.splitviewDisposables.add(this.splitview.onDidSashReset(() => this.splitview?.distributeViewSizes()));
+        if (this.orientation === 1 ) {
+            this.splitview.orthogonalEndSash = this._boundarySashes?.bottom;
+        }
+        else {
+            this.splitview.orthogonalStartSash = this._boundarySashes?.left;
+            this.splitview.orthogonalEndSash = this._boundarySashes?.right;
+        }
+        let leftSizing = Sizing.Distribute;
+        let rightSizing = Sizing.Distribute;
+        if (ratio) {
+            const totalSize = this.splitview.orientation === 1  ? this.dimension.width : this.dimension.height;
+            leftSizing = Math.round(totalSize * ratio);
+            rightSizing = totalSize - leftSizing;
+            this.splitview.layout(this.orientation === 1  ? this.dimension.width : this.dimension.height);
+        }
+        const secondaryEditorContainer = assertIsDefined(this.secondaryEditorContainer);
+        this.splitview.addView({
+            element: secondaryEditorContainer,
+            layout: size => this.layoutPane(this.secondaryEditorPane, size),
+            minimumSize: this.orientation === 1  ? DEFAULT_EDITOR_MIN_DIMENSIONS.width : DEFAULT_EDITOR_MIN_DIMENSIONS.height,
+            maximumSize: Number.POSITIVE_INFINITY,
+            onDidChange: Event.None
+        }, leftSizing);
+        const primaryEditorContainer = assertIsDefined(this.primaryEditorContainer);
+        this.splitview.addView({
+            element: primaryEditorContainer,
+            layout: size => this.layoutPane(this.primaryEditorPane, size),
+            minimumSize: this.orientation === 1  ? DEFAULT_EDITOR_MIN_DIMENSIONS.width : DEFAULT_EDITOR_MIN_DIMENSIONS.height,
+            maximumSize: Number.POSITIVE_INFINITY,
+            onDidChange: Event.None
+        }, rightSizing);
+        this.updateStyles();
+    }
+    getTitle() {
+        if (this.input) {
+            return this.input.getName();
+        }
+        return (
+             (localize('sideBySideEditor', "Side by Side Editor"))
+        );
+    }
+    async setInput(input, options, context, token) {
+        const oldInput = this.input;
+        await super.setInput(input, options, context, token);
+        if (!oldInput || !input.matches(oldInput)) {
+            if (oldInput) {
+                this.disposeEditors();
+            }
+            this.createEditors(input);
+        }
+        const { primary, secondary, viewState } = this.loadViewState(input, options, context);
+        this.lastFocusedSide = viewState?.focus;
+        if (typeof viewState?.ratio === 'number' && this.splitview) {
+            const totalSize = this.splitview.orientation === 1  ? this.dimension.width : this.dimension.height;
+            this.splitview.resizeView(0, Math.round(totalSize * viewState.ratio));
+        }
+        else {
+            this.splitview?.distributeViewSizes();
+        }
+        await Promise.all([
+            this.secondaryEditorPane?.setInput(input.secondary, secondary, context, token),
+            this.primaryEditorPane?.setInput(input.primary, primary, context, token)
+        ]);
+        if (typeof options?.target === 'number') {
+            this.lastFocusedSide = options.target;
+        }
+    }
+    loadViewState(input, options, context) {
+        const viewState = isSideBySideEditorViewState(options?.viewState) ? options?.viewState : this.loadEditorViewState(input, context);
+        let primaryOptions = Object.create(null);
+        let secondaryOptions = undefined;
+        if (options?.target === SideBySideEditor$1.SECONDARY) {
+            secondaryOptions = { ...options };
+        }
+        else {
+            primaryOptions = { ...options };
+        }
+        primaryOptions.viewState = viewState?.primary;
+        if (viewState?.secondary) {
+            if (!secondaryOptions) {
+                secondaryOptions = { viewState: viewState.secondary };
+            }
+            else {
+                secondaryOptions.viewState = viewState?.secondary;
+            }
+        }
+        return { primary: primaryOptions, secondary: secondaryOptions, viewState };
+    }
+    createEditors(newInput) {
+        this.secondaryEditorPane = this.doCreateEditor(newInput.secondary, assertIsDefined(this.secondaryEditorContainer));
+        this.primaryEditorPane = this.doCreateEditor(newInput.primary, assertIsDefined(this.primaryEditorContainer));
+        this.layout(this.dimension);
+        this._onDidChangeSizeConstraints.input = Event.any(( (Event.map(this.secondaryEditorPane.onDidChangeSizeConstraints, () => undefined))), ( (Event.map(this.primaryEditorPane.onDidChangeSizeConstraints, () => undefined))));
+        this.onDidCreateEditors.fire(undefined);
+        this.editorDisposables.add(this.primaryEditorPane.onDidFocus(() => this.onDidFocusChange(SideBySideEditor$1.PRIMARY)));
+        this.editorDisposables.add(this.secondaryEditorPane.onDidFocus(() => this.onDidFocusChange(SideBySideEditor$1.SECONDARY)));
+    }
+    doCreateEditor(editorInput, container) {
+        const editorPaneDescriptor = ( (Registry.as(EditorExtensions.EditorPane))).getEditorPane(editorInput);
+        if (!editorPaneDescriptor) {
+            throw new Error('No editor pane descriptor for editor found');
+        }
+        const editorPane = editorPaneDescriptor.instantiate(this.instantiationService);
+        editorPane.create(container);
+        editorPane.setVisible(this.isVisible(), this.group);
+        if (isEditorPaneWithSelection(editorPane)) {
+            this.editorDisposables.add(editorPane.onDidChangeSelection(e => this._onDidChangeSelection.fire(e)));
+        }
+        this.editorDisposables.add(editorPane);
+        return editorPane;
+    }
+    onDidFocusChange(side) {
+        this.lastFocusedSide = side;
+        this._onDidChangeControl.fire();
+    }
+    getSelection() {
+        const lastFocusedEditorPane = this.getLastFocusedEditorPane();
+        if (isEditorPaneWithSelection(lastFocusedEditorPane)) {
+            const selection = lastFocusedEditorPane.getSelection();
+            if (selection) {
+                return (
+                     (new SideBySideAwareEditorPaneSelection(
+                        selection,
+                        lastFocusedEditorPane === this.primaryEditorPane ? SideBySideEditor$1.PRIMARY : SideBySideEditor$1.SECONDARY
+                    ))
+                );
+            }
+        }
+        return undefined;
+    }
+    setOptions(options) {
+        super.setOptions(options);
+        if (typeof options?.target === 'number') {
+            this.lastFocusedSide = options.target;
+        }
+        this.getLastFocusedEditorPane()?.setOptions(options);
+    }
+    setEditorVisible(visible, group) {
+        this.primaryEditorPane?.setVisible(visible, group);
+        this.secondaryEditorPane?.setVisible(visible, group);
+        super.setEditorVisible(visible, group);
+    }
+    clearInput() {
+        super.clearInput();
+        this.primaryEditorPane?.clearInput();
+        this.secondaryEditorPane?.clearInput();
+        this.disposeEditors();
+    }
+    focus() {
+        this.getLastFocusedEditorPane()?.focus();
+    }
+    getLastFocusedEditorPane() {
+        if (this.lastFocusedSide === SideBySideEditor$1.SECONDARY) {
+            return this.secondaryEditorPane;
+        }
+        return this.primaryEditorPane;
+    }
+    layout(dimension) {
+        this.dimension = dimension;
+        const splitview = assertIsDefined(this.splitview);
+        splitview.layout(this.orientation === 1  ? dimension.width : dimension.height);
+    }
+    setBoundarySashes(sashes) {
+        this._boundarySashes = sashes;
+        if (this.splitview) {
+            this.splitview.orthogonalEndSash = sashes.bottom;
+        }
+    }
+    layoutPane(pane, size) {
+        pane?.layout(this.orientation === 1  ? ( (new Dimension(size, this.dimension.height))) : ( (new Dimension(this.dimension.width, size))));
+    }
+    getControl() {
+        return this.getLastFocusedEditorPane()?.getControl();
+    }
+    getPrimaryEditorPane() {
+        return this.primaryEditorPane;
+    }
+    getSecondaryEditorPane() {
+        return this.secondaryEditorPane;
+    }
+    tracksEditorViewState(input) {
+        return input instanceof SideBySideEditorInput;
+    }
+    computeEditorViewState(resource) {
+        if (!this.input || !isEqual(resource, this.toEditorViewStateResource(this.input))) {
+            return;
+        }
+        const primarViewState = this.primaryEditorPane?.getViewState();
+        const secondaryViewState = this.secondaryEditorPane?.getViewState();
+        if (!primarViewState || !secondaryViewState) {
+            return;
+        }
+        return {
+            primary: primarViewState,
+            secondary: secondaryViewState,
+            focus: this.lastFocusedSide,
+            ratio: this.getSplitViewRatio()
+        };
+    }
+    toEditorViewStateResource(input) {
+        let primary;
+        let secondary;
+        if (input instanceof SideBySideEditorInput) {
+            primary = input.primary.resource;
+            secondary = input.secondary.resource;
+        }
+        if (!secondary || !primary) {
+            return undefined;
+        }
+        return (
+             (URI.from({ scheme: 'sideBySide', path: `${multibyteAwareBtoa(( ( secondary.toString())))}${multibyteAwareBtoa(( ( primary.toString())))}` }))
+        );
+    }
+    updateStyles() {
+        super.updateStyles();
+        if (this.primaryEditorContainer) {
+            if (this.orientation === 1 ) {
+                this.primaryEditorContainer.style.borderLeftWidth = '1px';
+                this.primaryEditorContainer.style.borderLeftStyle = 'solid';
+                this.primaryEditorContainer.style.borderLeftColor = this.getColor(SIDE_BY_SIDE_EDITOR_VERTICAL_BORDER) ?? '';
+                this.primaryEditorContainer.style.borderTopWidth = '0';
+            }
+            else {
+                this.primaryEditorContainer.style.borderTopWidth = '1px';
+                this.primaryEditorContainer.style.borderTopStyle = 'solid';
+                this.primaryEditorContainer.style.borderTopColor = this.getColor(SIDE_BY_SIDE_EDITOR_HORIZONTAL_BORDER) ?? '';
+                this.primaryEditorContainer.style.borderLeftWidth = '0';
+            }
+        }
+    }
+    dispose() {
+        this.disposeEditors();
+        super.dispose();
+    }
+    disposeEditors() {
+        this.editorDisposables.clear();
+        this.secondaryEditorPane = undefined;
+        this.primaryEditorPane = undefined;
+        this.lastFocusedSide = undefined;
+        if (this.secondaryEditorContainer) {
+            clearNode(this.secondaryEditorContainer);
+        }
+        if (this.primaryEditorContainer) {
+            clearNode(this.primaryEditorContainer);
+        }
+    }
+};
+SideBySideEditor.ID = SIDE_BY_SIDE_EDITOR_ID;
+SideBySideEditor.SIDE_BY_SIDE_LAYOUT_SETTING = 'workbench.editor.splitInGroupLayout';
+SideBySideEditor.VIEW_STATE_PREFERENCE_KEY = 'sideBySideEditorViewState';
+SideBySideEditor = ( (__decorate([
+    ( (__param(0, ITelemetryService))),
+    ( (__param(1, IInstantiationService))),
+    ( (__param(2, IThemeService))),
+    ( (__param(3, IStorageService))),
+    ( (__param(4, IConfigurationService))),
+    ( (__param(5, ITextResourceConfigurationService))),
+    ( (__param(6, IEditorService))),
+    ( (__param(7, IEditorGroupsService)))
+], SideBySideEditor)));
+class SideBySideAwareEditorPaneSelection {
+    constructor(selection, side) {
+        this.selection = selection;
+        this.side = side;
+    }
+    compare(other) {
+        if (!(other instanceof SideBySideAwareEditorPaneSelection)) {
+            return 3 ;
+        }
+        if (this.side !== other.side) {
+            return 3 ;
+        }
+        return this.selection.compare(other.selection);
+    }
+    restore(options) {
+        const sideBySideEditorOptions = {
+            ...options,
+            target: this.side
+        };
+        return this.selection.restore(sideBySideEditorOptions);
+    }
+}
+export { SideBySideEditor };

package/dist/vscode/vs/workbench/browser/parts/editor/textDiffEditor.js

@@ -0,0 +1,289 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { deepClone } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { assertIsDefined, withUndefinedAsNull, isObject, withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { AbstractTextEditor } from '../../../../../../override/vs/workbench/browser/parts/editor/textEditor.js';
+import { TEXT_DIFF_EDITOR_ID, isTextEditorViewState, createTooLargeFileError, EditorExtensions, isEditorInput } from '../../../common/editor.js';
+import { applyTextEditorOptions } from '../../../common/editor/editorOptions.js';
+import { DiffEditorInput } from '../../../common/editor/diffEditorInput.js';
+import { DiffNavigator } from 'monaco-editor/esm/vs/editor/browser/widget/diffNavigator.js';
+import { DiffEditorWidget } from 'monaco-editor/esm/vs/editor/browser/widget/diffEditorWidget.js';
+import { TextDiffEditorModel } from '../../../common/editor/textDiffEditorModel.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { EditorActivation } from 'monaco-editor/esm/vs/platform/editor/common/editor.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { multibyteAwareBtoa } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { TooLargeFileOperationError, ByteSize, IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IPreferencesService } from '../../../services/preferences/common/preferences.js';
+let TextDiffEditor = class TextDiffEditor extends AbstractTextEditor {
+    get scopedContextKeyService() {
+        if (!this.diffEditorControl) {
+            return undefined;
+        }
+        const originalEditor = this.diffEditorControl.getOriginalEditor();
+        const modifiedEditor = this.diffEditorControl.getModifiedEditor();
+        return (originalEditor.hasTextFocus() ? originalEditor : modifiedEditor).invokeWithinContext(accessor => accessor.get(IContextKeyService));
+    }
+    constructor(telemetryService, instantiationService, storageService, configurationService, editorService, themeService, editorGroupService, fileService, preferencesService) {
+        super(TextDiffEditor.ID, telemetryService, instantiationService, storageService, configurationService, themeService, editorService, editorGroupService, fileService);
+        this.preferencesService = preferencesService;
+        this.diffEditorControl = undefined;
+        this.diffNavigatorDisposables = this._register(( (new DisposableStore())));
+    }
+    getTitle() {
+        if (this.input) {
+            return this.input.getName();
+        }
+        return (
+             (localize('textDiffEditor', "Text Diff Editor"))
+        );
+    }
+    createEditorControl(parent, configuration) {
+        this.diffEditorControl = this._register(this.instantiationService.createInstance(DiffEditorWidget, parent, configuration, {}));
+    }
+    updateEditorControlOptions(options) {
+        this.diffEditorControl?.updateOptions(options);
+    }
+    getMainControl() {
+        return this.diffEditorControl?.getModifiedEditor();
+    }
+    async setInput(input, options, context, token) {
+        this.diffNavigatorDisposables.clear();
+        await super.setInput(input, options, context, token);
+        try {
+            const resolvedModel = await input.resolve(options);
+            if (token.isCancellationRequested) {
+                return undefined;
+            }
+            if (!(resolvedModel instanceof TextDiffEditorModel)) {
+                this.openAsBinary(input, options);
+                return undefined;
+            }
+            const control = assertIsDefined(this.diffEditorControl);
+            const resolvedDiffEditorModel = resolvedModel;
+            control.setModel(withUndefinedAsNull(resolvedDiffEditorModel.textDiffEditorModel));
+            let hasPreviousViewState = false;
+            if (!isTextEditorViewState(options?.viewState)) {
+                hasPreviousViewState = this.restoreTextDiffEditorViewState(input, options, context, control);
+            }
+            let optionsGotApplied = false;
+            if (options) {
+                optionsGotApplied = applyTextEditorOptions(options, control, 1 );
+            }
+            this.diffNavigator = this.instantiationService.createInstance(DiffNavigator, control, {
+                alwaysRevealFirst: !optionsGotApplied && !hasPreviousViewState,
+                findResultLoop: this.getMainControl()?.getOption(39 ).loop
+            });
+            this.diffNavigatorDisposables.add(this.diffNavigator);
+            control.updateOptions({
+                readOnly: resolvedDiffEditorModel.modifiedModel?.isReadonly(),
+                originalEditable: !resolvedDiffEditorModel.originalModel?.isReadonly()
+            });
+        }
+        catch (error) {
+            await this.handleSetInputError(error, input, options);
+        }
+    }
+    async handleSetInputError(error, input, options) {
+        if (this.isFileBinaryError(error)) {
+            return this.openAsBinary(input, options);
+        }
+        if (error.fileOperationResult === 7  && this.group) {
+            let message;
+            if (error instanceof TooLargeFileOperationError) {
+                message = ( (localize(
+                    'fileTooLargeForHeapErrorWithSize',
+                    "At least one file is not displayed in the text compare editor because it is very large ({0}).",
+                    ByteSize.formatSize(error.size)
+                )));
+            }
+            else {
+                message = ( (localize(
+                    'fileTooLargeForHeapErrorWithoutSize',
+                    "At least one file is not displayed in the text compare editor because it is very large."
+                )));
+            }
+            throw createTooLargeFileError(this.group, input, options, message, this.preferencesService);
+        }
+        throw error;
+    }
+    restoreTextDiffEditorViewState(editor, options, context, control) {
+        const editorViewState = this.loadEditorViewState(editor, context);
+        if (editorViewState) {
+            if (options?.selection && editorViewState.modified) {
+                editorViewState.modified.cursorState = [];
+            }
+            control.restoreViewState(editorViewState);
+            return true;
+        }
+        return false;
+    }
+    openAsBinary(input, options) {
+        const original = input.original;
+        const modified = input.modified;
+        const binaryDiffInput = this.instantiationService.createInstance(DiffEditorInput, input.getName(), input.getDescription(), original, modified, true);
+        const fileEditorFactory = ( (Registry.as(EditorExtensions.EditorFactory))).getFileEditorFactory();
+        if (fileEditorFactory.isFileEditor(original)) {
+            original.setForceOpenAsBinary();
+        }
+        if (fileEditorFactory.isFileEditor(modified)) {
+            modified.setForceOpenAsBinary();
+        }
+        (this.group ?? this.editorGroupService.activeGroup).replaceEditors([{
+                editor: input,
+                replacement: binaryDiffInput,
+                options: {
+                    ...options,
+                    activation: EditorActivation.PRESERVE,
+                    pinned: this.group?.isPinned(input),
+                    sticky: this.group?.isSticky(input)
+                }
+            }]);
+    }
+    setOptions(options) {
+        super.setOptions(options);
+        if (options) {
+            applyTextEditorOptions(options, assertIsDefined(this.diffEditorControl), 0 );
+        }
+    }
+    shouldHandleConfigurationChangeEvent(e, resource) {
+        if (super.shouldHandleConfigurationChangeEvent(e, resource)) {
+            return true;
+        }
+        return e.affectsConfiguration(resource, 'diffEditor');
+    }
+    computeConfiguration(configuration) {
+        const editorConfiguration = super.computeConfiguration(configuration);
+        if (isObject(configuration.diffEditor)) {
+            const diffEditorConfiguration = deepClone(configuration.diffEditor);
+            diffEditorConfiguration.diffCodeLens = diffEditorConfiguration.codeLens;
+            delete diffEditorConfiguration.codeLens;
+            diffEditorConfiguration.diffWordWrap = diffEditorConfiguration.wordWrap;
+            delete diffEditorConfiguration.wordWrap;
+            Object.assign(editorConfiguration, diffEditorConfiguration);
+        }
+        return editorConfiguration;
+    }
+    getConfigurationOverrides() {
+        const readOnly = this.input instanceof DiffEditorInput && this.input.modified.hasCapability(2 );
+        return {
+            ...super.getConfigurationOverrides(),
+            readOnly,
+            originalEditable: this.input instanceof DiffEditorInput && !this.input.original.hasCapability(2 ),
+            lineDecorationsWidth: '2ch'
+        };
+    }
+    updateReadonly(input) {
+        if (input instanceof DiffEditorInput) {
+            this.diffEditorControl?.updateOptions({
+                readOnly: input.hasCapability(2 ),
+                originalEditable: !input.original.hasCapability(2 ),
+            });
+        }
+        else {
+            super.updateReadonly(input);
+        }
+    }
+    isFileBinaryError(error) {
+        if (Array.isArray(error)) {
+            const errors = error;
+            return (
+                 (errors.some(error => this.isFileBinaryError(error)))
+            );
+        }
+        return error.textFileOperationResult === 0 ;
+    }
+    clearInput() {
+        super.clearInput();
+        this.diffNavigatorDisposables.clear();
+        this.diffEditorControl?.setModel(null);
+    }
+    getDiffNavigator() {
+        return this.diffNavigator;
+    }
+    getControl() {
+        return this.diffEditorControl;
+    }
+    focus() {
+        this.diffEditorControl?.focus();
+    }
+    hasFocus() {
+        return this.diffEditorControl?.hasTextFocus() || super.hasFocus();
+    }
+    setEditorVisible(visible, group) {
+        super.setEditorVisible(visible, group);
+        if (visible) {
+            this.diffEditorControl?.onVisible();
+        }
+        else {
+            this.diffEditorControl?.onHide();
+        }
+    }
+    layout(dimension) {
+        this.diffEditorControl?.layout(dimension);
+    }
+    setBoundarySashes(sashes) {
+        this.diffEditorControl?.setBoundarySashes(sashes);
+    }
+    tracksEditorViewState(input) {
+        return input instanceof DiffEditorInput;
+    }
+    computeEditorViewState(resource) {
+        if (!this.diffEditorControl) {
+            return undefined;
+        }
+        const model = this.diffEditorControl.getModel();
+        if (!model || !model.modified || !model.original) {
+            return undefined;
+        }
+        const modelUri = this.toEditorViewStateResource(model);
+        if (!modelUri) {
+            return undefined;
+        }
+        if (!isEqual(modelUri, resource)) {
+            return undefined;
+        }
+        return withNullAsUndefined(this.diffEditorControl.saveViewState());
+    }
+    toEditorViewStateResource(modelOrInput) {
+        let original;
+        let modified;
+        if (modelOrInput instanceof DiffEditorInput) {
+            original = modelOrInput.original.resource;
+            modified = modelOrInput.modified.resource;
+        }
+        else if (!isEditorInput(modelOrInput)) {
+            original = modelOrInput.original.uri;
+            modified = modelOrInput.modified.uri;
+        }
+        if (!original || !modified) {
+            return undefined;
+        }
+        return (
+             (URI.from({ scheme: 'diff', path: `${multibyteAwareBtoa(( ( original.toString())))}${multibyteAwareBtoa(( ( modified.toString())))}` }))
+        );
+    }
+};
+TextDiffEditor.ID = TEXT_DIFF_EDITOR_ID;
+TextDiffEditor = ( (__decorate([
+    ( (__param(0, ITelemetryService))),
+    ( (__param(1, IInstantiationService))),
+    ( (__param(2, IStorageService))),
+    ( (__param(3, ITextResourceConfigurationService))),
+    ( (__param(4, IEditorService))),
+    ( (__param(5, IThemeService))),
+    ( (__param(6, IEditorGroupsService))),
+    ( (__param(7, IFileService))),
+    ( (__param(8, IPreferencesService)))
+], TextDiffEditor)));
+export { TextDiffEditor };