@codingame/monaco-vscode-api 4.0.0 → 4.1.0

package/vscode/src/vs/platform/quickinput/browser/commandsQuickAccess.js

@@ -0,0 +1,355 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { toErrorMessage } from '../../../base/common/errorMessage.js';
+import { isCancellationError } from '../../../base/common/errors.js';
+import { or, matchesContiguousSubString, matchesWords, matchesPrefix } from '../../../base/common/filters.js';
+import { createSingleCallFunction } from '../../../base/common/functional.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { LRUCache } from '../../../base/common/map.js';
+import { normalizeTfIdfScores, TfIdfCalculator } from '../../../base/common/tfIdf.js';
+import { localizeWithPath } from '../../../nls.js';
+import { ICommandService } from '../../commands/common/commands.js';
+import { IConfigurationService } from '../../configuration/common/configuration.js';
+import '../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { IInstantiationService } from '../../instantiation/common/instantiation.js';
+import { IKeybindingService } from '../../keybinding/common/keybinding.js';
+import { ILogService } from '../../log/common/log.js';
+import { PickerQuickAccessProvider } from './pickerQuickAccess.js';
+import { WillSaveStateReason, IStorageService } from '../../storage/common/storage.js';
+import { ITelemetryService } from '../../telemetry/common/telemetry.js';
+import { IDialogService } from '../../dialogs/common/dialogs.js';
+var AbstractCommandsQuickAccessProvider_1, CommandsHistory_1;
+let AbstractCommandsQuickAccessProvider = class AbstractCommandsQuickAccessProvider extends PickerQuickAccessProvider {
+    static { AbstractCommandsQuickAccessProvider_1 = this; }
+    static { this.PREFIX = '>'; }
+    static { this.TFIDF_THRESHOLD = 0.5; }
+    static { this.TFIDF_MAX_RESULTS = 5; }
+    static { this.WORD_FILTER = or(matchesPrefix, matchesWords, matchesContiguousSubString); }
+    constructor(options, instantiationService, keybindingService, commandService, telemetryService, dialogService) {
+        super(AbstractCommandsQuickAccessProvider_1.PREFIX, options);
+        this.instantiationService = instantiationService;
+        this.keybindingService = keybindingService;
+        this.commandService = commandService;
+        this.telemetryService = telemetryService;
+        this.dialogService = dialogService;
+        this.commandsHistory = this._register(this.instantiationService.createInstance(CommandsHistory));
+        this.options = options;
+    }
+    async _getPicks(filter, _disposables, token, runOptions) {
+        const allCommandPicks = await this.getCommandPicks(token);
+        if (token.isCancellationRequested) {
+            return [];
+        }
+        const runTfidf = createSingleCallFunction(() => {
+            const tfidf = ( new TfIdfCalculator());
+            tfidf.updateDocuments(( allCommandPicks.map(commandPick => ({
+                key: commandPick.commandId,
+                textChunks: [this.getTfIdfChunk(commandPick)]
+            }))));
+            const result = tfidf.calculateScores(filter, token);
+            return normalizeTfIdfScores(result)
+                .filter(score => score.score > AbstractCommandsQuickAccessProvider_1.TFIDF_THRESHOLD)
+                .slice(0, AbstractCommandsQuickAccessProvider_1.TFIDF_MAX_RESULTS);
+        });
+        const filteredCommandPicks = [];
+        for (const commandPick of allCommandPicks) {
+            const labelHighlights = AbstractCommandsQuickAccessProvider_1.WORD_FILTER(filter, commandPick.label) ?? undefined;
+            const aliasHighlights = commandPick.commandAlias ? AbstractCommandsQuickAccessProvider_1.WORD_FILTER(filter, commandPick.commandAlias) ?? undefined : undefined;
+            if (labelHighlights || aliasHighlights) {
+                commandPick.highlights = {
+                    label: labelHighlights,
+                    detail: this.options.showAlias ? aliasHighlights : undefined
+                };
+                filteredCommandPicks.push(commandPick);
+            }
+            else if (filter === commandPick.commandId) {
+                filteredCommandPicks.push(commandPick);
+            }
+            else if (filter.length >= 3) {
+                const tfidf = runTfidf();
+                if (token.isCancellationRequested) {
+                    return [];
+                }
+                const tfidfScore = tfidf.find(score => score.key === commandPick.commandId);
+                if (tfidfScore) {
+                    commandPick.tfIdfScore = tfidfScore.score;
+                    filteredCommandPicks.push(commandPick);
+                }
+            }
+        }
+        const mapLabelToCommand = ( new Map());
+        for (const commandPick of filteredCommandPicks) {
+            const existingCommandForLabel = mapLabelToCommand.get(commandPick.label);
+            if (existingCommandForLabel) {
+                commandPick.description = commandPick.commandId;
+                existingCommandForLabel.description = existingCommandForLabel.commandId;
+            }
+            else {
+                mapLabelToCommand.set(commandPick.label, commandPick);
+            }
+        }
+        filteredCommandPicks.sort((commandPickA, commandPickB) => {
+            if (commandPickA.tfIdfScore && commandPickB.tfIdfScore) {
+                if (commandPickA.tfIdfScore === commandPickB.tfIdfScore) {
+                    return commandPickA.label.localeCompare(commandPickB.label);
+                }
+                return commandPickB.tfIdfScore - commandPickA.tfIdfScore;
+            }
+            else if (commandPickA.tfIdfScore) {
+                return 1;
+            }
+            else if (commandPickB.tfIdfScore) {
+                return -1;
+            }
+            const commandACounter = this.commandsHistory.peek(commandPickA.commandId);
+            const commandBCounter = this.commandsHistory.peek(commandPickB.commandId);
+            if (commandACounter && commandBCounter) {
+                return commandACounter > commandBCounter ? -1 : 1;
+            }
+            if (commandACounter) {
+                return -1;
+            }
+            if (commandBCounter) {
+                return 1;
+            }
+            if (this.options.suggestedCommandIds) {
+                const commandASuggestion = ( this.options.suggestedCommandIds.has(commandPickA.commandId));
+                const commandBSuggestion = ( this.options.suggestedCommandIds.has(commandPickB.commandId));
+                if (commandASuggestion && commandBSuggestion) {
+                    return 0;
+                }
+                if (commandASuggestion) {
+                    return -1;
+                }
+                if (commandBSuggestion) {
+                    return 1;
+                }
+            }
+            return commandPickA.label.localeCompare(commandPickB.label);
+        });
+        const commandPicks = [];
+        let addOtherSeparator = false;
+        let addSuggestedSeparator = true;
+        let addCommonlyUsedSeparator = !!this.options.suggestedCommandIds;
+        for (let i = 0; i < filteredCommandPicks.length; i++) {
+            const commandPick = filteredCommandPicks[i];
+            if (i === 0 && this.commandsHistory.peek(commandPick.commandId)) {
+                commandPicks.push({ type: 'separator', label: ( localizeWithPath(
+                    'vs/platform/quickinput/browser/commandsQuickAccess',
+                    'recentlyUsed',
+                    "recently used"
+                )) });
+                addOtherSeparator = true;
+            }
+            if (addSuggestedSeparator && commandPick.tfIdfScore !== undefined) {
+                commandPicks.push({ type: 'separator', label: ( localizeWithPath(
+                    'vs/platform/quickinput/browser/commandsQuickAccess',
+                    'suggested',
+                    "similar commands"
+                )) });
+                addSuggestedSeparator = false;
+            }
+            if (addCommonlyUsedSeparator && commandPick.tfIdfScore === undefined && !this.commandsHistory.peek(commandPick.commandId) && this.options.suggestedCommandIds?.has(commandPick.commandId)) {
+                commandPicks.push({ type: 'separator', label: ( localizeWithPath(
+                    'vs/platform/quickinput/browser/commandsQuickAccess',
+                    'commonlyUsed',
+                    "commonly used"
+                )) });
+                addOtherSeparator = true;
+                addCommonlyUsedSeparator = false;
+            }
+            if (addOtherSeparator && commandPick.tfIdfScore === undefined && !this.commandsHistory.peek(commandPick.commandId) && !this.options.suggestedCommandIds?.has(commandPick.commandId)) {
+                commandPicks.push({ type: 'separator', label: ( localizeWithPath(
+                    'vs/platform/quickinput/browser/commandsQuickAccess',
+                    'morecCommands',
+                    "other commands"
+                )) });
+                addOtherSeparator = false;
+            }
+            commandPicks.push(this.toCommandPick(commandPick, runOptions));
+        }
+        if (!this.hasAdditionalCommandPicks(filter, token)) {
+            return commandPicks;
+        }
+        return {
+            picks: commandPicks,
+            additionalPicks: (async () => {
+                const additionalCommandPicks = await this.getAdditionalCommandPicks(allCommandPicks, filteredCommandPicks, filter, token);
+                if (token.isCancellationRequested) {
+                    return [];
+                }
+                const commandPicks = ( additionalCommandPicks.map(commandPick => this.toCommandPick(commandPick, runOptions)));
+                if (addSuggestedSeparator && commandPicks[0]?.type !== 'separator') {
+                    commandPicks.unshift({ type: 'separator', label: ( localizeWithPath(
+                        'vs/platform/quickinput/browser/commandsQuickAccess',
+                        'suggested',
+                        "similar commands"
+                    )) });
+                }
+                return commandPicks;
+            })()
+        };
+    }
+    toCommandPick(commandPick, runOptions) {
+        if (commandPick.type === 'separator') {
+            return commandPick;
+        }
+        const keybinding = this.keybindingService.lookupKeybinding(commandPick.commandId);
+        const ariaLabel = keybinding ?
+            ( localizeWithPath(
+                'vs/platform/quickinput/browser/commandsQuickAccess',
+                'commandPickAriaLabelWithKeybinding',
+                "{0}, {1}",
+                commandPick.label,
+                keybinding.getAriaLabel()
+            )) :
+            commandPick.label;
+        return {
+            ...commandPick,
+            ariaLabel,
+            detail: this.options.showAlias && commandPick.commandAlias !== commandPick.label ? commandPick.commandAlias : undefined,
+            keybinding,
+            accept: async () => {
+                this.commandsHistory.push(commandPick.commandId);
+                this.telemetryService.publicLog2('workbenchActionExecuted', {
+                    id: commandPick.commandId,
+                    from: runOptions?.from ?? 'quick open'
+                });
+                try {
+                    commandPick.args?.length
+                        ? await this.commandService.executeCommand(commandPick.commandId, ...commandPick.args)
+                        : await this.commandService.executeCommand(commandPick.commandId);
+                }
+                catch (error) {
+                    if (!isCancellationError(error)) {
+                        this.dialogService.error(( localizeWithPath(
+                            'vs/platform/quickinput/browser/commandsQuickAccess',
+                            'canNotRun',
+                            "Command '{0}' resulted in an error",
+                            commandPick.label
+                        )), toErrorMessage(error));
+                    }
+                }
+            }
+        };
+    }
+    getTfIdfChunk({ label, commandAlias, commandDescription }) {
+        let chunk = label;
+        if (commandAlias && commandAlias !== label) {
+            chunk += ` - ${commandAlias}`;
+        }
+        if (commandDescription && commandDescription.value !== label) {
+            chunk += ` - ${commandDescription.value === commandDescription.original ? commandDescription.value : `${commandDescription.value} (${commandDescription.original})`}`;
+        }
+        return chunk;
+    }
+};
+AbstractCommandsQuickAccessProvider = AbstractCommandsQuickAccessProvider_1 = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IKeybindingService)),
+    ( __param(3, ICommandService)),
+    ( __param(4, ITelemetryService)),
+    ( __param(5, IDialogService))
+], AbstractCommandsQuickAccessProvider));
+let CommandsHistory = class CommandsHistory extends Disposable {
+    static { CommandsHistory_1 = this; }
+    static { this.DEFAULT_COMMANDS_HISTORY_LENGTH = 50; }
+    static { this.PREF_KEY_CACHE = 'commandPalette.mru.cache'; }
+    static { this.PREF_KEY_COUNTER = 'commandPalette.mru.counter'; }
+    static { this.counter = 1; }
+    static { this.hasChanges = false; }
+    constructor(storageService, configurationService, logService) {
+        super();
+        this.storageService = storageService;
+        this.configurationService = configurationService;
+        this.logService = logService;
+        this.configuredCommandsHistoryLength = 0;
+        this.updateConfiguration();
+        this.load();
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.configurationService.onDidChangeConfiguration(e => this.updateConfiguration(e)));
+        this._register(this.storageService.onWillSaveState(e => {
+            if (e.reason === WillSaveStateReason.SHUTDOWN) {
+                this.saveState();
+            }
+        }));
+    }
+    updateConfiguration(e) {
+        if (e && !e.affectsConfiguration('workbench.commandPalette.history')) {
+            return;
+        }
+        this.configuredCommandsHistoryLength = CommandsHistory_1.getConfiguredCommandHistoryLength(this.configurationService);
+        if (CommandsHistory_1.cache && CommandsHistory_1.cache.limit !== this.configuredCommandsHistoryLength) {
+            CommandsHistory_1.cache.limit = this.configuredCommandsHistoryLength;
+            CommandsHistory_1.hasChanges = true;
+        }
+    }
+    load() {
+        const raw = this.storageService.get(CommandsHistory_1.PREF_KEY_CACHE, 0 );
+        let serializedCache;
+        if (raw) {
+            try {
+                serializedCache = JSON.parse(raw);
+            }
+            catch (error) {
+                this.logService.error(`[CommandsHistory] invalid data: ${error}`);
+            }
+        }
+        const cache = CommandsHistory_1.cache = ( new LRUCache(this.configuredCommandsHistoryLength, 1));
+        if (serializedCache) {
+            let entries;
+            if (serializedCache.usesLRU) {
+                entries = serializedCache.entries;
+            }
+            else {
+                entries = serializedCache.entries.sort((a, b) => a.value - b.value);
+            }
+            entries.forEach(entry => cache.set(entry.key, entry.value));
+        }
+        CommandsHistory_1.counter = this.storageService.getNumber(CommandsHistory_1.PREF_KEY_COUNTER, 0 , CommandsHistory_1.counter);
+    }
+    push(commandId) {
+        if (!CommandsHistory_1.cache) {
+            return;
+        }
+        CommandsHistory_1.cache.set(commandId, CommandsHistory_1.counter++);
+        CommandsHistory_1.hasChanges = true;
+    }
+    peek(commandId) {
+        return CommandsHistory_1.cache?.peek(commandId);
+    }
+    saveState() {
+        if (!CommandsHistory_1.cache) {
+            return;
+        }
+        if (!CommandsHistory_1.hasChanges) {
+            return;
+        }
+        const serializedCache = { usesLRU: true, entries: [] };
+        CommandsHistory_1.cache.forEach((value, key) => serializedCache.entries.push({ key, value }));
+        this.storageService.store(CommandsHistory_1.PREF_KEY_CACHE, JSON.stringify(serializedCache), 0 , 0 );
+        this.storageService.store(CommandsHistory_1.PREF_KEY_COUNTER, CommandsHistory_1.counter, 0 , 0 );
+        CommandsHistory_1.hasChanges = false;
+    }
+    static getConfiguredCommandHistoryLength(configurationService) {
+        const config = configurationService.getValue();
+        const configuredCommandHistoryLength = config.workbench?.commandPalette?.history;
+        if (typeof configuredCommandHistoryLength === 'number') {
+            return configuredCommandHistoryLength;
+        }
+        return CommandsHistory_1.DEFAULT_COMMANDS_HISTORY_LENGTH;
+    }
+    static clearHistory(configurationService, storageService) {
+        const commandHistoryLength = CommandsHistory_1.getConfiguredCommandHistoryLength(configurationService);
+        CommandsHistory_1.cache = ( new LRUCache(commandHistoryLength));
+        CommandsHistory_1.counter = 1;
+        CommandsHistory_1.hasChanges = true;
+    }
+};
+CommandsHistory = CommandsHistory_1 = ( __decorate([
+    ( __param(0, IStorageService)),
+    ( __param(1, IConfigurationService)),
+    ( __param(2, ILogService))
+], CommandsHistory));
+export { AbstractCommandsQuickAccessProvider, CommandsHistory };

