@codingame/monaco-vscode-extensions-service-override 1.83.7 → 1.83.9

package/vscode/src/vs/workbench/api/browser/mainThreadWebviews.js

@@ -0,0 +1,135 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { escape } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+import { ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { deserializeWebviewMessage, serializeWebviewMessage } from 'vscode/vscode/vs/workbench/api/common/extHostWebviewMessaging';
+import { SerializableObjectWithBuffers } from 'vscode/vscode/vs/workbench/services/extensions/common/proxyIdentifier';
+
+var MainThreadWebviews_1;
+let MainThreadWebviews = class MainThreadWebviews extends Disposable {
+    static { MainThreadWebviews_1 = this; }
+    static { this.standardSupportedLinkSchemes = ( new Set([
+        Schemas.http,
+        Schemas.https,
+        Schemas.mailto,
+        Schemas.vscode,
+        'vscode-insider',
+    ])); }
+    constructor(context, _openerService, _productService) {
+        super();
+        this._openerService = _openerService;
+        this._productService = _productService;
+        this._webviews = ( new Map());
+        this._proxy = ( context.getProxy(ExtHostContext.ExtHostWebviews));
+    }
+    addWebview(handle, webview, options) {
+        if (( this._webviews.has(handle))) {
+            throw new Error('Webview already registered');
+        }
+        this._webviews.set(handle, webview);
+        this.hookupWebviewEventDelegate(handle, webview, options);
+    }
+    $setHtml(handle, value) {
+        this.tryGetWebview(handle)?.setHtml(value);
+    }
+    $setOptions(handle, options) {
+        const webview = this.tryGetWebview(handle);
+        if (webview) {
+            webview.contentOptions = reviveWebviewContentOptions(options);
+        }
+    }
+    async $postMessage(handle, jsonMessage, ...buffers) {
+        const webview = this.tryGetWebview(handle);
+        if (!webview) {
+            return false;
+        }
+        const { message, arrayBuffers } = deserializeWebviewMessage(jsonMessage, buffers);
+        return webview.postMessage(message, arrayBuffers);
+    }
+    hookupWebviewEventDelegate(handle, webview, options) {
+        const disposables = ( new DisposableStore());
+        disposables.add(webview.onDidClickLink((uri) => this.onDidClickLink(handle, uri)));
+        disposables.add(webview.onMessage((message) => {
+            const serialized = serializeWebviewMessage(message.message, options);
+            this._proxy.$onMessage(handle, serialized.message, ( new SerializableObjectWithBuffers(serialized.buffers)));
+        }));
+        disposables.add(webview.onMissingCsp((extension) => this._proxy.$onMissingCsp(handle, extension.value)));
+        disposables.add(webview.onDidDispose(() => {
+            disposables.dispose();
+            this._webviews.delete(handle);
+        }));
+    }
+    onDidClickLink(handle, link) {
+        const webview = this.getWebview(handle);
+        if (this.isSupportedLink(webview, ( URI.parse(link)))) {
+            this._openerService.open(link, { fromUserGesture: true, allowContributedOpeners: true, allowCommands: Array.isArray(webview.contentOptions.enableCommandUris) || webview.contentOptions.enableCommandUris === true, fromWorkspace: true });
+        }
+    }
+    isSupportedLink(webview, link) {
+        if (( MainThreadWebviews_1.standardSupportedLinkSchemes.has(link.scheme))) {
+            return true;
+        }
+        if (!isWeb && this._productService.urlProtocol === link.scheme) {
+            return true;
+        }
+        if (link.scheme === Schemas.command) {
+            if (Array.isArray(webview.contentOptions.enableCommandUris)) {
+                return webview.contentOptions.enableCommandUris.includes(link.path);
+            }
+            return webview.contentOptions.enableCommandUris === true;
+        }
+        return false;
+    }
+    tryGetWebview(handle) {
+        return this._webviews.get(handle);
+    }
+    getWebview(handle) {
+        const webview = this.tryGetWebview(handle);
+        if (!webview) {
+            throw new Error(`Unknown webview handle:${handle}`);
+        }
+        return webview;
+    }
+    getWebviewResolvedFailedContent(viewType) {
+        return `<!DOCTYPE html>
+		<html>
+			<head>
+				<meta http-equiv="Content-type" content="text/html;charset=UTF-8">
+				<meta http-equiv="Content-Security-Policy" content="default-src 'none';">
+			</head>
+			<body>${( localizeWithPath(
+            'vs/workbench/api/browser/mainThreadWebviews',
+            'errorMessage',
+            "An error occurred while loading view: {0}",
+            escape(viewType)
+        ))}</body>
+		</html>`;
+    }
+};
+MainThreadWebviews = MainThreadWebviews_1 = ( __decorate([
+    ( __param(1, IOpenerService)),
+    ( __param(2, IProductService))
+], MainThreadWebviews));
+function reviveWebviewExtension(extensionData) {
+    return {
+        id: extensionData.id,
+        location: URI.revive(extensionData.location),
+    };
+}
+function reviveWebviewContentOptions(webviewOptions) {
+    return {
+        allowScripts: webviewOptions.enableScripts,
+        allowForms: webviewOptions.enableForms,
+        enableCommandUris: webviewOptions.enableCommandUris,
+        localResourceRoots: Array.isArray(webviewOptions.localResourceRoots) ? ( webviewOptions.localResourceRoots.map(r => URI.revive(r))) : undefined,
+        portMapping: webviewOptions.portMapping,
+    };
+}
+
+export { MainThreadWebviews, reviveWebviewContentOptions, reviveWebviewExtension };

package/vscode/src/vs/workbench/api/browser/mainThreadWindow.js

@@ -0,0 +1,57 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host';
+import { IUserActivityService } from 'vscode/vscode/vs/workbench/services/userActivity/common/userActivityService';
+
+let MainThreadWindow = class MainThreadWindow {
+    constructor(extHostContext, hostService, openerService, userActivityService) {
+        this.hostService = hostService;
+        this.openerService = openerService;
+        this.userActivityService = userActivityService;
+        this.disposables = ( new DisposableStore());
+        this.proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostWindow));
+        Event.latch(hostService.onDidChangeFocus)(this.proxy.$onDidChangeWindowFocus, this.proxy, this.disposables);
+        userActivityService.onDidChangeIsActive(this.proxy.$onDidChangeWindowActive, this.proxy, this.disposables);
+    }
+    dispose() {
+        this.disposables.dispose();
+    }
+    $getInitialState() {
+        return Promise.resolve({
+            isFocused: this.hostService.hasFocus,
+            isActive: this.userActivityService.isActive,
+        });
+    }
+    async $openUri(uriComponents, uriString, options) {
+        const uri = ( URI.from(uriComponents));
+        let target;
+        if (uriString && ( ( URI.parse(uriString)).toString()) === ( uri.toString())) {
+            target = uriString;
+        }
+        else {
+            target = uri;
+        }
+        return this.openerService.open(target, {
+            openExternal: true,
+            allowTunneling: options.allowTunneling,
+            allowContributedOpeners: options.allowContributedOpeners,
+        });
+    }
+    async $asExternalUri(uriComponents, options) {
+        const result = await this.openerService.resolveExternalUri(URI.revive(uriComponents), options);
+        return result.resolved;
+    }
+};
+MainThreadWindow = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadWindow),
+    ( __param(1, IHostService)),
+    ( __param(2, IOpenerService)),
+    ( __param(3, IUserActivityService))
+], MainThreadWindow);
+
+export { MainThreadWindow };

