@codingame/monaco-vscode-api 4.5.1 → 5.0.0

package/vscode/src/vs/workbench/services/configurationResolver/common/variableResolver.js

@@ -7,6 +7,7 @@ import { normalizeDriveLetter } from '../../../../base/common/labels.js';
 import { localizeWithPath } from '../../../../nls.js';
 import { VariableKind, VariableError } from './configurationResolver.js';
 import { replaceAsync } from '../../../../base/common/strings.js';
+const _moduleId = "vs/workbench/services/configurationResolver/common/variableResolver";
 class AbstractVariableResolverService {
     static { this.VARIABLE_LHS = '${'; }
     static { this.VARIABLE_REGEXP = /\$\{(.*?)\}/g; }
@@ -70,14 +71,14 @@ class AbstractVariableResolverService {
         return { newConfig, resolvedVariables };
     }
     resolveWithInteractionReplace(folder, config, section, variables) {
-        throw new Error('resolveWithInteractionReplace not implemented.');
+        throw ( new Error('resolveWithInteractionReplace not implemented.'));
     }
     resolveWithInteraction(folder, config, section, variables) {
-        throw new Error('resolveWithInteraction not implemented.');
+        throw ( new Error('resolveWithInteraction not implemented.'));
     }
     contributeVariable(variable, resolution) {
         if (( this._contributedVariables.has(variable))) {
-            throw new Error('Variable ' + variable + ' is contributed twice.');
+            throw ( new Error('Variable ' + variable + ' is contributed twice.'));
         }
         else {
             this._contributedVariables.set(variable, resolution);
@@ -133,7 +134,12 @@ class AbstractVariableResolverService {
             if (filePath) {
                 return normalizeDriveLetter(filePath);
             }
-            throw new VariableError(variableKind, (localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'canNotResolveFile', "Variable {0} can not be resolved. Please open an editor.", match)));
+            throw ( new VariableError(variableKind, localizeWithPath(
+                _moduleId,
+                0,
+                "Variable {0} can not be resolved. Please open an editor.",
+                match
+            )));
         };
         const getFolderPathForFile = (variableKind) => {
             const filePath = getFilePath(variableKind);
@@ -143,7 +149,13 @@ class AbstractVariableResolverService {
                     return normalizeDriveLetter(folderPath);
                 }
             }
-            throw new VariableError(variableKind, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'canNotResolveFolderForFile', "Variable {0}: can not find workspace folder of '{1}'.", match, basename(filePath)));
+            throw ( new VariableError(variableKind, localizeWithPath(
+                _moduleId,
+                1,
+                "Variable {0}: can not find workspace folder of '{1}'.",
+                match,
+                basename(filePath)
+            )));
         };
         const getFolderUri = (variableKind) => {
             if (argument) {
@@ -151,15 +163,31 @@ class AbstractVariableResolverService {
                 if (folder) {
                     return folder;
                 }
-                throw new VariableError(variableKind, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'canNotFindFolder', "Variable {0} can not be resolved. No such folder '{1}'.", match, argument));
+                throw ( new VariableError(variableKind, localizeWithPath(
+                    _moduleId,
+                    2,
+                    "Variable {0} can not be resolved. No such folder '{1}'.",
+                    match,
+                    argument
+                )));
             }
             if (folderUri) {
                 return folderUri;
             }
             if (this._context.getWorkspaceFolderCount() > 1) {
-                throw new VariableError(variableKind, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'canNotResolveWorkspaceFolderMultiRoot', "Variable {0} can not be resolved in a multi folder workspace. Scope this variable using ':' and a workspace folder name.", match));
+                throw ( new VariableError(variableKind, localizeWithPath(
+                    _moduleId,
+                    3,
+                    "Variable {0} can not be resolved in a multi folder workspace. Scope this variable using ':' and a workspace folder name.",
+                    match
+                )));
             }
-            throw new VariableError(variableKind, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'canNotResolveWorkspaceFolder', "Variable {0} can not be resolved. Please open a folder.", match));
+            throw ( new VariableError(variableKind, localizeWithPath(
+                _moduleId,
+                4,
+                "Variable {0} can not be resolved. Please open a folder.",
+                match
+            )));
         };
         switch (variable) {
             case 'env':
@@ -172,19 +200,41 @@ class AbstractVariableResolverService {
                     }
                     return '';
                 }