package/vscode/src/vs/platform/quickinput/browser/helpQuickAccess.js

@@ -0,0 +1,65 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from '../../../nls.js';
+import { Registry } from '../../registry/common/platform.js';
+import { DisposableStore } from '../../../base/common/lifecycle.js';
+import { IKeybindingService } from '../../keybinding/common/keybinding.js';
+import { Extensions } from '../common/quickAccess.js';
+import { IQuickInputService } from '../common/quickInput.js';
+var HelpQuickAccessProvider_1;
+let HelpQuickAccessProvider = class HelpQuickAccessProvider {
+    static { HelpQuickAccessProvider_1 = this; }
+    static { this.PREFIX = '?'; }
+    constructor(quickInputService, keybindingService) {
+        this.quickInputService = quickInputService;
+        this.keybindingService = keybindingService;
+        this.registry = ( Registry.as(Extensions.Quickaccess));
+    }
+    provide(picker) {
+        const disposables = ( new DisposableStore());
+        disposables.add(picker.onDidAccept(() => {
+            const [item] = picker.selectedItems;
+            if (item) {
+                this.quickInputService.quickAccess.show(item.prefix, { preserveValue: true });
+            }
+        }));
+        disposables.add(picker.onDidChangeValue(value => {
+            const providerDescriptor = this.registry.getQuickAccessProvider(value.substr(HelpQuickAccessProvider_1.PREFIX.length));
+            if (providerDescriptor && providerDescriptor.prefix && providerDescriptor.prefix !== HelpQuickAccessProvider_1.PREFIX) {
+                this.quickInputService.quickAccess.show(providerDescriptor.prefix, { preserveValue: true });
+            }
+        }));
+        picker.items = this.getQuickAccessProviders().filter(p => p.prefix !== HelpQuickAccessProvider_1.PREFIX);
+        return disposables;
+    }
+    getQuickAccessProviders() {
+        const providers = this.registry
+            .getQuickAccessProviders()
+            .sort((providerA, providerB) => providerA.prefix.localeCompare(providerB.prefix))
+            .flatMap(provider => this.createPicks(provider));
+        return providers;
+    }
+    createPicks(provider) {
+        return ( provider.helpEntries.map(helpEntry => {
+            const prefix = helpEntry.prefix || provider.prefix;
+            const label = prefix || '\u2026' ;
+            return {
+                prefix,
+                label,
+                keybinding: helpEntry.commandId ? this.keybindingService.lookupKeybinding(helpEntry.commandId) : undefined,
+                ariaLabel: ( localizeWithPath(
+                    'vs/platform/quickinput/browser/helpQuickAccess',
+                    'helpPickAriaLabel',
+                    "{0}, {1}",
+                    label,
+                    helpEntry.description
+                )),
+                description: helpEntry.description
+            };
+        }));
+    }
+};
+HelpQuickAccessProvider = HelpQuickAccessProvider_1 = ( __decorate([
+    ( __param(0, IQuickInputService)),
+    ( __param(1, IKeybindingService))
+], HelpQuickAccessProvider));
+export { HelpQuickAccessProvider };

