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

package/dist/vscode/vs/workbench/api/browser/mainThreadSearch.js

@@ -0,0 +1,146 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { dispose, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { ISearchService } from '../../services/search/common/search.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
+let MainThreadSearch = class MainThreadSearch {
+    constructor(extHostContext, _searchService, _telemetryService, _configurationService) {
+        this._searchService = _searchService;
+        this._telemetryService = _telemetryService;
+        this._searchProvider = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostSearch));
+        this._proxy.$enableExtensionHostSearch();
+    }
+    dispose() {
+        this._searchProvider.forEach(value => value.dispose());
+        this._searchProvider.clear();
+    }
+    $registerTextSearchProvider(handle, scheme) {
+        this._searchProvider.set(handle, ( new RemoteSearchProvider(
+            this._searchService,
+            1 ,
+            scheme,
+            handle,
+            this._proxy
+        )));
+    }
+    $registerFileSearchProvider(handle, scheme) {
+        this._searchProvider.set(handle, ( new RemoteSearchProvider(
+            this._searchService,
+            0 ,
+            scheme,
+            handle,
+            this._proxy
+        )));
+    }
+    $unregisterProvider(handle) {
+        dispose(this._searchProvider.get(handle));
+        this._searchProvider.delete(handle);
+    }
+    $handleFileMatch(handle, session, data) {
+        const provider = this._searchProvider.get(handle);
+        if (!provider) {
+            throw new Error('Got result for unknown provider');
+        }
+        provider.handleFindMatch(session, data);
+    }
+    $handleTextMatch(handle, session, data) {
+        const provider = this._searchProvider.get(handle);
+        if (!provider) {
+            throw new Error('Got result for unknown provider');
+        }
+        provider.handleFindMatch(session, data);
+    }
+    $handleTelemetry(eventName, data) {
+        this._telemetryService.publicLog(eventName, data);
+    }
+};
+MainThreadSearch = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadSearch),
+    ( __param(1, ISearchService)),
+    ( __param(2, ITelemetryService)),
+    ( __param(3, IConfigurationService))
+], MainThreadSearch);
+class SearchOperation {
+    constructor(progress, id = ++SearchOperation._idPool, matches = ( new Map())) {
+        this.progress = progress;
+        this.id = id;
+        this.matches = matches;
+    }
+    addMatch(match) {
+        const existingMatch = this.matches.get(( match.resource.toString()));
+        if (existingMatch) {
+            if (existingMatch.results && match.results) {
+                existingMatch.results.push(...match.results);
+            }
+        }
+        else {
+            this.matches.set(( match.resource.toString()), match);
+        }
+        this.progress?.(match);
+    }
+}
+SearchOperation._idPool = 0;
+class RemoteSearchProvider {
+    constructor(searchService, type, _scheme, _handle, _proxy) {
+        this._scheme = _scheme;
+        this._handle = _handle;
+        this._proxy = _proxy;
+        this._registrations = ( new DisposableStore());
+        this._searches = ( new Map());
+        this._registrations.add(searchService.registerSearchResultProvider(this._scheme, type, this));
+    }
+    dispose() {
+        this._registrations.dispose();
+    }
+    fileSearch(query, token = CancellationToken.None) {
+        return this.doSearch(query, undefined, token);
+    }
+    textSearch(query, onProgress, token = CancellationToken.None) {
+        return this.doSearch(query, onProgress, token);
+    }
+    doSearch(query, onProgress, token = CancellationToken.None) {
+        if (!query.folderQueries.length) {
+            throw new Error('Empty folderQueries');
+        }
+        const search = ( new SearchOperation(onProgress));
+        this._searches.set(search.id, search);
+        const searchP = query.type === 1
+            ? this._proxy.$provideFileSearchResults(this._handle, search.id, query, token)
+            : this._proxy.$provideTextSearchResults(this._handle, search.id, query, token);
+        return Promise.resolve(searchP).then((result) => {
+            this._searches.delete(search.id);
+            return { results: Array.from(( search.matches.values())), stats: result.stats, limitHit: result.limitHit, messages: result.messages };
+        }, err => {
+            this._searches.delete(search.id);
+            return Promise.reject(err);
+        });
+    }
+    clearCache(cacheKey) {
+        return Promise.resolve(this._proxy.$clearCache(cacheKey));
+    }
+    handleFindMatch(session, dataOrUri) {
+        const searchOp = this._searches.get(session);
+        if (!searchOp) {
+            return;
+        }
+        dataOrUri.forEach(result => {
+            if (result.results) {
+                searchOp.addMatch({
+                    resource: URI.revive(result.resource),
+                    results: result.results
+                });
+            }
+            else {
+                searchOp.addMatch({
+                    resource: URI.revive(result)
+                });
+            }
+        });
+    }
+}
+export { MainThreadSearch };