package/vscode/src/vs/workbench/api/browser/mainThreadWorkspace.js

@@ -0,0 +1,273 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { isNative } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { IRequestService } from 'vscode/vscode/vs/platform/request/common/request';
+import { IWorkspaceTrustManagementService, IWorkspaceTrustRequestService } from 'monaco-editor/esm/vs/platform/workspace/common/workspaceTrust.js';
+import { IWorkspaceContextService, isUntitledWorkspace } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { checkGlobFileExists } from 'vscode/vscode/vs/workbench/services/extensions/common/workspaceContains';
+import { QueryBuilder } from 'vscode/vscode/vs/workbench/services/search/common/queryBuilder';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { ISearchService } from 'vscode/vscode/vs/workbench/services/search/common/search';
+import { IWorkspaceEditingService } from 'vscode/vscode/vs/workbench/services/workspaces/common/workspaceEditing';
+import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
+import { IEditSessionIdentityService } from 'vscode/vscode/vs/platform/workspace/common/editSessions';
+import { SideBySideEditor, EditorResourceAccessor } from 'vscode/vscode/vs/workbench/common/editor';
+import { firstOrDefault, coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { ICanonicalUriService } from 'vscode/vscode/vs/platform/workspace/common/canonicalUri';
+
+let MainThreadWorkspace = class MainThreadWorkspace {
+    constructor(extHostContext, _searchService, _contextService, _editSessionIdentityService, _canonicalUriService, _editorService, _workspaceEditingService, _notificationService, _requestService, _instantiationService, _labelService, _environmentService, fileService, _workspaceTrustManagementService, _workspaceTrustRequestService) {
+        this._searchService = _searchService;
+        this._contextService = _contextService;
+        this._editSessionIdentityService = _editSessionIdentityService;
+        this._canonicalUriService = _canonicalUriService;
+        this._editorService = _editorService;
+        this._workspaceEditingService = _workspaceEditingService;
+        this._notificationService = _notificationService;
+        this._requestService = _requestService;
+        this._instantiationService = _instantiationService;
+        this._labelService = _labelService;
+        this._environmentService = _environmentService;
+        this._workspaceTrustManagementService = _workspaceTrustManagementService;
+        this._workspaceTrustRequestService = _workspaceTrustRequestService;
+        this._toDispose = ( new DisposableStore());
+        this._activeCancelTokens = Object.create(null);
+        this._queryBuilder = this._instantiationService.createInstance(QueryBuilder);
+        this.registeredEditSessionProviders = ( new Map());
+        this.registeredCanonicalUriProviders = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostWorkspace));
+        const workspace = this._contextService.getWorkspace();
+        if (workspace.configuration && !isNative && !fileService.hasProvider(workspace.configuration)) {
+            this._proxy.$initializeWorkspace(this.getWorkspaceData(workspace), this.isWorkspaceTrusted());
+        }
+        else {
+            this._contextService.getCompleteWorkspace().then(workspace => this._proxy.$initializeWorkspace(this.getWorkspaceData(workspace), this.isWorkspaceTrusted()));
+        }
+        this._contextService.onDidChangeWorkspaceFolders(this._onDidChangeWorkspace, this, this._toDispose);
+        this._contextService.onDidChangeWorkbenchState(this._onDidChangeWorkspace, this, this._toDispose);
+        this._workspaceTrustManagementService.onDidChangeTrust(this._onDidGrantWorkspaceTrust, this, this._toDispose);
+    }
+    dispose() {
+        this._toDispose.dispose();
+        for (const requestId in this._activeCancelTokens) {
+            const tokenSource = this._activeCancelTokens[requestId];
+            tokenSource.cancel();
+        }
+    }
+    $updateWorkspaceFolders(extensionName, index, deleteCount, foldersToAdd) {
+        const workspaceFoldersToAdd = ( foldersToAdd.map(f => ({ uri: URI.revive(f.uri), name: f.name })));
+        this._notificationService.status(this.getStatusMessage(extensionName, workspaceFoldersToAdd.length, deleteCount), { hideAfter: 10 * 1000  });
+        return this._workspaceEditingService.updateFolders(index, deleteCount, workspaceFoldersToAdd, true);
+    }
+    getStatusMessage(extensionName, addCount, removeCount) {
+        let message;
+        const wantsToAdd = addCount > 0;
+        const wantsToDelete = removeCount > 0;
+        if (wantsToAdd && !wantsToDelete) {
+            if (addCount === 1) {
+                message = ( localizeWithPath(
+                    'vs/workbench/api/browser/mainThreadWorkspace',
+                    'folderStatusMessageAddSingleFolder',
+                    "Extension '{0}' added 1 folder to the workspace",
+                    extensionName
+                ));
+            }
+            else {
+                message = ( localizeWithPath(
+                    'vs/workbench/api/browser/mainThreadWorkspace',
+                    'folderStatusMessageAddMultipleFolders',
+                    "Extension '{0}' added {1} folders to the workspace",
+                    extensionName,
+                    addCount
+                ));
+            }
+        }
+        else if (wantsToDelete && !wantsToAdd) {
+            if (removeCount === 1) {
+                message = ( localizeWithPath(
+                    'vs/workbench/api/browser/mainThreadWorkspace',
+                    'folderStatusMessageRemoveSingleFolder',
+                    "Extension '{0}' removed 1 folder from the workspace",
+                    extensionName
+                ));
+            }
+            else {
+                message = ( localizeWithPath(
+                    'vs/workbench/api/browser/mainThreadWorkspace',
+                    'folderStatusMessageRemoveMultipleFolders',
+                    "Extension '{0}' removed {1} folders from the workspace",
+                    extensionName,
+                    removeCount
+                ));
+            }
+        }
+        else {
+            message = ( localizeWithPath(
+                'vs/workbench/api/browser/mainThreadWorkspace',
+                'folderStatusChangeFolder',
+                "Extension '{0}' changed folders of the workspace",
+                extensionName
+            ));
+        }
+        return message;
+    }
+    _onDidChangeWorkspace() {
+        this._proxy.$acceptWorkspaceData(this.getWorkspaceData(this._contextService.getWorkspace()));
+    }
+    getWorkspaceData(workspace) {
+        if (this._contextService.getWorkbenchState() === 1 ) {
+            return null;
+        }
+        return {
+            configuration: workspace.configuration || undefined,
+            isUntitled: workspace.configuration ? isUntitledWorkspace(workspace.configuration, this._environmentService) : false,
+            folders: workspace.folders,
+            id: workspace.id,
+            name: this._labelService.getWorkspaceLabel(workspace),
+            transient: workspace.transient
+        };
+    }
+    $startFileSearch(includePattern, _includeFolder, excludePatternOrDisregardExcludes, maxResults, token) {
+        const includeFolder = URI.revive(_includeFolder);
+        const workspace = this._contextService.getWorkspace();
+        const query = this._queryBuilder.file(includeFolder ? [includeFolder] : workspace.folders, {
+            maxResults: maxResults ?? undefined,
+            disregardExcludeSettings: (excludePatternOrDisregardExcludes === false) || undefined,
+            disregardSearchExcludeSettings: true,
+            disregardIgnoreFiles: true,
+            includePattern: includePattern ?? undefined,
+            excludePattern: typeof excludePatternOrDisregardExcludes === 'string' ? excludePatternOrDisregardExcludes : undefined,
+            _reason: 'startFileSearch'
+        });
+        return this._searchService.fileSearch(query, token).then(result => {
+            return ( result.results.map(m => m.resource));
+        }, err => {
+            if (!isCancellationError(err)) {
+                return Promise.reject(err);
+            }
+            return null;
+        });
+    }
+    $startTextSearch(pattern, _folder, options, requestId, token) {
+        const folder = URI.revive(_folder);
+        const workspace = this._contextService.getWorkspace();
+        const folders = folder ? [folder] : ( workspace.folders.map(folder => folder.uri));
+        const query = this._queryBuilder.text(pattern, folders, options);
+        query._reason = 'startTextSearch';
+        const onProgress = (p) => {
+            if (p.results) {
+                this._proxy.$handleTextSearchResult(p, requestId);
+            }
+        };
+        const search = this._searchService.textSearch(query, token, onProgress).then(result => {
+            return { limitHit: result.limitHit };
+        }, err => {
+            if (!isCancellationError(err)) {
+                return Promise.reject(err);
+            }
+            return null;
+        });
+        return search;
+    }
+    $checkExists(folders, includes, token) {
+        return this._instantiationService.invokeFunction((accessor) => checkGlobFileExists(accessor, folders, includes, token));
+    }
+    async $save(uriComponents, options) {
+        const uri = URI.revive(uriComponents);
+        const editors = [...this._editorService.findEditors(uri, { supportSideBySide: SideBySideEditor.PRIMARY })];
+        const result = await this._editorService.save(editors, {
+            reason: 1 ,
+            saveAs: options.saveAs,
+            force: !options.saveAs
+        });
+        return firstOrDefault(this._saveResultToUris(result));
+    }
+    _saveResultToUris(result) {
+        if (!result.success) {
+            return [];
+        }
+        return coalesce(( result.editors.map(
+            editor => EditorResourceAccessor.getCanonicalUri(editor, { supportSideBySide: SideBySideEditor.PRIMARY })
+        )));
+    }
+    $saveAll(includeUntitled) {
+        return this._editorService.saveAll({ includeUntitled }).then(res => res.success);
+    }
+    $resolveProxy(url) {
+        return this._requestService.resolveProxy(url);
+    }
+    $requestWorkspaceTrust(options) {
+        return this._workspaceTrustRequestService.requestWorkspaceTrust(options);
+    }
+    isWorkspaceTrusted() {
+        return this._workspaceTrustManagementService.isWorkspaceTrusted();
+    }
+    _onDidGrantWorkspaceTrust() {
+        this._proxy.$onDidGrantWorkspaceTrust();
+    }
+    $registerEditSessionIdentityProvider(handle, scheme) {
+        const disposable = this._editSessionIdentityService.registerEditSessionIdentityProvider({
+            scheme: scheme,
+            getEditSessionIdentifier: async (workspaceFolder, token) => {
+                return this._proxy.$getEditSessionIdentifier(workspaceFolder.uri, token);
+            },
+            provideEditSessionIdentityMatch: async (workspaceFolder, identity1, identity2, token) => {
+                return this._proxy.$provideEditSessionIdentityMatch(workspaceFolder.uri, identity1, identity2, token);
+            }
+        });
+        this.registeredEditSessionProviders.set(handle, disposable);
+        this._toDispose.add(disposable);
+    }
+    $unregisterEditSessionIdentityProvider(handle) {
+        const disposable = this.registeredEditSessionProviders.get(handle);
+        disposable?.dispose();
+        this.registeredEditSessionProviders.delete(handle);
+    }
+    $registerCanonicalUriProvider(handle, scheme) {
+        const disposable = this._canonicalUriService.registerCanonicalUriProvider({
+            scheme: scheme,
+            provideCanonicalUri: async (uri, targetScheme, token) => {
+                const result = await this._proxy.$provideCanonicalUri(uri, targetScheme, token);
+                if (result) {
+                    return URI.revive(result);
+                }
+                return result;
+            }
+        });
+        this.registeredCanonicalUriProviders.set(handle, disposable);
+        this._toDispose.add(disposable);
+    }
+    $unregisterCanonicalUriProvider(handle) {
+        const disposable = this.registeredCanonicalUriProviders.get(handle);
+        disposable?.dispose();
+        this.registeredCanonicalUriProviders.delete(handle);
+    }
+};
+MainThreadWorkspace = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadWorkspace),
+    ( __param(1, ISearchService)),
+    ( __param(2, IWorkspaceContextService)),
+    ( __param(3, IEditSessionIdentityService)),
+    ( __param(4, ICanonicalUriService)),
+    ( __param(5, IEditorService)),
+    ( __param(6, IWorkspaceEditingService)),
+    ( __param(7, INotificationService)),
+    ( __param(8, IRequestService)),
+    ( __param(9, IInstantiationService)),
+    ( __param(10, ILabelService)),
+    ( __param(11, IEnvironmentService)),
+    ( __param(12, IFileService)),
+    ( __param(13, IWorkspaceTrustManagementService)),
+    ( __param(14, IWorkspaceTrustRequestService))
+], MainThreadWorkspace);
+
+export { MainThreadWorkspace };

