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

package/dist/vscode/vs/workbench/common/contextkeys.js

@@ -23,6 +23,10 @@ const RemoteNameContext = ( new RawContextKey('remoteName', '', ( localize(
     'remoteName',
     "The name of the remote the window is connected to or an empty string if not connected to any remote"
 ))));
+const VirtualWorkspaceContext = ( new RawContextKey('virtualWorkspace', '', ( localize(
+    'virtualWorkspace',
+    "The scheme of the current workspace is from a virtual file system or an empty string."
+))));
 const IsFullscreenContext = ( new RawContextKey('isFullscreen', false, ( localize('isFullscreen', "Whether the window is in fullscreen mode"))));
 const HasWebFileSystemAccess = ( new RawContextKey('hasWebFileSystemAccess', false, true));
 const ActiveEditorDirtyContext = ( new RawContextKey('activeEditorIsDirty', false, ( localize('activeEditorIsDirty', "Whether the active editor has unsaved changes"))));
@@ -39,6 +43,10 @@ const ActiveEditorLastInGroupContext = ( new RawContextKey('activeEditorIsLastIn
     "Whether the active editor is the last one in its group"
 ))));
 const ActiveEditorStickyContext = ( new RawContextKey('activeEditorIsPinned', false, ( localize('activeEditorIsPinned', "Whether the active editor is pinned"))));