package/vscode/src/vs/platform/remote/browser/remoteAuthorityResolverService.js

@@ -0,0 +1,108 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { mainWindow } from '../../../base/browser/window.js';
+import { DeferredPromise } from '../../../base/common/async.js';
+import { ErrorNoTelemetry } from '../../../base/common/errors.js';
+import { Emitter } from '../../../base/common/event.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { RemoteAuthorities } from '../../../base/common/network.js';
+import { mark } from '../../../base/common/performance.js';
+import { StopWatch } from '../../../base/common/stopwatch.js';
+import { ILogService } from '../../log/common/log.js';
+import { IProductService } from '../../product/common/productService.js';
+import { getRemoteAuthorityPrefix, WebSocketRemoteConnection } from '../common/remoteAuthorityResolver.js';
+import { parseAuthorityWithOptionalPort } from '../common/remoteHosts.js';
+let RemoteAuthorityResolverService = class RemoteAuthorityResolverService extends Disposable {
+    constructor(isWorkbenchOptionsBasedResolution, connectionToken, resourceUriProvider, serverBasePath, productService, _logService) {
+        super();
+        this._logService = _logService;
+        this._onDidChangeConnectionData = this._register(( new Emitter()));
+        this.onDidChangeConnectionData = this._onDidChangeConnectionData.event;
+        this._resolveAuthorityRequests = ( new Map());
+        this._cache = ( new Map());
+        this._connectionToken = connectionToken;
+        this._connectionTokens = ( new Map());
+        this._isWorkbenchOptionsBasedResolution = isWorkbenchOptionsBasedResolution;
+        if (resourceUriProvider) {
+            RemoteAuthorities.setDelegate(resourceUriProvider);
+        }
+        RemoteAuthorities.setServerRootPath(productService, serverBasePath);
+    }
+    async resolveAuthority(authority) {
+        let result = this._resolveAuthorityRequests.get(authority);
+        if (!result) {
+            result = ( new DeferredPromise());
+            this._resolveAuthorityRequests.set(authority, result);
+            if (this._isWorkbenchOptionsBasedResolution) {
+                this._doResolveAuthority(authority).then(v => result.complete(v), (err) => result.error(err));
+            }
+        }
+        return result.p;
+    }
+    async getCanonicalURI(uri) {
+        return uri;
+    }
+    getConnectionData(authority) {
+        if (!( this._cache.has(authority))) {
+            return null;
+        }
+        const resolverResult = this._cache.get(authority);
+        const connectionToken = this._connectionTokens.get(authority) || resolverResult.authority.connectionToken;
+        return {
+            connectTo: resolverResult.authority.connectTo,
+            connectionToken: connectionToken
+        };
+    }
+    async _doResolveAuthority(authority) {
+        const authorityPrefix = getRemoteAuthorityPrefix(authority);
+        const sw = StopWatch.create(false);
+        this._logService.info(`Resolving connection token (${authorityPrefix})...`);
+        mark(`code/willResolveConnectionToken/${authorityPrefix}`);
+        const connectionToken = await Promise.resolve(this._connectionTokens.get(authority) || this._connectionToken);
+        mark(`code/didResolveConnectionToken/${authorityPrefix}`);
+        this._logService.info(`Resolved connection token (${authorityPrefix}) after ${sw.elapsed()} ms`);
+        const defaultPort = (/^https:/.test(mainWindow.location.href) ? 443 : 80);
+        const { host, port } = parseAuthorityWithOptionalPort(authority, defaultPort);
+        const result = { authority: { authority, connectTo: ( new WebSocketRemoteConnection(host, port)), connectionToken } };
+        RemoteAuthorities.set(authority, host, port);
+        this._cache.set(authority, result);
+        this._onDidChangeConnectionData.fire();
+        return result;
+    }
+    _clearResolvedAuthority(authority) {
+        if (( this._resolveAuthorityRequests.has(authority))) {
+            this._resolveAuthorityRequests.get(authority).cancel();
+            this._resolveAuthorityRequests.delete(authority);
+        }
+    }
+    _setResolvedAuthority(resolvedAuthority, options) {
+        if (( this._resolveAuthorityRequests.has(resolvedAuthority.authority))) {
+            const request = this._resolveAuthorityRequests.get(resolvedAuthority.authority);
+            if (resolvedAuthority.connectTo.type === 0 ) {
+                RemoteAuthorities.set(resolvedAuthority.authority, resolvedAuthority.connectTo.host, resolvedAuthority.connectTo.port);
+            }
+            if (resolvedAuthority.connectionToken) {
+                RemoteAuthorities.setConnectionToken(resolvedAuthority.authority, resolvedAuthority.connectionToken);
+            }
+            request.complete({ authority: resolvedAuthority, options });
+            this._onDidChangeConnectionData.fire();
+        }
+    }
+    _setResolvedAuthorityError(authority, err) {
+        if (( this._resolveAuthorityRequests.has(authority))) {
+            const request = this._resolveAuthorityRequests.get(authority);
+            request.error(ErrorNoTelemetry.fromError(err));
+        }
+    }
+    _setAuthorityConnectionToken(authority, connectionToken) {
+        this._connectionTokens.set(authority, connectionToken);
+        RemoteAuthorities.setConnectionToken(authority, connectionToken);
+        this._onDidChangeConnectionData.fire();
+    }
+    _setCanonicalURIProvider(provider) {
+    }
+};
+RemoteAuthorityResolverService = ( __decorate([
+    ( __param(4, IProductService)),
+    ( __param(5, ILogService))
+], RemoteAuthorityResolverService));
+export { RemoteAuthorityResolverService };