-                throw new VariableError(VariableKind.Env, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'missingEnvVarName', "Variable {0} can not be resolved because no environment variable name is given.", match));
+                throw ( new VariableError(VariableKind.Env, localizeWithPath(
+                    _moduleId,
+                    5,
+                    "Variable {0} can not be resolved because no environment variable name is given.",
+                    match
+                )));
             case 'config':
                 if (argument) {
                     const config = this._context.getConfigurationValue(folderUri, argument);
                     if (isUndefinedOrNull(config)) {
-                        throw new VariableError(VariableKind.Config, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'configNotFound', "Variable {0} can not be resolved because setting '{1}' not found.", match, argument));
+                        throw ( new VariableError(VariableKind.Config, localizeWithPath(
+                            _moduleId,
+                            6,
+                            "Variable {0} can not be resolved because setting '{1}' not found.",
+                            match,
+                            argument
+                        )));
                     }
                     if (isObject(config)) {
-                        throw new VariableError(VariableKind.Config, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'configNoString', "Variable {0} can not be resolved because '{1}' is a structured value.", match, argument));
+                        throw ( new VariableError(VariableKind.Config, localizeWithPath(
+                            _moduleId,
+                            7,
+                            "Variable {0} can not be resolved because '{1}' is a structured value.",
+                            match,
+                            argument
+                        )));
                     }
                     return config;
                 }
-                throw new VariableError(VariableKind.Config, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'missingConfigName', "Variable {0} can not be resolved because no settings name is given.", match));
+                throw ( new VariableError(VariableKind.Config, localizeWithPath(
+                    _moduleId,
+                    8,
+                    "Variable {0} can not be resolved because no settings name is given.",
+                    match
+                )));
             case 'command':
                 return this.resolveFromMap(VariableKind.Command, match, argument, commandValueMapping, 'command');
             case 'input':
@@ -193,11 +243,22 @@ class AbstractVariableResolverService {
                 if (argument) {
                     const ext = await this._context.getExtension(argument);
                     if (!ext) {
-                        throw new VariableError(VariableKind.ExtensionInstallFolder, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'extensionNotInstalled', "Variable {0} can not be resolved because the extension {1} is not installed.", match, argument));
+                        throw ( new VariableError(VariableKind.ExtensionInstallFolder, localizeWithPath(
+                            _moduleId,
+                            9,
+                            "Variable {0} can not be resolved because the extension {1} is not installed.",
+                            match,
+                            argument
+                        )));
                     }
                     return this.fsPath(ext.extensionLocation);
                 }
-                throw new VariableError(VariableKind.ExtensionInstallFolder, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'missingExtensionName', "Variable {0} can not be resolved because no extension name is given.", match));
+                throw ( new VariableError(VariableKind.ExtensionInstallFolder, localizeWithPath(
+                    _moduleId,
+                    10,
+                    "Variable {0} can not be resolved because no extension name is given.",
+                    match
+                )));
             default: {
                 switch (variable) {
                     case 'workspaceRoot':
@@ -212,21 +273,36 @@ class AbstractVariableResolverService {
                         if (environment.userHome) {
                             return environment.userHome;
                         }
-                        throw new VariableError(VariableKind.UserHome, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'canNotResolveUserHome', "Variable {0} can not be resolved. UserHome path is not defined", match));
+                        throw ( new VariableError(VariableKind.UserHome, localizeWithPath(
+                            _moduleId,
+                            11,
+                            "Variable {0} can not be resolved. UserHome path is not defined",
+                            match
+                        )));
                     }
                     case 'lineNumber': {
                         const lineNumber = this._context.getLineNumber();
                         if (lineNumber) {
                             return lineNumber;
                         }
-                        throw new VariableError(VariableKind.LineNumber, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'canNotResolveLineNumber', "Variable {0} can not be resolved. Make sure to have a line selected in the active editor.", match));
+                        throw ( new VariableError(VariableKind.LineNumber, localizeWithPath(
+                            _moduleId,
+                            12,
+                            "Variable {0} can not be resolved. Make sure to have a line selected in the active editor.",
+                            match
+                        )));
                     }
                     case 'selectedText': {
                         const selectedText = this._context.getSelectedText();
                         if (selectedText) {
                             return selectedText;
                         }
-                        throw new VariableError(VariableKind.SelectedText, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'canNotResolveSelectedText', "Variable {0} can not be resolved. Make sure to have some text selected in the active editor.", match));
+                        throw ( new VariableError(VariableKind.SelectedText, localizeWithPath(
+                            _moduleId,
+                            13,
+                            "Variable {0} can not be resolved. Make sure to have some text selected in the active editor.",
+                            match
+                        )));
                     }
                     case 'file':
                         return getFilePath(VariableKind.File);