+const ActiveEditorCanToggleReadonlyContext = ( new RawContextKey('activeEditorCanToggleReadonly', true, ( localize(
+    'activeEditorCanToggleReadonly',
+    "Whether the active editor can toggle between being readonly or writeable"
+))));
 const ActiveEditorCanSplitInGroupContext = ( new RawContextKey('activeEditorCanSplitInGroup', true));
 const ActiveEditorContext = ( new RawContextKey('activeEditor', null, { type: 'string', description: ( localize('activeEditor', "The identifier of the active editor")) }));
 const ActiveEditorAvailableEditorIdsContext = ( new RawContextKey('activeEditorAvailableEditorIds', '', ( localize(
@@ -193,4 +201,4 @@ ResourceContextKey = ( __decorate([
     ( __param(2, ILanguageService)),
     ( __param(3, IModelService))
 ], ResourceContextKey));
-export { ActiveEditorAvailableEditorIdsContext, ActiveEditorCanSplitInGroupContext, ActiveEditorContext, ActiveEditorDirtyContext, ActiveEditorFirstInGroupContext, ActiveEditorGroupEmptyContext, ActiveEditorGroupLockedContext, ActiveEditorLastInGroupContext, ActiveEditorPinnedContext, ActiveEditorStickyContext, ActivePanelContext, ActiveViewletContext, AuxiliaryBarVisibleContext, DirtyWorkingCopiesContext, EditorGroupEditorsCountContext, EditorTabsVisibleContext, EmptyWorkspaceSupportContext, EnterMultiRootWorkspaceSupportContext, FocusedViewContext, HasWebFileSystemAccess, InEditorZenModeContext, IsCenteredLayoutContext, IsFullscreenContext, MultipleEditorGroupsContext, NotificationFocusedContext, NotificationsCenterVisibleContext, NotificationsToastsVisibleContext, OpenFolderWorkspaceSupportContext, PanelAlignmentContext, PanelFocusContext, PanelPositionContext, PanelVisibleContext, RemoteNameContext, ResourceContextKey, SideBarVisibleContext, SideBySideEditorActiveContext, SidebarFocusContext, StatusBarFocused, TextCompareEditorActiveContext, TextCompareEditorVisibleContext, WorkbenchStateContext, WorkspaceFolderCountContext, getEnabledViewContainerContextKey, getVisbileViewContextKey };
+export { ActiveEditorAvailableEditorIdsContext, ActiveEditorCanSplitInGroupContext, ActiveEditorCanToggleReadonlyContext, ActiveEditorContext, ActiveEditorDirtyContext, ActiveEditorFirstInGroupContext, ActiveEditorGroupEmptyContext, ActiveEditorGroupLockedContext, ActiveEditorLastInGroupContext, ActiveEditorPinnedContext, ActiveEditorStickyContext, ActivePanelContext, ActiveViewletContext, AuxiliaryBarVisibleContext, DirtyWorkingCopiesContext, EditorGroupEditorsCountContext, EditorTabsVisibleContext, EmptyWorkspaceSupportContext, EnterMultiRootWorkspaceSupportContext, FocusedViewContext, HasWebFileSystemAccess, InEditorZenModeContext, IsCenteredLayoutContext, IsFullscreenContext, MultipleEditorGroupsContext, NotificationFocusedContext, NotificationsCenterVisibleContext, NotificationsToastsVisibleContext, OpenFolderWorkspaceSupportContext, PanelAlignmentContext, PanelFocusContext, PanelPositionContext, PanelVisibleContext, RemoteNameContext, ResourceContextKey, SideBarVisibleContext, SideBySideEditorActiveContext, SidebarFocusContext, StatusBarFocused, TextCompareEditorActiveContext, TextCompareEditorVisibleContext, VirtualWorkspaceContext, WorkbenchStateContext, WorkspaceFolderCountContext, getEnabledViewContainerContextKey, getVisbileViewContextKey };

package/dist/vscode/vs/workbench/common/editor/editorGroupModel.js

@@ -22,6 +22,10 @@ function isGroupEditorOpenEvent(e) {
     const candidate = e;
     return candidate.kind === 3  && candidate.editorIndex !== undefined;
 }
+function isGroupEditorMoveEvent(e) {
+    const candidate = e;
+    return candidate.kind === 5  && candidate.editorIndex !== undefined && candidate.oldEditorIndex !== undefined;
+}
 function isGroupEditorCloseEvent(e) {
     const candidate = e;
     return candidate.kind === 4  && candidate.editorIndex !== undefined && candidate.context !== undefined && candidate.sticky !== undefined;
@@ -671,4 +675,4 @@ EditorGroupModel = ( __decorate([
     ( __param(1, IInstantiationService)),
     ( __param(2, IConfigurationService))
 ], EditorGroupModel));
-export { EditorGroupModel, isGroupEditorCloseEvent, isGroupEditorOpenEvent, isSerializedEditorGroupModel };
+export { EditorGroupModel, isGroupEditorCloseEvent, isGroupEditorMoveEvent, isGroupEditorOpenEvent, isSerializedEditorGroupModel };

package/dist/vscode/vs/workbench/common/editor/resourceEditorInput.js

@@ -3,11 +3,12 @@ import { EditorInput } from './editorInput.js';
 import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
 import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
 import { isEqual, dirname } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { IFilesConfigurationService } from '../../services/filesConfiguration/common/filesConfigurationService.js';
 let AbstractResourceEditorInput = class AbstractResourceEditorInput extends EditorInput {
     get capabilities() {
         let capabilities = 32 ;
         if (this.fileService.hasProvider(this.resource)) {
-            if (this.fileService.hasCapability(this.resource, 2048 )) {
+            if (this.filesConfigurationService.isReadonly(this.resource)) {
                 capabilities |= 2 ;
             }
         }
@@ -20,11 +21,12 @@ let AbstractResourceEditorInput = class AbstractResourceEditorInput extends Edit
         return capabilities;
     }
     get preferredResource() { return this._preferredResource; }
-    constructor(resource, preferredResource, labelService, fileService) {
+    constructor(resource, preferredResource, labelService, fileService, filesConfigurationService) {
         super();
         this.resource = resource;
         this.labelService = labelService;
         this.fileService = fileService;
+        this.filesConfigurationService = filesConfigurationService;
         this._name = undefined;
         this._shortDescription = undefined;
         this._mediumDescription = undefined;
@@ -128,6 +130,7 @@ let AbstractResourceEditorInput = class AbstractResourceEditorInput extends Edit
 };
 AbstractResourceEditorInput = ( __decorate([
     ( __param(2, ILabelService)),
-    ( __param(3, IFileService))
+    ( __param(3, IFileService)),
+    ( __param(4, IFilesConfigurationService))
 ], AbstractResourceEditorInput));
 export { AbstractResourceEditorInput };

package/dist/vscode/vs/workbench/common/editor/textResourceEditorInput.js

@@ -10,9 +10,10 @@ import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
 import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
 import { TextResourceEditorModel } from './textResourceEditorModel.js';
 import { createTextBufferFactory } from 'monaco-editor/esm/vs/editor/common/model/textModel.js';
+import { IFilesConfigurationService } from '../../services/filesConfiguration/common/filesConfigurationService.js';
 let AbstractTextResourceEditorInput = class AbstractTextResourceEditorInput extends AbstractResourceEditorInput {
-    constructor(resource, preferredResource, editorService, textFileService, labelService, fileService) {
-        super(resource, preferredResource, labelService, fileService);
+    constructor(resource, preferredResource, editorService, textFileService, labelService, fileService, filesConfigurationService) {
+        super(resource, preferredResource, labelService, fileService, filesConfigurationService);
         this.editorService = editorService;
         this.textFileService = textFileService;
     }
@@ -46,7 +47,8 @@ AbstractTextResourceEditorInput = ( __decorate([
     ( __param(2, IEditorService)),
     ( __param(3, ITextFileService)),
     ( __param(4, ILabelService)),
-    ( __param(5, IFileService))
+    ( __param(5, IFileService)),
+    ( __param(6, IFilesConfigurationService))
 ], AbstractTextResourceEditorInput));
 let TextResourceEditorInput = class TextResourceEditorInput extends AbstractTextResourceEditorInput {
     get typeId() {
@@ -55,8 +57,8 @@ let TextResourceEditorInput = class TextResourceEditorInput extends AbstractText
     get editorId() {
         return DEFAULT_EDITOR_ASSOCIATION.id;
     }
-    constructor(resource, name, description, preferredLanguageId, preferredContents, textModelResolverService, textFileService, editorService, fileService, labelService) {
-        super(resource, undefined, editorService, textFileService, labelService, fileService);
+    constructor(resource, name, description, preferredLanguageId, preferredContents, textModelResolverService, textFileService, editorService, fileService, labelService, filesConfigurationService) {
+        super(resource, undefined, editorService, textFileService, labelService, fileService, filesConfigurationService);
         this.name = name;
         this.description = description;
         this.preferredLanguageId = preferredLanguageId;
@@ -141,6 +143,7 @@ TextResourceEditorInput = ( __decorate([
     ( __param(6, ITextFileService)),
     ( __param(7, IEditorService)),
     ( __param(8, IFileService)),
-    ( __param(9, ILabelService))
+    ( __param(9, ILabelService)),
+    ( __param(10, IFilesConfigurationService))
 ], TextResourceEditorInput));
 export { AbstractTextResourceEditorInput, TextResourceEditorInput };

package/dist/vscode/vs/workbench/common/editor.js

@@ -66,10 +66,6 @@ function isUntitledResourceEditorInput(editor) {
     }
     return candidate.resource === undefined || candidate.resource.scheme === Schemas.untitled || candidate.forceUntitled === true;
 }
-const UNTITLED_WITHOUT_ASSOCIATED_RESOURCE_REGEX = /Untitled-\d+/;
-function isUntitledWithAssociatedResource(resource) {
-    return resource.scheme === Schemas.untitled && resource.path.length > 1 && !UNTITLED_WITHOUT_ASSOCIATED_RESOURCE_REGEX.test(resource.path);
-}
 function isResourceMergeEditorInput(editor) {
     if (isEditorInput(editor)) {
         return false;
@@ -314,4 +310,4 @@ function createEditorOpenError(messageOrError, actions, options) {
     error.allowDialog = options?.allowDialog;
     return error;
 }
-export { AbstractEditorInput, BINARY_DIFF_EDITOR_ID, DEFAULT_EDITOR_ASSOCIATION, EditorCloseContext, EditorExtensions, EditorResourceAccessor, SIDE_BY_SIDE_EDITOR_ID, SaveSourceRegistry, SideBySideEditor, TEXT_DIFF_EDITOR_ID, createEditorOpenError, createTooLargeFileError, findViewStateForEditor, isDiffEditorInput, isEditorIdentifier, isEditorInput, isEditorInputWithOptions, isEditorInputWithOptionsAndGroup, isEditorOpenError, isEditorPaneWithSelection, isResourceDiffEditorInput, isResourceEditorInput, isResourceMergeEditorInput, isResourceSideBySideEditorInput, isSideBySideEditorInput, isTextEditorViewState, isUntitledResourceEditorInput, isUntitledWithAssociatedResource };
+export { AbstractEditorInput, BINARY_DIFF_EDITOR_ID, DEFAULT_EDITOR_ASSOCIATION, EditorCloseContext, EditorExtensions, EditorResourceAccessor, SIDE_BY_SIDE_EDITOR_ID, SaveSourceRegistry, SideBySideEditor, TEXT_DIFF_EDITOR_ID, createEditorOpenError, createTooLargeFileError, findViewStateForEditor, isDiffEditorInput, isEditorIdentifier, isEditorInput, isEditorInputWithOptions, isEditorInputWithOptionsAndGroup, isEditorOpenError, isEditorPaneWithSelection, isResourceDiffEditorInput, isResourceEditorInput, isResourceMergeEditorInput, isResourceSideBySideEditorInput, isSideBySideEditorInput, isTextEditorViewState, isUntitledResourceEditorInput };

package/dist/vscode/vs/workbench/common/resources.js

@@ -1,84 +1,161 @@
 import { __decorate, __param } from '../../../../node_modules/tslib/tslib.es6.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { equals, deepClone } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { equals } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { isAbsolute } from 'monaco-editor/esm/vs/base/common/path.js';
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { relativePath } from 'monaco-editor/esm/vs/base/common/resources.js';
 import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { parse } from 'monaco-editor/esm/vs/base/common/glob.js';
 import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { ResourceSet } from 'monaco-editor/esm/vs/base/common/map.js';
+import { getDriveLetter } from 'monaco-editor/esm/vs/base/common/extpath.js';
 let ResourceGlobMatcher = class ResourceGlobMatcher extends Disposable {
-    constructor(globFn, shouldUpdate, contextService, configurationService) {
+    constructor(getExpression, shouldUpdate, contextService, configurationService) {
         super();
-        this.globFn = globFn;
+        this.getExpression = getExpression;
         this.shouldUpdate = shouldUpdate;
         this.contextService = contextService;
         this.configurationService = configurationService;
         this._onExpressionChange = this._register(( new Emitter()));
         this.onExpressionChange = this._onExpressionChange.event;
-        this.mapRootToParsedExpression = ( new Map());
-        this.mapRootToExpressionConfig = ( new Map());
-        this.updateExcludes(false);
+        this.mapFolderToParsedExpression = ( new Map());
+        this.mapFolderToConfiguredExpression = ( new Map());
+        this.updateExpressions(false);
         this.registerListeners();
     }
     registerListeners() {
         this._register(this.configurationService.onDidChangeConfiguration(e => {
             if (this.shouldUpdate(e)) {
-                this.updateExcludes(true);
+                this.updateExpressions(true);
             }
         }));
-        this._register(this.contextService.onDidChangeWorkspaceFolders(() => this.updateExcludes(true)));
+        this._register(this.contextService.onDidChangeWorkspaceFolders(() => this.updateExpressions(true)));
     }
-    updateExcludes(fromEvent) {
+    updateExpressions(fromEvent) {
         let changed = false;
-        this.contextService.getWorkspace().folders.forEach(folder => {
-            const rootExcludes = this.globFn(folder.uri);
-            if (!( this.mapRootToExpressionConfig.has(( folder.uri.toString()))) || !equals(this.mapRootToExpressionConfig.get(( folder.uri.toString())), rootExcludes)) {
+        for (const folder of this.contextService.getWorkspace().folders) {
+            const folderUriStr = ( folder.uri.toString());
+            const newExpression = this.doGetExpression(folder.uri);
+            const currentExpression = this.mapFolderToConfiguredExpression.get(folderUriStr);
+            if (newExpression) {
+                if (!currentExpression || !equals(currentExpression.expression, newExpression.expression)) {
+                    changed = true;
+                    this.mapFolderToParsedExpression.set(folderUriStr, parse(newExpression.expression));
+                    this.mapFolderToConfiguredExpression.set(folderUriStr, newExpression);
+                }
+            }
+            else {
+                if (currentExpression) {
+                    changed = true;
+                    this.mapFolderToParsedExpression.delete(folderUriStr);
+                    this.mapFolderToConfiguredExpression.delete(folderUriStr);
+                }
+            }
+        }
+        const foldersMap = ( new ResourceSet(( this.contextService.getWorkspace().folders.map(folder => folder.uri))));
+        for (const [folder] of this.mapFolderToConfiguredExpression) {
+            if (folder === ResourceGlobMatcher.NO_FOLDER) {
+                continue;
+            }
+            if (!( foldersMap.has(( URI.parse(folder))))) {
+                this.mapFolderToParsedExpression.delete(folder);
+                this.mapFolderToConfiguredExpression.delete(folder);
                 changed = true;
-                this.mapRootToParsedExpression.set(( folder.uri.toString()), parse(rootExcludes));
-                this.mapRootToExpressionConfig.set(( folder.uri.toString()), deepClone(rootExcludes));
             }
-        });
-        this.mapRootToExpressionConfig.forEach((value, root) => {
-            if (root === ResourceGlobMatcher.NO_ROOT) {
-                return;
+        }
+        const globalNewExpression = this.doGetExpression(undefined);
+        const globalCurrentExpression = this.mapFolderToConfiguredExpression.get(ResourceGlobMatcher.NO_FOLDER);
+        if (globalNewExpression) {
+            if (!globalCurrentExpression || !equals(globalCurrentExpression.expression, globalNewExpression.expression)) {
+                changed = true;
+                this.mapFolderToParsedExpression.set(ResourceGlobMatcher.NO_FOLDER, parse(globalNewExpression.expression));
+                this.mapFolderToConfiguredExpression.set(ResourceGlobMatcher.NO_FOLDER, globalNewExpression);
             }
-            if (root && !this.contextService.getWorkspaceFolder(( URI.parse(root)))) {
-                this.mapRootToParsedExpression.delete(root);
-                this.mapRootToExpressionConfig.delete(root);
+        }
+        else {
+            if (globalCurrentExpression) {
                 changed = true;
+                this.mapFolderToParsedExpression.delete(ResourceGlobMatcher.NO_FOLDER);
+                this.mapFolderToConfiguredExpression.delete(ResourceGlobMatcher.NO_FOLDER);
             }
-        });
-        const globalExcludes = this.globFn();
-        if (!( this.mapRootToExpressionConfig.has(ResourceGlobMatcher.NO_ROOT)) || !equals(this.mapRootToExpressionConfig.get(ResourceGlobMatcher.NO_ROOT), globalExcludes)) {
-            changed = true;
-            this.mapRootToParsedExpression.set(ResourceGlobMatcher.NO_ROOT, parse(globalExcludes));
-            this.mapRootToExpressionConfig.set(ResourceGlobMatcher.NO_ROOT, deepClone(globalExcludes));
         }
         if (fromEvent && changed) {
             this._onExpressionChange.fire();
         }
     }
+    doGetExpression(resource) {
+        const expression = this.getExpression(resource);
+        if (!expression) {
+            return undefined;
+        }
+        const keys = ( Object.keys(expression));
+        if (keys.length === 0) {
+            return undefined;
+        }
+        let hasAbsolutePath = false;
+        const massagedExpression = Object.create(null);
+        for (const key of keys) {
+            if (!hasAbsolutePath) {
+                hasAbsolutePath = isAbsolute(key);
+            }
+            let massagedKey = key;
+            const driveLetter = getDriveLetter(massagedKey, true );
+            if (driveLetter) {
+                const driveLetterLower = driveLetter.toLowerCase();
+                if (driveLetter !== driveLetter.toLowerCase()) {
+                    massagedKey = `${driveLetterLower}${massagedKey.substring(1)}`;
+                }
+            }
+            massagedExpression[massagedKey] = expression[key];
+        }
+        return {
+            expression: massagedExpression,
+            hasAbsolutePath
+        };
+    }
     matches(resource, hasSibling) {
+        if (this.mapFolderToParsedExpression.size === 0) {
+            return false;
+        }
         const folder = this.contextService.getWorkspaceFolder(resource);
-        let expressionForRoot;
-        if (folder && ( this.mapRootToParsedExpression.has(( folder.uri.toString())))) {
-            expressionForRoot = this.mapRootToParsedExpression.get(( folder.uri.toString()));
+        let expressionForFolder;
+        let expressionConfigForFolder;
+        if (folder && ( this.mapFolderToParsedExpression.has(( folder.uri.toString())))) {
+            expressionForFolder = this.mapFolderToParsedExpression.get(( folder.uri.toString()));
+            expressionConfigForFolder = this.mapFolderToConfiguredExpression.get(( folder.uri.toString()));
         }
         else {
-            expressionForRoot = this.mapRootToParsedExpression.get(ResourceGlobMatcher.NO_ROOT);
+            expressionForFolder = this.mapFolderToParsedExpression.get(ResourceGlobMatcher.NO_FOLDER);
+            expressionConfigForFolder = this.mapFolderToConfiguredExpression.get(ResourceGlobMatcher.NO_FOLDER);
+        }
+        if (!expressionForFolder) {
+            return false;
         }
         let resourcePathToMatch;
         if (folder) {
             resourcePathToMatch = relativePath(folder.uri, resource);
         }
         else {
-            resourcePathToMatch = resource.fsPath;
+            resourcePathToMatch = this.uriToPath(resource);
+        }
+        if (typeof resourcePathToMatch === 'string' && !!expressionForFolder(resourcePathToMatch, undefined, hasSibling)) {
+            return true;
+        }
+        if (resourcePathToMatch !== this.uriToPath(resource) && expressionConfigForFolder?.hasAbsolutePath) {
+            return !!expressionForFolder(this.uriToPath(resource), undefined, hasSibling);
+        }
+        return false;
+    }
+    uriToPath(uri) {
+        if (uri.scheme === Schemas.file) {
+            return uri.fsPath;
         }
-        return !!expressionForRoot && typeof resourcePathToMatch === 'string' && !!expressionForRoot(resourcePathToMatch, undefined, hasSibling);
+        return uri.path;
     }
 };
-ResourceGlobMatcher.NO_ROOT = null;
+ResourceGlobMatcher.NO_FOLDER = null;
 ResourceGlobMatcher = ( __decorate([
     ( __param(2, IWorkspaceContextService)),
     ( __param(3, IConfigurationService))

package/dist/vscode/vs/workbench/contrib/bulkEdit/browser/bulkEditService.js

@@ -183,7 +183,7 @@ let BulkEditService = class BulkEditService {
                 codeEditor = candidate;
             }
         }
-        if (codeEditor && codeEditor.getOption(87 )) {
+        if (codeEditor && codeEditor.getOption(88 )) {
             codeEditor = undefined;
         }
         let undoRedoGroup;

package/dist/vscode/vs/workbench/contrib/bulkEdit/browser/bulkTextEdits.js

@@ -107,7 +107,7 @@ class EditorEditTask extends ModelEditTask {
                         });
                     }
                 }
-                snippetCtrl.apply(snippetEdits);
+                snippetCtrl.apply(snippetEdits, { undoStopBefore: false, undoStopAfter: false });
             }
             else {
                 this._edits = (

package/dist/vscode/vs/workbench/contrib/chat/browser/chat.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IChatWidgetService = ( createDecorator('chatWidgetService'));
+export { IChatWidgetService };

package/dist/vscode/vs/workbench/contrib/chat/common/chatService.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IChatService = ( createDecorator('IChatService'));
+export { IChatService };

package/dist/vscode/vs/workbench/contrib/codeEditor/browser/languageConfigurationExtensionPoint.js

@@ -471,9 +471,10 @@ const schema = {
         },
         brackets: {
             default: [['(', ')'], ['[', ']'], ['{', '}']],
-            description: ( nls.localize(
+            markdownDescription: ( nls.localize(
                 'schema.brackets',
-                'Defines the bracket symbols that increase or decrease the indentation.'
+                'Defines the bracket symbols that increase or decrease the indentation. When bracket pair colorization is enabled and {0} is not defined, this also defines the bracket pairs that are colorized by their nesting level.',
+                '\`colorizedBracketPairs\`'
             )),
             type: 'array',
             items: {
@@ -482,9 +483,10 @@ const schema = {
         },
         colorizedBracketPairs: {
             default: [['(', ')'], ['[', ']'], ['{', '}']],
-            description: ( nls.localize(
+            markdownDescription: ( nls.localize(
                 'schema.colorizedBracketPairs',
-                'Defines the bracket pairs that are colorized by their nesting level if bracket pair colorization is enabled.'
+                'Defines the bracket pairs that are colorized by their nesting level if bracket pair colorization is enabled. Any brackets included here that are not included in {0} will be automatically included in {0}.',
+                '\`brackets\`'
             )),
             type: 'array',
             items: {

package/dist/vscode/vs/workbench/contrib/codeEditor/browser/suggestEnabledInput/suggestEnabledInput.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../node_modules/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".suggest-input-container{border-radius:2px;padding:2px 6px}.suggest-input-container .monaco-editor,.suggest-input-container .monaco-editor-background,.suggest-input-container .mtk1{color:inherit}.suggest-input-container .suggest-input-placeholder{margin-top:1px;overflow:hidden;pointer-events:none;position:absolute;text-overflow:ellipsis;white-space:nowrap;z-index:1}.suggest-input-container .monaco-editor,.suggest-input-container .monaco-editor .lines-content{background:none}";
+n(css,{});
+export { css, css as default };