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

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

@@ -1,73 +1,12 @@
-import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
-import { EditorResourceAccessor, SideBySideEditor } from '../../../common/editor.js';
-import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
 import { ContextKeyExpr, RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { Disposable, MutableDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
-import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
-import { ITextFileService } from '../../../services/textfile/common/textfiles.js';
 import { InputFocusedContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkeys.js';
-import { once } from 'monaco-editor/esm/vs/base/common/functional.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 const VIEWLET_ID = 'workbench.view.explorer';
-const VIEW_ID = 'workbench.explorer.fileView';
-const ExplorerViewletVisibleContext = ( new RawContextKey(
-    'explorerViewletVisible',
-    true,
-    { type: 'boolean', description: ( localize('explorerViewletVisible', "True when the EXPLORER viewlet is visible.")) }
-));
 const FoldersViewVisibleContext = ( new RawContextKey('foldersViewVisible', true, { type: 'boolean', description: ( localize(
     'foldersViewVisible',
     "True when the FOLDERS view (the file tree within the explorer view container) is visible."
 )) }));
-const ExplorerFolderContext = ( new RawContextKey(
-    'explorerResourceIsFolder',
-    false,
-    { type: 'boolean', description: ( localize(
-        'explorerResourceIsFolder',
-        "True when the focused item in the EXPLORER is a folder."
-    )) }
-));
-const ExplorerResourceReadonlyContext = ( new RawContextKey(
-    'explorerResourceReadonly',
-    false,
-    { type: 'boolean', description: ( localize(
-        'explorerResourceReadonly',
-        "True when the focused item in the EXPLORER is readonly."
-    )) }
-));
-const ExplorerResourceNotReadonlyContext = ( ExplorerResourceReadonlyContext.toNegated());
-const ExplorerResourceAvailableEditorIdsContext = ( new RawContextKey('explorerResourceAvailableEditorIds', ''));
-const ExplorerRootContext = ( new RawContextKey(
-    'explorerResourceIsRoot',
-    false,
-    { type: 'boolean', description: ( localize(
-        'explorerResourceIsRoot',
-        "True when the focused item in the EXPLORER is a root folder."
-    )) }
-));
-const ExplorerResourceCut = ( new RawContextKey(
-    'explorerResourceCut',
-    false,
-    { type: 'boolean', description: ( localize(
-        'explorerResourceCut',
-        "True when an item in the EXPLORER has been cut for cut and paste."
-    )) }
-));
-const ExplorerResourceMoveableToTrash = ( new RawContextKey(
-    'explorerResourceMoveableToTrash',
-    false,
-    { type: 'boolean', description: ( localize(
-        'explorerResourceMoveableToTrash',
-        "True when the focused item in the EXPLORER can be moved to trash."
-    )) }
-));
 const FilesExplorerFocusedContext = ( new RawContextKey('filesExplorerFocus', true, { type: 'boolean', description: ( localize('filesExplorerFocus', "True when the focus is inside the EXPLORER view.")) }));
-const OpenEditorsVisibleContext = ( new RawContextKey(
-    'openEditorsVisible',
-    false,
-    { type: 'boolean', description: ( localize('openEditorsVisible', "True when the OPEN EDITORS view is visible.")) }
-));
 const ExplorerFocusedContext = ( new RawContextKey(
     'explorerViewletFocus',
     true,
@@ -76,44 +15,12 @@ const ExplorerFocusedContext = ( new RawContextKey(
         "True when the focus is inside the EXPLORER viewlet."
     )) }
 ));
-const ExplorerCompressedFocusContext = ( new RawContextKey(
-    'explorerViewletCompressedFocus',
-    true,
-    { type: 'boolean', description: ( localize(
-        'explorerViewletCompressedFocus',
-        "True when the focused item in the EXPLORER view is a compact item."
-    )) }
-));
-const ExplorerCompressedFirstFocusContext = ( new RawContextKey(
-    'explorerViewletCompressedFirstFocus',
-    true,
-    { type: 'boolean', description: ( localize(
-        'explorerViewletCompressedFirstFocus',
-        "True when the focus is inside a compact item's first part in the EXPLORER view."
-    )) }
-));
-const ExplorerCompressedLastFocusContext = ( new RawContextKey(
-    'explorerViewletCompressedLastFocus',
-    true,
-    { type: 'boolean', description: ( localize(
-        'explorerViewletCompressedLastFocus',
-        "True when the focus is inside a compact item's last part in the EXPLORER view."
-    )) }
-));
-const ViewHasSomeCollapsibleRootItemContext = ( new RawContextKey(
-    'viewHasSomeCollapsibleItem',
-    false,
-    { type: 'boolean', description: ( localize(
-        'viewHasSomeCollapsibleItem',
-        "True when a workspace in the EXPLORER view has some collapsible root child."
-    )) }
-));
-const FilesExplorerFocusCondition = ( ContextKeyExpr.and(
+( ContextKeyExpr.and(
     FoldersViewVisibleContext,
     FilesExplorerFocusedContext,
     ContextKeyExpr.not(InputFocusedContextKey)
 ));
-const ExplorerFocusCondition = ( ContextKeyExpr.and(
+( ContextKeyExpr.and(
     FoldersViewVisibleContext,
     ExplorerFocusedContext,
     ContextKeyExpr.not(InputFocusedContextKey)
@@ -122,102 +29,4 @@ const TEXT_FILE_EDITOR_ID = 'workbench.editors.files.textFileEditor';
 const FILE_EDITOR_INPUT_ID = 'workbench.editors.files.fileEditorInput';
 const BINARY_FILE_EDITOR_ID = 'workbench.editors.files.binaryFileEditor';
 const BINARY_TEXT_FILE_MODE = 'code-text-binary';
-let TextFileContentProvider = class TextFileContentProvider extends Disposable {
-    constructor(textFileService, fileService, languageService, modelService) {
-        super();
-        this.textFileService = textFileService;
-        this.fileService = fileService;
-        this.languageService = languageService;
-        this.modelService = modelService;
-        this.fileWatcherDisposable = this._register(( new MutableDisposable()));
-    }
-    static async open(resource, scheme, label, editorService, options) {
-        await editorService.openEditor({
-            original: { resource: TextFileContentProvider.resourceToTextFile(scheme, resource) },
-            modified: { resource },
-            label,
-            options
-        });
-    }
-    static resourceToTextFile(scheme, resource) {
-        return resource.with({ scheme, query: JSON.stringify({ scheme: resource.scheme, query: resource.query }) });
-    }
-    static textFileToResource(resource) {
-        const { scheme, query } = JSON.parse(resource.query);
-        return resource.with({ scheme, query });
-    }
-    async provideTextContent(resource) {
-        if (!resource.query) {
-            return null;
-        }
-        const savedFileResource = TextFileContentProvider.textFileToResource(resource);
-        const codeEditorModel = await this.resolveEditorModel(resource);
-        if (!this.fileWatcherDisposable.value) {
-            this.fileWatcherDisposable.value = this.fileService.onDidFilesChange(changes => {
-                if (changes.contains(savedFileResource, 0 )) {
-                    this.resolveEditorModel(resource, false );
-                }
-            });
-            if (codeEditorModel) {
-                once(codeEditorModel.onWillDispose)(() => this.fileWatcherDisposable.clear());
-            }
-        }
-        return codeEditorModel;
-    }
-    async resolveEditorModel(resource, createAsNeeded = true) {
-        const savedFileResource = TextFileContentProvider.textFileToResource(resource);
-        const content = await this.textFileService.readStream(savedFileResource);
-        let codeEditorModel = this.modelService.getModel(resource);
-        if (codeEditorModel) {
-            this.modelService.updateModel(codeEditorModel, content.value);
-        }
-        else if (createAsNeeded) {
-            const textFileModel = this.modelService.getModel(savedFileResource);
-            let languageSelector;
-            if (textFileModel) {
-                languageSelector = this.languageService.createById(textFileModel.getLanguageId());
-            }
-            else {
-                languageSelector = this.languageService.createByFilepathOrFirstLine(savedFileResource);
-            }
-            codeEditorModel = this.modelService.createModel(content.value, languageSelector, resource);
-        }
-        return codeEditorModel;
-    }
-};
-TextFileContentProvider = ( __decorate([
-    ( __param(0, ITextFileService)),
-    ( __param(1, IFileService)),
-    ( __param(2, ILanguageService)),
-    ( __param(3, IModelService))
-], TextFileContentProvider));
-class OpenEditor {
-    constructor(_editor, _group) {
-        this._editor = _editor;
-        this._group = _group;
-        this.id = OpenEditor.COUNTER++;
-    }
-    get editor() {
-        return this._editor;
-    }
-    get group() {
-        return this._group;
-    }
-    get groupId() {
-        return this._group.id;
-    }
-    getId() {
-        return `openeditor:${this.groupId}:${this.id}`;
-    }
-    isPreview() {
-        return !this._group.isPinned(this.editor);
-    }
-    isSticky() {
-        return this._group.isSticky(this.editor);
-    }
-    getResource() {
-        return EditorResourceAccessor.getOriginalUri(this.editor, { supportSideBySide: SideBySideEditor.PRIMARY });
-    }
-}
-OpenEditor.COUNTER = 0;
-export { BINARY_FILE_EDITOR_ID, BINARY_TEXT_FILE_MODE, ExplorerCompressedFirstFocusContext, ExplorerCompressedFocusContext, ExplorerCompressedLastFocusContext, ExplorerFocusCondition, ExplorerFocusedContext, ExplorerFolderContext, ExplorerResourceAvailableEditorIdsContext, ExplorerResourceCut, ExplorerResourceMoveableToTrash, ExplorerResourceNotReadonlyContext, ExplorerResourceReadonlyContext, ExplorerRootContext, ExplorerViewletVisibleContext, FILE_EDITOR_INPUT_ID, FilesExplorerFocusCondition, FilesExplorerFocusedContext, FoldersViewVisibleContext, OpenEditor, OpenEditorsVisibleContext, TEXT_FILE_EDITOR_ID, TextFileContentProvider, VIEWLET_ID, VIEW_ID, ViewHasSomeCollapsibleRootItemContext };
+export { BINARY_FILE_EDITOR_ID, BINARY_TEXT_FILE_MODE, ExplorerFocusedContext, FILE_EDITOR_INPUT_ID, FilesExplorerFocusedContext, FoldersViewVisibleContext, TEXT_FILE_EDITOR_ID, VIEWLET_ID };

package/dist/vscode/vs/workbench/contrib/notebook/common/notebookCommon.js

@@ -1,87 +1,9 @@
-import { encodeBase64, VSBuffer, decodeBase64 } from 'monaco-editor/esm/vs/base/common/buffer.js';
-import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-const NOTEBOOK_EDITOR_ID = 'workbench.editor.notebook';
 var CellKind;
 ( (function(CellKind) {
     CellKind[CellKind["Markup"] = 1] = "Markup";
     CellKind[CellKind["Code"] = 2] = "Code";
 })(CellKind || (CellKind = {})));
-var SelectionStateType;
-( (function(SelectionStateType) {
-    SelectionStateType[SelectionStateType["Handle"] = 0] = "Handle";
-    SelectionStateType[SelectionStateType["Index"] = 1] = "Index";
-})(SelectionStateType || (SelectionStateType = {})));
-var CellUri;
-( (function(CellUri) {
-    CellUri.scheme = Schemas.vscodeNotebookCell;
-    const _lengths = ['W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f'];
-    const _padRegexp = ( new RegExp(`^[${_lengths.join('')}]+`));
-    const _radix = 7;
-    function generate(notebook, handle) {
-        const s = ( handle.toString(_radix));
-        const p = s.length < _lengths.length ? _lengths[s.length - 1] : 'z';
-        const fragment = `${p}${s}s${encodeBase64(VSBuffer.fromString(notebook.scheme), true, true)}`;
-        return notebook.with({ scheme: CellUri.scheme, fragment });
-    }
-    CellUri.generate = generate;
-    function parse(cell) {
-        if (cell.scheme !== CellUri.scheme) {
-            return undefined;
-        }
-        const idx = cell.fragment.indexOf('s');
-        if (idx < 0) {
-            return undefined;
-        }
-        const handle = parseInt(cell.fragment.substring(0, idx).replace(_padRegexp, ''), _radix);
-        const _scheme = ( decodeBase64(cell.fragment.substring(idx + 1)).toString());
-        if (isNaN(handle)) {
-            return undefined;
-        }
-        return {
-            handle,
-            notebook: cell.with({ scheme: _scheme, fragment: null })
-        };
-    }
-    CellUri.parse = parse;
-    function generateCellOutputUri(notebook, outputId) {
-        return notebook.with({
-            scheme: Schemas.vscodeNotebookCellOutput,
-            fragment: `op${outputId ?? ''},${notebook.scheme !== Schemas.file ? notebook.scheme : ''}`
-        });
-    }
-    CellUri.generateCellOutputUri = generateCellOutputUri;
-    function parseCellOutputUri(uri) {
-        if (uri.scheme !== Schemas.vscodeNotebookCellOutput) {
-            return;
-        }
-        const match = /^op([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})?\,(.*)$/i.exec(uri.fragment);
-        if (!match) {
-            return undefined;
-        }
-        const outputId = (match[1] && match[1] !== '') ? match[1] : undefined;
-        const scheme = match[2];
-        return {
-            outputId,
-            notebook: uri.with({
-                scheme: scheme || Schemas.file,
-                fragment: null
-            })
-        };
-    }
-    CellUri.parseCellOutputUri = parseCellOutputUri;
-    function generateCellPropertyUri(notebook, handle, scheme) {
-        return CellUri.generate(notebook, handle).with({ scheme: scheme });
-    }
-    CellUri.generateCellPropertyUri = generateCellPropertyUri;
-    function parseCellPropertyUri(uri, propertyScheme) {
-        if (uri.scheme !== propertyScheme) {
-            return undefined;
-        }
-        return CellUri.parse(uri.with({ scheme: CellUri.scheme }));
-    }
-    CellUri.parseCellPropertyUri = parseCellPropertyUri;
-})(CellUri || (CellUri = {})));
 function isTextStreamMime(mimeType) {
     return ['application/vnd.code.notebook.stdout', 'application/vnd.code.notebook.stderr'].includes(mimeType);
 }
-export { CellKind, CellUri, NOTEBOOK_EDITOR_ID, SelectionStateType, isTextStreamMime };
+export { CellKind, isTextStreamMime };

package/dist/vscode/vs/workbench/services/actions/common/menusExtensionPoint.js

@@ -3,11 +3,10 @@ import { isFalsyOrWhitespace } from 'monaco-editor/esm/vs/base/common/strings.js
 import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
 import { ExtensionsRegistry } from '../../extensions/common/extensionsRegistry.js';
 import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { MenuId, MenuRegistry } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { MenuRegistry, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
 import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
 import { index } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { isProposedApiEnabled } from '../../extensions/common/extensions.js';
 const apiMenus = [
     {
         key: 'commandPalette',
@@ -827,181 +826,4 @@ commandsExtensionPoint.setHandler(extensions => {
         }
     }
 });
-const _submenus = ( new Map());
-const submenusExtensionPoint = ( ExtensionsRegistry.registerExtensionPoint({
-    extensionPoint: 'submenus',
-    jsonSchema: schema.submenusContribution
-}));
-submenusExtensionPoint.setHandler(extensions => {
-    _submenus.clear();
-    for (const extension of extensions) {
-        const { value, collector } = extension;
-        for (const [, submenuInfo] of Object.entries(value)) {
-            if (!schema.isValidSubmenu(submenuInfo, collector)) {
-                continue;
-            }
-            if (!submenuInfo.id) {
-                collector.warn(( localize(
-                    'submenuId.invalid.id',
-                    "`{0}` is not a valid submenu identifier",
-                    submenuInfo.id
-                )));
-                continue;
-            }
-            if (( _submenus.has(submenuInfo.id))) {
-                collector.info(( localize(
-                    'submenuId.duplicate.id',
-                    "The `{0}` submenu was already previously registered.",
-                    submenuInfo.id
-                )));
-                continue;
-            }
-            if (!submenuInfo.label) {
-                collector.warn(( localize(
-                    'submenuId.invalid.label',
-                    "`{0}` is not a valid submenu label",
-                    submenuInfo.label
-                )));
-                continue;
-            }
-            let absoluteIcon;
-            if (submenuInfo.icon) {
-                if (typeof submenuInfo.icon === 'string') {
-                    absoluteIcon = ThemeIcon.fromString(submenuInfo.icon) || { dark: resources.joinPath(extension.description.extensionLocation, submenuInfo.icon) };
-                }
-                else {
-                    absoluteIcon = {
-                        dark: resources.joinPath(extension.description.extensionLocation, submenuInfo.icon.dark),
-                        light: resources.joinPath(extension.description.extensionLocation, submenuInfo.icon.light)
-                    };
-                }
-            }
-            const item = {
-                id: MenuId.for(`api:${submenuInfo.id}`),
-                label: submenuInfo.label,
-                icon: absoluteIcon
-            };
-            _submenus.set(submenuInfo.id, item);
-        }
-    }
-});
-const _apiMenusByKey = ( new Map(( apiMenus.map(menu => ([menu.key, menu])))));
-const _menuRegistrations = ( new DisposableStore());
-const _submenuMenuItems = ( new Map());
-const menusExtensionPoint = ( ExtensionsRegistry.registerExtensionPoint({
-    extensionPoint: 'menus',
-    jsonSchema: schema.menusContribution,
-    deps: [submenusExtensionPoint]
-}));
-menusExtensionPoint.setHandler(extensions => {
-    _menuRegistrations.clear();
-    _submenuMenuItems.clear();
-    for (const extension of extensions) {
-        const { value, collector } = extension;
-        for (const entry of Object.entries(value)) {
-            if (!schema.isValidItems(entry[1], collector)) {
-                continue;
-            }
-            let menu = _apiMenusByKey.get(entry[0]);
-            if (!menu) {
-                const submenu = _submenus.get(entry[0]);
-                if (submenu) {
-                    menu = {
-                        key: entry[0],
-                        id: submenu.id,
-                        description: ''
-                    };
-                }
-            }
-            if (!menu) {
-                continue;
-            }
-            if (menu.proposed && !isProposedApiEnabled(extension.description, menu.proposed)) {
-                collector.error(( localize(
-                    'proposedAPI.invalid',
-                    "{0} is a proposed menu identifier. It requires 'package.json#enabledApiProposals: [\"{1}\"]' and is only available when running out of dev or with the following command line switch: --enable-proposed-api {2}",
-                    entry[0],
-                    menu.proposed,
-                    extension.description.identifier.value
-                )));
-                continue;
-            }
-            for (const menuItem of entry[1]) {
-                let item;
-                if (schema.isMenuItem(menuItem)) {
-                    const command = MenuRegistry.getCommand(menuItem.command);
-                    const alt = menuItem.alt && MenuRegistry.getCommand(menuItem.alt) || undefined;
-                    if (!command) {
-                        collector.error(( localize(
-                            'missing.command',
-                            "Menu item references a command `{0}` which is not defined in the 'commands' section.",
-                            menuItem.command
-                        )));
-                        continue;
-                    }
-                    if (menuItem.alt && !alt) {
-                        collector.warn(( localize(
-                            'missing.altCommand',
-                            "Menu item references an alt-command `{0}` which is not defined in the 'commands' section.",
-                            menuItem.alt
-                        )));
-                    }
-                    if (menuItem.command === menuItem.alt) {
-                        collector.info(( localize(
-                            'dupe.command',
-                            "Menu item references the same command as default and alt-command"
-                        )));
-                    }
-                    item = { command, alt, group: undefined, order: undefined, when: undefined };
-                }
-                else {
-                    if (menu.supportsSubmenus === false) {
-                        collector.error(( localize(
-                            'unsupported.submenureference',
-                            "Menu item references a submenu for a menu which doesn't have submenu support."
-                        )));
-                        continue;
-                    }
-                    const submenu = _submenus.get(menuItem.submenu);
-                    if (!submenu) {
-                        collector.error(( localize(
-                            'missing.submenu',
-                            "Menu item references a submenu `{0}` which is not defined in the 'submenus' section.",
-                            menuItem.submenu
-                        )));
-                        continue;
-                    }
-                    let submenuRegistrations = _submenuMenuItems.get(menu.id.id);
-                    if (!submenuRegistrations) {
-                        submenuRegistrations = ( new Set());
-                        _submenuMenuItems.set(menu.id.id, submenuRegistrations);
-                    }
-                    if (( submenuRegistrations.has(submenu.id.id))) {
-                        collector.warn(( localize(
-                            'submenuItem.duplicate',
-                            "The `{0}` submenu was already contributed to the `{1}` menu.",
-                            menuItem.submenu,
-                            entry[0]
-                        )));
-                        continue;
-                    }
-                    submenuRegistrations.add(submenu.id.id);
-                    item = { submenu: submenu.id, icon: submenu.icon, title: submenu.label, group: undefined, order: undefined, when: undefined };
-                }
-                if (menuItem.group) {
-                    const idx = menuItem.group.lastIndexOf('@');
-                    if (idx > 0) {
-                        item.group = menuItem.group.substr(0, idx);
-                        item.order = Number(menuItem.group.substr(idx + 1)) || undefined;
-                    }
-                    else {
-                        item.group = menuItem.group;
-                    }
-                }
-                item.when = ContextKeyExpr.deserialize(menuItem.when);
-                _menuRegistrations.add(MenuRegistry.appendMenuItem(menu.id, item));
-            }
-        }
-    }
-});
 export { commandsExtensionPoint };

package/dist/vscode/vs/workbench/services/activity/common/activity.js

@@ -19,18 +19,4 @@ class NumberBadge extends BaseBadge {
         return this.descriptorFn(this.number);
     }
 }
-class TextBadge extends BaseBadge {
-    constructor(text, descriptorFn) {
-        super(descriptorFn);
-        this.text = text;
-    }
-}
-class IconBadge extends BaseBadge {
-    constructor(icon, descriptorFn) {
-        super(descriptorFn);
-        this.icon = icon;
-    }
-}
-class ProgressBadge extends BaseBadge {
-}
-export { IActivityService, IconBadge, NumberBadge, ProgressBadge, TextBadge };
+export { IActivityService, NumberBadge };

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

@@ -1,4 +1,4 @@
-import * as path from 'monaco-editor/esm/vs/base/common/path.js';
+import * as paths from 'monaco-editor/esm/vs/base/common/path.js';
 import * as process from 'monaco-editor/esm/vs/base/common/process.js';
 import * as types from 'monaco-editor/esm/vs/base/common/types.js';
 import * as objects from 'monaco-editor/esm/vs/base/common/objects.js';
@@ -141,7 +141,7 @@ class AbstractVariableResolverService {
                     return normalizeDriveLetter(folderPath);
                 }
             }
-            throw new VariableError(variableKind, localize('canNotResolveFolderForFile', "Variable {0}: can not find workspace folder of '{1}'.", match, path.basename(filePath)));
+            throw new VariableError(variableKind, localize('canNotResolveFolderForFile', "Variable {0}: can not find workspace folder of '{1}'.", match, paths.basename(filePath)));
         };
         const getFolderUri = (variableKind) => {
             if (argument) {
@@ -205,7 +205,7 @@ class AbstractVariableResolverService {
                         return ((folderUri || argument) ? normalizeDriveLetter(this.fsPath(getFolderUri(VariableKind.Cwd))) : process.cwd());
                     case 'workspaceRootFolderName':
                     case 'workspaceFolderBasename':
-                        return normalizeDriveLetter(path.basename(this.fsPath(getFolderUri(VariableKind.WorkspaceFolderBasename))));
+                        return normalizeDriveLetter(paths.basename(this.fsPath(getFolderUri(VariableKind.WorkspaceFolderBasename))));
                     case 'userHome': {
                         if (environment.userHome) {
                             return environment.userHome;
@@ -232,29 +232,29 @@ class AbstractVariableResolverService {
                         return getFolderPathForFile(VariableKind.FileWorkspaceFolder);
                     case 'relativeFile':
                         if (folderUri || argument) {
-                            return path.relative(this.fsPath(getFolderUri(VariableKind.RelativeFile)), getFilePath(VariableKind.RelativeFile));
+                            return paths.relative(this.fsPath(getFolderUri(VariableKind.RelativeFile)), getFilePath(VariableKind.RelativeFile));
                         }
                         return getFilePath(VariableKind.RelativeFile);
                     case 'relativeFileDirname': {
-                        const dirname = path.dirname(getFilePath(VariableKind.RelativeFileDirname));
+                        const dirname = paths.dirname(getFilePath(VariableKind.RelativeFileDirname));
                         if (folderUri || argument) {
-                            const relative = path.relative(this.fsPath(getFolderUri(VariableKind.RelativeFileDirname)), dirname);
+                            const relative = paths.relative(this.fsPath(getFolderUri(VariableKind.RelativeFileDirname)), dirname);
                             return relative.length === 0 ? '.' : relative;
                         }
                         return dirname;
                     }
                     case 'fileDirname':
-                        return path.dirname(getFilePath(VariableKind.FileDirname));
+                        return paths.dirname(getFilePath(VariableKind.FileDirname));
                     case 'fileExtname':
-                        return path.extname(getFilePath(VariableKind.FileExtname));
+                        return paths.extname(getFilePath(VariableKind.FileExtname));
                     case 'fileBasename':
-                        return path.basename(getFilePath(VariableKind.FileBasename));
+                        return paths.basename(getFilePath(VariableKind.FileBasename));
                     case 'fileBasenameNoExtension': {
-                        const basename = path.basename(getFilePath(VariableKind.FileBasenameNoExtension));
-                        return (basename.slice(0, basename.length - path.extname(basename).length));
+                        const basename = paths.basename(getFilePath(VariableKind.FileBasenameNoExtension));
+                        return (basename.slice(0, basename.length - paths.extname(basename).length));
                     }
                     case 'fileDirnameBasename':
-                        return path.basename(path.dirname(getFilePath(VariableKind.FileDirnameBasename)));
+                        return paths.basename(paths.dirname(getFilePath(VariableKind.FileDirnameBasename)));
                     case 'execPath': {
                         const ep = this._context.getExecPath();
                         if (ep) {
@@ -270,7 +270,7 @@ class AbstractVariableResolverService {
                         return match;
                     }
                     case 'pathSeparator':
-                        return path.sep;
+                        return paths.sep;
                     default:
                         try {
                             const key = argument ? `${variable}:${argument}` : variable;

package/dist/vscode/vs/workbench/services/extensions/common/extensionDescriptionRegistry.js

@@ -1,6 +1,6 @@
 import { ExtensionIdentifierMap, ExtensionIdentifier, ExtensionIdentifierSet } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import * as path from 'monaco-editor/esm/vs/base/common/path.js';
+import * as paths from 'monaco-editor/esm/vs/base/common/path.js';
 class DeltaExtensionsResult {
     constructor(removedDueToLooping) {
         this.removedDueToLooping = removedDueToLooping;
@@ -172,8 +172,8 @@ function extensionCmp(a, b) {
     if (aSortBucket !== bSortBucket) {
         return aSortBucket - bSortBucket;
     }
-    const aLastSegment = path.posix.basename(a.extensionLocation.path);
-    const bLastSegment = path.posix.basename(b.extensionLocation.path);
+    const aLastSegment = paths.posix.basename(a.extensionLocation.path);
+    const bLastSegment = paths.posix.basename(b.extensionLocation.path);
     if (aLastSegment < bLastSegment) {
         return -1;
     }

package/dist/vscode/vs/workbench/services/layout/browser/layoutService.js

@@ -1,12 +1,4 @@
 import { refineServiceDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
 const IWorkbenchLayoutService = refineServiceDecorator(ILayoutService);
-function positionToString(position) {
-    switch (position) {
-        case 0 : return 'left';
-        case 1 : return 'right';
-        case 2 : return 'bottom';
-        default: return 'bottom';
-    }
-}
-export { IWorkbenchLayoutService, positionToString };
+export { IWorkbenchLayoutService };