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

package/dist/vscode/vs/workbench/services/keybinding/common/windowsKeyboardMapper.js

@@ -0,0 +1,350 @@
+import { KeyCodeUtils, ScanCodeUtils, IMMUTABLE_CODE_TO_KEY_CODE, NATIVE_WINDOWS_KEY_CODE_TO_KEY_CODE } from 'monaco-editor/esm/vs/base/common/keyCodes.js';
+import { KeyCodeChord, ScanCodeChord } from 'monaco-editor/esm/vs/base/common/keybindings.js';
+import { UILabelProvider } from 'monaco-editor/esm/vs/base/common/keybindingLabels.js';
+import { BaseResolvedKeybinding } from 'monaco-editor/esm/vs/platform/keybinding/common/baseResolvedKeybinding.js';
+import { toEmptyArrayIfContainsNull } from 'monaco-editor/esm/vs/platform/keybinding/common/resolvedKeybindingItem.js';
+class WindowsNativeResolvedKeybinding extends BaseResolvedKeybinding {
+    constructor(mapper, chords) {
+        super(1 , chords);
+        this._mapper = mapper;
+    }
+    _getLabel(chord) {
+        if (chord.isDuplicateModifierCase()) {
+            return '';
+        }
+        return this._mapper.getUILabelForKeyCode(chord.keyCode);
+    }
+    _getUSLabelForKeybinding(chord) {
+        if (chord.isDuplicateModifierCase()) {
+            return '';
+        }
+        return ( KeyCodeUtils.toString(chord.keyCode));
+    }
+    getUSLabel() {
+        return UILabelProvider.toLabel(this._os, this._chords, (keybinding) => this._getUSLabelForKeybinding(keybinding));
+    }
+    _getAriaLabel(chord) {
+        if (chord.isDuplicateModifierCase()) {
+            return '';
+        }
+        return this._mapper.getAriaLabelForKeyCode(chord.keyCode);
+    }
+    _getElectronAccelerator(chord) {
+        return this._mapper.getElectronAcceleratorForKeyBinding(chord);
+    }
+    _getUserSettingsLabel(chord) {
+        if (chord.isDuplicateModifierCase()) {
+            return '';
+        }
+        const result = this._mapper.getUserSettingsLabelForKeyCode(chord.keyCode);
+        return (result ? result.toLowerCase() : result);
+    }
+    _isWYSIWYG(chord) {
+        return this.__isWYSIWYG(chord.keyCode);
+    }
+    __isWYSIWYG(keyCode) {
+        if (keyCode === 15
+            || keyCode === 16
+            || keyCode === 17
+            || keyCode === 18 ) {
+            return true;
+        }
+        const ariaLabel = this._mapper.getAriaLabelForKeyCode(keyCode);
+        const userSettingsLabel = this._mapper.getUserSettingsLabelForKeyCode(keyCode);
+        return (ariaLabel === userSettingsLabel);
+    }
+    _getChordDispatch(chord) {
+        if (chord.isModifierKey()) {
+            return null;
+        }
+        let result = '';
+        if (chord.ctrlKey) {
+            result += 'ctrl+';
+        }
+        if (chord.shiftKey) {
+            result += 'shift+';
+        }
+        if (chord.altKey) {
+            result += 'alt+';
+        }
+        if (chord.metaKey) {
+            result += 'meta+';
+        }
+        result += ( KeyCodeUtils.toString(chord.keyCode));
+        return result;
+    }
+    _getSingleModifierChordDispatch(chord) {
+        if (chord.keyCode === 5  && !chord.shiftKey && !chord.altKey && !chord.metaKey) {
+            return 'ctrl';
+        }
+        if (chord.keyCode === 4  && !chord.ctrlKey && !chord.altKey && !chord.metaKey) {
+            return 'shift';
+        }
+        if (chord.keyCode === 6  && !chord.ctrlKey && !chord.shiftKey && !chord.metaKey) {
+            return 'alt';
+        }
+        if (chord.keyCode === 57  && !chord.ctrlKey && !chord.shiftKey && !chord.altKey) {
+            return 'meta';
+        }
+        return null;
+    }
+    static getProducedCharCode(chord, mapping) {
+        if (!mapping) {
+            return null;
+        }
+        if (chord.ctrlKey && chord.shiftKey && chord.altKey) {
+            return mapping.withShiftAltGr;
+        }
+        if (chord.ctrlKey && chord.altKey) {
+            return mapping.withAltGr;
+        }
+        if (chord.shiftKey) {
+            return mapping.withShift;
+        }
+        return mapping.value;
+    }
+    static getProducedChar(chord, mapping) {
+        const char = this.getProducedCharCode(chord, mapping);
+        if (char === null || char.length === 0) {
+            return ' --- ';
+        }
+        return '  ' + char + '  ';
+    }
+}
+class WindowsKeyboardMapper {
+    constructor(_isUSStandard, rawMappings, _mapAltGrToCtrlAlt) {
+        this._isUSStandard = _isUSStandard;
+        this._mapAltGrToCtrlAlt = _mapAltGrToCtrlAlt;
+        this._keyCodeToLabel = [];
+        this._scanCodeToKeyCode = [];
+        this._keyCodeToLabel = [];
+        this._keyCodeExists = [];
+        this._keyCodeToLabel[0 ] = ( KeyCodeUtils.toString(0 ));
+        for (let scanCode = 0 ; scanCode < 193 ; scanCode++) {
+            const immutableKeyCode = IMMUTABLE_CODE_TO_KEY_CODE[scanCode];
+            if (immutableKeyCode !== -1 ) {
+                this._scanCodeToKeyCode[scanCode] = immutableKeyCode;
+                this._keyCodeToLabel[immutableKeyCode] = ( KeyCodeUtils.toString(immutableKeyCode));
+                this._keyCodeExists[immutableKeyCode] = true;
+            }
+        }
+        const producesLetter = [];
+        let producesLetters = false;
+        this._codeInfo = [];
+        for (const strCode in rawMappings) {
+            if (rawMappings.hasOwnProperty(strCode)) {
+                const scanCode = ScanCodeUtils.toEnum(strCode);
+                if (scanCode === 0 ) {
+                    continue;
+                }
+                const rawMapping = rawMappings[strCode];
+                const immutableKeyCode = IMMUTABLE_CODE_TO_KEY_CODE[scanCode];
+                if (immutableKeyCode !== -1 ) {
+                    const keyCode = NATIVE_WINDOWS_KEY_CODE_TO_KEY_CODE[rawMapping.vkey] || 0 ;
+                    if (keyCode === 0  || immutableKeyCode === keyCode) {
+                        continue;
+                    }
+                    if (scanCode !== 134 ) {
+                        continue;
+                    }
+                }
+                const value = rawMapping.value;
+                const withShift = rawMapping.withShift;
+                const withAltGr = rawMapping.withAltGr;
+                const withShiftAltGr = rawMapping.withShiftAltGr;
+                const keyCode = NATIVE_WINDOWS_KEY_CODE_TO_KEY_CODE[rawMapping.vkey] || 0 ;
+                const mapping = {
+                    scanCode: scanCode,
+                    keyCode: keyCode,
+                    value: value,
+                    withShift: withShift,
+                    withAltGr: withAltGr,
+                    withShiftAltGr: withShiftAltGr,
+                };
+                this._codeInfo[scanCode] = mapping;
+                this._scanCodeToKeyCode[scanCode] = keyCode;
+                if (keyCode === 0 ) {
+                    continue;
+                }
+                this._keyCodeExists[keyCode] = true;
+                if (value.length === 0) {
+                    this._keyCodeToLabel[keyCode] = null;
+                }
+                else if (value.length > 1) {
+                    this._keyCodeToLabel[keyCode] = value;
+                }
+                else {
+                    const charCode = value.charCodeAt(0);
+                    if (charCode >= 97  && charCode <= 122 ) {
+                        const upperCaseValue = 65  + ((charCode - 97) );
+                        producesLetter[upperCaseValue] = true;
+                        producesLetters = true;
+                        this._keyCodeToLabel[keyCode] = String.fromCharCode(65  + ((charCode - 97) ));
+                    }
+                    else if (charCode >= 65  && charCode <= 90 ) {
+                        producesLetter[charCode] = true;
+                        producesLetters = true;
+                        this._keyCodeToLabel[keyCode] = value;
+                    }
+                    else {
+                        this._keyCodeToLabel[keyCode] = value;
+                    }
+                }
+            }
+        }
+        const _registerLetterIfMissing = (charCode, keyCode) => {
+            if (!producesLetter[charCode]) {
+                this._keyCodeToLabel[keyCode] = String.fromCharCode(charCode);
+            }
+        };
+        _registerLetterIfMissing(65 , 31 );
+        _registerLetterIfMissing(66 , 32 );
+        _registerLetterIfMissing(67 , 33 );
+        _registerLetterIfMissing(68 , 34 );
+        _registerLetterIfMissing(69 , 35 );
+        _registerLetterIfMissing(70 , 36 );
+        _registerLetterIfMissing(71 , 37 );
+        _registerLetterIfMissing(72 , 38 );
+        _registerLetterIfMissing(73 , 39 );
+        _registerLetterIfMissing(74 , 40 );
+        _registerLetterIfMissing(75 , 41 );
+        _registerLetterIfMissing(76 , 42 );
+        _registerLetterIfMissing(77 , 43 );
+        _registerLetterIfMissing(78 , 44 );
+        _registerLetterIfMissing(79 , 45 );
+        _registerLetterIfMissing(80 , 46 );
+        _registerLetterIfMissing(81 , 47 );
+        _registerLetterIfMissing(82 , 48 );
+        _registerLetterIfMissing(83 , 49 );
+        _registerLetterIfMissing(84 , 50 );
+        _registerLetterIfMissing(85 , 51 );
+        _registerLetterIfMissing(86 , 52 );
+        _registerLetterIfMissing(87 , 53 );
+        _registerLetterIfMissing(88 , 54 );
+        _registerLetterIfMissing(89 , 55 );
+        _registerLetterIfMissing(90 , 56 );
+        if (!producesLetters) {
+            const _registerLabel = (keyCode, charCode) => {
+                this._keyCodeToLabel[keyCode] = String.fromCharCode(charCode);
+            };
+            _registerLabel(80 , 59 );
+            _registerLabel(81 , 61 );
+            _registerLabel(82 , 44 );
+            _registerLabel(83 , 45 );
+            _registerLabel(84 , 46 );
+            _registerLabel(85 , 47 );
+            _registerLabel(86 , 96 );
+            _registerLabel(87 , 91 );
+            _registerLabel(88 , 92 );
+            _registerLabel(89 , 93 );
+            _registerLabel(90 , 39 );
+        }
+    }
+    dumpDebugInfo() {
+        const result = [];
+        const immutableSamples = [
+            88 ,
+            104
+        ];
+        let cnt = 0;
+        result.push(`-----------------------------------------------------------------------------------------------------------------------------------------`);
+        for (let scanCode = 0 ; scanCode < 193 ; scanCode++) {
+            if (IMMUTABLE_CODE_TO_KEY_CODE[scanCode] !== -1 ) {
+                if (immutableSamples.indexOf(scanCode) === -1) {
+                    continue;
+                }
+            }
+            if (cnt % 6 === 0) {
+                result.push(`|       HW Code combination      |  Key  |    KeyCode combination    |          UI label         |        User settings       | WYSIWYG |`);
+                result.push(`-----------------------------------------------------------------------------------------------------------------------------------------`);
+            }
+            cnt++;
+            const mapping = this._codeInfo[scanCode];
+            const strCode = ( ScanCodeUtils.toString(scanCode));
+            const mods = [0b000, 0b010, 0b101, 0b111];
+            for (const mod of mods) {
+                const ctrlKey = (mod & 0b001) ? true : false;
+                const shiftKey = (mod & 0b010) ? true : false;
+                const altKey = (mod & 0b100) ? true : false;
+                const scanCodeChord = ( new ScanCodeChord(ctrlKey, shiftKey, altKey, false, scanCode));
+                const keyCodeChord = this._resolveChord(scanCodeChord);
+                const strKeyCode = (keyCodeChord ? ( KeyCodeUtils.toString(keyCodeChord.keyCode)) : null);
+                const resolvedKb = (keyCodeChord ? ( new WindowsNativeResolvedKeybinding(this, [keyCodeChord])) : null);
+                const outScanCode = `${ctrlKey ? 'Ctrl+' : ''}${shiftKey ? 'Shift+' : ''}${altKey ? 'Alt+' : ''}${strCode}`;
+                const ariaLabel = (resolvedKb ? resolvedKb.getAriaLabel() : null);
+                const outUILabel = (ariaLabel ? ariaLabel.replace(/Control\+/, 'Ctrl+') : null);
+                const outUserSettings = (resolvedKb ? resolvedKb.getUserSettingsLabel() : null);
+                const outKey = WindowsNativeResolvedKeybinding.getProducedChar(scanCodeChord, mapping);
+                const outKb = (strKeyCode ? `${ctrlKey ? 'Ctrl+' : ''}${shiftKey ? 'Shift+' : ''}${altKey ? 'Alt+' : ''}${strKeyCode}` : null);
+                const isWYSIWYG = (resolvedKb ? resolvedKb.isWYSIWYG() : false);
+                const outWYSIWYG = (isWYSIWYG ? '       ' : '   NO  ');
+                result.push(`| ${this._leftPad(outScanCode, 30)} | ${outKey} | ${this._leftPad(outKb, 25)} | ${this._leftPad(outUILabel, 25)} |  ${this._leftPad(outUserSettings, 25)} | ${outWYSIWYG} |`);
+            }
+            result.push(`-----------------------------------------------------------------------------------------------------------------------------------------`);
+        }
+        return result.join('\n');
+    }
+    _leftPad(str, cnt) {
+        if (str === null) {
+            str = 'null';
+        }
+        while (str.length < cnt) {
+            str = ' ' + str;
+        }
+        return str;
+    }
+    getUILabelForKeyCode(keyCode) {
+        return this._getLabelForKeyCode(keyCode);
+    }
+    getAriaLabelForKeyCode(keyCode) {
+        return this._getLabelForKeyCode(keyCode);
+    }
+    getUserSettingsLabelForKeyCode(keyCode) {
+        if (this._isUSStandard) {
+            return KeyCodeUtils.toUserSettingsUS(keyCode);
+        }
+        return KeyCodeUtils.toUserSettingsGeneral(keyCode);
+    }
+    getElectronAcceleratorForKeyBinding(chord) {
+        return KeyCodeUtils.toElectronAccelerator(chord.keyCode);
+    }
+    _getLabelForKeyCode(keyCode) {
+        return this._keyCodeToLabel[keyCode] || ( KeyCodeUtils.toString(0 ));
+    }
+    resolveKeyboardEvent(keyboardEvent) {
+        const ctrlKey = keyboardEvent.ctrlKey || (this._mapAltGrToCtrlAlt && keyboardEvent.altGraphKey);
+        const altKey = keyboardEvent.altKey || (this._mapAltGrToCtrlAlt && keyboardEvent.altGraphKey);
+        const chord = ( new KeyCodeChord(
+            ctrlKey,
+            keyboardEvent.shiftKey,
+            altKey,
+            keyboardEvent.metaKey,
+            keyboardEvent.keyCode
+        ));
+        return ( new WindowsNativeResolvedKeybinding(this, [chord]));
+    }
+    _resolveChord(chord) {
+        if (!chord) {
+            return null;
+        }
+        if (chord instanceof KeyCodeChord) {
+            if (!this._keyCodeExists[chord.keyCode]) {
+                return null;
+            }
+            return chord;
+        }
+        const keyCode = this._scanCodeToKeyCode[chord.scanCode] || 0 ;
+        if (keyCode === 0  || !this._keyCodeExists[keyCode]) {
+            return null;
+        }
+        return ( new KeyCodeChord(chord.ctrlKey, chord.shiftKey, chord.altKey, chord.metaKey, keyCode));
+    }
+    resolveKeybinding(keybinding) {
+        const chords = toEmptyArrayIfContainsNull(( keybinding.chords.map(chord => this._resolveChord(chord))));
+        if (chords.length > 0) {
+            return [( new WindowsNativeResolvedKeybinding(this, chords))];
+        }
+        return [];
+    }
+}
+export { WindowsKeyboardMapper, WindowsNativeResolvedKeybinding };