@@ -294,7 +370,12 @@ class AbstractVariableResolverService {
             if (typeof v === 'string') {
                 return v;
             }
-            throw new VariableError(variableKind, localizeWithPath('vs/workbench/services/configurationResolver/common/variableResolver', 'noValueForCommand', "Variable {0} can not be resolved because the command has no value.", match));
+            throw ( new VariableError(variableKind, localizeWithPath(
+                _moduleId,
+                14,
+                "Variable {0} can not be resolved because the command has no value.",
+                match
+            )));
         }
         return match;
     }

package/vscode/src/vs/workbench/services/editor/common/customEditorLabelService.js

@@ -2,10 +2,11 @@ import { __decorate, __param } from '../../../../../../../external/tslib/tslib.e
 import { Emitter } from '../../../../base/common/event.js';
 import { parse } from '../../../../base/common/glob.js';
 import { Disposable } from '../../../../base/common/lifecycle.js';
-import { isAbsolute, parse as parse$1 } from '../../../../base/common/path.js';
-import { relativePath } from '../../../../base/common/resources.js';
+import { isAbsolute, parse as parse$1, dirname as dirname$1 } from '../../../../base/common/path.js';
+import { relativePath, dirname } from '../../../../base/common/resources.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
 import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.service.js';
+import { MRUCache } from '../../../../base/common/map.js';
 import '../../../../platform/instantiation/common/instantiation.js';
 var CustomEditorLabelService_1;
 let CustomEditorLabelService = class CustomEditorLabelService extends Disposable {
@@ -20,8 +21,9 @@ let CustomEditorLabelService = class CustomEditorLabelService extends Disposable
         this.onDidChange = this._onDidChange.event;
         this.patterns = [];
         this.enabled = true;
+        this.cache = ( new MRUCache(1000));
         this._templateRegexValidation = /[a-zA-Z0-9]/;
-        this._parsedTemplateExpression = /\$\{(dirname|filename|extname|dirname\((\d+)\))\}/g;
+        this._parsedTemplateExpression = /\$\{(dirname|filename|extname|dirname\(([-+]?\d+)\))\}/g;
         this.storeEnablementState();
         this.storeCustomPatterns();
         this.registerListernes();
@@ -36,6 +38,7 @@ let CustomEditorLabelService = class CustomEditorLabelService extends Disposable
                 }
             }
             else if (e.affectsConfiguration(CustomEditorLabelService_1.SETTING_ID_PATTERNS)) {
+                this.cache.clear();
                 this.storeCustomPatterns();
                 this._onDidChange.fire();
             }
