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

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

@@ -1,460 +0,0 @@
-import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
-import "../../../../../../assets/editorstatus.css";
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { extname, basename } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { withNullAsUndefined, withUndefinedAsNull, areFunctions } from 'monaco-editor/esm/vs/base/common/types.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
-import { Language } from 'monaco-editor/esm/vs/base/common/platform.js';
-import { UntitledTextEditorInput } from '../../../services/untitled/common/untitledTextEditorInput.js';
-import { EditorResourceAccessor, SideBySideEditor } from '../../../common/editor.js';
-import { IEditorService } from '../../../services/editor/common/editorService.js';
-import { FILES_ASSOCIATIONS_CONFIG, IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
-import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
-import { IExtensionGalleryService } from '../../../../platform/extensionManagement/common/extensionManagement.js';
-import { ITextFileService } from '../../../services/textfile/common/textfiles.js';
-import { SUPPORTED_ENCODINGS } from '../../../services/textfile/common/encoding.js';
-import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { deepClone } from 'monaco-editor/esm/vs/base/common/objects.js';
-import { getCodeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
-import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-import { IPreferencesService } from '../../../services/preferences/common/preferences.js';
-import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
-import { getIconClassesForLanguageId } from 'monaco-editor/esm/vs/editor/common/services/getIconClasses.js';
-import { timeout, Promises } from 'monaco-editor/esm/vs/base/common/async.js';
-import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
-import { SideBySideEditorInput } from '../../../common/editor/sideBySideEditorInput.js';
-import { ILanguageDetectionService, AutomaticLanguageDetectionLikelyWrongId } from '../../../services/languageDetection/common/languageDetectionWorkerService.js';
-import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
-import { KeyChord } from 'monaco-editor/esm/vs/base/common/keyCodes.js';
-class SideBySideEditorEncodingSupport {
-    constructor(primary, secondary) {
-        this.primary = primary;
-        this.secondary = secondary;
-    }
-    getEncoding() {
-        return this.primary.getEncoding();
-    }
-    async setEncoding(encoding, mode) {
-        await Promises.settled(( [this.primary, this.secondary].map(editor => editor.setEncoding(encoding, mode))));
-    }
-}
-class SideBySideEditorLanguageSupport {
-    constructor(primary, secondary) {
-        this.primary = primary;
-        this.secondary = secondary;
-    }
-    setLanguageId(languageId, source) {
-        [this.primary, this.secondary].forEach(editor => editor.setLanguageId(languageId, source));
-    }
-}
-function toEditorWithEncodingSupport(input) {
-    if (input instanceof UntitledTextEditorInput) {
-        return input;
-    }
-    if (input instanceof SideBySideEditorInput) {
-        const primaryEncodingSupport = toEditorWithEncodingSupport(input.primary);
-        const secondaryEncodingSupport = toEditorWithEncodingSupport(input.secondary);
-        if (primaryEncodingSupport && secondaryEncodingSupport) {
-            return ( new SideBySideEditorEncodingSupport(primaryEncodingSupport, secondaryEncodingSupport));
-        }
-        return primaryEncodingSupport;
-    }
-    const encodingSupport = input;
-    if (areFunctions(encodingSupport.setEncoding, encodingSupport.getEncoding)) {
-        return encodingSupport;
-    }
-    return null;
-}
-function toEditorWithLanguageSupport(input) {
-    if (input instanceof UntitledTextEditorInput) {
-        return input;
-    }
-    if (input instanceof SideBySideEditorInput) {
-        const primaryLanguageSupport = toEditorWithLanguageSupport(input.primary);
-        const secondaryLanguageSupport = toEditorWithLanguageSupport(input.secondary);
-        if (primaryLanguageSupport && secondaryLanguageSupport) {
-            return ( new SideBySideEditorLanguageSupport(primaryLanguageSupport, secondaryLanguageSupport));
-        }
-        return primaryLanguageSupport;
-    }
-    const languageSupport = input;
-    if (typeof languageSupport.setLanguageId === 'function') {
-        return languageSupport;
-    }
-    return null;
-}
-const nlsEOLLF = ( localize('endOfLineLineFeed', "LF"));
-const nlsEOLCRLF = ( localize('endOfLineCarriageReturnLineFeed', "CRLF"));
-let ShowLanguageExtensionsAction = class ShowLanguageExtensionsAction extends Action {
-    constructor(fileExtension, commandService, galleryService) {
-        super(ShowLanguageExtensionsAction.ID, ( localize(
-            'showLanguageExtensions',
-            "Search Marketplace Extensions for '{0}'...",
-            fileExtension
-        )));
-        this.fileExtension = fileExtension;
-        this.commandService = commandService;
-        this.enabled = galleryService.isEnabled();
-    }
-    async run() {
-        await this.commandService.executeCommand('workbench.extensions.action.showExtensionsForLanguage', this.fileExtension);
-    }
-};
-ShowLanguageExtensionsAction.ID = 'workbench.action.showLanguageExtensions';
-ShowLanguageExtensionsAction = ( __decorate([
-    ( __param(1, ICommandService)),
-    ( __param(2, IExtensionGalleryService))
-], ShowLanguageExtensionsAction));
-class ChangeLanguageAction extends Action2 {
-    constructor() {
-        super({
-            id: ChangeLanguageAction.ID,
-            title: { value: ( localize('changeMode', "Change Language Mode")), original: 'Change Language Mode' },
-            f1: true,
-            keybinding: {
-                weight: 200 ,
-                primary: KeyChord(2048  | 41 , 43 )
-            },
-            precondition: ContextKeyExpr.not('notebookEditorFocused')
-        });
-    }
-    async run(accessor) {
-        const quickInputService = accessor.get(IQuickInputService);
-        const editorService = accessor.get(IEditorService);
-        const languageService = accessor.get(ILanguageService);
-        const languageDetectionService = accessor.get(ILanguageDetectionService);
-        const textFileService = accessor.get(ITextFileService);
-        const preferencesService = accessor.get(IPreferencesService);
-        const instantiationService = accessor.get(IInstantiationService);
-        const configurationService = accessor.get(IConfigurationService);
-        const telemetryService = accessor.get(ITelemetryService);
-        const activeTextEditorControl = getCodeEditor(editorService.activeTextEditorControl);
-        if (!activeTextEditorControl) {
-            await quickInputService.pick([{ label: ( localize('noEditor', "No text editor active at this time")) }]);
-            return;
-        }
-        const textModel = activeTextEditorControl.getModel();
-        const resource = EditorResourceAccessor.getOriginalUri(editorService.activeEditor, { supportSideBySide: SideBySideEditor.PRIMARY });
-        let currentLanguageName;
-        let currentLanguageId;
-        if (textModel) {
-            currentLanguageId = textModel.getLanguageId();
-            currentLanguageName = withNullAsUndefined(languageService.getLanguageName(currentLanguageId));
-        }
-        let hasLanguageSupport = !!resource;
-        if (resource?.scheme === Schemas.untitled && !textFileService.untitled.get(resource)?.hasAssociatedFilePath) {
-            hasLanguageSupport = false;
-        }
-        const languages = languageService.getSortedRegisteredLanguageNames();
-        const picks = ( languages
-            .map(({ languageName, languageId }) => {
-            const extensions = languageService.getExtensions(languageId).join(' ');
-            let description;
-            if (currentLanguageName === languageName) {
-                description = ( localize('languageDescription', "({0}) - Configured Language", languageId));
-            }
-            else {
-                description = ( localize('languageDescriptionConfigured', "({0})", languageId));
-            }
-            return {
-                label: languageName,
-                meta: extensions,
-                iconClasses: getIconClassesForLanguageId(languageId),
-                description
-            };
-        }));
-        picks.unshift({ type: 'separator', label: ( localize('languagesPicks', "languages (identifier)")) });
-        let configureLanguageAssociations;
-        let configureLanguageSettings;
-        let galleryAction;
-        if (hasLanguageSupport && resource) {
-            const ext = extname(resource) || basename(resource);
-            galleryAction = instantiationService.createInstance(ShowLanguageExtensionsAction, ext);
-            if (galleryAction.enabled) {
-                picks.unshift(galleryAction);
-            }
-            configureLanguageSettings = { label: ( localize(
-                'configureModeSettings',
-                "Configure '{0}' language based settings...",
-                currentLanguageName
-            )) };
-            picks.unshift(configureLanguageSettings);
-            configureLanguageAssociations = { label: ( localize('configureAssociationsExt', "Configure File Association for '{0}'...", ext)) };
-            picks.unshift(configureLanguageAssociations);
-        }
-        const autoDetectLanguage = {
-            label: ( localize('autoDetect', "Auto Detect"))
-        };
-        picks.unshift(autoDetectLanguage);
-        const pick = await quickInputService.pick(picks, { placeHolder: ( localize('pickLanguage', "Select Language Mode")), matchOnDescription: true });
-        if (!pick) {
-            return;
-        }
-        if (pick === galleryAction) {
-            galleryAction.run();
-            return;
-        }
-        if (pick === configureLanguageAssociations) {
-            if (resource) {
-                this.configureFileAssociation(resource, languageService, quickInputService, configurationService);
-            }
-            return;
-        }
-        if (pick === configureLanguageSettings) {
-            preferencesService.openUserSettings({ jsonEditor: true, revealSetting: { key: `[${withUndefinedAsNull(currentLanguageId)}]`, edit: true } });
-            return;
-        }
-        const activeEditor = editorService.activeEditor;
-        if (activeEditor) {
-            const languageSupport = toEditorWithLanguageSupport(activeEditor);
-            if (languageSupport) {
-                let languageSelection;
-                let detectedLanguage;
-                if (pick === autoDetectLanguage) {
-                    if (textModel) {
-                        const resource = EditorResourceAccessor.getOriginalUri(activeEditor, { supportSideBySide: SideBySideEditor.PRIMARY });
-                        if (resource) {
-                            let languageId = withNullAsUndefined(languageService.guessLanguageIdByFilepathOrFirstLine(resource, textModel.getLineContent(1)));
-                            if (!languageId || languageId === 'unknown') {
-                                detectedLanguage = await languageDetectionService.detectLanguage(resource);
-                                languageId = detectedLanguage;
-                            }
-                            if (languageId) {
-                                languageSelection = languageService.createById(languageId);
-                            }
-                        }
-                    }
-                }
-                else {
-                    const languageId = languageService.getLanguageIdByLanguageName(pick.label);
-                    languageSelection = languageService.createById(languageId);
-                    if (resource) {
-                        languageDetectionService.detectLanguage(resource).then(detectedLanguageId => {
-                            const chosenLanguageId = languageService.getLanguageIdByLanguageName(pick.label) || 'unknown';
-                            if (detectedLanguageId === currentLanguageId && currentLanguageId !== chosenLanguageId) {
-                                const modelPreference = configurationService.getValue('workbench.editor.preferHistoryBasedLanguageDetection') ? 'history' : 'classic';
-                                telemetryService.publicLog2(AutomaticLanguageDetectionLikelyWrongId, {
-                                    currentLanguageId: currentLanguageName ?? 'unknown',
-                                    nextLanguageId: pick.label,
-                                    lineCount: textModel?.getLineCount() ?? -1,
-                                    modelPreference,
-                                });
-                            }
-                        });
-                    }
-                }
-                if (typeof languageSelection !== 'undefined') {
-                    languageSupport.setLanguageId(languageSelection.languageId, ChangeLanguageAction.ID);
-                    if (resource?.scheme === Schemas.untitled) {
-                        const modelPreference = configurationService.getValue('workbench.editor.preferHistoryBasedLanguageDetection') ? 'history' : 'classic';
-                        telemetryService.publicLog2('setUntitledDocumentLanguage', {
-                            to: languageSelection.languageId,
-                            from: currentLanguageId ?? 'none',
-                            modelPreference,
-                        });
-                    }
-                }
-            }
-            activeTextEditorControl.focus();
-        }
-    }
-    configureFileAssociation(resource, languageService, quickInputService, configurationService) {
-        const extension = extname(resource);
-        const base = basename(resource);
-        const currentAssociation = languageService.guessLanguageIdByFilepathOrFirstLine(URI.file(base));
-        const languages = languageService.getSortedRegisteredLanguageNames();
-        const picks = ( languages.map(({ languageName, languageId }) => {
-            return {
-                id: languageId,
-                label: languageName,
-                iconClasses: getIconClassesForLanguageId(languageId),
-                description: (languageId === currentAssociation) ? ( localize('currentAssociation', "Current Association")) : undefined
-            };
-        }));
-        setTimeout(async () => {
-            const language = await quickInputService.pick(picks, { placeHolder: ( localize(
-                'pickLanguageToConfigure',
-                "Select Language Mode to Associate with '{0}'",
-                extension || base
-            )) });
-            if (language) {
-                const fileAssociationsConfig = configurationService.inspect(FILES_ASSOCIATIONS_CONFIG);
-                let associationKey;
-                if (extension && base[0] !== '.') {
-                    associationKey = `*${extension}`;
-                }
-                else {
-                    associationKey = base;
-                }
-                let target = 2 ;
-                if (fileAssociationsConfig.workspaceValue && !!fileAssociationsConfig.workspaceValue[associationKey]) {
-                    target = 5 ;
-                }
-                const currentAssociations = deepClone(((target === 5) ) ? fileAssociationsConfig.workspaceValue : fileAssociationsConfig.userValue) || Object.create(null);
-                currentAssociations[associationKey] = language.id;
-                configurationService.updateValue(FILES_ASSOCIATIONS_CONFIG, currentAssociations, target);
-            }
-        }, 50 );
-    }
-}
-ChangeLanguageAction.ID = 'workbench.action.editor.changeLanguageMode';
-class ChangeEOLAction extends Action2 {
-    constructor() {
-        super({
-            id: 'workbench.action.editor.changeEOL',
-            title: { value: ( localize('changeEndOfLine', "Change End of Line Sequence")), original: 'Change End of Line Sequence' },
-            f1: true
-        });
-    }
-    async run(accessor) {
-        const editorService = accessor.get(IEditorService);
-        const quickInputService = accessor.get(IQuickInputService);
-        const activeTextEditorControl = getCodeEditor(editorService.activeTextEditorControl);
-        if (!activeTextEditorControl) {
-            await quickInputService.pick([{ label: ( localize('noEditor', "No text editor active at this time")) }]);
-            return;
-        }
-        if (editorService.activeEditor?.hasCapability(2 )) {
-            await quickInputService.pick([{ label: ( localize('noWritableCodeEditor', "The active code editor is read-only.")) }]);
-            return;
-        }
-        let textModel = activeTextEditorControl.getModel();
-        const EOLOptions = [
-            { label: nlsEOLLF, eol: 0  },
-            { label: nlsEOLCRLF, eol: 1  },
-        ];
-        const selectedIndex = (textModel?.getEOL() === '\n') ? 0 : 1;
-        const eol = await quickInputService.pick(EOLOptions, { placeHolder: ( localize('pickEndOfLine', "Select End of Line Sequence")), activeItem: EOLOptions[selectedIndex] });
-        if (eol) {
-            const activeCodeEditor = getCodeEditor(editorService.activeTextEditorControl);
-            if (activeCodeEditor?.hasModel() && !editorService.activeEditor?.hasCapability(2 )) {
-                textModel = activeCodeEditor.getModel();
-                textModel.pushStackElement();
-                textModel.pushEOL(eol.eol);
-                textModel.pushStackElement();
-            }
-        }
-        activeTextEditorControl.focus();
-    }
-}
-class ChangeEncodingAction extends Action2 {
-    constructor() {
-        super({
-            id: 'workbench.action.editor.changeEncoding',
-            title: { value: ( localize('changeEncoding', "Change File Encoding")), original: 'Change File Encoding' },
-            f1: true
-        });
-    }
-    async run(accessor) {
-        const editorService = accessor.get(IEditorService);
-        const quickInputService = accessor.get(IQuickInputService);
-        const fileService = accessor.get(IFileService);
-        const textFileService = accessor.get(ITextFileService);
-        const textResourceConfigurationService = accessor.get(ITextResourceConfigurationService);
-        const activeTextEditorControl = getCodeEditor(editorService.activeTextEditorControl);
-        if (!activeTextEditorControl) {
-            await quickInputService.pick([{ label: ( localize('noEditor', "No text editor active at this time")) }]);
-            return;
-        }
-        const activeEditorPane = editorService.activeEditorPane;
-        if (!activeEditorPane) {
-            await quickInputService.pick([{ label: ( localize('noEditor', "No text editor active at this time")) }]);
-            return;
-        }
-        const encodingSupport = toEditorWithEncodingSupport(activeEditorPane.input);
-        if (!encodingSupport) {
-            await quickInputService.pick([{ label: ( localize('noFileEditor', "No file active at this time")) }]);
-            return;
-        }
-        const saveWithEncodingPick = { label: ( localize('saveWithEncoding', "Save with Encoding")) };
-        const reopenWithEncodingPick = { label: ( localize('reopenWithEncoding', "Reopen with Encoding")) };
-        if (!Language.isDefaultVariant()) {
-            const saveWithEncodingAlias = 'Save with Encoding';
-            if (saveWithEncodingAlias !== saveWithEncodingPick.label) {
-                saveWithEncodingPick.detail = saveWithEncodingAlias;
-            }
-            const reopenWithEncodingAlias = 'Reopen with Encoding';
-            if (reopenWithEncodingAlias !== reopenWithEncodingPick.label) {
-                reopenWithEncodingPick.detail = reopenWithEncodingAlias;
-            }
-        }
-        let action;
-        if (encodingSupport instanceof UntitledTextEditorInput) {
-            action = saveWithEncodingPick;
-        }
-        else if (activeEditorPane.input.hasCapability(2 )) {
-            action = reopenWithEncodingPick;
-        }
-        else {
-            action = await quickInputService.pick([reopenWithEncodingPick, saveWithEncodingPick], { placeHolder: ( localize('pickAction', "Select Action")), matchOnDetail: true });
-        }
-        if (!action) {
-            return;
-        }
-        await timeout(50);
-        const resource = EditorResourceAccessor.getOriginalUri(activeEditorPane.input, { supportSideBySide: SideBySideEditor.PRIMARY });
-        if (!resource || (!fileService.hasProvider(resource) && resource.scheme !== Schemas.untitled)) {
-            return;
-        }
-        let guessedEncoding = undefined;
-        if (fileService.hasProvider(resource)) {
-            const content = await textFileService.readStream(resource, { autoGuessEncoding: true });
-            guessedEncoding = content.encoding;
-        }
-        const isReopenWithEncoding = (action === reopenWithEncodingPick);
-        const configuredEncoding = textResourceConfigurationService.getValue(withNullAsUndefined(resource), 'files.encoding');
-        let directMatchIndex;
-        let aliasMatchIndex;
-        const picks = ( ( Object.keys(SUPPORTED_ENCODINGS))
-            .sort((k1, k2) => {
-            if (k1 === configuredEncoding) {
-                return -1;
-            }
-            else if (k2 === configuredEncoding) {
-                return 1;
-            }
-            return SUPPORTED_ENCODINGS[k1].order - SUPPORTED_ENCODINGS[k2].order;
-        })
-            .filter(k => {
-            if (k === guessedEncoding && guessedEncoding !== configuredEncoding) {
-                return false;
-            }
-            return !isReopenWithEncoding || !SUPPORTED_ENCODINGS[k].encodeOnly;
-        })
-            .map((key, index) => {
-            if (key === encodingSupport.getEncoding()) {
-                directMatchIndex = index;
-            }
-            else if (SUPPORTED_ENCODINGS[key].alias === encodingSupport.getEncoding()) {
-                aliasMatchIndex = index;
-            }
-            return { id: key, label: SUPPORTED_ENCODINGS[key].labelLong, description: key };
-        }));
-        const items = picks.slice();
-        if (guessedEncoding && configuredEncoding !== guessedEncoding && SUPPORTED_ENCODINGS[guessedEncoding]) {
-            picks.unshift({ type: 'separator' });
-            picks.unshift({ id: guessedEncoding, label: SUPPORTED_ENCODINGS[guessedEncoding].labelLong, description: ( localize('guessedEncoding', "Guessed from content")) });
-        }
-        const encoding = await quickInputService.pick(picks, {
-            placeHolder: isReopenWithEncoding ? ( localize('pickEncodingForReopen', "Select File Encoding to Reopen File")) : ( localize('pickEncodingForSave', "Select File Encoding to Save with")),
-            activeItem: items[typeof directMatchIndex === 'number' ? directMatchIndex : typeof aliasMatchIndex === 'number' ? aliasMatchIndex : -1]
-        });
-        if (!encoding) {
-            return;
-        }
-        if (!editorService.activeEditorPane) {
-            return;
-        }
-        const activeEncodingSupport = toEditorWithEncodingSupport(editorService.activeEditorPane.input);
-        if (typeof encoding.id !== 'undefined' && activeEncodingSupport) {
-            await activeEncodingSupport.setEncoding(encoding.id, isReopenWithEncoding ? 1  : 0 );
-        }
-        activeTextEditorControl.focus();
-    }
-}
-export { ChangeEOLAction, ChangeEncodingAction, ChangeLanguageAction, ShowLanguageExtensionsAction };

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

@@ -1,139 +0,0 @@
-import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
-import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { EditorResourceAccessor, SideBySideEditor } from '../../../common/editor.js';
-import { EditorPane } from './editorPane.js';
-import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
-import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
-import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
-import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
-import { IEditorService } from '../../../services/editor/common/editorService.js';
-import { MutableDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-let AbstractEditorWithViewState = class AbstractEditorWithViewState extends EditorPane {
-    constructor(id, viewStateStorageKey, telemetryService, instantiationService, storageService, textResourceConfigurationService, themeService, editorService, editorGroupService) {
-        super(id, telemetryService, themeService, storageService);
-        this.instantiationService = instantiationService;
-        this.textResourceConfigurationService = textResourceConfigurationService;
-        this.editorService = editorService;
-        this.editorGroupService = editorGroupService;
-        this.groupListener = this._register(( new MutableDisposable()));
-        this.viewState = this.getEditorMemento(editorGroupService, textResourceConfigurationService, viewStateStorageKey, 100);
-    }
-    setEditorVisible(visible, group) {
-        this.groupListener.value = group?.onWillCloseEditor(e => this.onWillCloseEditor(e));
-        super.setEditorVisible(visible, group);
-    }
-    onWillCloseEditor(e) {
-        const editor = e.editor;
-        if (editor === this.input) {
-            this.updateEditorViewState(editor);
-        }
-    }
-    clearInput() {
-        this.updateEditorViewState(this.input);
-        super.clearInput();
-    }
-    saveState() {
-        this.updateEditorViewState(this.input);
-        super.saveState();
-    }
-    updateEditorViewState(input) {
-        if (!input || !this.tracksEditorViewState(input)) {
-            return;
-        }
-        const resource = this.toEditorViewStateResource(input);
-        if (!resource) {
-            return;
-        }
-        if (!this.tracksDisposedEditorViewState()) {
-            if (!this.editorViewStateDisposables) {
-                this.editorViewStateDisposables = ( new Map());
-            }
-            if (!this.editorViewStateDisposables.has(input)) {
-                this.editorViewStateDisposables.set(input, Event.once(input.onWillDispose)(() => {
-                    this.clearEditorViewState(resource, this.group);
-                    this.editorViewStateDisposables?.delete(input);
-                }));
-            }
-        }
-        if ((input.isDisposed() && !this.tracksDisposedEditorViewState()) ||
-            (!this.shouldRestoreEditorViewState(input) && (!this.group || !this.group.contains(input)))) {
-            this.clearEditorViewState(resource, this.group);
-        }
-        else if (!input.isDisposed()) {
-            this.saveEditorViewState(resource);
-        }
-    }
-    shouldRestoreEditorViewState(input, context) {
-        if (context?.newInGroup) {
-            return this.textResourceConfigurationService.getValue(EditorResourceAccessor.getOriginalUri(input, { supportSideBySide: SideBySideEditor.PRIMARY }), 'workbench.editor.restoreViewState') === false ? false : true ;
-        }
-        return true;
-    }
-    getViewState() {
-        const input = this.input;
-        if (!input || !this.tracksEditorViewState(input)) {
-            return;
-        }
-        const resource = this.toEditorViewStateResource(input);
-        if (!resource) {
-            return;
-        }
-        return this.computeEditorViewState(resource);
-    }
-    saveEditorViewState(resource) {
-        if (!this.group) {
-            return;
-        }
-        const editorViewState = this.computeEditorViewState(resource);
-        if (!editorViewState) {
-            return;
-        }
-        this.viewState.saveEditorState(this.group, resource, editorViewState);
-    }
-    loadEditorViewState(input, context) {
-        if (!input || !this.group) {
-            return undefined;
-        }
-        if (!this.tracksEditorViewState(input)) {
-            return undefined;
-        }
-        if (!this.shouldRestoreEditorViewState(input, context)) {
-            return undefined;
-        }
-        const resource = this.toEditorViewStateResource(input);
-        if (!resource) {
-            return;
-        }
-        return this.viewState.loadEditorState(this.group, resource);
-    }
-    moveEditorViewState(source, target, comparer) {
-        return this.viewState.moveEditorState(source, target, comparer);
-    }
-    clearEditorViewState(resource, group) {
-        this.viewState.clearEditorState(resource, group);
-    }
-    dispose() {
-        super.dispose();
-        if (this.editorViewStateDisposables) {
-            for (const [, disposables] of this.editorViewStateDisposables) {
-                disposables.dispose();
-            }
-            this.editorViewStateDisposables = undefined;
-        }
-    }
-    tracksDisposedEditorViewState() {
-        return false;
-    }
-};
-AbstractEditorWithViewState = ( __decorate([
-    ( __param(2, ITelemetryService)),
-    ( __param(3, IInstantiationService)),
-    ( __param(4, IStorageService)),
-    ( __param(5, ITextResourceConfigurationService)),
-    ( __param(6, IThemeService)),
-    ( __param(7, IEditorService)),
-    ( __param(8, IEditorGroupsService))
-], AbstractEditorWithViewState));
-export { AbstractEditorWithViewState };