package/dist/vscode/vs/workbench/api/browser/mainThreadStatusBar.js

@@ -0,0 +1,49 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { MainContext, ExtHostContext } from '../common/extHost.protocol.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IExtensionStatusBarItemService } from './statusBarExtensionPoint.js';
+let MainThreadStatusBar = class MainThreadStatusBar {
+    constructor(extHostContext, statusbarService) {
+        this.statusbarService = statusbarService;
+        this.entries = ( new DisposableMap());
+        const proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostStatusBar));
+        const entries = [];
+        for (const [entryId, item] of statusbarService.getEntries()) {
+            entries.push(asDto(entryId, item));
+        }
+        proxy.$acceptStaticEntries(entries);
+        statusbarService.onDidChange(e => {
+            if (e.added) {
+                proxy.$acceptStaticEntries([asDto(e.added[0], e.added[1])]);
+            }
+        });
+        function asDto(entryId, item) {
+            return {
+                entryId,
+                name: item.entry.name,
+                text: item.entry.text,
+                command: typeof item.entry.command === 'string' ? item.entry.command : typeof item.entry.command === 'object' ? item.entry.command.id : undefined,
+                priority: item.priority,
+                alignLeft: item.alignment === 0
+            };
+        }
+    }
+    dispose() {
+        this.entries.dispose();
+    }
+    $setEntry(entryId, id, extensionId, name, text, tooltip, command, color, backgroundColor, alignLeft, priority, accessibilityInformation) {
+        const dispo = this.statusbarService.setOrUpdateEntry(entryId, id, extensionId, name, text, tooltip, command, color, backgroundColor, alignLeft, priority, accessibilityInformation);
+        if (!( this.entries.has(entryId))) {
+            this.entries.set(entryId, dispo);
+        }
+    }
+    $disposeEntry(entryId) {
+        this.entries.deleteAndDispose(entryId);
+    }
+};
+MainThreadStatusBar = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadStatusBar),
+    ( __param(1, IExtensionStatusBarItemService))
+], MainThreadStatusBar);
+export { MainThreadStatusBar };

package/dist/vscode/vs/workbench/api/browser/mainThreadTerminalService.js