package/dist/vscode/vs/workbench/services/label/common/labelService.js

@@ -0,0 +1,302 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { posix, win32 } from 'monaco-editor/esm/vs/base/common/path.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.js';
+import { isWorkspace, toWorkspaceIdentifier, isSingleFolderWorkspaceIdentifier, isWorkspaceIdentifier, isUntitledWorkspace, isTemporaryWorkspace, WORKSPACE_EXTENSION, IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { basenameOrAuthority, basename, joinPath, dirname } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { getPathLabel, tildify } from 'monaco-editor/esm/vs/base/common/labels.js';
+import { match } from 'monaco-editor/esm/vs/base/common/glob.js';
+import { ILifecycleService } from '../../lifecycle/common/lifecycle.js';
+import { IPathService } from '../../path/common/pathService.js';
+import { OS } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { IRemoteAgentService } from '../../remote/common/remoteAgentService.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { Memento } from '../../../common/memento.js';
+import { firstOrDefault } from 'monaco-editor/esm/vs/base/common/arrays.js';
+const sepRegexp = /\//g;
+const labelMatchingRegexp = /\$\{(scheme|authoritySuffix|authority|path|(query)\.(.+?))\}/g;
+function hasDriveLetterIgnorePlatform(path) {
+    return !!(path && path[2] === ':');
+}
+const FORMATTER_CACHE_SIZE = 50;
+let LabelService = class LabelService extends Disposable {
+    constructor(environmentService, contextService, pathService, remoteAgentService, storageService, lifecycleService) {
+        super();
+        this.environmentService = environmentService;
+        this.contextService = contextService;
+        this.pathService = pathService;
+        this.remoteAgentService = remoteAgentService;
+        this._onDidChangeFormatters = this._register(( new Emitter({ leakWarningThreshold: 400 })));
+        this.onDidChangeFormatters = this._onDidChangeFormatters.event;
+        this.os = OS;
+        this.userHome = pathService.defaultUriScheme === Schemas.file ? this.pathService.userHome({ preferLocal: true }) : undefined;
+        const memento = this.storedFormattersMemento = ( new Memento('cachedResourceLabelFormatters2', storageService));
+        this.storedFormatters = memento.getMemento(0 , 1 );
+        this.formatters = this.storedFormatters?.formatters?.slice() || [];
+        this.resolveRemoteEnvironment();
+    }
+    async resolveRemoteEnvironment() {
+        const env = await this.remoteAgentService.getEnvironment();
+        this.os = env?.os ?? OS;
+        this.userHome = await this.pathService.userHome();
+    }
+    findFormatting(resource) {
+        let bestResult;
+        for (const formatter of this.formatters) {
+            if (formatter.scheme === resource.scheme) {
+                if (!formatter.authority && (!bestResult || formatter.priority)) {
+                    bestResult = formatter;
+                    continue;
+                }
+                if (!formatter.authority) {
+                    continue;
+                }
+                if (match(formatter.authority.toLowerCase(), resource.authority.toLowerCase()) &&
+                    (!bestResult ||
+                        !bestResult.authority ||
+                        formatter.authority.length > bestResult.authority.length ||
+                        ((formatter.authority.length === bestResult.authority.length) && formatter.priority))) {
+                    bestResult = formatter;
+                }
+            }
+        }
+        return bestResult ? bestResult.formatting : undefined;
+    }
+    getUriLabel(resource, options = {}) {
+        let formatting = this.findFormatting(resource);
+        if (formatting && options.separator) {
+            formatting = { ...formatting, separator: options.separator };
+        }
+        const label = this.doGetUriLabel(resource, formatting, options);
+        if (!formatting && options.separator) {
+            return label.replace(sepRegexp, options.separator);
+        }
+        return label;
+    }
+    doGetUriLabel(resource, formatting, options = {}) {
+        if (!formatting) {
+            return getPathLabel(resource, {
+                os: this.os,
+                tildify: this.userHome ? { userHome: this.userHome } : undefined,
+                relative: options.relative ? {
+                    noPrefix: options.noPrefix,
+                    getWorkspace: () => this.contextService.getWorkspace(),
+                    getWorkspaceFolder: resource => this.contextService.getWorkspaceFolder(resource)
+                } : undefined
+            });
+        }
+        if (options.relative && this.contextService) {
+            let folder = this.contextService.getWorkspaceFolder(resource);
+            if (!folder) {
+                const workspace = this.contextService.getWorkspace();
+                const firstFolder = firstOrDefault(workspace.folders);
+                if (firstFolder && resource.scheme !== firstFolder.uri.scheme && resource.path.startsWith(posix.sep)) {
+                    folder = this.contextService.getWorkspaceFolder(firstFolder.uri.with({ path: resource.path }));
+                }
+            }
+            if (folder) {
+                const folderLabel = this.formatUri(folder.uri, formatting, options.noPrefix);
+                let relativeLabel = this.formatUri(resource, formatting, options.noPrefix);
+                let overlap = 0;
+                while (relativeLabel[overlap] && relativeLabel[overlap] === folderLabel[overlap]) {
+                    overlap++;
+                }
+                if (!relativeLabel[overlap] || relativeLabel[overlap] === formatting.separator) {
+                    relativeLabel = relativeLabel.substring(1 + overlap);
+                }
+                else if (overlap === folderLabel.length && folder.uri.path === posix.sep) {
+                    relativeLabel = relativeLabel.substring(overlap);
+                }
+                const hasMultipleRoots = this.contextService.getWorkspace().folders.length > 1;
+                if (hasMultipleRoots && !options.noPrefix) {
+                    const rootName = folder?.name ?? basenameOrAuthority(folder.uri);
+                    relativeLabel = relativeLabel ? `${rootName} • ${relativeLabel}` : rootName;
+                }
+                return relativeLabel;
+            }
+        }
+        return this.formatUri(resource, formatting, options.noPrefix);
+    }
+    getUriBasenameLabel(resource) {
+        const formatting = this.findFormatting(resource);
+        const label = this.doGetUriLabel(resource, formatting);
+        let pathLib;
+        if (formatting?.separator === win32.sep) {
+            pathLib = win32;
+        }
+        else if (formatting?.separator === posix.sep) {
+            pathLib = posix;
+        }
+        else {
+            pathLib = ((this.os === 1) ) ? win32 : posix;
+        }
+        return pathLib.basename(label);
+    }
+    getWorkspaceLabel(workspace, options) {
+        if (isWorkspace(workspace)) {
+            const identifier = toWorkspaceIdentifier(workspace);
+            if (isSingleFolderWorkspaceIdentifier(identifier) || isWorkspaceIdentifier(identifier)) {
+                return this.getWorkspaceLabel(identifier, options);
+            }
+            return '';
+        }
+        if (URI.isUri(workspace)) {
+            return this.doGetSingleFolderWorkspaceLabel(workspace, options);
+        }
+        if (isSingleFolderWorkspaceIdentifier(workspace)) {
+            return this.doGetSingleFolderWorkspaceLabel(workspace.uri, options);
+        }
+        if (isWorkspaceIdentifier(workspace)) {
+            return this.doGetWorkspaceLabel(workspace.configPath, options);
+        }
+        return '';
+    }
+    doGetWorkspaceLabel(workspaceUri, options) {
+        if (isUntitledWorkspace(workspaceUri, this.environmentService)) {
+            return ( localize('untitledWorkspace', "Untitled (Workspace)"));
+        }
+        if (isTemporaryWorkspace(workspaceUri)) {
+            return ( localize('temporaryWorkspace', "Workspace"));
+        }
+        let filename = basename(workspaceUri);
+        if (filename.endsWith(WORKSPACE_EXTENSION)) {
+            filename = filename.substr(0, filename.length - WORKSPACE_EXTENSION.length - 1);
+        }
+        let label;
+        switch (options?.verbose) {
+            case 0 :
+                label = filename;
+                break;
+            case 2 :
+                label = ( localize(
+                    'workspaceNameVerbose',
+                    "{0} (Workspace)",
+                    this.getUriLabel(joinPath(dirname(workspaceUri), filename))
+                ));
+                break;
+            case 1 :
+            default:
+                label = ( localize('workspaceName', "{0} (Workspace)", filename));
+                break;
+        }
+        if (options?.verbose === 0 ) {
+            return label;
+        }
+        return this.appendWorkspaceSuffix(label, workspaceUri);
+    }
+    doGetSingleFolderWorkspaceLabel(folderUri, options) {
+        let label;
+        switch (options?.verbose) {
+            case 2 :
+                label = this.getUriLabel(folderUri);
+                break;
+            case 0 :
+            case 1 :
+            default:
+                label = basename(folderUri) || posix.sep;
+                break;
+        }
+        if (options?.verbose === 0 ) {
+            return label;
+        }
+        return this.appendWorkspaceSuffix(label, folderUri);
+    }
+    getSeparator(scheme, authority) {
+        const formatter = this.findFormatting(( URI.from({ scheme, authority })));
+        return formatter?.separator || posix.sep;
+    }
+    getHostLabel(scheme, authority) {
+        const formatter = this.findFormatting(( URI.from({ scheme, authority })));
+        return formatter?.workspaceSuffix || authority || '';
+    }
+    getHostTooltip(scheme, authority) {
+        const formatter = this.findFormatting(( URI.from({ scheme, authority })));
+        return formatter?.workspaceTooltip;
+    }
+    registerCachedFormatter(formatter) {
+        const list = this.storedFormatters.formatters ??= [];
+        let replace = list.findIndex(f => f.scheme === formatter.scheme && f.authority === formatter.authority);
+        if (replace === -1 && list.length >= FORMATTER_CACHE_SIZE) {
+            replace = FORMATTER_CACHE_SIZE - 1;
+        }
+        if (replace === -1) {
+            list.unshift(formatter);
+        }
+        else {
+            for (let i = replace; i > 0; i--) {
+                list[i] = list[i - 1];
+            }
+            list[0] = formatter;
+        }
+        this.storedFormattersMemento.saveMemento();
+        return this.registerFormatter(formatter);
+    }
+    registerFormatter(formatter) {
+        this.formatters.push(formatter);
+        this._onDidChangeFormatters.fire({ scheme: formatter.scheme });
+        return {
+            dispose: () => {
+                this.formatters = this.formatters.filter(f => f !== formatter);
+                this._onDidChangeFormatters.fire({ scheme: formatter.scheme });
+            }
+        };
+    }
+    formatUri(resource, formatting, forceNoTildify) {
+        let label = formatting.label.replace(labelMatchingRegexp, (match, token, qsToken, qsValue) => {
+            switch (token) {
+                case 'scheme': return resource.scheme;
+                case 'authority': return resource.authority;
+                case 'authoritySuffix': {
+                    const i = resource.authority.indexOf('+');
+                    return i === -1 ? resource.authority : resource.authority.slice(i + 1);
+                }
+                case 'path':
+                    return formatting.stripPathStartingSeparator
+                        ? resource.path.slice(resource.path[0] === formatting.separator ? 1 : 0)
+                        : resource.path;
+                default: {
+                    if (qsToken === 'query') {
+                        const { query } = resource;
+                        if (query && query[0] === '{' && query[query.length - 1] === '}') {
+                            try {
+                                return JSON.parse(query)[qsValue] || '';
+                            }
+                            catch { }
+                        }
+                    }
+                    return '';
+                }
+            }
+        });
+        if (formatting.normalizeDriveLetter && hasDriveLetterIgnorePlatform(label)) {
+            label = label.charAt(1).toUpperCase() + label.substr(2);
+        }
+        if (formatting.tildify && !forceNoTildify) {
+            if (this.userHome) {
+                label = tildify(label, this.userHome.fsPath, this.os);
+            }
+        }
+        if (formatting.authorityPrefix && resource.authority) {
+            label = formatting.authorityPrefix + label;
+        }
+        return label.replace(sepRegexp, formatting.separator);
+    }
+    appendWorkspaceSuffix(label, uri) {
+        const formatting = this.findFormatting(uri);
+        const suffix = formatting && (typeof formatting.workspaceSuffix === 'string') ? formatting.workspaceSuffix : undefined;
+        return suffix ? `${label} [${suffix}]` : label;
+    }
+};
+LabelService = ( __decorate([
+    ( __param(0, IWorkbenchEnvironmentService)),
+    ( __param(1, IWorkspaceContextService)),
+    ( __param(2, IPathService)),
+    ( __param(3, IRemoteAgentService)),
+    ( __param(4, IStorageService)),
+    ( __param(5, ILifecycleService))
+], LabelService));
+export { LabelService };