@@ -77,32 +80,39 @@ let CustomEditorLabelService = class CustomEditorLabelService extends Disposable
         return weight;
     }
     getName(resource) {
-        if (!this.enabled) {
+        if (!this.enabled || this.patterns.length === 0) {
             return undefined;
         }
-        return this.applyPatterns(resource);
+        const key = ( resource.toString());
+        const cached = this.cache.get(key);
+        if (cached !== undefined) {
+            return cached ?? undefined;
+        }
+        const result = this.applyPatterns(resource);
+        this.cache.set(key, result ?? null);
+        return result;
     }
     applyPatterns(resource) {
-        if (this.patterns.length === 0) {
-            return undefined;
-        }
         const root = this.workspaceContextService.getWorkspaceFolder(resource);
         let relativePath$1;
         for (const pattern of this.patterns) {
             let relevantPath;
             if (root && !pattern.isAbsolutePath) {
-                relevantPath = relativePath$1 = relativePath$1 ?? relativePath(root.uri, resource) ?? resource.path;
+                if (!relativePath$1) {
+                    relativePath$1 = relativePath(dirname(root.uri), resource) ?? resource.path;
+                }
+                relevantPath = relativePath$1;
             }
             else {
                 relevantPath = resource.path;
             }
             if (pattern.parsedPattern(relevantPath)) {
-                return this.applyTempate(pattern.template, resource);
+                return this.applyTempate(pattern.template, resource, relevantPath);
             }
         }
         return undefined;
     }
-    applyTempate(template, resource) {
+    applyTempate(template, resource, relevantPath) {
         let parsedPath;
         return template.replace(this._parsedTemplateExpression, (match, variable, arg) => {
             parsedPath = parsedPath ?? parse$1(resource.path);
@@ -113,7 +123,7 @@ let CustomEditorLabelService = class CustomEditorLabelService extends Disposable
                     return parsedPath.ext.slice(1);
                 default: {
                     const n = variable === 'dirname' ? 0 : parseInt(arg);
-                    const nthDir = this.getNthDirname(parsedPath, n);
+                    const nthDir = this.getNthDirname(dirname$1(relevantPath), n);
                     if (nthDir) {
                         return nthDir;
                     }
@@ -123,11 +133,15 @@ let CustomEditorLabelService = class CustomEditorLabelService extends Disposable
         });
     }
     getNthDirname(path, n) {
-        const pathFragments = path.dir.split('/');
+        path = path.startsWith('/') ? path.slice(1) : path;
+        const pathFragments = path.split('/');
         const length = pathFragments.length;
-        const nth = length - 1 - n;
-        if (nth < 0) {
-            return undefined;
+        let nth;
+        if (n < 0) {
+            nth = Math.abs(n) - 1;
+        }
+        else {
+            nth = length - n - 1;
         }
         const nthDir = pathFragments[nth];
         if (nthDir === undefined || nthDir === '') {

package/vscode/src/vs/workbench/services/editor/common/editorGroupsService.d.ts

@@ -90,6 +90,7 @@ type ICloseEditorsFilter = {
 };
 interface ICloseAllEditorsOptions {
     readonly excludeSticky?: boolean;
+    readonly excludeConfirming?: boolean;
 }
 interface IEditorReplacement {
     readonly editor: EditorInput;
@@ -323,12 +324,16 @@ interface IEditorGroupsContainer {
      * will be moved over to the target and the source group will close. Configure to
      * `MOVE_EDITORS_KEEP_GROUP` to prevent the source group from closing. Set to
      * `COPY_EDITORS` to copy the editors into the target instead of moding them.
+     *
+     * @returns if merging was successful
      */
-    mergeGroup(group: IEditorGroup | GroupIdentifier, target: IEditorGroup | GroupIdentifier, options?: IMergeGroupOptions): IEditorGroup;
+    mergeGroup(group: IEditorGroup | GroupIdentifier, target: IEditorGroup | GroupIdentifier, options?: IMergeGroupOptions): boolean;
     /**
      * Merge all editor groups into the target one.
+     *
+     * @returns if merging was successful
      */
-    mergeAllGroups(target: IEditorGroup | GroupIdentifier): IEditorGroup;
+    mergeAllGroups(target: IEditorGroup | GroupIdentifier): boolean;
     /**
      * Copy a group to a new group in the container.
      *
@@ -385,14 +390,20 @@ interface IAuxiliaryEditorPart extends IEditorPart {
     /**
      * Close this auxiliary editor part after moving all
      * editors of all groups back to the main editor part.
+     *
+     * @returns `false` if an editor could not be moved back.
      */
-    close(): void;
+    close(): boolean;
 }
 interface IAuxiliaryEditorPartCreateEvent {
     readonly part: IAuxiliaryEditorPart;
     readonly instantiationService: IInstantiationService;
     readonly disposables: DisposableStore;
 }
+interface IEditorWorkingSet {
+    readonly id: string;
+    readonly name: string;
+}
 interface IActiveEditorActions {
     readonly actions: IToolbarActions;
     readonly onDidChange: Event<IMenuChangeEvent | void>;
@@ -667,4 +678,4 @@ interface IEditorGroup {
     createEditorActions(disposables: DisposableStore): IActiveEditorActions;
 }
 
-export { type EditorGroupLayout, GroupDirection, type GroupLayoutArgument, GroupLocation, GroupOrientation, GroupsArrangement, GroupsOrder, type IActiveEditorActions, type IAuxiliaryEditorPart, type IAuxiliaryEditorPartCreateEvent, type ICloseAllEditorsOptions, type ICloseEditorOptions, type ICloseEditorsFilter, type IEditorDropTargetDelegate, type IEditorGroup, type IEditorGroupsContainer, type IEditorPart, type IEditorReplacement, type IEditorSideGroup, type IFindGroupScope, type IMergeGroupOptions, MergeGroupMode };
+export { type EditorGroupLayout, GroupDirection, type GroupLayoutArgument, GroupLocation, GroupOrientation, GroupsArrangement, GroupsOrder, type IActiveEditorActions, type IAuxiliaryEditorPart, type IAuxiliaryEditorPartCreateEvent, type ICloseAllEditorsOptions, type ICloseEditorOptions, type ICloseEditorsFilter, type IEditorDropTargetDelegate, type IEditorGroup, type IEditorGroupsContainer, type IEditorPart, type IEditorReplacement, type IEditorSideGroup, type IEditorWorkingSet, type IFindGroupScope, type IMergeGroupOptions, MergeGroupMode };

package/vscode/src/vs/workbench/services/editor/common/editorGroupsService.service.d.ts

@@ -2,7 +2,7 @@ import { ServiceIdentifier } from '../../../../platform/instantiation/common/ins
 import { Event } from '../../../../base/common/event.js';
 import { GroupIdentifier, IEditorPartOptions, IEditorPartOptionsChangeEvent } from '../../../common/editor.js';
 import { IRectangle } from '../../../../platform/window/common/window.js';
-import { IEditorGroupsContainer, IAuxiliaryEditorPartCreateEvent, IEditorPart, IEditorGroup, IAuxiliaryEditorPart } from './editorGroupsService.js';
+import { IEditorGroupsContainer, IAuxiliaryEditorPartCreateEvent, IEditorPart, IEditorGroup, IAuxiliaryEditorPart, IEditorWorkingSet } from './editorGroupsService.js';
 
 declare const IEditorGroupsService: ServiceIdentifier<IEditorGroupsService>;
 /**
@@ -45,6 +45,25 @@ interface IEditorGroupsService extends IEditorGroupsContainer {
     createAuxiliaryEditorPart(options?: {
         bounds?: Partial<IRectangle>;
     }): Promise<IAuxiliaryEditorPart>;
+    /**
+    * Save a new editor working set from the currently opened
+    * editors and group layout.
+    */
+    saveWorkingSet(name: string): IEditorWorkingSet;
+    /**
+    * Returns all known editor working sets.
+    */
+    getWorkingSets(): IEditorWorkingSet[];
+    /**
+    * Applies the working set. Use `empty` to apply an empty working set.
+    *
+    * @returns `true` when the working set as applied.
+    */
+    applyWorkingSet(workingSet: IEditorWorkingSet | 'empty'): Promise<boolean>;
+    /**
+    * Deletes a working set.
+    */
+    deleteWorkingSet(workingSet: IEditorWorkingSet): void;
 }
 
 export { IEditorGroupsService };

package/vscode/src/vs/workbench/services/editor/common/editorResolverService.js

@@ -6,16 +6,17 @@ import { localizeWithPath } from '../../../../nls.js';
 import { workbenchConfigurationNodeBase } from '../../../common/configuration.js';
 import { Extensions } from '../../../../platform/configuration/common/configurationRegistry.js';
 import { Registry } from '../../../../platform/registry/common/platform.js';
+const _moduleId = "vs/workbench/services/editor/common/editorResolverService";
 const editorsAssociationsSettingId = 'workbench.editorAssociations';
-const configurationRegistry = ( Registry.as(Extensions.Configuration));
+const configurationRegistry = ( (Registry.as(Extensions.Configuration)));
 const editorAssociationsConfigurationNode = {
     ...workbenchConfigurationNodeBase,
     properties: {
         'workbench.editorAssociations': {
             type: 'object',
             markdownDescription: ( localizeWithPath(
-                'vs/workbench/services/editor/common/editorResolverService',
-                'editor.editorAssociations',
+                _moduleId,
+                0,
                 "Configure [glob patterns](https://aka.ms/vscode-glob-patterns) to editors (for example `\"*.hex\": \"hexEditor.hexedit\"`). These have precedence over the default behavior."
             )),
             additionalProperties: {
@@ -26,12 +27,12 @@ const editorAssociationsConfigurationNode = {
 };
 configurationRegistry.registerConfiguration(editorAssociationsConfigurationNode);
 var RegisteredEditorPriority;
-( (function(RegisteredEditorPriority) {
+( ((function(RegisteredEditorPriority) {
     RegisteredEditorPriority["builtin"] = "builtin";
     RegisteredEditorPriority["option"] = "option";
     RegisteredEditorPriority["exclusive"] = "exclusive";
     RegisteredEditorPriority["default"] = "default";
-})(RegisteredEditorPriority || (RegisteredEditorPriority = {})));
+})(RegisteredEditorPriority || (RegisteredEditorPriority = {}))));
 function priorityToRank(priority) {
     switch (priority) {
         case RegisteredEditorPriority.exclusive:
@@ -46,13 +47,13 @@ function priorityToRank(priority) {
     }
 }
 function globMatchesResource(globPattern, resource) {
-    const excludedSchemes = ( new Set([
+    const excludedSchemes = ( (new Set([
         Schemas.extension,
         Schemas.webviewPanel,
         Schemas.vscodeWorkspaceTrust,
         Schemas.vscodeSettings
-    ]));
-    if (( excludedSchemes.has(resource.scheme))) {
+    ])));
+    if (( (excludedSchemes.has(resource.scheme)))) {
         return false;
     }
     const matchOnPath = typeof globPattern === 'string' && globPattern.indexOf(posix.sep) >= 0;

package/vscode/src/vs/workbench/services/extensionManagement/common/extensionFeatures.js

@@ -9,7 +9,7 @@ class ExtensionFeaturesRegistry {
     }
     registerExtensionFeature(descriptor) {
         if (( this.extensionFeatures.has(descriptor.id))) {
-            throw new Error(`Extension feature with id '${descriptor.id}' already exists`);
+            throw ( new Error(`Extension feature with id '${descriptor.id}' already exists`));
         }
         this.extensionFeatures.set(descriptor.id, descriptor);
         return {

package/vscode/src/vs/workbench/services/extensionManagement/common/extensionManagement.js

@@ -1,14 +1,11 @@
 import { FileAccess } from '../../../../base/common/network.js';
 import { localizeWithPath } from '../../../../nls.js';
-const getDefaultIconPath = () => ( ( FileAccess.asBrowserUri('vs/workbench/services/extensionManagement/common/media/defaultIcon.png')).toString(true));
+const _moduleId = "vs/workbench/services/extensionManagement/common/extensionManagement";
+const getDefaultIconPath = () => ( (( (FileAccess.asBrowserUri('vs/workbench/services/extensionManagement/common/media/defaultIcon.png'))).toString(true)));
 const extensionsConfigurationNodeBase = {
     id: 'extensions',
     order: 30,
-    title: ( localizeWithPath(
-        'vs/workbench/services/extensionManagement/common/extensionManagement',
-        'extensionsConfigurationTitle',
-        "Extensions"
-    )),
+    title: ( localizeWithPath(_moduleId, 0, "Extensions")),
     type: 'object'
 };
 export { extensionsConfigurationNodeBase, getDefaultIconPath };

package/vscode/src/vs/workbench/services/extensionManagement/common/extensionManagement.service.d.ts

@@ -19,7 +19,6 @@ interface IWorkbenchExtensionManagementService extends IProfileAwareExtensionMan
     onDidUninstallExtension: Event<DidUninstallExtensionOnServerEvent>;
     onDidChangeProfile: Event<DidChangeProfileForServerEvent>;
     onDidEnableExtensions: Event<IExtension[]>;
-    isWorkspaceExtensionsSupported(): boolean;
     getExtensions(locations: URI[]): Promise<IResourceExtension[]>;
     getInstalledWorkspaceExtensions(includeInvalid: boolean): Promise<ILocalExtension[]>;
     installVSIX(location: URI, manifest: IExtensionManifest, installOptions?: InstallOptions): Promise<ILocalExtension>;