@@ -0,0 +1,395 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { DisposableStore, Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { StopWatch } from 'monaco-editor/esm/vs/base/common/stopwatch.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { TerminalLocation, TerminalExitReason } from '../../../platform/terminal/common/terminal.js';
+import { TerminalDataBufferer } from '../../../platform/terminal/common/terminalDataBuffering.js';
+import { ITerminalService, ITerminalGroupService, ITerminalEditorService } from '../../contrib/terminal/browser/terminal.js';
+import { TerminalProcessExtHostProxy } from '../../contrib/terminal/browser/terminalProcessExtHostProxy.js';
+import { IEnvironmentVariableService } from '../../contrib/terminal/common/environmentVariable.js';
+import { serializeEnvironmentVariableCollection, deserializeEnvironmentVariableCollection, deserializeEnvironmentDescriptionMap } from '../../../platform/terminal/common/environmentVariableShared.js';
+import { ITerminalProfileResolverService, ITerminalProfileService } from '../../contrib/terminal/common/terminal.js';
+import { IRemoteAgentService } from '../../services/remote/common/remoteAgentService.js';
+import { withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { OS } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { Promises } from 'monaco-editor/esm/vs/base/common/async.js';
+import { TerminalQuickFixType } from '../common/extHostTypes.js';
+import { ITerminalLinkProviderService } from '../../contrib/terminalContrib/links/browser/links.js';
+import { ITerminalQuickFixService } from '../../contrib/terminalContrib/quickFix/browser/quickFix.js';
+let MainThreadTerminalService = class MainThreadTerminalService {
+    constructor(_extHostContext, _terminalService, _terminalLinkProviderService, _terminalQuickFixService, _instantiationService, _environmentVariableService, _logService, _terminalProfileResolverService, remoteAgentService, _terminalGroupService, _terminalEditorService, _terminalProfileService) {
+        this._extHostContext = _extHostContext;
+        this._terminalService = _terminalService;
+        this._terminalLinkProviderService = _terminalLinkProviderService;
+        this._terminalQuickFixService = _terminalQuickFixService;
+        this._instantiationService = _instantiationService;
+        this._environmentVariableService = _environmentVariableService;
+        this._logService = _logService;
+        this._terminalProfileResolverService = _terminalProfileResolverService;
+        this._terminalGroupService = _terminalGroupService;
+        this._terminalEditorService = _terminalEditorService;
+        this._terminalProfileService = _terminalProfileService;
+        this._extHostTerminals = ( new Map());
+        this._toDispose = ( new DisposableStore());
+        this._terminalProcessProxies = ( new Map());
+        this._profileProviders = ( new Map());
+        this._quickFixProviders = ( new Map());
+        this._os = OS;
+        this._proxy = ( _extHostContext.getProxy(ExtHostContext.ExtHostTerminalService));
+        this._toDispose.add(_terminalService.onDidCreateInstance((instance) => {
+            this._onTerminalOpened(instance);
+            this._onInstanceDimensionsChanged(instance);
+        }));
+        this._toDispose.add(_terminalService.onDidDisposeInstance(instance => this._onTerminalDisposed(instance)));
+        this._toDispose.add(_terminalService.onDidReceiveProcessId(instance => this._onTerminalProcessIdReady(instance)));
+        this._toDispose.add(_terminalService.onDidChangeInstanceDimensions(instance => this._onInstanceDimensionsChanged(instance)));
+        this._toDispose.add(_terminalService.onDidMaximumDimensionsChange(instance => this._onInstanceMaximumDimensionsChanged(instance)));
+        this._toDispose.add(_terminalService.onDidRequestStartExtensionTerminal(e => this._onRequestStartExtensionTerminal(e)));
+        this._toDispose.add(_terminalService.onDidChangeActiveInstance(instance => this._onActiveTerminalChanged(instance ? instance.instanceId : null)));
+        this._toDispose.add(_terminalService.onDidChangeInstanceTitle(instance => instance && this._onTitleChanged(instance.instanceId, instance.title)));
+        this._toDispose.add(_terminalService.onDidInputInstanceData(instance => this._proxy.$acceptTerminalInteraction(instance.instanceId)));
+        this._terminalService.instances.forEach(t => {
+            this._onTerminalOpened(t);
+            t.processReady.then(() => this._onTerminalProcessIdReady(t));
+        });
+        const activeInstance = this._terminalService.activeInstance;
+        if (activeInstance) {
+            this._proxy.$acceptActiveTerminalChanged(activeInstance.instanceId);
+        }
+        if (this._environmentVariableService.collections.size > 0) {
+            const collectionAsArray = [...this._environmentVariableService.collections.entries()];
+            const serializedCollections = ( collectionAsArray.map(e => {
+                return [e[0], serializeEnvironmentVariableCollection(e[1].map)];
+            }));
+            this._proxy.$initEnvironmentVariableCollections(serializedCollections);
+        }
+        remoteAgentService.getEnvironment().then(async (env) => {
+            this._os = env?.os || OS;
+            this._updateDefaultProfile();
+        });
+        this._terminalProfileService.onDidChangeAvailableProfiles(() => this._updateDefaultProfile());
+    }
+    dispose() {
+        this._toDispose.dispose();
+        this._linkProvider?.dispose();
+    }
+    async _updateDefaultProfile() {
+        const remoteAuthority = withNullAsUndefined(this._extHostContext.remoteAuthority);
+        const defaultProfile = this._terminalProfileResolverService.getDefaultProfile({ remoteAuthority, os: this._os });
+        const defaultAutomationProfile = this._terminalProfileResolverService.getDefaultProfile({ remoteAuthority, os: this._os, allowAutomationShell: true });
+        this._proxy.$acceptDefaultProfile(...(await Promise.all([defaultProfile, defaultAutomationProfile])));
+    }
+    async _getTerminalInstance(id) {
+        if (typeof id === 'string') {
+            return this._extHostTerminals.get(id);
+        }
+        return this._terminalService.getInstanceFromId(id);
+    }
+    async $createTerminal(extHostTerminalId, launchConfig) {
+        const shellLaunchConfig = {
+            name: launchConfig.name,
+            executable: launchConfig.shellPath,
+            args: launchConfig.shellArgs,
+            cwd: typeof launchConfig.cwd === 'string' ? launchConfig.cwd : URI.revive(launchConfig.cwd),
+            icon: launchConfig.icon,
+            color: launchConfig.color,
+            initialText: launchConfig.initialText,
+            waitOnExit: launchConfig.waitOnExit,
+            ignoreConfigurationCwd: true,
+            env: launchConfig.env,
+            strictEnv: launchConfig.strictEnv,
+            hideFromUser: launchConfig.hideFromUser,
+            customPtyImplementation: launchConfig.isExtensionCustomPtyTerminal
+                ? (id, cols, rows) => ( new TerminalProcessExtHostProxy(id, cols, rows, this._terminalService))
+                : undefined,
+            extHostTerminalId,
+            isFeatureTerminal: launchConfig.isFeatureTerminal,
+            isExtensionOwnedTerminal: launchConfig.isExtensionOwnedTerminal,
+            useShellEnvironment: launchConfig.useShellEnvironment,
+            isTransient: launchConfig.isTransient
+        };
+        const terminal = Promises.withAsyncBody(async (r) => {
+            const terminal = await this._terminalService.createTerminal({
+                config: shellLaunchConfig,
+                location: await this._deserializeParentTerminal(launchConfig.location)
+            });
+            r(terminal);
+        });
+        this._extHostTerminals.set(extHostTerminalId, terminal);
+        const terminalInstance = await terminal;
+        this._toDispose.add(terminalInstance.onDisposed(() => {
+            this._extHostTerminals.delete(extHostTerminalId);
+        }));
+    }
+    async _deserializeParentTerminal(location) {
+        if (typeof location === 'object' && 'parentTerminal' in location) {
+            const parentTerminal = await this._extHostTerminals.get(( location.parentTerminal.toString()));
+            return parentTerminal ? { parentTerminal } : undefined;
+        }
+        return location;
+    }
+    async $show(id, preserveFocus) {
+        const terminalInstance = await this._getTerminalInstance(id);
+        if (terminalInstance) {
+            this._terminalService.setActiveInstance(terminalInstance);
+            if (terminalInstance.target === TerminalLocation.Editor) {
+                await this._terminalEditorService.revealActiveEditor(preserveFocus);
+            }
+            else {
+                await this._terminalGroupService.showPanel(!preserveFocus);
+            }
+        }
+    }
+    async $hide(id) {
+        const instanceToHide = await this._getTerminalInstance(id);
+        const activeInstance = this._terminalService.activeInstance;
+        if (activeInstance && activeInstance.instanceId === instanceToHide?.instanceId && activeInstance.target !== TerminalLocation.Editor) {
+            this._terminalGroupService.hidePanel();
+        }
+    }
+    async $dispose(id) {
+        (await this._getTerminalInstance(id))?.dispose(TerminalExitReason.Extension);
+    }
+    async $sendText(id, text, addNewLine) {
+        const instance = await this._getTerminalInstance(id);
+        await instance?.sendText(text, addNewLine);
+    }
+    $sendProcessExit(terminalId, exitCode) {
+        this._terminalProcessProxies.get(terminalId)?.emitExit(exitCode);
+    }
+    $startSendingDataEvents() {
+        if (!this._dataEventTracker) {
+            this._dataEventTracker = this._instantiationService.createInstance(TerminalDataEventTracker, (id, data) => {
+                this._onTerminalData(id, data);
+            });
+            this._terminalService.instances.forEach(t => {
+                t.initialDataEvents?.forEach(d => this._onTerminalData(t.instanceId, d));
+            });
+        }
+    }
+    $stopSendingDataEvents() {
+        this._dataEventTracker?.dispose();
+        this._dataEventTracker = undefined;
+    }
+    $startLinkProvider() {
+        this._linkProvider?.dispose();
+        this._linkProvider = this._terminalLinkProviderService.registerLinkProvider(( new ExtensionTerminalLinkProvider(this._proxy)));
+    }
+    $stopLinkProvider() {
+        this._linkProvider?.dispose();
+        this._linkProvider = undefined;
+    }
+    $registerProcessSupport(isSupported) {
+        this._terminalService.registerProcessSupport(isSupported);
+    }
+    $registerProfileProvider(id, extensionIdentifier) {
+        this._profileProviders.set(id, this._terminalProfileService.registerTerminalProfileProvider(extensionIdentifier, id, {
+            createContributedTerminalProfile: async (options) => {
+                return this._proxy.$createContributedProfileTerminal(id, options);
+            }
+        }));
+    }
+    $unregisterProfileProvider(id) {
+        this._profileProviders.get(id)?.dispose();
+        this._profileProviders.delete(id);
+    }
+    async $registerQuickFixProvider(id, extensionId) {
+        this._quickFixProviders.set(id, this._terminalQuickFixService.registerQuickFixProvider(id, {
+            provideTerminalQuickFixes: async (terminalCommand, lines, option, token) => {
+                if (token.isCancellationRequested) {
+                    return;
+                }
+                if (option.outputMatcher?.length && option.outputMatcher.length > 40) {
+                    option.outputMatcher.length = 40;
+                    this._logService.warn('Cannot exceed output matcher length of 40');
+                }
+                const commandLineMatch = terminalCommand.command.match(option.commandLineMatcher);
+                if (!commandLineMatch) {
+                    return;
+                }
+                const outputMatcher = option.outputMatcher;
+                let outputMatch;
+                if (outputMatcher) {
+                    outputMatch = getOutputMatchForLines(lines, outputMatcher);
+                }
+                if (!outputMatch) {
+                    return;
+                }
+                const matchResult = { commandLineMatch, outputMatch, commandLine: terminalCommand.command };
+                if (matchResult) {
+                    const result = await this._proxy.$provideTerminalQuickFixes(id, matchResult, token);
+                    if (result && Array.isArray(result)) {
+                        return ( result.map(r => parseQuickFix(id, extensionId, r)));
+                    }
+                    else if (result) {
+                        return parseQuickFix(id, extensionId, result);
+                    }
+                }
+                return;
+            }
+        }));
+    }
+    $unregisterQuickFixProvider(id) {
+        this._quickFixProviders.get(id)?.dispose();
+        this._quickFixProviders.delete(id);
+    }
+    _onActiveTerminalChanged(terminalId) {
+        this._proxy.$acceptActiveTerminalChanged(terminalId);
+    }
+    _onTerminalData(terminalId, data) {
+        this._proxy.$acceptTerminalProcessData(terminalId, data);
+    }
+    _onTitleChanged(terminalId, name) {
+        this._proxy.$acceptTerminalTitleChange(terminalId, name);
+    }
+    _onTerminalDisposed(terminalInstance) {
+        this._proxy.$acceptTerminalClosed(terminalInstance.instanceId, terminalInstance.exitCode, terminalInstance.exitReason ?? TerminalExitReason.Unknown);
+    }
+    _onTerminalOpened(terminalInstance) {
+        const extHostTerminalId = terminalInstance.shellLaunchConfig.extHostTerminalId;
+        const shellLaunchConfigDto = {
+            name: terminalInstance.shellLaunchConfig.name,
+            executable: terminalInstance.shellLaunchConfig.executable,
+            args: terminalInstance.shellLaunchConfig.args,
+            cwd: terminalInstance.shellLaunchConfig.cwd,
+            env: terminalInstance.shellLaunchConfig.env,
+            hideFromUser: terminalInstance.shellLaunchConfig.hideFromUser
+        };
+        this._proxy.$acceptTerminalOpened(terminalInstance.instanceId, extHostTerminalId, terminalInstance.title, shellLaunchConfigDto);
+    }
+    _onTerminalProcessIdReady(terminalInstance) {
+        if (terminalInstance.processId === undefined) {
+            return;
+        }
+        this._proxy.$acceptTerminalProcessId(terminalInstance.instanceId, terminalInstance.processId);
+    }
+    _onInstanceDimensionsChanged(instance) {
+        this._proxy.$acceptTerminalDimensions(instance.instanceId, instance.cols, instance.rows);
+    }
+    _onInstanceMaximumDimensionsChanged(instance) {
+        this._proxy.$acceptTerminalMaximumDimensions(instance.instanceId, instance.maxCols, instance.maxRows);
+    }
+    _onRequestStartExtensionTerminal(request) {
+        const proxy = request.proxy;
+        this._terminalProcessProxies.set(proxy.instanceId, proxy);
+        const initialDimensions = request.cols && request.rows ? {
+            columns: request.cols,
+            rows: request.rows
+        } : undefined;
+        this._proxy.$startExtensionTerminal(proxy.instanceId, initialDimensions).then(request.callback);
+        proxy.onInput(data => this._proxy.$acceptProcessInput(proxy.instanceId, data));
+        proxy.onShutdown(immediate => this._proxy.$acceptProcessShutdown(proxy.instanceId, immediate));
+        proxy.onRequestCwd(() => this._proxy.$acceptProcessRequestCwd(proxy.instanceId));
+        proxy.onRequestInitialCwd(() => this._proxy.$acceptProcessRequestInitialCwd(proxy.instanceId));
+        proxy.onRequestLatency(() => this._onRequestLatency(proxy.instanceId));
+    }
+    $sendProcessData(terminalId, data) {
+        this._terminalProcessProxies.get(terminalId)?.emitData(data);
+    }
+    $sendProcessReady(terminalId, pid, cwd) {
+        this._terminalProcessProxies.get(terminalId)?.emitReady(pid, cwd);
+    }
+    $sendProcessProperty(terminalId, property) {
+        if (property.type === "title" ) {
+            const instance = this._terminalService.getInstanceFromId(terminalId);
+            instance?.rename(property.value);
+        }
+        this._terminalProcessProxies.get(terminalId)?.emitProcessProperty(property);
+    }
+    async _onRequestLatency(terminalId) {
+        const COUNT = 2;
+        let sum = 0;
+        for (let i = 0; i < COUNT; i++) {
+            const sw = StopWatch.create(true);
+            await this._proxy.$acceptProcessRequestLatency(terminalId);
+            sw.stop();
+            sum += sw.elapsed();
+        }
+        this._getTerminalProcess(terminalId)?.emitLatency(sum / COUNT);
+    }
+    _getTerminalProcess(terminalId) {
+        const terminal = this._terminalProcessProxies.get(terminalId);
+        if (!terminal) {
+            this._logService.error(`Unknown terminal: ${terminalId}`);
+            return undefined;
+        }
+        return terminal;
+    }
+    $setEnvironmentVariableCollection(extensionIdentifier, persistent, collection, descriptionMap) {
+        if (collection) {
+            const translatedCollection = {
+                persistent,
+                map: deserializeEnvironmentVariableCollection(collection),
+                descriptionMap: deserializeEnvironmentDescriptionMap(descriptionMap)
+            };
+            this._environmentVariableService.set(extensionIdentifier, translatedCollection);
+        }
+        else {
+            this._environmentVariableService.delete(extensionIdentifier);
+        }
+    }
+};
+MainThreadTerminalService = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadTerminalService),
+    ( __param(1, ITerminalService)),
+    ( __param(2, ITerminalLinkProviderService)),
+    ( __param(3, ITerminalQuickFixService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IEnvironmentVariableService)),
+    ( __param(6, ILogService)),
+    ( __param(7, ITerminalProfileResolverService)),
+    ( __param(8, IRemoteAgentService)),
+    ( __param(9, ITerminalGroupService)),
+    ( __param(10, ITerminalEditorService)),
+    ( __param(11, ITerminalProfileService))
+], MainThreadTerminalService);
+let TerminalDataEventTracker = class TerminalDataEventTracker extends Disposable {
+    constructor(_callback, _terminalService) {
+        super();
+        this._callback = _callback;
+        this._terminalService = _terminalService;
+        this._register(this._bufferer = ( new TerminalDataBufferer(this._callback)));
+        this._terminalService.instances.forEach(instance => this._registerInstance(instance));
+        this._register(this._terminalService.onDidCreateInstance(instance => this._registerInstance(instance)));
+        this._register(this._terminalService.onDidDisposeInstance(instance => this._bufferer.stopBuffering(instance.instanceId)));
+    }
+    _registerInstance(instance) {
+        this._register(this._bufferer.startBuffering(instance.instanceId, instance.onData));
+    }
+};
+TerminalDataEventTracker = ( __decorate([
+    ( __param(1, ITerminalService))
+], TerminalDataEventTracker));
+class ExtensionTerminalLinkProvider {
+    constructor(_proxy) {
+        this._proxy = _proxy;
+    }
+    async provideLinks(instance, line) {
+        const proxy = this._proxy;
+        const extHostLinks = await proxy.$provideLinks(instance.instanceId, line);
+        return ( extHostLinks.map(dto => ({
+            id: dto.id,
+            startIndex: dto.startIndex,
+            length: dto.length,
+            label: dto.label,
+            activate: () => proxy.$activateLink(instance.instanceId, dto.id)
+        })));
+    }
+}
+function getOutputMatchForLines(lines, outputMatcher) {
+    const match = lines.join('\n').match(outputMatcher.lineMatcher);
+    return match ? { regexMatch: match, outputLines: lines } : undefined;
+}
+function parseQuickFix(id, source, fix) {
+    let type = TerminalQuickFixType.Command;
+    if ('uri' in fix) {
+        fix.uri = URI.revive(fix.uri);
+        type = TerminalQuickFixType.Opener;
+    }
+    return { id, type, source, ...fix };
+}
+export { MainThreadTerminalService, getOutputMatchForLines };