package/vscode/src/vs/platform/remote/common/managedSocket.js

@@ -0,0 +1,96 @@
+import { VSBuffer, encodeBase64 } from '../../../base/common/buffer.js';
+import { PauseableEmitter, Emitter } from '../../../base/common/event.js';
+import { Disposable, DisposableStore } from '../../../base/common/lifecycle.js';
+import { SocketDiagnostics } from '../../../base/parts/ipc/common/ipc.net.js';
+const makeRawSocketHeaders = (path, query, deubgLabel) => {
+    const buffer = ( new Uint8Array(16));
+    for (let i = 0; i < 16; i++) {
+        buffer[i] = Math.round(Math.random() * 256);
+    }
+    const nonce = encodeBase64(VSBuffer.wrap(buffer));
+    const headers = [
+        `GET ws://localhost${path}?${query}&skipWebSocketFrames=true HTTP/1.1`,
+        `Connection: Upgrade`,
+        `Upgrade: websocket`,
+        `Sec-WebSocket-Key: ${nonce}`
+    ];
+    return headers.join('\r\n') + '\r\n\r\n';
+};
+const socketRawEndHeaderSequence = VSBuffer.fromString('\r\n\r\n');
+async function connectManagedSocket(socket, path, query, debugLabel, half) {
+    socket.write(VSBuffer.fromString(makeRawSocketHeaders(path, query)));
+    const d = ( new DisposableStore());
+    try {
+        return await ( new Promise((resolve, reject) => {
+            let dataSoFar;
+            d.add(socket.onData(d_1 => {
+                if (!dataSoFar) {
+                    dataSoFar = d_1;
+                }
+                else {
+                    dataSoFar = VSBuffer.concat([dataSoFar, d_1], dataSoFar.byteLength + d_1.byteLength);
+                }
+                const index = dataSoFar.indexOf(socketRawEndHeaderSequence);
+                if (index === -1) {
+                    return;
+                }
+                resolve(socket);
+                socket.pauseData();
+                const rest = dataSoFar.slice(index + socketRawEndHeaderSequence.byteLength);
+                if (rest.byteLength) {
+                    half.onData.fire(rest);
+                }
+            }));
+            d.add(socket.onClose(err => reject(err ?? ( new Error('socket closed')))));
+            d.add(socket.onEnd(() => reject(( new Error('socket ended')))));
+        }));
+    }
+    catch (e) {
+        socket.dispose();
+        throw e;
+    }
+    finally {
+        d.dispose();
+    }
+}
+class ManagedSocket extends Disposable {
+    constructor(debugLabel, half) {
+        super();
+        this.debugLabel = debugLabel;
+        this.pausableDataEmitter = this._register(( new PauseableEmitter()));
+        this.onData = (...args) => {
+            if (this.pausableDataEmitter.isPaused) {
+                queueMicrotask(() => this.pausableDataEmitter.resume());
+            }
+            return this.pausableDataEmitter.event(...args);
+        };
+        this.didDisposeEmitter = this._register(( new Emitter()));
+        this.onDidDispose = this.didDisposeEmitter.event;
+        this.ended = false;
+        this._register(half.onData);
+        this._register(half.onData.event(data => this.pausableDataEmitter.fire(data)));
+        this.onClose = this._register(half.onClose).event;
+        this.onEnd = this._register(half.onEnd).event;
+    }
+    pauseData() {
+        this.pausableDataEmitter.pause();
+    }
+    drain() {
+        return Promise.resolve();
+    }
+    end() {
+        this.ended = true;
+        this.closeRemote();
+    }
+    traceSocketEvent(type, data) {
+        SocketDiagnostics.traceSocketEvent(this, this.debugLabel, type, data);
+    }
+    dispose() {
+        if (!this.ended) {
+            this.closeRemote();
+        }
+        this.didDisposeEmitter.fire();
+        super.dispose();
+    }
+}
+export { ManagedSocket, connectManagedSocket, makeRawSocketHeaders, socketRawEndHeaderSequence };