package/{dist/main/vscode → vscode}/src/vs/workbench/api/common/extHost.api.impl.d.ts

@@ -1,6 +1,6 @@
 import { ExtHostConfigProvider } from './extHostConfiguration.js';
 import { ExtensionDescriptionRegistry } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionDescriptionRegistry';
-import * as vscodeProposed_d from '../../../../../../../../vscode-proposed.js';
+import * as vscode from 'vscode';
 import { IExtensionDescription } from 'vscode/vscode/vs/platform/extensions/common/extensions';
 
 interface IExtensionRegistries {
@@ -8,7 +8,7 @@ interface IExtensionRegistries {
     all: ExtensionDescriptionRegistry;
 }
 interface IExtensionApiFactory {
-    (extension: IExtensionDescription, extensionInfo: IExtensionRegistries, configProvider: ExtHostConfigProvider): typeof vscodeProposed_d;
+    (extension: IExtensionDescription, extensionInfo: IExtensionRegistries, configProvider: ExtHostConfigProvider): typeof vscode;
 }
 
 export type { IExtensionApiFactory, IExtensionRegistries };

package/{dist/main/vscode → vscode}/src/vs/workbench/api/common/extHostConfiguration.d.ts

@@ -1,6 +1,6 @@
 import { ServiceIdentifier } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { Event } from 'vscode/vscode/vs/base/common/event';
-import { ConfigurationChangeEvent, ConfigurationScope, WorkspaceConfiguration } from 'vscode';
+import * as vscode from 'vscode';
 import { IExtHostWorkspace, ExtHostWorkspace } from './extHostWorkspace.js';
 import { ExtHostConfigurationShape, IConfigurationInitData, MainThreadConfigurationShape } from './extHost.protocol.js';
 import { IConfigurationChange } from 'vscode/vscode/vs/platform/configuration/common/configuration';
@@ -28,9 +28,9 @@ declare class ExtHostConfigProvider {
     private _configuration;
     private _logService;
     constructor(proxy: MainThreadConfigurationShape, extHostWorkspace: ExtHostWorkspace, data: IConfigurationInitData, logService: ILogService);
-    get onDidChangeConfiguration(): Event<ConfigurationChangeEvent>;
+    get onDidChangeConfiguration(): Event<vscode.ConfigurationChangeEvent>;
     $acceptConfigurationChanged(data: IConfigurationInitData, change: IConfigurationChange): void;
-    getConfiguration(section?: string, scope?: ConfigurationScope | null, extensionDescription?: IExtensionDescription): WorkspaceConfiguration;
+    getConfiguration(section?: string, scope?: vscode.ConfigurationScope | null, extensionDescription?: IExtensionDescription): vscode.WorkspaceConfiguration;
     private _toReadonlyValue;
     private _validateConfigurationAccess;
     private _toConfigurationChangeEvent;

package/{dist/main/vscode → vscode}/src/vs/workbench/api/common/extHostExtensionService.d.ts

@@ -10,7 +10,7 @@ import { IExtensionAPI, ExtensionActivationTimesBuilder } from './extHostExtensi
 import { ExtHostWorkspace, IExtHostWorkspace } from './extHostWorkspace.js';
 import { ExtensionActivationReason, ActivationKind } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
 import { ExtensionDescriptionRegistry } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionDescriptionRegistry';
-import { RemoteAuthorityResolver, ExecServer } from '../../../../../../../../vscode-proposed.js';
+import * as vscode from 'vscode';
 import { ExtensionIdentifier, IExtensionDescription } from 'vscode/vscode/vs/platform/extensions/common/extensions';
 import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
 import { ExtensionRuntime } from './extHostTypes.js';
@@ -25,7 +25,6 @@ import { IResolveAuthorityResult } from 'vscode/vscode/vs/workbench/services/ext
 import { IExtHostLocalizationService } from './extHostLocalizationService.js';
 import { IExtHostManagedSockets } from './extHostManagedSockets.js';
 import { Dto } from 'vscode/vscode/vs/workbench/services/extensions/common/proxyIdentifier';
-import { Disposable as Disposable$1 } from 'vscode';
 
 declare const IHostUtils: ServiceIdentifier<IHostUtils>;
 interface IHostUtils {
@@ -108,8 +107,8 @@ declare abstract class AbstractExtHostExtensionService extends Disposable implem
     $extensionTestsExecute(): Promise<number>;
     private _doHandleExtensionTests;
     private _startExtensionHost;
-    registerRemoteAuthorityResolver(authorityPrefix: string, resolver: RemoteAuthorityResolver): Disposable$1;
-    getRemoteExecServer(remoteAuthority: string): Promise<ExecServer | undefined>;
+    registerRemoteAuthorityResolver(authorityPrefix: string, resolver: vscode.RemoteAuthorityResolver): vscode.Disposable;
+    getRemoteExecServer(remoteAuthority: string): Promise<vscode.ExecServer | undefined>;
     private _activateAndGetResolver;
     $resolveAuthority(remoteAuthorityChain: string, resolveAttempt: number): Promise<Dto<IResolveAuthorityResult>>;
     $getCanonicalURI(remoteAuthority: string, uriComponents: UriComponents): Promise<UriComponents | null>;

package/{dist/main/vscode → vscode}/src/vs/workbench/api/common/extHostManagedSockets.d.ts

@@ -1,9 +1,9 @@
 import { ServiceIdentifier } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { ExtHostManagedSocketsShape } from './extHost.protocol.js';
-import { ManagedMessagePassing } from '../../../../../../../../vscode-proposed.js';
+import * as vscode from 'vscode';
 
 interface IExtHostManagedSockets extends ExtHostManagedSocketsShape {
-    setFactory(socketFactoryId: number, makeConnection: () => Thenable<ManagedMessagePassing>): void;
+    setFactory(socketFactoryId: number, makeConnection: () => Thenable<vscode.ManagedMessagePassing>): void;
     readonly _serviceBrand: undefined;
 }
 declare const IExtHostManagedSockets: ServiceIdentifier<IExtHostManagedSockets>;

package/{dist/main/vscode → vscode}/src/vs/workbench/api/common/extHostTerminalService.d.ts

@@ -1,14 +1,13 @@
 import { ServiceIdentifier } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { Terminal, TerminalDimensionsChangeEvent, TerminalDataWriteEvent, TerminalExecutedCommand, TerminalQuickFixProvider } from '../../../../../../../../vscode-proposed.js';
+import * as vscode from 'vscode';
 import { Event } from 'vscode/vscode/vs/base/common/event';
 import { ExtHostTerminalServiceShape, ExtHostTerminalIdentifier } from './extHost.protocol.js';
 import { IDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { IExtensionDescription } from 'vscode/vscode/vs/platform/extensions/common/extensions';
 import { TerminalLocation } from 'vscode/vscode/vs/platform/terminal/common/terminal';
-import { TerminalOptions, ExtensionTerminalOptions, Pseudoterminal, TerminalLinkProvider, Disposable, TerminalProfileProvider, EnvironmentVariableCollection, EnvironmentVariableScope } from 'vscode';
 
-interface IEnvironmentVariableCollection extends EnvironmentVariableCollection {
-    getScoped(scope: EnvironmentVariableScope): EnvironmentVariableCollection;
+interface IEnvironmentVariableCollection extends vscode.EnvironmentVariableCollection {
+    getScoped(scope: vscode.EnvironmentVariableScope): vscode.EnvironmentVariableCollection;
 }
 interface ITerminalInternalOptions {
     isFeatureTerminal?: boolean;
@@ -28,25 +27,25 @@ interface ITerminalInternalOptions {
 
 interface IExtHostTerminalService extends ExtHostTerminalServiceShape, IDisposable {
     readonly _serviceBrand: undefined;
-    activeTerminal: Terminal | undefined;
-    terminals: Terminal[];
-    readonly onDidCloseTerminal: Event<Terminal>;
-    readonly onDidOpenTerminal: Event<Terminal>;
-    readonly onDidChangeActiveTerminal: Event<Terminal | undefined>;
-    readonly onDidChangeTerminalDimensions: Event<TerminalDimensionsChangeEvent>;
-    readonly onDidChangeTerminalState: Event<Terminal>;
-    readonly onDidWriteTerminalData: Event<TerminalDataWriteEvent>;
-    readonly onDidExecuteTerminalCommand: Event<TerminalExecutedCommand>;
+    activeTerminal: vscode.Terminal | undefined;
+    terminals: vscode.Terminal[];
+    readonly onDidCloseTerminal: Event<vscode.Terminal>;
+    readonly onDidOpenTerminal: Event<vscode.Terminal>;
+    readonly onDidChangeActiveTerminal: Event<vscode.Terminal | undefined>;
+    readonly onDidChangeTerminalDimensions: Event<vscode.TerminalDimensionsChangeEvent>;
+    readonly onDidChangeTerminalState: Event<vscode.Terminal>;
+    readonly onDidWriteTerminalData: Event<vscode.TerminalDataWriteEvent>;
+    readonly onDidExecuteTerminalCommand: Event<vscode.TerminalExecutedCommand>;
     readonly onDidChangeShell: Event<string>;
-    createTerminal(name?: string, shellPath?: string, shellArgs?: readonly string[] | string): Terminal;
-    createTerminalFromOptions(options: TerminalOptions, internalOptions?: ITerminalInternalOptions): Terminal;
-    createExtensionTerminal(options: ExtensionTerminalOptions): Terminal;
-    attachPtyToTerminal(id: number, pty: Pseudoterminal): void;
+    createTerminal(name?: string, shellPath?: string, shellArgs?: readonly string[] | string): vscode.Terminal;
+    createTerminalFromOptions(options: vscode.TerminalOptions, internalOptions?: ITerminalInternalOptions): vscode.Terminal;
+    createExtensionTerminal(options: vscode.ExtensionTerminalOptions): vscode.Terminal;
+    attachPtyToTerminal(id: number, pty: vscode.Pseudoterminal): void;
     getDefaultShell(useAutomationShell: boolean): string;
     getDefaultShellArgs(useAutomationShell: boolean): string[] | string;
-    registerLinkProvider(provider: TerminalLinkProvider): Disposable;
-    registerProfileProvider(extension: IExtensionDescription, id: string, provider: TerminalProfileProvider): Disposable;
-    registerTerminalQuickFixProvider(id: string, extensionId: string, provider: TerminalQuickFixProvider): Disposable;
+    registerLinkProvider(provider: vscode.TerminalLinkProvider): vscode.Disposable;
+    registerProfileProvider(extension: IExtensionDescription, id: string, provider: vscode.TerminalProfileProvider): vscode.Disposable;
+    registerTerminalQuickFixProvider(id: string, extensionId: string, provider: vscode.TerminalQuickFixProvider): vscode.Disposable;
     getEnvironmentVariableCollection(extension: IExtensionDescription): IEnvironmentVariableCollection;
 }
 declare const IExtHostTerminalService: ServiceIdentifier<IExtHostTerminalService>;

package/{dist/main/vscode → vscode}/src/vs/workbench/api/common/extHostTunnelService.d.ts

@@ -1,19 +1,18 @@
 import { ServiceIdentifier } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { IDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { IExtensionDescription } from 'vscode/vscode/vs/platform/extensions/common/extensions';
-import { Tunnel, TunnelDescription, RemoteAuthorityResolver, ManagedResolvedAuthority, PortAttributesProvider, TunnelProvider, TunnelInformation } from '../../../../../../../../vscode-proposed.js';
+import * as vscode from 'vscode';
 import { TunnelOptions } from 'vscode/vscode/vs/platform/tunnel/common/tunnel';
 import { ExtHostTunnelServiceShape, PortAttributesSelector } from './extHost.protocol.js';
-import { Event } from 'vscode';
 
 interface IExtHostTunnelService extends ExtHostTunnelServiceShape {
     readonly _serviceBrand: undefined;
-    openTunnel(extension: IExtensionDescription, forward: TunnelOptions): Promise<Tunnel | undefined>;
-    getTunnels(): Promise<TunnelDescription[]>;
-    onDidChangeTunnels: Event<void>;
-    setTunnelFactory(provider: RemoteAuthorityResolver | undefined, managedRemoteAuthority: ManagedResolvedAuthority | undefined): Promise<IDisposable>;
-    registerPortsAttributesProvider(portSelector: PortAttributesSelector, provider: PortAttributesProvider): IDisposable;
-    registerTunnelProvider(provider: TunnelProvider, information: TunnelInformation): Promise<IDisposable>;
+    openTunnel(extension: IExtensionDescription, forward: TunnelOptions): Promise<vscode.Tunnel | undefined>;
+    getTunnels(): Promise<vscode.TunnelDescription[]>;
+    onDidChangeTunnels: vscode.Event<void>;
+    setTunnelFactory(provider: vscode.RemoteAuthorityResolver | undefined, managedRemoteAuthority: vscode.ManagedResolvedAuthority | undefined): Promise<IDisposable>;
+    registerPortsAttributesProvider(portSelector: PortAttributesSelector, provider: vscode.PortAttributesProvider): IDisposable;
+    registerTunnelProvider(provider: vscode.TunnelProvider, information: vscode.TunnelInformation): Promise<IDisposable>;
 }
 declare const IExtHostTunnelService: ServiceIdentifier<IExtHostTunnelService>;