package/dist/vscode/vs/workbench/api/browser/mainThreadTheming.js

@@ -0,0 +1,22 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+let MainThreadTheming = class MainThreadTheming {
+    constructor(extHostContext, themeService) {
+        this._themeService = themeService;
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostTheming));
+        this._themeChangeListener = this._themeService.onDidColorThemeChange(e => {
+            this._proxy.$onColorThemeChange(this._themeService.getColorTheme().type);
+        });
+        this._proxy.$onColorThemeChange(this._themeService.getColorTheme().type);
+    }
+    dispose() {
+        this._themeChangeListener.dispose();
+    }
+};
+MainThreadTheming = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadTheming),
+    ( __param(1, IThemeService))
+], MainThreadTheming);
+export { MainThreadTheming };

package/dist/vscode/vs/workbench/api/browser/mainThreadTreeViews.js

@@ -10,7 +10,7 @@ import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform
 import { IExtensionService } from '../../services/extensions/common/extensions.js';
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { createStringDataTransferItem, VSDataTransfer } from 'monaco-editor/esm/vs/base/common/dataTransfer.js';
-import { DataTransferCache } from '../common/shared/dataTransferCache.js';
+import { DataTransferFileCache } from '../common/shared/dataTransferCache.js';
 import { DataTransfer } from '../common/extHostTypeConverters.js';
 let MainThreadTreeViews = class MainThreadTreeViews extends Disposable {
     constructor(extHostContext, viewsService, notificationService, extensionService, logService) {
@@ -38,8 +38,9 @@ let MainThreadTreeViews = class MainThreadTreeViews extends Disposable {
             )) : undefined;
             const viewer = this.getTreeView(treeViewId);
             if (viewer) {
-                viewer.showCollapseAllAction = !!options.showCollapseAll;
-                viewer.canSelectMany = !!options.canSelectMany;
+                viewer.showCollapseAllAction = options.showCollapseAll;
+                viewer.canSelectMany = options.canSelectMany;
+                viewer.manuallyManageCheckboxes = options.manuallyManageCheckboxes;
                 viewer.dragAndDropController = dndController;
                 if (dndController) {
                     this._dndControllers.set(treeViewId, dndController);
@@ -190,12 +191,16 @@ class TreeViewDragAndDropController {
         this.dragMimeTypes = dragMimeTypes;
         this.hasWillDrop = hasWillDrop;
         this._proxy = _proxy;
-        this.dataTransfersCache = ( new DataTransferCache());
+        this.dataTransfersCache = ( new DataTransferFileCache());
     }
     async handleDrop(dataTransfer, targetTreeItem, token, operationUuid, sourceTreeId, sourceTreeItemHandles) {
         const request = this.dataTransfersCache.add(dataTransfer);
         try {
-            return await this._proxy.$handleDrop(this.treeViewId, request.id, await DataTransfer.toDataTransferDTO(dataTransfer), targetTreeItem?.handle, token, operationUuid, sourceTreeId, sourceTreeItemHandles);
+            const dataTransferDto = await DataTransfer.from(dataTransfer);
+            if (token.isCancellationRequested) {
+                return;
+            }
+            return await this._proxy.$handleDrop(this.treeViewId, request.id, dataTransferDto, targetTreeItem?.handle, token, operationUuid, sourceTreeId, sourceTreeItemHandles);
         }
         finally {
             request.dispose();