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

package/dist/vscode/vs/workbench/contrib/extensions/browser/extensionsIcons.js

@@ -0,0 +1,82 @@
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+registerIcon('extensions-view-icon', Codicon.extensions, ( localize('extensionsViewIcon', 'View icon of the extensions view.')));
+const manageExtensionIcon = registerIcon('extensions-manage', Codicon.gear, ( localize(
+ 'manageExtensionIcon',
+ 'Icon for the \'Manage\' action in the extensions view.'
+)));
+registerIcon('extensions-clear-search-results', Codicon.clearAll, ( localize(
+ 'clearSearchResultsIcon',
+ 'Icon for the \'Clear Search Result\' action in the extensions view.'
+)));
+registerIcon('extensions-refresh', Codicon.refresh, ( localize('refreshIcon', 'Icon for the \'Refresh\' action in the extensions view.')));
+const filterIcon = registerIcon('extensions-filter', Codicon.filter, ( localize('filterIcon', 'Icon for the \'Filter\' action in the extensions view.')));
+registerIcon('extensions-install-local-in-remote', Codicon.cloudDownload, ( localize(
+ 'installLocalInRemoteIcon',
+ 'Icon for the \'Install Local Extension in Remote\' action in the extensions view.'
+)));
+registerIcon('extensions-install-workspace-recommended', Codicon.cloudDownload, ( localize(
+ 'installWorkspaceRecommendedIcon',
+ 'Icon for the \'Install Workspace Recommended Extensions\' action in the extensions view.'
+)));
+registerIcon('extensions-configure-recommended', Codicon.pencil, ( localize(
+ 'configureRecommendedIcon',
+ 'Icon for the \'Configure Recommended Extensions\' action in the extensions view.'
+)));
+const syncEnabledIcon = registerIcon('extensions-sync-enabled', Codicon.sync, ( localize('syncEnabledIcon', 'Icon to indicate that an extension is synced.')));
+const syncIgnoredIcon = registerIcon('extensions-sync-ignored', Codicon.syncIgnored, ( localize(
+ 'syncIgnoredIcon',
+ 'Icon to indicate that an extension is ignored when syncing.'
+)));
+registerIcon('extensions-remote', Codicon.remote, ( localize(
+ 'remoteIcon',
+ 'Icon to indicate that an extension is remote in the extensions view and editor.'
+)));
+registerIcon('extensions-install-count', Codicon.cloudDownload, ( localize(
+ 'installCountIcon',
+ 'Icon shown along with the install count in the extensions view and editor.'
+)));
+registerIcon('extensions-rating', Codicon.star, ( localize(
+ 'ratingIcon',
+ 'Icon shown along with the rating in the extensions view and editor.'
+)));
+registerIcon('extensions-verified-publisher', Codicon.verifiedFilled, ( localize(
+ 'verifiedPublisher',
+ 'Icon used for the verified extension publisher in the extensions view and editor.'
+)));
+const preReleaseIcon = registerIcon('extensions-pre-release', Codicon.versions, ( localize(
+ 'preReleaseIcon',
+ 'Icon shown for extensions having pre-release versions in extensions view and editor.'
+)));
+registerIcon('extensions-sponsor', Codicon.heartFilled, ( localize(
+ 'sponsorIcon',
+ 'Icon used for sponsoring extensions in the extensions view and editor.'
+)));
+registerIcon('extensions-star-full', Codicon.starFull, ( localize(
+ 'starFullIcon',
+ 'Full star icon used for the rating in the extensions editor.'
+)));
+registerIcon('extensions-star-half', Codicon.starHalf, ( localize(
+ 'starHalfIcon',
+ 'Half star icon used for the rating in the extensions editor.'
+)));
+registerIcon('extensions-star-empty', Codicon.starEmpty, ( localize(
+ 'starEmptyIcon',
+ 'Empty star icon used for the rating in the extensions editor.'
+)));
+const errorIcon = registerIcon('extensions-error-message', Codicon.error, ( localize('errorIcon', 'Icon shown with a error message in the extensions editor.')));
+const warningIcon = registerIcon('extensions-warning-message', Codicon.warning, ( localize(
+ 'warningIcon',
+ 'Icon shown with a warning message in the extensions editor.'
+)));
+const infoIcon = registerIcon('extensions-info-message', Codicon.info, ( localize('infoIcon', 'Icon shown with an info message in the extensions editor.')));
+const trustIcon = registerIcon('extension-workspace-trust', Codicon.shield, ( localize(
+ 'trustIcon',
+ 'Icon shown with a workspace trust message in the extension editor.'
+)));
+registerIcon('extension-activation-time', Codicon.history, ( localize(
+ 'activationtimeIcon',
+ 'Icon shown with a activation time message in the extension editor.'
+)));
+export { errorIcon, filterIcon, infoIcon, manageExtensionIcon, preReleaseIcon, syncEnabledIcon, syncIgnoredIcon, trustIcon, warningIcon };