package/vscode/src/vs/platform/request/browser/requestService.js

@@ -0,0 +1,28 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { request } from '../../../base/parts/request/browser/request.js';
+import { IConfigurationService } from '../../configuration/common/configuration.js';
+import { ILoggerService } from '../../log/common/log.js';
+import { AbstractRequestService } from '../common/request.js';
+let RequestService = class RequestService extends AbstractRequestService {
+    constructor(configurationService, loggerService) {
+        super(loggerService);
+        this.configurationService = configurationService;
+    }
+    async request(options, token) {
+        if (!options.proxyAuthorization) {
+            options.proxyAuthorization = this.configurationService.getValue('http.proxyAuthorization');
+        }
+        return this.logAndRequest('browser', options, () => request(options, token));
+    }
+    async resolveProxy(url) {
+        return undefined;
+    }
+    async loadCertificates() {
+        return [];
+    }
+};
+RequestService = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, ILoggerService))
+], RequestService));
+export { RequestService };

package/vscode/src/vs/platform/request/common/requestIpc.js

@@ -0,0 +1,18 @@
+import { bufferToStream } from '../../../base/common/buffer.js';
+import '../../../base/common/cancellation.js';
+class RequestChannelClient {
+    constructor(channel) {
+        this.channel = channel;
+    }
+    async request(options, token) {
+        const [res, buffer] = await this.channel.call('request', [options], token);
+        return { res, stream: bufferToStream(buffer) };
+    }
+    async resolveProxy(url) {
+        return this.channel.call('resolveProxy', [url]);
+    }
+    async loadCertificates() {
+        return this.channel.call('loadCertificates');
+    }
+}
+export { RequestChannelClient };