package/dist/vscode/vs/workbench/contrib/extensions/browser/media/extensionActions.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../node_modules/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-action-bar .action-item .action-label.extension-action{line-height:normal;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.monaco-action-bar .action-dropdown-item>.action-label.extension-action.label,.monaco-action-bar .action-item>.action-label.extension-action.label{padding:0 5px}.monaco-action-bar .action-dropdown-item>.monaco-dropdown .action-label{padding:0}.monaco-action-bar .action-item .action-label.extension-action.label{outline-offset:1px}.monaco-action-bar .action-dropdown-item .action-label.extension-action.label,.monaco-action-bar .action-item .action-label.extension-action.label,.monaco-action-bar .action-item .action-label.extension-action.text{height:auto;line-height:14px;width:auto}.monaco-action-bar .action-item .action-label.extension-action.built-in-status{border-color:var(--vscode-foreground)}.monaco-action-bar .action-item .action-label.extension-action.label,.monaco-action-bar .action-item.action-dropdown-item>.action-dropdown-item-separator{background-color:var(--vscode-extensionButton-background)!important}.monaco-action-bar .action-item .action-label.extension-action.label{color:var(--vscode-extensionButton-foreground)!important}.monaco-action-bar .action-item .action-label.extension-action.label:hover{background-color:var(--vscode-extensionButton-hoverBackground)!important}.monaco-action-bar .action-item.action-dropdown-item>.action-dropdown-item-separator>div{background-color:var(--vscode-extensionButton-separator)}.monaco-action-bar .action-item .action-label.extension-action.label.prominent,.monaco-action-bar .action-item.action-dropdown-item>.action-dropdown-item-separator.prominent{background-color:var(--vscode-extensionButton-prominentBackground)}.monaco-action-bar .action-item .action-label.extension-action.label.prominent{color:var(--vscode-extensionButton-prominentForeground)!important}.monaco-action-bar .action-item .action-label.extension-action.label.prominent:hover{background-color:var(--vscode-extensionButton-prominentHoverBackground)}.monaco-action-bar .action-item .action-label.extension-action:not(.disabled){border:1px solid var(--vscode-contrastBorder)}.monaco-action-bar .action-item.action-dropdown-item>.action-dropdown-item-separator{border-bottom:1px solid var(--vscode-contrastBorder);border-top:1px solid var(--vscode-contrastBorder)}.monaco-action-bar .action-item .action-label.extension-action.extension-status-error{color:var(--vscode-editorError-foreground)}.monaco-action-bar .action-item .action-label.extension-action.extension-status-warning{color:var(--vscode-editorWarning-foreground)}.monaco-action-bar .action-item .action-label.extension-action.extension-status-info{color:var(--vscode-editorInfo-foreground)}.monaco-action-bar .action-dropdown-item .action-label.extension-action.label,.monaco-action-bar .action-item .action-label.extension-action.icon,.monaco-action-bar .action-item:not(.disabled) .action-label.extension-action.label,.monaco-action-bar .action-item:not(.disabled) .action-label.extension-action.text{margin-top:2px}.monaco-action-bar .action-item .action-label.extension-action.manage.hide,.monaco-action-bar .action-item.action-dropdown-item .action-label.extension-action.hide,.monaco-action-bar .action-item.action-dropdown-item.disabled,.monaco-action-bar .action-item.disabled .action-label.disable-status.hide,.monaco-action-bar .action-item.disabled .action-label.extension-action.extension-sync,.monaco-action-bar .action-item.disabled .action-label.extension-action.hide,.monaco-action-bar .action-item.disabled .action-label.extension-action.hide-when-disabled,.monaco-action-bar .action-item.disabled .action-label.extension-action.ignore,.monaco-action-bar .action-item.disabled .action-label.extension-action.install:not(.installing),.monaco-action-bar .action-item.disabled .action-label.extension-action.language,.monaco-action-bar .action-item.disabled .action-label.extension-action.migrate,.monaco-action-bar .action-item.disabled .action-label.extension-action.reload,.monaco-action-bar .action-item.disabled .action-label.extension-action.theme,.monaco-action-bar .action-item.disabled .action-label.extension-action.undo-ignore,.monaco-action-bar .action-item.disabled .action-label.extension-action.uninstall:not(.uninstalling),.monaco-action-bar .action-item.disabled .action-label.extension-action.update,.monaco-action-bar .action-item.disabled .action-label.extension-status-label.hide,.monaco-action-bar .action-item.disabled .action-label.extension-status.hide{display:none}.monaco-action-bar .extension-action.label{display:inherit}.monaco-action-bar .action-item.disabled .action-label.extension-status:before{opacity:1}.monaco-action-bar .action-item.disabled .action-label.extension-status-label:before{content:\"\\2713\";padding-right:4px}.monaco-action-bar .action-item.disabled .action-label.extension-action{opacity:1}.monaco-action-bar .action-item.disabled .action-label.extension-action.text{font-style:italic;opacity:.9}";
+n(css,{});
+export { css, css as default };

package/dist/vscode/vs/workbench/contrib/extensions/common/extensions.js

@@ -1,3 +1,8 @@
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const VIEWLET_ID = 'workbench.view.extensions';
 const IExtensionsWorkbenchService = ( createDecorator('extensionsWorkbenchService'));
-export { IExtensionsWorkbenchService };
+const TOGGLE_IGNORE_EXTENSION_ACTION_ID = 'workbench.extensions.action.toggleIgnoreExtension';
+const SELECT_INSTALL_VSIX_EXTENSION_COMMAND_ID = 'workbench.extensions.action.installVSIX';
+const THEME_ACTIONS_GROUP = '_theme_';
+const INSTALL_ACTIONS_GROUP = '0_install';
+export { IExtensionsWorkbenchService, INSTALL_ACTIONS_GROUP, SELECT_INSTALL_VSIX_EXTENSION_COMMAND_ID, THEME_ACTIONS_GROUP, TOGGLE_IGNORE_EXTENSION_ACTION_ID, VIEWLET_ID };

package/dist/vscode/vs/workbench/contrib/extensions/common/extensionsFileTemplate.js

@@ -0,0 +1,16 @@
+const ExtensionsConfigurationInitialContent = [
+    '{',
+    '\t// See https://go.microsoft.com/fwlink/?LinkId=827846 to learn about workspace recommendations.',
+    '\t// Extension identifier format: ${publisher}.${name}. Example: vscode.csharp',
+    '',
+    '\t// List of extensions which should be recommended for users of this workspace.',
+    '\t"recommendations": [',
+    '\t\t',
+    '\t],',
+    '\t// List of extensions recommended by VS Code that should not be recommended for users of this workspace.',
+    '\t"unwantedRecommendations": [',
+    '\t\t',
+    '\t]',
+    '}'
+].join('\n');
+export { ExtensionsConfigurationInitialContent };

package/dist/vscode/vs/workbench/contrib/files/browser/editors/binaryFileEditor.js

@@ -0,0 +1,71 @@
+import { __decorate, __param } from '../../../../../../../node_modules/tslib/tslib.es6.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { BaseBinaryResourceEditor } from '../../../../browser/parts/editor/binaryEditor.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 { FileEditorInput } from './fileEditorInput.js';
+import { BINARY_FILE_EDITOR_ID, BINARY_TEXT_FILE_MODE } from '../../common/files.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { EditorResolution } from 'monaco-editor/esm/vs/platform/editor/common/editor.js';
+import { IEditorResolverService } from '../../../../services/editor/common/editorResolverService.js';
+import { isEditorInputWithOptions } from '../../../../common/editor.js';
+import { DiffEditorInput } from '../../../../common/editor/diffEditorInput.js';
+import { IEditorGroupsService } from '../../../../services/editor/common/editorGroupsService.js';
+let BinaryFileEditor = class BinaryFileEditor extends BaseBinaryResourceEditor {
+    constructor(telemetryService, themeService, editorResolverService, storageService, editorGroupService) {
+        super(BinaryFileEditor.ID, {
+            openInternal: (input, options) => this.openInternal(input, options)
+        }, telemetryService, themeService, storageService);
+        this.editorResolverService = editorResolverService;
+        this.editorGroupService = editorGroupService;
+    }
+    async openInternal(input, options) {
+        if (input instanceof FileEditorInput && this.group?.activeEditor) {
+            const activeEditor = this.group.activeEditor;
+            const untypedActiveEditor = activeEditor?.toUntyped();
+            if (!untypedActiveEditor) {
+                return;
+            }
+            let resolvedEditor = await this.editorResolverService.resolveEditor({
+                ...untypedActiveEditor,
+                options: {
+                    ...options,
+                    override: EditorResolution.PICK
+                }
+            }, this.group);
+            if (resolvedEditor === 2 ) {
+                resolvedEditor = undefined;
+            }
+            else if (resolvedEditor === 1 ) {
+                return;
+            }
+            if (isEditorInputWithOptions(resolvedEditor)) {
+                for (const editor of resolvedEditor.editor instanceof DiffEditorInput ? [resolvedEditor.editor.original, resolvedEditor.editor.modified] : [resolvedEditor.editor]) {
+                    if (editor instanceof FileEditorInput) {
+                        editor.setForceOpenAsText();
+                        editor.setPreferredLanguageId(BINARY_TEXT_FILE_MODE);
+                    }
+                }
+            }
+            await (this.group ?? this.editorGroupService.activeGroup).replaceEditors([{
+                    editor: activeEditor,
+                    replacement: resolvedEditor?.editor ?? input,
+                    options: {
+                        ...(resolvedEditor?.options ?? options)
+                    }
+                }]);
+        }
+    }
+    getTitle() {
+        return this.input ? this.input.getName() : ( localize('binaryFileEditor', "Binary File Viewer"));
+    }
+};
+BinaryFileEditor.ID = BINARY_FILE_EDITOR_ID;
+BinaryFileEditor = ( __decorate([
+    ( __param(0, ITelemetryService)),
+    ( __param(1, IThemeService)),
+    ( __param(2, IEditorResolverService)),
+    ( __param(3, IStorageService)),
+    ( __param(4, IEditorGroupsService))
+], BinaryFileEditor));
+export { BinaryFileEditor };

package/dist/vscode/vs/workbench/contrib/files/browser/editors/fileEditorInput.js

@@ -33,7 +33,7 @@ let FileEditorInput = class FileEditorInput extends AbstractTextResourceEditorIn
         }
         else {
             if (this.fileService.hasProvider(this.resource)) {
-                if (this.fileService.hasCapability(this.resource, 2048 )) {
+                if (this.filesConfigurationService.isReadonly(this.resource)) {
                     capabilities |= 2 ;
                 }
             }
@@ -47,10 +47,9 @@ let FileEditorInput = class FileEditorInput extends AbstractTextResourceEditorIn
         return capabilities;
     }
     constructor(resource, preferredResource, preferredName, preferredDescription, preferredEncoding, preferredLanguageId, preferredContents, instantiationService, textFileService, textModelResolverService, labelService, fileService, filesConfigurationService, editorService, pathService, textResourceConfigurationService) {
-        super(resource, preferredResource, editorService, textFileService, labelService, fileService);
+        super(resource, preferredResource, editorService, textFileService, labelService, fileService, filesConfigurationService);
         this.instantiationService = instantiationService;
         this.textModelResolverService = textModelResolverService;
-        this.filesConfigurationService = filesConfigurationService;
         this.pathService = pathService;
         this.textResourceConfigurationService = textResourceConfigurationService;
         this.forceOpenAs = 0 ;

package/dist/vscode/vs/workbench/contrib/files/browser/editors/textFileEditor.js

@@ -0,0 +1,225 @@
+import { __decorate, __param } from '../../../../../../../node_modules/tslib/tslib.es6.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { mark } from 'monaco-editor/esm/vs/base/common/performance.js';
+import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { IPathService } from '../../../../services/path/common/pathService.js';
+import { toAction } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { TEXT_FILE_EDITOR_ID, VIEWLET_ID, BINARY_TEXT_FILE_MODE } from '../../common/files.js';
+import { ITextFileService } from '../../../../services/textfile/common/textfiles.js';
+import { AbstractTextCodeEditor } from '../../../../browser/parts/editor/textCodeEditor.js';
+import { isTextEditorViewState, createEditorOpenError, createTooLargeFileError, DEFAULT_EDITOR_ASSOCIATION } from '../../../../common/editor.js';
+import { applyTextEditorOptions } from '../../../../common/editor/editorOptions.js';
+import { BinaryEditorModel } from '../../../../common/editor/binaryEditorModel.js';
+import { FileEditorInput } from './fileEditorInput.js';
+import { TooLargeFileOperationError, ByteSize, FileOperationError, IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.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 { IEditorService } from '../../../../services/editor/common/editorService.js';
+import { IEditorGroupsService } from '../../../../services/editor/common/editorGroupsService.js';
+import { EditorActivation } from 'monaco-editor/esm/vs/platform/editor/common/editor.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { IExplorerService } from '../files.js';
+import { IPaneCompositePartService } from '../../../../services/panecomposite/browser/panecomposite.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IPreferencesService } from '../../../../services/preferences/common/preferences.js';
+import { IHostService } from '../../../../services/host/browser/host.js';
+let TextFileEditor = class TextFileEditor extends AbstractTextCodeEditor {
+    constructor(telemetryService, fileService, paneCompositeService, instantiationService, contextService, storageService, textResourceConfigurationService, editorService, themeService, editorGroupService, textFileService, explorerService, uriIdentityService, pathService, configurationService, preferencesService, hostService) {
+        super(TextFileEditor.ID, telemetryService, instantiationService, storageService, textResourceConfigurationService, themeService, editorService, editorGroupService, fileService);
+        this.paneCompositeService = paneCompositeService;
+        this.contextService = contextService;
+        this.textFileService = textFileService;
+        this.explorerService = explorerService;
+        this.uriIdentityService = uriIdentityService;
+        this.pathService = pathService;
+        this.configurationService = configurationService;
+        this.preferencesService = preferencesService;
+        this.hostService = hostService;
+        this._register(this.fileService.onDidFilesChange(e => this.onDidFilesChange(e)));
+        this._register(this.fileService.onDidRunOperation(e => this.onDidRunOperation(e)));
+    }
+    onDidFilesChange(e) {
+        for (const resource of e.rawDeleted) {
+            this.clearEditorViewState(resource);
+        }
+    }
+    onDidRunOperation(e) {
+        if (e.operation === 2  && e.target) {
+            this.moveEditorViewState(e.resource, e.target.resource, this.uriIdentityService.extUri);
+        }
+    }
+    getTitle() {
+        if (this.input) {
+            return this.input.getName();
+        }
+        return ( localize('textFileEditor', "Text File Editor"));
+    }
+    get input() {
+        return this._input;
+    }
+    async setInput(input, options, context, token) {
+        mark('code/willSetInputToTextFileEditor');
+        await super.setInput(input, options, context, token);
+        try {
+            const resolvedModel = await input.resolve(options);
+            if (token.isCancellationRequested) {
+                return;
+            }
+            if (resolvedModel instanceof BinaryEditorModel) {
+                return this.openAsBinary(input, options);
+            }
+            const textFileModel = resolvedModel;
+            const control = assertIsDefined(this.editorControl);
+            control.setModel(textFileModel.textEditorModel);
+            if (!isTextEditorViewState(options?.viewState)) {
+                const editorViewState = this.loadEditorViewState(input, context);
+                if (editorViewState) {
+                    if (options?.selection) {
+                        editorViewState.cursorState = [];
+                    }
+                    control.restoreViewState(editorViewState);
+                }
+            }
+            if (options) {
+                applyTextEditorOptions(options, control, 1 );
+            }
+            control.updateOptions({ readOnly: textFileModel.isReadonly() });
+        }
+        catch (error) {
+            await this.handleSetInputError(error, input, options);
+        }
+        mark('code/didSetInputToTextFileEditor');
+    }
+    async handleSetInputError(error, input, options) {
+        if (error.textFileOperationResult === 0 ) {
+            return this.openAsBinary(input, options);
+        }
+        if (error.fileOperationResult === 0 ) {
+            const actions = [];
+            actions.push(toAction({
+                id: 'workbench.files.action.openFolder', label: ( localize('openFolder', "Open Folder")), run: async () => {
+                    return this.hostService.openWindow([{ folderUri: input.resource }], { forceNewWindow: true });
+                }
+            }));
+            if (this.contextService.isInsideWorkspace(input.preferredResource)) {
+                actions.push(toAction({
+                    id: 'workbench.files.action.reveal', label: ( localize('reveal', "Reveal Folder")), run: async () => {
+                        await this.paneCompositeService.openPaneComposite(VIEWLET_ID, 0 , true);
+                        return this.explorerService.select(input.preferredResource, true);
+                    }
+                }));
+            }
+            throw createEditorOpenError(localize('fileIsDirectory', "The file is not displayed in the text editor because it is a directory."), actions, { forceMessage: true });
+        }
+        if (error.fileOperationResult === 7  && this.group) {
+            let message;
+            if (error instanceof TooLargeFileOperationError) {
+                message = ( localize(
+                    'fileTooLargeForHeapErrorWithSize',
+                    "The file is not displayed in the text editor because it is very large ({0}).",
+                    ByteSize.formatSize(error.size)
+                ));
+            }
+            else {
+                message = ( localize(
+                    'fileTooLargeForHeapErrorWithoutSize',
+                    "The file is not displayed in the text editor because it is very large."
+                ));
+            }
+            throw createTooLargeFileError(this.group, input, options, message, this.preferencesService);
+        }
+        if (error.fileOperationResult === 1  && (await this.pathService.hasValidBasename(input.preferredResource))) {
+            const fileNotFoundError = createEditorOpenError(( new FileOperationError(( localize(
+                'unavailableResourceErrorEditorText',
+                "The editor could not be opened because the file was not found."
+            )), 1 )), [
+                toAction({
+                    id: 'workbench.files.action.createMissingFile', label: ( localize('createFile', "Create File")), run: async () => {
+                        await this.textFileService.create([{ resource: input.preferredResource }]);
+                        return this.editorService.openEditor({
+                            resource: input.preferredResource,
+                            options: {
+                                pinned: true
+                            }
+                        });
+                    }
+                })
+            ], {
+                allowDialog: true
+            });
+            throw fileNotFoundError;
+        }
+        throw error;
+    }
+    openAsBinary(input, options) {
+        const defaultBinaryEditor = this.configurationService.getValue('workbench.editor.defaultBinaryEditor');
+        const group = this.group ?? this.editorGroupService.activeGroup;
+        const editorOptions = {
+            ...options,
+            activation: EditorActivation.PRESERVE
+        };
+        if (defaultBinaryEditor && defaultBinaryEditor !== '' && defaultBinaryEditor !== DEFAULT_EDITOR_ASSOCIATION.id) {
+            this.doOpenAsBinaryInDifferentEditor(group, defaultBinaryEditor, input, editorOptions);
+        }
+        else {
+            this.doOpenAsBinaryInSameEditor(group, defaultBinaryEditor, input, editorOptions);
+        }
+    }
+    doOpenAsBinaryInDifferentEditor(group, editorId, editor, editorOptions) {
+        this.editorService.replaceEditors([{
+                editor,
+                replacement: { resource: editor.resource, options: { ...editorOptions, override: editorId } }
+            }], group);
+    }
+    doOpenAsBinaryInSameEditor(group, editorId, editor, editorOptions) {
+        if (editorId === DEFAULT_EDITOR_ASSOCIATION.id) {
+            editor.setForceOpenAsText();
+            editor.setPreferredLanguageId(BINARY_TEXT_FILE_MODE);
+            editorOptions = { ...editorOptions, forceReload: true };
+        }
+        else {
+            editor.setForceOpenAsBinary();
+        }
+        group.openEditor(editor, editorOptions);
+    }
+    clearInput() {
+        super.clearInput();
+        this.editorControl?.setModel(null);
+    }
+    createEditorControl(parent, initialOptions) {
+        mark('code/willCreateTextFileEditorControl');
+        super.createEditorControl(parent, initialOptions);
+        mark('code/didCreateTextFileEditorControl');
+    }
+    tracksEditorViewState(input) {
+        return input instanceof FileEditorInput;
+    }
+    tracksDisposedEditorViewState() {
+        return true;
+    }
+};
+TextFileEditor.ID = TEXT_FILE_EDITOR_ID;
+TextFileEditor = ( __decorate([
+    ( __param(0, ITelemetryService)),
+    ( __param(1, IFileService)),
+    ( __param(2, IPaneCompositePartService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IWorkspaceContextService)),
+    ( __param(5, IStorageService)),
+    ( __param(6, ITextResourceConfigurationService)),
+    ( __param(7, IEditorService)),
+    ( __param(8, IThemeService)),
+    ( __param(9, IEditorGroupsService)),
+    ( __param(10, ITextFileService)),
+    ( __param(11, IExplorerService)),
+    ( __param(12, IUriIdentityService)),
+    ( __param(13, IPathService)),
+    ( __param(14, IConfigurationService)),
+    ( __param(15, IPreferencesService)),
+    ( __param(16, IHostService))
+], TextFileEditor));
+export { TextFileEditor };

package/dist/vscode/vs/workbench/contrib/files/browser/editors/textFileSaveErrorHandler.js

@@ -0,0 +1,2 @@
+const CONFLICT_RESOLUTION_CONTEXT = 'saveConflictResolutionContext';
+export { CONFLICT_RESOLUTION_CONTEXT };

package/dist/vscode/vs/workbench/contrib/files/browser/explorerService.js

@@ -16,9 +16,10 @@ import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancel
 import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
 import { IHostService } from '../../../services/host/browser/host.js';
 import { ResourceGlobMatcher } from '../../../common/resources.js';
+import { IFilesConfigurationService } from '../../../services/filesConfiguration/common/filesConfigurationService.js';
 const UNDO_REDO_SOURCE = ( new UndoRedoSource());
 let ExplorerService = class ExplorerService {
-    constructor(fileService, configurationService, contextService, clipboardService, editorService, uriIdentityService, bulkEditService, progressService, hostService) {
+    constructor(fileService, configurationService, contextService, clipboardService, editorService, uriIdentityService, bulkEditService, progressService, hostService, filesConfigurationService) {
         this.fileService = fileService;
         this.configurationService = configurationService;
         this.contextService = contextService;
@@ -27,6 +28,7 @@ let ExplorerService = class ExplorerService {
         this.uriIdentityService = uriIdentityService;
         this.bulkEditService = bulkEditService;
         this.progressService = progressService;
+        this.filesConfigurationService = filesConfigurationService;
         this.disposables = ( new DisposableStore());
         this.fileChangeEvents = [];
         this.config = this.configurationService.getValue('explorer');
@@ -34,7 +36,8 @@ let ExplorerService = class ExplorerService {
             this.contextService,
             this.uriIdentityService,
             this.fileService,
-            this.configurationService
+            this.configurationService,
+            this.filesConfigurationService
         ));
         this.disposables.add(this.model);
         this.disposables.add(this.fileService.onDidRunOperation(e => this.onDidRunOperation(e)));
@@ -222,7 +225,7 @@ let ExplorerService = class ExplorerService {
         }
         try {
             const stat = await this.fileService.resolve(root.resource, options);
-            const modelStat = ExplorerItem.create(this.fileService, this.configurationService, stat, undefined, options.resolveTo);
+            const modelStat = ExplorerItem.create(this.fileService, this.configurationService, this.filesConfigurationService, stat, undefined, options.resolveTo);
             ExplorerItem.mergeLocalWithDisk(modelStat, root);
             const item = root.find(resource);
             await this.view.refresh(true, root);
@@ -259,11 +262,11 @@ let ExplorerService = class ExplorerService {
                     if (!p.isDirectoryResolved) {
                         const stat = await this.fileService.resolve(p.resource, { resolveMetadata });
                         if (stat) {
-                            const modelStat = ExplorerItem.create(this.fileService, this.configurationService, stat, p.parent);
+                            const modelStat = ExplorerItem.create(this.fileService, this.configurationService, this.filesConfigurationService, stat, p.parent);
                             ExplorerItem.mergeLocalWithDisk(modelStat, p);
                         }
                     }
-                    const childElement = ExplorerItem.create(this.fileService, this.configurationService, addedElement, p.parent);
+                    const childElement = ExplorerItem.create(this.fileService, this.configurationService, this.filesConfigurationService, addedElement, p.parent);
                     p.removeChild(childElement);
                     p.addChild(childElement);
                     await this.view?.refresh(shouldDeepRefresh, p);
@@ -371,7 +374,8 @@ ExplorerService = ( __decorate([
     ( __param(5, IUriIdentityService)),
     ( __param(6, IBulkEditService)),
     ( __param(7, IProgressService)),
-    ( __param(8, IHostService))
+    ( __param(8, IHostService)),
+    ( __param(9, IFilesConfigurationService))
 ], ExplorerService));
 function doesFileEventAffect(item, view, events, types) {
     for (const [_name, child] of item.children) {

package/dist/vscode/vs/workbench/contrib/files/browser/explorerViewlet.js

@@ -1,12 +1,12 @@
 import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
-import "../../../../../../assets/explorerviewlet.css";
+import './media/explorerviewlet.css.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { mark } from 'monaco-editor/esm/vs/base/common/performance.js';
-import { VIEWLET_ID, OpenEditorsVisibleContext, VIEW_ID, ExplorerViewletVisibleContext } from '../common/files.js';
+import { VIEWLET_ID, VIEW_ID, ExplorerViewletVisibleContext } from '../common/files.js';
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import { ExplorerView } from './views/explorerView.js';
 import { EmptyView } from './views/emptyView.js';
-import { OpenEditorsView } from '../../../../../../override/vs/workbench/contrib/files/browser/views/openEditorsView.js';
+import { OpenEditorsView } from './views/openEditorsView.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 { IExtensionService } from '../../../services/extensions/common/extensions.js';
@@ -29,20 +29,16 @@ import { OpenFileFolderAction, OpenFolderAction } from '../../../browser/actions
 import { isMacintosh, isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
 import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
 import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
-const explorerViewIcon = ( registerIcon('explorer-view-icon', Codicon.files, ( localize('explorerViewIcon', 'View icon of the explorer view.'))));
-const openEditorsViewIcon = ( registerIcon('open-editors-view-icon', Codicon.book, ( localize('openEditorsIcon', 'View icon of the open editors view.'))));
+const explorerViewIcon = registerIcon('explorer-view-icon', Codicon.files, ( localize('explorerViewIcon', 'View icon of the explorer view.')));
+const openEditorsViewIcon = registerIcon('open-editors-view-icon', Codicon.book, ( localize('openEditorsIcon', 'View icon of the open editors view.')));
 let ExplorerViewletViewsContribution = class ExplorerViewletViewsContribution extends Disposable {
-    constructor(workspaceContextService, configurationService, contextKeyService, progressService) {
+    constructor(workspaceContextService, progressService) {
         super();
         this.workspaceContextService = workspaceContextService;
-        this.configurationService = configurationService;
         progressService.withProgress({ location: 1  }, () => workspaceContextService.getCompleteWorkspace()).finally(() => {
             this.registerViews();
-            this.openEditorsVisibleContextKey = OpenEditorsVisibleContext.bindTo(contextKeyService);
-            this.updateOpenEditorsVisibility();
             this._register(workspaceContextService.onDidChangeWorkbenchState(() => this.registerViews()));
             this._register(workspaceContextService.onDidChangeWorkspaceFolders(() => this.registerViews()));
-            this._register(this.configurationService.onDidChangeConfiguration(e => this.onConfigurationUpdated(e)));
         });
     }
     registerViews() {
@@ -50,6 +46,7 @@ let ExplorerViewletViewsContribution = class ExplorerViewletViewsContribution ex
         const viewDescriptors = viewsRegistry.getViews(VIEW_CONTAINER);
         const viewDescriptorsToRegister = [];
         const viewDescriptorsToDeregister = [];
+        this.createOpenEditorsViewDescriptor();
         const explorerViewDescriptor = this.createExplorerViewDescriptor();
         const registeredExplorerViewDescriptor = viewDescriptors.find(v => v.id === explorerViewDescriptor.id);
         const emptyViewDescriptor = this.createEmptyViewDescriptor();
@@ -85,7 +82,6 @@ let ExplorerViewletViewsContribution = class ExplorerViewletViewsContribution ex
             ctorDescriptor: ( new SyncDescriptor(OpenEditorsView)),
             containerIcon: openEditorsViewIcon,
             order: 0,
-            when: OpenEditorsVisibleContext,
             canToggleVisibility: true,
             canMoveView: true,
             collapsed: false,
@@ -123,20 +119,10 @@ let ExplorerViewletViewsContribution = class ExplorerViewletViewsContribution ex
             }
         };
     }
-    onConfigurationUpdated(e) {
-        if (e.affectsConfiguration('explorer.openEditors.visible')) {
-            this.updateOpenEditorsVisibility();
-        }
-    }
-    updateOpenEditorsVisibility() {
-        this.openEditorsVisibleContextKey.set(this.workspaceContextService.getWorkbenchState() === 1  || this.configurationService.getValue('explorer.openEditors.visible') !== 0);
-    }
 };
 ExplorerViewletViewsContribution = ( __decorate([
     ( __param(0, IWorkspaceContextService)),
-    ( __param(1, IConfigurationService)),
-    ( __param(2, IContextKeyService)),
-    ( __param(3, IProgressService))
+    ( __param(1, IProgressService))
 ], ExplorerViewletViewsContribution));
 let ExplorerViewPaneContainer = class ExplorerViewPaneContainer extends ViewPaneContainer {
     constructor(layoutService, telemetryService, contextService, storageService, configurationService, instantiationService, contextKeyService, themeService, contextMenuService, extensionService, viewDescriptorService) {