@codingame/monaco-vscode-views-service-override 1.83.4 → 1.83.6

package/missing-services.js

@@ -0,0 +1,2141 @@
+import { __decorate, __param } from './external/tslib/tslib.es6.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { IPaneCompositePartService } from 'vscode/vscode/vs/workbench/services/panecomposite/browser/panecomposite';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { ITextFileService } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
+import { IWorkingCopyFileService, WorkingCopyFileService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService';
+import { IPathService } from 'vscode/vscode/vs/workbench/services/path/common/pathService';
+import { registerSingleton } from 'monaco-editor/esm/vs/platform/instantiation/common/extensions.js';
+import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+import { ILanguageStatusService } from 'vscode/vscode/vs/workbench/services/languageStatus/common/languageStatusService';
+import { LanguageFeatureRegistry } from 'monaco-editor/esm/vs/editor/common/languageFeatureRegistry.js';
+import { compare } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host';
+import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+import { ILanguageDetectionService } from 'vscode/vscode/vs/workbench/services/languageDetection/common/languageDetectionWorkerService';
+import { IExtensionService, NullExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { IKeyboardLayoutService } from 'vscode/vscode/vs/platform/keyboardLayout/common/keyboardLayout';
+import { OS } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
+import { IUserDataInitializationService } from 'vscode/vscode/vs/workbench/services/userData/browser/userDataInit';
+import { BrowserHostColorSchemeService } from 'vscode/vscode/vs/workbench/services/themes/browser/browserHostColorSchemeService';
+import { IHostColorSchemeService } from 'vscode/vscode/vs/workbench/services/themes/common/hostColorSchemeService';
+import { IPreferencesService } from 'vscode/vscode/vs/workbench/services/preferences/common/preferences';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
+import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import { IUserDataProfilesService, toUserDataProfile } from 'monaco-editor/esm/vs/platform/userDataProfile/common/userDataProfile.js';
+import { IPolicyService } from 'monaco-editor/esm/vs/platform/policy/common/policy.js';
+import { IUserDataProfileService, IUserDataProfileImportExportService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
+import { UserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfileService';
+import { ISnippetsService } from 'vscode/vscode/vs/workbench/contrib/snippets/browser/snippets';
+import { ILoggerService, AbstractLoggerService, LogLevel, NullLogger } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { FallbackKeyboardMapper } from 'vscode/vscode/vs/workbench/services/keybinding/common/fallbackKeyboardMapper';
+import { ITextMateTokenizationService } from 'vscode/vscode/vs/workbench/services/textMate/browser/textMateTokenizationFeature';
+import { IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
+import { IWorkspaceTrustRequestService, IWorkspaceTrustEnablementService } from 'monaco-editor/esm/vs/platform/workspace/common/workspaceTrust.js';
+import { IActivityService } from 'vscode/vscode/vs/workbench/services/activity/common/activity';
+import { IExtensionHostDebugService } from 'vscode/vscode/vs/platform/debug/common/extensionHostDebug';
+import { IViewsService, IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
+import { IHistoryService } from 'vscode/vscode/vs/workbench/services/history/common/history';
+import { ITaskService } from 'vscode/vscode/vs/workbench/contrib/tasks/common/taskService';
+import { IConfigurationResolverService } from 'vscode/vscode/vs/workbench/services/configurationResolver/common/configurationResolver';
+import { BrowserPathService } from 'vscode/vscode/vs/workbench/services/path/browser/pathService';
+import { IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService';
+import { ICustomEndpointTelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { NullEndpointTelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetryUtils';
+import { ISearchService } from 'vscode/vscode/vs/workbench/services/search/common/search';
+import { IRequestService } from 'vscode/vscode/vs/platform/request/common/request';
+import { IEditSessionIdentityService } from 'vscode/vscode/vs/platform/workspace/common/editSessions';
+import { IWorkspaceEditingService } from 'vscode/vscode/vs/workbench/services/workspaces/common/workspaceEditing';
+import { ITimerService } from 'vscode/vscode/vs/workbench/services/timer/browser/timerService';
+import { IExtensionsWorkbenchService } from 'vscode/vscode/vs/workbench/contrib/extensions/common/extensions';
+import { IWorkbenchExtensionEnablementService, IWorkbenchExtensionManagementService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionManagement';
+import { ITunnelService } from 'vscode/vscode/vs/platform/tunnel/common/tunnel';
+import { IWorkingCopyBackupService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup';
+import { IWorkingCopyService, WorkingCopyService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService';
+import { IFilesConfigurationService, FilesConfigurationService } from 'vscode/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService';
+import { IUntitledTextEditorService } from 'vscode/vscode/vs/workbench/services/untitled/common/untitledTextEditorService';
+import './override/vs/platform/dialogs/common/dialogs.js';
+import { IElevatedFileService } from 'vscode/vscode/vs/workbench/services/files/common/elevatedFileService';
+import { BrowserElevatedFileService } from 'vscode/vscode/vs/workbench/services/files/browser/elevatedFileService';
+import { IDecorationsService } from 'vscode/vscode/vs/workbench/services/decorations/common/decorations';
+import { RequestService } from 'vscode/vscode/vs/platform/request/browser/requestService';
+import { InMemoryWorkingCopyBackupService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyBackupService';
+import { BrowserTextFileService } from 'vscode/vscode/vs/workbench/services/textfile/browser/browserTextFileService';
+import { DecorationsService } from 'vscode/vscode/vs/workbench/services/decorations/browser/decorationsService';
+import { UriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentityService';
+import { IJSONEditingService } from 'vscode/vscode/vs/workbench/services/configuration/common/jsonEditing';
+import { JSONEditingService } from 'vscode/vscode/vs/workbench/services/configuration/common/jsonEditingService';
+import { IWorkspacesService } from 'vscode/vscode/vs/platform/workspaces/common/workspaces';
+import { ITextEditorService } from 'vscode/vscode/vs/workbench/services/textfile/common/textEditorService';
+import { IEditorResolverService } from 'vscode/vscode/vs/workbench/services/editor/common/editorResolverService';
+import { AbstractLifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycleService';
+import { IOutputService } from 'vscode/vscode/vs/workbench/services/output/common/output';
+import { OutputService } from 'vscode/vscode/vs/workbench/contrib/output/browser/outputServices';
+import { IOutputChannelModelService, OutputChannelModelService } from 'vscode/vscode/vs/workbench/contrib/output/common/outputChannelModelService';
+import { IExtensionResourceLoaderService, AbstractExtensionResourceLoaderService } from 'vscode/vscode/vs/platform/extensionResourceLoader/common/extensionResourceLoader';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IHoverService } from 'vscode/vscode/vs/workbench/services/hover/browser/hover';
+import { IExplorerService } from 'vscode/vscode/vs/workbench/contrib/files/browser/files';
+import { IExtensionStorageService, ExtensionStorageService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionStorage';
+import { ILanguagePackService } from 'vscode/vscode/vs/platform/languagePacks/common/languagePacks';
+import { TreeViewsDnDService } from 'monaco-editor/esm/vs/editor/common/services/treeViewsDnd.js';
+import { ITreeViewsDnDService } from 'monaco-editor/esm/vs/editor/common/services/treeViewsDndService.js';
+import { TreeviewsService } from 'vscode/vscode/vs/workbench/services/views/common/treeViewsService';
+import { ITreeViewsService } from 'vscode/vscode/vs/workbench/services/views/browser/treeViewsService';
+import { IBreadcrumbsService } from 'vscode/vscode/vs/workbench/browser/parts/editor/breadcrumbs';
+import { IOutlineService } from 'vscode/vscode/vs/workbench/services/outline/browser/outline';
+import { IUpdateService, State } from 'vscode/vscode/vs/platform/update/common/update';
+import { IStatusbarService } from 'vscode/vscode/vs/workbench/services/statusbar/browser/statusbar';
+import { IExtensionGalleryService, IExtensionManagementService } from 'vscode/vscode/vs/platform/extensionManagement/common/extensionManagement';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { ITerminalService, ITerminalEditorService, ITerminalGroupService, ITerminalInstanceService } from 'vscode/vscode/vs/workbench/contrib/terminal/browser/terminal';
+import { ITerminalProfileService, ITerminalProfileResolverService } from 'vscode/vscode/vs/workbench/contrib/terminal/common/terminal';
+import { TerminalLocation, ITerminalLogService } from 'vscode/vscode/vs/platform/terminal/common/terminal';
+import { ITerminalContributionService } from 'vscode/vscode/vs/workbench/contrib/terminal/common/terminalExtensionPoints';
+import { ITerminalLinkProviderService } from 'vscode/vscode/vs/workbench/contrib/terminalContrib/links/browser/links';
+import { IEnvironmentVariableService } from 'vscode/vscode/vs/workbench/contrib/terminal/common/environmentVariable';
+import { ITerminalQuickFixService } from 'vscode/vscode/vs/workbench/contrib/terminalContrib/quickFix/browser/quickFix';
+import { IPreferencesSearchService } from 'vscode/vscode/vs/workbench/contrib/preferences/common/preferences';
+import { IUserDataSyncWorkbenchService } from 'vscode/vscode/vs/workbench/services/userDataSync/common/userDataSync';
+import { IUserDataSyncEnablementService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSync';
+import { IKeybindingEditingService } from 'vscode/vscode/vs/workbench/services/keybinding/common/keybindingEditing';
+import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService';
+import { ISearchHistoryService } from 'vscode/vscode/vs/workbench/contrib/search/common/searchHistoryService';
+import { IReplaceService } from 'vscode/vscode/vs/workbench/contrib/search/browser/replace';
+import { ISearchViewModelWorkbenchService } from 'vscode/vscode/vs/workbench/contrib/search/browser/searchModel';
+import { INotebookEditorService } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService';
+import { INotebookEditorModelResolverService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookEditorModelResolverService';
+import { IWorkingCopyEditorService, WorkingCopyEditorService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyEditorService';
+import { IUserActivityService, UserActivityService } from 'vscode/vscode/vs/workbench/services/userActivity/common/userActivityService';
+import { CanonicalUriService } from 'vscode/vscode/vs/workbench/services/workspaces/common/canonicalUriService';
+import { ICanonicalUriService } from 'vscode/vscode/vs/platform/workspace/common/canonicalUri';
+import { IExtensionStatusBarItemService, ExtensionStatusBarItemService } from 'vscode/vscode/vs/workbench/api/browser/statusBarExtensionPoint';
+import { IWorkbenchAssignmentService } from 'vscode/vscode/vs/workbench/services/assignment/common/assignmentService';
+import { IChatService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatService';
+import { IEmbedderTerminalService } from 'vscode/vscode/vs/workbench/services/terminal/common/embedderTerminalService';
+import { ICustomEditorService } from 'vscode/vscode/vs/workbench/contrib/customEditor/common/customEditor';
+import { IWebviewWorkbenchService } from 'vscode/vscode/vs/workbench/contrib/webviewPanel/browser/webviewWorkbenchService';
+import { IWebviewService } from 'vscode/vscode/vs/workbench/contrib/webview/browser/webview';
+import { IWebviewViewService } from 'vscode/vscode/vs/workbench/contrib/webviewView/browser/webviewViewService';
+import { IEditorDropService } from 'vscode/vscode/vs/workbench/services/editor/browser/editorDropService';
+import { IRemoteAuthorityResolverService } from 'vscode/vscode/vs/platform/remote/common/remoteAuthorityResolver';
+import { IExternalUriOpenerService, ExternalUriOpenerService } from 'vscode/vscode/vs/workbench/contrib/externalUriOpener/common/externalUriOpenerService';
+import { IAccessibleViewService } from 'vscode/vscode/vs/workbench/contrib/accessibility/browser/accessibleView';
+import { IExtensionManifestPropertiesService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionManifestPropertiesService';
+import { IRemoteExtensionsScannerService } from 'vscode/vscode/vs/platform/remote/common/remoteExtensionsScanner';
+import { BrowserURLService } from 'vscode/vscode/vs/workbench/services/url/browser/urlService';
+import { IURLService } from 'vscode/vscode/vs/platform/url/common/url';
+import { IRemoteSocketFactoryService } from 'vscode/vscode/vs/platform/remote/common/remoteSocketFactoryService';
+import { IQuickDiffService } from 'vscode/vscode/vs/workbench/contrib/scm/common/quickDiff';
+import { ISCMService, ISCMViewService } from 'vscode/vscode/vs/workbench/contrib/scm/common/scm';
+import { IDownloadService } from 'vscode/vscode/vs/platform/download/common/download';
+import { IExtensionUrlHandler } from 'vscode/vscode/vs/workbench/services/extensions/browser/extensionUrlHandler';
+import { ICommentService } from 'vscode/vscode/vs/workbench/contrib/comments/browser/commentService';
+import { INotebookCellStatusBarService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCellStatusBarService';
+import { INotebookKernelService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookKernelService';
+import { INotebookRendererMessagingService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookRendererMessagingService';
+import { IInteractiveDocumentService } from 'vscode/vscode/vs/workbench/contrib/interactive/browser/interactiveDocumentService';
+import { IInlineChatService } from 'vscode/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
+import { IQuickChatService, IChatWidgetService } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chat';
+import { IRemoteExplorerService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteExplorerService';
+import { IAuthenticationService } from 'vscode/vscode/vs/workbench/services/authentication/common/authentication';
+import { ITimelineService } from 'vscode/vscode/vs/workbench/contrib/timeline/common/timeline';
+import { ITestService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testService';
+import { ISecretStorageService } from 'vscode/vscode/vs/platform/secrets/common/secrets';
+import { IShareService } from 'vscode/vscode/vs/workbench/contrib/share/common/share';
+import { IWorkbenchIssueService } from 'vscode/vscode/vs/workbench/services/issue/common/issue';
+import { INotebookExecutionStateService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService';
+import { IChatContributionService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatContributionService';
+import { ITestProfileService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testProfileService';
+import { IEncryptionService } from 'vscode/vscode/vs/platform/encryption/common/encryptionService';
+import { ITestResultService } from 'vscode/vscode/vs/workbench/contrib/testing/common/testResultService';
+import { IDiagnosticsService, NullDiagnosticsService } from 'vscode/vscode/vs/platform/diagnostics/common/diagnostics';
+import { INotebookSearchService } from 'vscode/vscode/vs/workbench/contrib/search/common/notebookSearch';
+import { IChatProviderService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatProvider';
+import { IChatSlashCommandService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatSlashCommands';
+import { IChatVariablesService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatVariables';
+import { IAiRelatedInformationService } from 'vscode/vscode/vs/workbench/services/aiRelatedInformation/common/aiRelatedInformation';
+import { IAiEmbeddingVectorService } from 'vscode/vscode/vs/workbench/services/aiEmbeddingVector/common/aiEmbeddingVectorService';
+import { ResourceSet } from 'monaco-editor/esm/vs/base/common/map.js';
+import { ISignService } from 'vscode/vscode/vs/platform/sign/common/sign';
+import { BrowserHostService } from 'vscode/vscode/vs/workbench/services/host/browser/browserHostService';
+import { IBannerService } from 'vscode/vscode/vs/workbench/services/banner/browser/bannerService';
+import { ITitleService } from 'vscode/vscode/vs/workbench/services/title/common/titleService';
+import { IChatAgentService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents';
+import { joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { unsupported } from './tools.js';
+import { getBuiltInExtensionTranslationsUris } from './l10n.js';
+import { IFileDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+var _a;
+class NullLoggerService extends AbstractLoggerService {
+    constructor() {
+        super(LogLevel.Info, URI.file('logs.log'));
+    }
+    doCreateLogger() { return new NullLogger(); }
+}
+registerSingleton(ILoggerService, NullLoggerService, 0 );
+registerSingleton(IEditorService, class EditorService {
+    constructor() {
+        this._serviceBrand = undefined;
+        this.onDidActiveEditorChange = Event.None;
+        this.onDidVisibleEditorsChange = Event.None;
+        this.onDidEditorsChange = Event.None;
+        this.onDidCloseEditor = Event.None;
+        this.activeEditorPane = undefined;
+        this.activeEditor = undefined;
+        this.activeTextEditorLanguageId = undefined;
+        this.visibleEditorPanes = [];
+        this.visibleEditors = [];
+        this.visibleTextEditorControls = [];
+        this.editors = [];
+        this.count = 0;
+        this.getEditors = () => [];
+        this.openEditor = unsupported;
+        this.openEditors = unsupported;
+        this.replaceEditors = async () => { };
+        this.isOpened = () => false;
+        this.isVisible = () => false;
+        this.closeEditor = async () => { };
+        this.closeEditors = async () => { };
+        this.findEditors = () => [];
+        this.save = async () => ({ success: false, editors: [] });
+        this.saveAll = async () => ({ success: false, editors: [] });
+        this.revert = async () => false;
+        this.revertAll = async () => false;
+    }
+    get activeTextEditorControl() { return StandaloneServices.get(ICodeEditorService).getFocusedCodeEditor() ?? undefined; }
+}, 0 );
+registerSingleton(IPaneCompositePartService, class PaneCompositePartService {
+    constructor() {
+        this._serviceBrand = undefined;
+        this.onDidPaneCompositeOpen = Event.None;
+        this.onDidPaneCompositeClose = Event.None;
+        this.openPaneComposite = async () => undefined;
+        this.getActivePaneComposite = () => undefined;
+        this.getPaneComposite = () => undefined;
+        this.getPaneComposites = () => [];
+        this.getPinnedPaneCompositeIds = () => [];
+        this.getVisiblePaneCompositeIds = () => [];
+        this.getProgressIndicator = () => undefined;
+        this.hideActivePaneComposite = () => { };
+        this.getLastActivePaneCompositeId = unsupported;
+        this.showActivity = () => Disposable.None;
+    }
+}, 0 );
+registerSingleton(IUriIdentityService, UriIdentityService, 1 );
+registerSingleton(ITextFileService, BrowserTextFileService, 0 );
+registerSingleton(IFileService, class FileService {
+    constructor() {
+        this._serviceBrand = undefined;
+        this.onDidChangeFileSystemProviderRegistrations = Event.None;
+        this.onDidChangeFileSystemProviderCapabilities = Event.None;
+        this.onWillActivateFileSystemProvider = Event.None;
+        this.registerProvider = unsupported;
+        this.getProvider = function () {
+            return undefined;
+        };
+        this.activateProvider = async () => { };
+        this.canHandleResource = async () => false;
+        this.hasProvider = () => false;
+        this.hasCapability = () => false;
+        this.listCapabilities = () => [];
+        this.onDidFilesChange = Event.None;
+        this.onDidRunOperation = Event.None;
+        this.resolve = unsupported;
+        this.resolveAll = unsupported;
+        this.stat = unsupported;
+        this.exists = async () => false;
+        this.readFile = unsupported;
+        this.readFileStream = unsupported;
+        this.writeFile = unsupported;
+        this.move = unsupported;
+        this.canMove = unsupported;
+        this.copy = unsupported;
+        this.canCopy = unsupported;
+        this.cloneFile = unsupported;
+        this.createFile = unsupported;
+        this.canCreateFile = unsupported;
+        this.createFolder = unsupported;
+        this.del = unsupported;
+        this.canDelete = unsupported;
+        this.onDidWatchError = Event.None;
+        this.watch = unsupported;
+    }
+    dispose() {
+    }
+}, 0 );
+class EmptyEditorGroup {
+    constructor() {
+        this.onDidFocus = Event.None;
+        this.onDidOpenEditorFail = Event.None;
+        this.whenRestored = Promise.resolve();
+        this.disposed = false;
+        this.setActive = unsupported;
+        this.notifyIndexChanged = unsupported;
+        this.relayout = unsupported;
+        this.dispose = unsupported;
+        this.toJSON = unsupported;
+        this.minimumWidth = 0;
+        this.maximumWidth = Number.POSITIVE_INFINITY;
+        this.minimumHeight = 0;
+        this.maximumHeight = Number.POSITIVE_INFINITY;
+        this.onDidChange = Event.None;
+        this.layout = unsupported;
+        this.onDidModelChange = Event.None;
+        this.onWillDispose = Event.None;
+        this.onDidActiveEditorChange = Event.None;
+        this.onWillCloseEditor = Event.None;
+        this.onDidCloseEditor = Event.None;
+        this.onWillMoveEditor = Event.None;
+        this.onWillOpenEditor = Event.None;
+        this.id = 0;
+        this.index = 0;
+        this.label = 'main';
+        this.ariaLabel = 'main';
+        this.activeEditorPane = undefined;
+        this.activeEditor = null;
+        this.previewEditor = null;
+        this.count = 0;
+        this.isEmpty = false;
+        this.isLocked = false;
+        this.stickyCount = 0;
+        this.editors = [];
+        this.getEditors = () => [];
+        this.findEditors = () => [];
+        this.getEditorByIndex = () => undefined;
+        this.getIndexOfEditor = unsupported;
+        this.openEditor = unsupported;
+        this.openEditors = unsupported;
+        this.isPinned = () => false;
+        this.isSticky = () => false;
+        this.isActive = () => false;
+        this.contains = () => false;
+        this.moveEditor = unsupported;
+        this.moveEditors = unsupported;
+        this.copyEditor = unsupported;
+        this.copyEditors = unsupported;
+        this.closeEditor = unsupported;
+        this.closeEditors = unsupported;
+        this.closeAllEditors = unsupported;
+        this.replaceEditors = unsupported;
+        this.pinEditor = unsupported;
+        this.stickEditor = unsupported;
+        this.unstickEditor = unsupported;
+        this.lock = unsupported;
+        this.isFirst = unsupported;
+        this.isLast = unsupported;
+    }
+    get titleHeight() {
+        return unsupported();
+    }
+    get element() {
+        return unsupported();
+    }
+    get scopedContextKeyService() { return StandaloneServices.get(IContextKeyService); }
+    focus() {
+    }
+}
+const fakeActiveGroup = new EmptyEditorGroup();
+class EmptyEditorGroupsService {
+    constructor() {
+        this._serviceBrand = undefined;
+        this.getLayout = unsupported;
+        this.onDidChangeActiveGroup = Event.None;
+        this.onDidAddGroup = Event.None;
+        this.onDidRemoveGroup = Event.None;
+        this.onDidMoveGroup = Event.None;
+        this.onDidActivateGroup = Event.None;
+        this.onDidLayout = Event.None;
+        this.onDidScroll = Event.None;
+        this.onDidChangeGroupIndex = Event.None;
+        this.onDidChangeGroupLocked = Event.None;
+        this.activeGroup = fakeActiveGroup;
+        this.groups = [fakeActiveGroup];
+        this.count = 0;
+        this.orientation = 0 ;
+        this.isReady = false;
+        this.whenReady = Promise.resolve();
+        this.whenRestored = Promise.resolve();
+        this.hasRestorableState = false;
+        this.getGroups = () => [];
+        this.getGroup = () => undefined;
+        this.activateGroup = unsupported;
+        this.getSize = unsupported;
+        this.setSize = unsupported;
+        this.arrangeGroups = unsupported;
+        this.applyLayout = unsupported;
+        this.centerLayout = unsupported;
+        this.isLayoutCentered = () => false;
+        this.setGroupOrientation = unsupported;
+        this.findGroup = () => undefined;
+        this.addGroup = unsupported;
+        this.removeGroup = unsupported;
+        this.moveGroup = unsupported;
+        this.mergeGroup = unsupported;
+        this.mergeAllGroups = unsupported;
+        this.copyGroup = unsupported;
+        this.partOptions = {};
+        this.onDidChangeEditorPartOptions = Event.None;
+        this.enforcePartOptions = unsupported;
+    }
+    get contentDimension() { return unsupported(); }
+    get sideGroup() { return unsupported(); }
+}
+registerSingleton(IEditorGroupsService, EmptyEditorGroupsService, 0 );
+registerSingleton(IBannerService, class BannerService {
+    focus() { }
+    focusNextAction() { }
+    focusPreviousAction() { }
+    hide() { }
+    show() { }
+}, 0 );
+registerSingleton(ITitleService, class TitleService {
+    constructor() {
+        this.onMenubarVisibilityChange = Event.None;
+        this.isCommandCenterVisible = false;
+        this.onDidChangeCommandCenterVisibility = Event.None;
+    }
+    updateProperties() { }
+}, 0 );
+registerSingleton(IWorkingCopyFileService, WorkingCopyFileService, 0 );
+registerSingleton(IPathService, BrowserPathService, 1 );
+registerSingleton(IProductService, class ProductService {
+    constructor() {
+        this._serviceBrand = undefined;
+        this.version = "1.83.0";
+        this.commit = "e7e037083ff4455cf320e344325dacb480062c3c";
+        this.nameShort = 'Code - OSS Dev';
+        this.nameLong = 'Code - OSS Dev';
+        this.applicationName = 'code-oss';
+        this.dataFolderName = '.vscode-oss';
+        this.urlProtocol = 'code-oss';
+        this.reportIssueUrl = 'https://github.com/microsoft/vscode/issues/new';
+        this.licenseName = 'MIT';
+        this.licenseUrl = 'https://github.com/microsoft/vscode/blob/main/LICENSE.txt';
+        this.serverApplicationName = 'code-server-oss';
+    }
+}, 0 );
+registerSingleton(ILanguageStatusService, class LanguageStatusServiceImpl {
+    constructor() {
+        this._provider = new LanguageFeatureRegistry();
+        this.onDidChange = this._provider.onDidChange;
+    }
+    addStatus(status) {
+        return this._provider.register(status.selector, status);
+    }
+    getLanguageStatus(model) {
+        return this._provider.ordered(model).sort((a, b) => {
+            let res = b.severity - a.severity;
+            if (res === 0) {
+                res = compare(a.source, b.source);
+            }
+            if (res === 0) {
+                res = compare(a.id, b.id);
+            }
+            return res;
+        });
+    }
+}, 0 );
+registerSingleton(IHostService, BrowserHostService, 0 );
+registerSingleton(ILifecycleService, class LifecycleService extends AbstractLifecycleService {
+    constructor() {
+        super(...arguments);
+        this.shutdown = unsupported;
+    }
+}, 0 );
+registerSingleton(ILanguageDetectionService, class LanguageDetectionService {
+    isEnabledForLanguage() {
+        return false;
+    }
+    async detectLanguage() {
+        return undefined;
+    }
+}, 0 );
+registerSingleton(IExtensionService, NullExtensionService, 0 );
+registerSingleton(IKeyboardLayoutService, class KeyboardLayoutService {
+    constructor() {
+        this.onDidChangeKeyboardLayout = Event.None;
+        this.getRawKeyboardMapping = () => null;
+        this.getCurrentKeyboardLayout = () => null;
+        this.getAllKeyboardLayouts = () => [];
+        this.getKeyboardMapper = () => new FallbackKeyboardMapper(false, OS);
+        this.validateCurrentKeyboardMapping = () => { };
+    }
+}, 1 );
+registerSingleton(IUserDataInitializationService, class NullUserDataInitializationService {
+    async requiresInitialization() {
+        return false;
+    }
+    async whenInitializationFinished() { }
+    async initializeRequiredResources() { }
+    async initializeInstalledExtensions() { }
+    async initializeOtherResources() { }
+}, 0 );
+registerSingleton(IHostColorSchemeService, BrowserHostColorSchemeService, 0 );
+let PreferencesService = class PreferencesService {
+    constructor(profileService) {
+        this.profileService = profileService;
+        this.userSettingsResource = this.profileService.currentProfile.settingsResource;
+        this.workspaceSettingsResource = null;
+        this.getFolderSettingsResource = unsupported;
+        this.createPreferencesEditorModel = unsupported;
+        this.resolveModel = unsupported;
+        this.createSettings2EditorModel = unsupported;
+        this.openRawDefaultSettings = unsupported;
+        this.openSettings = unsupported;
+        this.openUserSettings = unsupported;
+        this.openRemoteSettings = unsupported;
+        this.openWorkspaceSettings = unsupported;
+        this.openFolderSettings = unsupported;
+        this.openGlobalKeybindingSettings = unsupported;
+        this.openDefaultKeybindingsFile = unsupported;
+        this.getEditableSettingsURI = unsupported;
+        this.createSplitJsonEditorInput = unsupported;
+        this.openApplicationSettings = unsupported;
+        this.openLanguageSpecificSettings = unsupported;
+    }
+};
+PreferencesService = __decorate([
+    ( __param(0, IUserDataProfileService))
+], PreferencesService);
+registerSingleton(IPreferencesService, PreferencesService, 0 );
+registerSingleton(ITextMateTokenizationService, class NullTextMateService {
+    constructor() {
+        this.onDidEncounterLanguage = Event.None;
+        this.createGrammar = unsupported;
+        this.startDebugMode = unsupported;
+        this.createTokenizer = unsupported;
+    }
+}, 0 );
+let UserDataProfilesService = class UserDataProfilesService {
+    constructor(profileService) {
+        this.profileService = profileService;
+        this.onDidResetWorkspaces = Event.None;
+        this.isEnabled = () => false;
+        this.createNamedProfile = unsupported;
+        this.createTransientProfile = unsupported;
+        this.resetWorkspaces = unsupported;
+        this.cleanUp = unsupported;
+        this.cleanUpTransientProfiles = unsupported;
+        this.defaultProfile = this.profileService.currentProfile;
+        this.onDidChangeProfiles = Event.None;
+        this.profiles = [this.profileService.currentProfile];
+        this.createProfile = unsupported;
+        this.updateProfile = unsupported;
+        this.setProfileForWorkspace = unsupported;
+        this.getProfile = () => this.profileService.currentProfile;
+        this.removeProfile = unsupported;
+    }
+    get profilesHome() { return unsupported(); }
+};
+UserDataProfilesService = __decorate([
+    ( __param(0, IUserDataProfileService))
+], UserDataProfilesService);
+registerSingleton(IUserDataProfilesService, UserDataProfilesService, 0 );
+let InjectedUserDataProfileService = class InjectedUserDataProfileService extends UserDataProfileService {
+    constructor(environmentService) {
+        super({
+            ...toUserDataProfile('__default__profile__', 'Default', environmentService.userRoamingDataHome, joinPath(environmentService.cacheHome, 'CachedProfilesData')),
+            isDefault: true
+        });
+    }
+};
+InjectedUserDataProfileService = __decorate([
+    ( __param(0, IEnvironmentService))
+], InjectedUserDataProfileService);
+registerSingleton(IUserDataProfileService, InjectedUserDataProfileService, 0 );
+registerSingleton(IPolicyService, class PolicyService {
+    constructor() {
+        this.updatePolicyDefinitions = unsupported;
+        this.onDidChange = Event.None;
+        this.registerPolicyDefinitions = unsupported;
+        this.getPolicyValue = () => undefined;
+        this.serialize = () => undefined;
+    }
+}, 0 );
+registerSingleton(ISnippetsService, class SnippetsService {
+    constructor() {
+        this.getSnippetFiles = unsupported;
+        this.isEnabled = unsupported;
+        this.updateEnablement = unsupported;
+        this.updateUsageTimestamp = unsupported;
+        this.getSnippets = async () => [];
+        this.getSnippetsSync = unsupported;
+    }
+}, 0 );
+const debugModel = {
+    getSession: () => undefined,
+    getSessions: () => [],
+    getBreakpoints: () => [],
+    areBreakpointsActivated: () => false,
+    getFunctionBreakpoints: () => [],
+    getDataBreakpoints: () => [],
+    getExceptionBreakpoints: () => [],
+    getExceptionBreakpointsForSession: () => [],
+    getInstructionBreakpoints: () => [],
+    getWatchExpressions: () => [],
+    onDidChangeBreakpoints: Event.None,
+    onDidChangeCallStack: Event.None,
+    onDidChangeWatchExpressions: Event.None,
+    fetchCallstack: unsupported,
+    getId: unsupported
+};
+class FakeViewModel {
+    constructor() {
+        this.getId = unsupported;
+        this.focusedSession = undefined;
+        this.focusedThread = undefined;
+        this.focusedStackFrame = undefined;
+        this.getSelectedExpression = unsupported;
+        this.setSelectedExpression = unsupported;
+        this.updateViews = unsupported;
+        this.isMultiSessionView = unsupported;
+        this.onDidFocusSession = Event.None;
+        this.onDidFocusStackFrame = Event.None;
+        this.onDidSelectExpression = Event.None;
+        this.onDidEvaluateLazyExpression = Event.None;
+        this.onWillUpdateViews = Event.None;
+        this.onDidFocusThread = Event.None;
+        this.evaluateLazyExpression = unsupported;
+    }
+}
+class FakeAdapterManager {
+    constructor() {
+        this.onDidRegisterDebugger = Event.None;
+        this.hasEnabledDebuggers = () => false;
+        this.getDebugAdapterDescriptor = unsupported;
+        this.getDebuggerLabel = unsupported;
+        this.someDebuggerInterestedInLanguage = () => false;
+        this.getDebugger = () => undefined;
+        this.activateDebuggers = unsupported;
+        this.registerDebugAdapterFactory = () => Disposable.None;
+        this.createDebugAdapter = unsupported;
+        this.registerDebugAdapterDescriptorFactory = unsupported;
+        this.unregisterDebugAdapterDescriptorFactory = unsupported;
+        this.substituteVariables = unsupported;
+        this.runInTerminal = unsupported;
+        this.getEnabledDebugger = unsupported;
+        this.guessDebugger = unsupported;
+        this.onDidDebuggersExtPointRead = Event.None;
+    }
+}
+registerSingleton(IDebugService, class DebugService {
+    constructor() {
+        this.onDidChangeState = Event.None;
+        this.onDidNewSession = Event.None;
+        this.onWillNewSession = Event.None;
+        this.onDidEndSession = Event.None;
+        this.getConfigurationManager = unsupported;
+        this.getAdapterManager = () => new FakeAdapterManager();
+        this.focusStackFrame = unsupported;
+        this.canSetBreakpointsIn = unsupported;
+        this.addBreakpoints = unsupported;
+        this.updateBreakpoints = unsupported;
+        this.enableOrDisableBreakpoints = unsupported;
+        this.setBreakpointsActivated = unsupported;
+        this.removeBreakpoints = unsupported;
+        this.addFunctionBreakpoint = unsupported;
+        this.updateFunctionBreakpoint = unsupported;
+        this.removeFunctionBreakpoints = unsupported;
+        this.addDataBreakpoint = unsupported;
+        this.removeDataBreakpoints = unsupported;
+        this.addInstructionBreakpoint = unsupported;
+        this.removeInstructionBreakpoints = unsupported;
+        this.setExceptionBreakpointCondition = unsupported;
+        this.setExceptionBreakpointsForSession = unsupported;
+        this.sendAllBreakpoints = unsupported;
+        this.addWatchExpression = unsupported;
+        this.renameWatchExpression = unsupported;
+        this.moveWatchExpression = unsupported;
+        this.removeWatchExpressions = unsupported;
+        this.startDebugging = unsupported;
+        this.restartSession = unsupported;
+        this.stopSession = unsupported;
+        this.sourceIsNotAvailable = unsupported;
+        this.getModel = () => debugModel;
+        this.getViewModel = () => new FakeViewModel();
+        this.runTo = unsupported;
+    }
+    get state() { return unsupported(); }
+}, 0 );
+registerSingleton(IRequestService, RequestService, 0 );
+registerSingleton(IWorkspaceTrustRequestService, class WorkspaceTrustRequestService {
+    constructor() {
+        this.onDidInitiateOpenFilesTrustRequest = Event.None;
+        this.onDidInitiateWorkspaceTrustRequest = Event.None;
+        this.onDidInitiateWorkspaceTrustRequestOnStartup = Event.None;
+        this.completeOpenFilesTrustRequest = unsupported;
+        this.requestOpenFilesTrust = async () => 1 ;
+        this.cancelWorkspaceTrustRequest = unsupported;
+        this.completeWorkspaceTrustRequest = unsupported;
+        this.requestWorkspaceTrust = async () => true;
+        this.requestWorkspaceTrustOnStartup = () => null;
+    }
+}, 0 );
+registerSingleton(IActivityService, class ActivityService {
+    constructor() {
+        this.showViewContainerActivity = () => Disposable.None;
+        this.showViewActivity = () => Disposable.None;
+        this.showAccountsActivity = () => Disposable.None;
+        this.showGlobalActivity = () => Disposable.None;
+    }
+}, 0 );
+registerSingleton(IExtensionHostDebugService, class ExtensionHostDebugService {
+    constructor() {
+        this.reload = unsupported;
+        this.onReload = Event.None;
+        this.close = unsupported;
+        this.onClose = Event.None;
+        this.attachSession = unsupported;
+        this.onAttachSession = Event.None;
+        this.terminateSession = unsupported;
+        this.onTerminateSession = Event.None;
+        this.openExtensionDevelopmentHostWindow = unsupported;
+    }
+}, 0 );
+registerSingleton(IViewsService, class ViewsService {
+    constructor() {
+        this.getFocusedViewName = unsupported;
+        this.onDidChangeFocusedView = Event.None;
+        this.onDidChangeViewContainerVisibility = Event.None;
+        this.isViewContainerVisible = () => false;
+        this.openViewContainer = unsupported;
+        this.closeViewContainer = unsupported;
+        this.getVisibleViewContainer = unsupported;
+        this.getActiveViewPaneContainerWithId = () => null;
+        this.onDidChangeViewVisibility = Event.None;
+        this.isViewVisible = () => false;
+        this.openView = async () => null;
+        this.closeView = unsupported;
+        this.getActiveViewWithId = () => null;
+        this.getViewWithId = () => null;
+        this.getViewProgressIndicator = () => undefined;
+    }
+}, 0 );
+registerSingleton(IViewDescriptorService, class ViewDescriptorService {
+    constructor() {
+        this.viewContainers = [];
+        this.onDidChangeViewContainers = Event.None;
+        this.getDefaultViewContainer = () => undefined;
+        this.getViewContainerById = () => null;
+        this.isViewContainerRemovedPermanently = unsupported;
+        this.getDefaultViewContainerLocation = () => null;
+        this.getViewContainerLocation = () => null;
+        this.getViewContainersByLocation = unsupported;
+        this.getViewContainerModel = () => ({
+            onDidChangeAllViewDescriptors: Event.None,
+            visibleViewDescriptors: []
+        });
+        this.onDidChangeContainerLocation = Event.None;
+        this.moveViewContainerToLocation = unsupported;
+        this.getViewContainerBadgeEnablementState = unsupported;
+        this.setViewContainerBadgeEnablementState = unsupported;
+        this.getViewDescriptorById = () => null;
+        this.getViewContainerByViewId = () => null;
+        this.getDefaultContainerById = () => null;
+        this.getViewLocationById = () => null;
+        this.onDidChangeContainer = Event.None;
+        this.moveViewsToContainer = unsupported;
+        this.onDidChangeLocation = Event.None;
+        this.moveViewToLocation = () => null;
+        this.reset = () => null;
+    }
+}, 0 );
+registerSingleton(IHistoryService, class HistoryService {
+    constructor() {
+        this.goForward = unsupported;
+        this.goBack = unsupported;
+        this.goPrevious = unsupported;
+        this.goLast = unsupported;
+        this.reopenLastClosedEditor = unsupported;
+        this.getHistory = () => [];
+        this.removeFromHistory = unsupported;
+        this.getLastActiveWorkspaceRoot = () => undefined;
+        this.getLastActiveFile = () => undefined;
+        this.openNextRecentlyUsedEditor = unsupported;
+        this.openPreviouslyUsedEditor = unsupported;
+        this.clear = unsupported;
+        this.clearRecentlyOpened = unsupported;
+    }
+}, 0 );
+registerSingleton(ITaskService, class TaskService {
+    constructor() {
+        this.onDidStateChange = Event.None;
+        this.supportsMultipleTaskExecutions = false;
+        this.configureAction = unsupported;
+        this.run = unsupported;
+        this.inTerminal = () => false;
+        this.getActiveTasks = async () => [];
+        this.getBusyTasks = unsupported;
+        this.terminate = unsupported;
+        this.tasks = unsupported;
+        this.taskTypes = unsupported;
+        this.getWorkspaceTasks = unsupported;
+        this.getSavedTasks = unsupported;
+        this.removeRecentlyUsedTask = unsupported;
+        this.getTask = unsupported;
+        this.tryResolveTask = unsupported;
+        this.createSorter = unsupported;
+        this.getTaskDescription = unsupported;
+        this.customize = unsupported;
+        this.openConfig = unsupported;
+        this.registerTaskProvider = unsupported;
+        this.registerTaskSystem = () => { };
+        this.onDidChangeTaskSystemInfo = Event.None;
+        this.hasTaskSystemInfo = false;
+        this.registerSupportedExecutions = () => { };
+        this.extensionCallbackTaskComplete = unsupported;
+        this.isReconnected = false;
+        this.onDidReconnectToTasks = Event.None;
+    }
+}, 0 );
+registerSingleton(IConfigurationResolverService, class ConfigurationResolverService {
+    constructor() {
+        this.resolveWithEnvironment = unsupported;
+        this.resolveAsync = unsupported;
+        this.resolveAnyAsync = unsupported;
+        this.resolveAnyMap = unsupported;
+        this.resolveWithInteractionReplace = unsupported;
+        this.resolveWithInteraction = unsupported;
+        this.contributeVariable = unsupported;
+    }
+}, 0 );
+registerSingleton(IRemoteAgentService, class RemoteAgentService {
+    constructor() {
+        this.getConnection = () => null;
+        this.getEnvironment = async () => null;
+        this.getRawEnvironment = async () => null;
+        this.getExtensionHostExitInfo = async () => null;
+        this.getRoundTripTime = async () => undefined;
+        this.whenExtensionsReady = async () => undefined;
+        this.scanExtensions = async () => [];
+        this.scanSingleExtension = async () => null;
+        this.getDiagnosticInfo = async () => undefined;
+        this.updateTelemetryLevel = async () => undefined;
+        this.logTelemetry = async () => undefined;
+        this.flushTelemetry = async () => undefined;
+    }
+}, 0 );
+registerSingleton(ICustomEndpointTelemetryService, NullEndpointTelemetryService, 0 );
+let MonacoSearchService = class MonacoSearchService {
+    constructor(modelService) {
+        this.modelService = modelService;
+        this.textSearchSplitSyncAsync = unsupported;
+        this.registerSearchResultProvider = unsupported;
+    }
+    async textSearch() {
+        return {
+            results: [],
+            messages: []
+        };
+    }
+    async fileSearch() {
+        return {
+            results: ( this.modelService.getModels().map(model => ({
+                resource: model.uri
+            }))),
+            messages: []
+        };
+    }
+    async clearCache() {
+    }
+};
+MonacoSearchService = __decorate([
+    ( __param(0, IModelService))
+], MonacoSearchService);
+registerSingleton(ISearchService, MonacoSearchService, 0 );
+registerSingleton(IEditSessionIdentityService, class EditSessionIdentityService {
+    constructor() {
+        this.registerEditSessionIdentityProvider = unsupported;
+        this.getEditSessionIdentifier = unsupported;
+        this.provideEditSessionIdentityMatch = unsupported;
+        this.addEditSessionIdentityCreateParticipant = () => new DisposableStore();
+        this.onWillCreateEditSessionIdentity = unsupported;
+    }
+}, 0 );
+registerSingleton(IWorkspaceEditingService, class WorkspaceEditingService {
+    constructor() {
+        this.addFolders = unsupported;
+        this.removeFolders = unsupported;
+        this.updateFolders = unsupported;
+        this.enterWorkspace = unsupported;
+        this.createAndEnterWorkspace = unsupported;
+        this.saveAndEnterWorkspace = unsupported;
+        this.copyWorkspaceSettings = unsupported;
+        this.pickNewWorkspacePath = unsupported;
+    }
+}, 0 );
+registerSingleton(ITimerService, class TimerService {
+    constructor() {
+        this.whenReady = unsupported;
+        this.setPerformanceMarks = () => { };
+        this.getPerformanceMarks = unsupported;
+        this.getDuration = unsupported;
+    }
+    get perfBaseline() { return unsupported(); }
+    get startupMetrics() { return unsupported(); }
+}, 0 );
+registerSingleton(IExtensionsWorkbenchService, class ExtensionsWorkbenchService {
+    constructor() {
+        this.toggleApplyExtensionToAllProfiles = unsupported;
+        this.whenInitialized = Promise.resolve();
+        this.onChange = Event.None;
+        this.onReset = Event.None;
+        this.preferPreReleases = false;
+        this.local = [];
+        this.installed = [];
+        this.outdated = [];
+        this.queryLocal = unsupported;
+        this.queryGallery = unsupported;
+        this.getExtensions = unsupported;
+        this.canInstall = unsupported;
+        this.install = unsupported;
+        this.installInServer = unsupported;
+        this.uninstall = unsupported;
+        this.installVersion = unsupported;
+        this.reinstall = unsupported;
+        this.canSetLanguage = unsupported;
+        this.setLanguage = unsupported;
+        this.setEnablement = unsupported;
+        this.pinExtension = unsupported;
+        this.open = unsupported;
+        this.checkForUpdates = unsupported;
+        this.getExtensionStatus = unsupported;
+        this.isExtensionIgnoredToSync = unsupported;
+        this.toggleExtensionIgnoredToSync = unsupported;
+    }
+}, 0 );
+registerSingleton(IWorkbenchExtensionEnablementService, class WorkbenchExtensionEnablementService {
+    constructor() {
+        this.onEnablementChanged = Event.None;
+        this.getEnablementState = () => 8 ;
+        this.getEnablementStates = (extensions) => ( extensions.map(() => 8 ));
+        this.getDependenciesEnablementStates = () => [];
+        this.canChangeEnablement = () => false;
+        this.canChangeWorkspaceEnablement = () => false;
+        this.isEnabled = () => true;
+        this.isEnabledEnablementState = () => true;
+        this.isDisabledGlobally = () => false;
+        this.setEnablement = unsupported;
+        this.updateExtensionsEnablementsWhenWorkspaceTrustChanges = unsupported;
+    }
+}, 0 );
+registerSingleton(ITunnelService, class TunnelService {
+    constructor() {
+        this.tunnels = Promise.resolve([]);
+        this.canChangePrivacy = false;
+        this.privacyOptions = [];
+        this.onTunnelOpened = Event.None;
+        this.onTunnelClosed = Event.None;
+        this.canElevate = false;
+        this.hasTunnelProvider = false;
+        this.onAddedTunnelProvider = Event.None;
+        this.canTunnel = () => false;
+        this.openTunnel = unsupported;
+        this.getExistingTunnel = async () => undefined;
+        this.setEnvironmentTunnel = unsupported;
+        this.closeTunnel = unsupported;
+        this.setTunnelProvider = unsupported;
+        this.setTunnelFeatures = unsupported;
+        this.isPortPrivileged = () => false;
+    }
+}, 0 );
+registerSingleton(IFilesConfigurationService, FilesConfigurationService, 0 );
+registerSingleton(IUntitledTextEditorService, class UntitledTextEditorService {
+    constructor() {
+        this.isUntitledWithAssociatedResource = () => false;
+        this.onDidChangeDirty = Event.None;
+        this.onDidChangeEncoding = Event.None;
+        this.onDidChangeLabel = Event.None;
+        this.onWillDispose = Event.None;
+        this.create = unsupported;
+        this.get = () => undefined;
+        this.getValue = () => undefined;
+        this.resolve = unsupported;
+    }
+}, 0 );
+registerSingleton(IWorkingCopyBackupService, InMemoryWorkingCopyBackupService, 0 );
+registerSingleton(IWorkingCopyService, WorkingCopyService, 0 );
+registerSingleton(IDecorationsService, DecorationsService, 0 );
+registerSingleton(IElevatedFileService, BrowserElevatedFileService, 0 );
+registerSingleton(IFileDialogService, class FileDialogService {
+    constructor() {
+        this.preferredHome = unsupported;
+        this.defaultFilePath = unsupported;
+        this.defaultFolderPath = unsupported;
+        this.defaultWorkspacePath = unsupported;
+        this.pickFileFolderAndOpen = unsupported;
+        this.pickFileAndOpen = unsupported;
+        this.pickFolderAndOpen = unsupported;
+        this.pickWorkspaceAndOpen = unsupported;
+        this.pickFileToSave = unsupported;
+        this.showSaveDialog = unsupported;
+        this.showSaveConfirm = unsupported;
+        this.showOpenDialog = unsupported;
+    }
+}, 0 );
+registerSingleton(IJSONEditingService, JSONEditingService, 1 );
+registerSingleton(IWorkspacesService, class WorkspacesService {
+    constructor() {
+        this.enterWorkspace = unsupported;
+        this.createUntitledWorkspace = unsupported;
+        this.deleteUntitledWorkspace = unsupported;
+        this.getWorkspaceIdentifier = unsupported;
+        this.onDidChangeRecentlyOpened = Event.None;
+        this.addRecentlyOpened = unsupported;
+        this.removeRecentlyOpened = unsupported;
+        this.clearRecentlyOpened = unsupported;
+        this.getRecentlyOpened = unsupported;
+        this.getDirtyWorkspaces = unsupported;
+    }
+}, 1 );
+registerSingleton(ITextEditorService, class TextEditorService {
+    constructor() {
+        this.createTextEditor = unsupported;
+        this.resolveTextEditor = unsupported;
+    }
+}, 0 );
+registerSingleton(IEditorResolverService, class EditorResolverService {
+    constructor() {
+        this.getAssociationsForResource = unsupported;
+        this.updateUserAssociations = unsupported;
+        this.onDidChangeEditorRegistrations = Event.None;
+        this.bufferChangeEvents = unsupported;
+        this.resolveEditor = unsupported;
+        this.getEditors = () => ([]);
+    }
+    registerEditor() {
+        return {
+            dispose: () => { }
+        };
+    }
+}, 0 );
+registerSingleton(IOutputService, OutputService, 1 );
+registerSingleton(IOutputChannelModelService, OutputChannelModelService, 1 );
+let SimpleExtensionResourceLoaderService = class SimpleExtensionResourceLoaderService extends AbstractExtensionResourceLoaderService {
+    constructor(fileService, storageService, productService, environmentService, configurationService) {
+        super(fileService, storageService, productService, environmentService, configurationService);
+    }
+    async readExtensionResource(uri) {
+        const result = await this._fileService.readFile(uri);
+        return ( result.value.toString());
+    }
+};
+SimpleExtensionResourceLoaderService = __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, IStorageService)),
+    ( __param(2, IProductService)),
+    ( __param(3, IEnvironmentService)),
+    ( __param(4, IConfigurationService))
+], SimpleExtensionResourceLoaderService);
+registerSingleton(IExtensionResourceLoaderService, SimpleExtensionResourceLoaderService, 0 );
+registerSingleton(IHoverService, class HoverService {
+    constructor() {
+        this.showAndFocusLastHover = unsupported;
+        this.showHover = unsupported;
+        this.hideHover = unsupported;
+    }
+}, 0 );
+registerSingleton(IExplorerService, class ExplorerService {
+    constructor() {
+        this.roots = [];
+        this.getContext = unsupported;
+        this.hasViewFocus = unsupported;
+        this.setEditable = unsupported;
+        this.getEditable = unsupported;
+        this.getEditableData = unsupported;
+        this.isEditable = unsupported;
+        this.findClosest = unsupported;
+        this.findClosestRoot = unsupported;
+        this.refresh = unsupported;
+        this.setToCopy = unsupported;
+        this.isCut = unsupported;
+        this.applyBulkEdit = unsupported;
+        this.select = unsupported;
+        this.registerView = unsupported;
+    }
+    get sortOrderConfiguration() { return unsupported(); }
+}, 1 );
+registerSingleton(IExtensionStorageService, ExtensionStorageService, 1 );
+registerSingleton(ILanguagePackService, class LanguagePackService {
+    async getAvailableLanguages() {
+        return [];
+    }
+    async getInstalledLanguages() {
+        return [];
+    }
+    async getBuiltInExtensionTranslationsUri(id, language) {
+        const uri = getBuiltInExtensionTranslationsUris(language)?.[id];
+        return uri != null ? ( URI.parse(uri)) : undefined;
+    }
+}, 1 );
+registerSingleton(ITreeViewsDnDService, TreeViewsDnDService, 1 );
+registerSingleton(ITreeViewsService, TreeviewsService, 1 );
+registerSingleton(IBreadcrumbsService, class BreadcrumbsService {
+    constructor() {
+        this.register = unsupported;
+        this.getWidget = () => undefined;
+    }
+}, 0 );
+registerSingleton(IOutlineService, class OutlineService {
+    constructor() {
+        this.onDidChange = Event.None;
+        this.canCreateOutline = () => false;
+        this.createOutline = async () => undefined;
+        this.registerOutlineCreator = unsupported;
+    }
+}, 0 );
+registerSingleton(IUpdateService, class UpdateService {
+    constructor() {
+        this.onStateChange = Event.None;
+        this.state = State.Uninitialized;
+        this.checkForUpdates = unsupported;
+        this.downloadUpdate = unsupported;
+        this.applyUpdate = unsupported;
+        this.quitAndInstall = unsupported;
+        this.isLatestVersion = unsupported;
+        this._applySpecificUpdate = unsupported;
+    }
+}, 0 );
+registerSingleton(IStatusbarService, class StatusbarService {
+    constructor() {
+        this.onDidChangeEntryVisibility = Event.None;
+        this.addEntry = () => ({
+            dispose: () => { },
+            update: () => { }
+        });
+        this.isEntryVisible = () => false;
+        this.updateEntryVisibility = () => { };
+        this.focus = () => { };
+        this.focusNextEntry = () => { };
+        this.focusPreviousEntry = () => { };
+        this.isEntryFocused = () => false;
+        this.overrideStyle = () => Disposable.None;
+    }
+}, 0 );
+registerSingleton(IExtensionGalleryService, class ExtensionGalleryService {
+    constructor() {
+        this.isEnabled = () => false;
+        this.query = unsupported;
+        this.getExtensions = unsupported;
+        this.isExtensionCompatible = unsupported;
+        this.getCompatibleExtension = unsupported;
+        this.getAllCompatibleVersions = unsupported;
+        this.download = unsupported;
+        this.downloadSignatureArchive = unsupported;
+        this.reportStatistic = unsupported;
+        this.getReadme = unsupported;
+        this.getManifest = unsupported;
+        this.getChangelog = unsupported;
+        this.getCoreTranslation = unsupported;
+        this.getExtensionsControlManifest = unsupported;
+    }
+}, 0 );
+registerSingleton(ITerminalService, class TerminalService {
+    constructor() {
+        this.onInstanceEvent = unsupported;
+        this.onInstanceCapabilityEvent = unsupported;
+        this.onDidChangeSelection = Event.None;
+        this.detachedXterms = [];
+        this.restoredGroupCount = 0;
+        this.createDetachedXterm = unsupported;
+        this.instances = [];
+        this.revealActiveTerminal = unsupported;
+        this.isProcessSupportRegistered = false;
+        this.connectionState = 1 ;
+        this.defaultLocation = TerminalLocation.Panel;
+        this.onDidChangeActiveGroup = Event.None;
+        this.onDidDisposeGroup = Event.None;
+        this.onDidCreateInstance = Event.None;
+        this.onDidReceiveProcessId = Event.None;
+        this.onDidChangeInstanceDimensions = Event.None;
+        this.onDidMaximumDimensionsChange = Event.None;
+        this.onDidRequestStartExtensionTerminal = Event.None;
+        this.onDidChangeInstanceTitle = Event.None;
+        this.onDidChangeInstanceIcon = Event.None;
+        this.onDidChangeInstanceColor = Event.None;
+        this.onDidChangeInstancePrimaryStatus = Event.None;
+        this.onDidInputInstanceData = Event.None;
+        this.onDidRegisterProcessSupport = Event.None;
+        this.onDidChangeConnectionState = Event.None;
+        this.createTerminal = unsupported;
+        this.getInstanceFromId = unsupported;
+        this.getInstanceFromIndex = unsupported;
+        this.getReconnectedTerminals = unsupported;
+        this.getActiveOrCreateInstance = unsupported;
+        this.moveToEditor = unsupported;
+        this.moveToTerminalView = unsupported;
+        this.getPrimaryBackend = unsupported;
+        this.refreshActiveGroup = unsupported;
+        this.registerProcessSupport = () => { };
+        this.showProfileQuickPick = unsupported;
+        this.setContainers = unsupported;
+        this.requestStartExtensionTerminal = unsupported;
+        this.isAttachedToTerminal = unsupported;
+        this.getEditableData = unsupported;
+        this.setEditable = unsupported;
+        this.isEditable = unsupported;
+        this.safeDisposeTerminal = unsupported;
+        this.getDefaultInstanceHost = unsupported;
+        this.getInstanceHost = unsupported;
+        this.resolveLocation = unsupported;
+        this.setNativeDelegate = unsupported;
+        this.toggleEscapeSequenceLogging = unsupported;
+        this.getEditingTerminal = unsupported;
+        this.setEditingTerminal = unsupported;
+        this.activeInstance = undefined;
+        this.onDidDisposeInstance = Event.None;
+        this.onDidFocusInstance = Event.None;
+        this.onDidChangeActiveInstance = Event.None;
+        this.onDidChangeInstances = Event.None;
+        this.onDidChangeInstanceCapability = Event.None;
+        this.setActiveInstance = unsupported;
+        this.focusActiveInstance = unsupported;
+        this.getInstanceFromResource = unsupported;
+    }
+    async createDetachedTerminal() {
+        unsupported();
+    }
+    get whenConnected() {
+        return (async () => {
+            unsupported();
+        })();
+    }
+    get configHelper() {
+        return unsupported();
+    }
+}, 1 );
+registerSingleton(ITerminalEditorService, class TerminalEditorService {
+    constructor() {
+        this.instances = [];
+        this.openEditor = unsupported;
+        this.detachActiveEditorInstance = unsupported;
+        this.detachInstance = unsupported;
+        this.splitInstance = unsupported;
+        this.revealActiveEditor = unsupported;
+        this.resolveResource = unsupported;
+        this.reviveInput = unsupported;
+        this.getInputFromResource = unsupported;
+        this.activeInstance = undefined;
+        this.onDidDisposeInstance = Event.None;
+        this.onDidFocusInstance = Event.None;
+        this.onDidChangeActiveInstance = Event.None;
+        this.onDidChangeInstances = Event.None;
+        this.onDidChangeInstanceCapability = Event.None;
+        this.setActiveInstance = unsupported;
+        this.focusActiveInstance = unsupported;
+        this.getInstanceFromResource = unsupported;
+    }
+}, 1 );
+registerSingleton(ITerminalGroupService, class TerminalGroupService {
+    constructor() {
+        this.lastAccessedMenu = 'inline-tab';
+        this.instances = [];
+        this.groups = [];
+        this.activeGroup = undefined;
+        this.activeGroupIndex = 0;
+        this.onDidChangeActiveGroup = Event.None;
+        this.onDidDisposeGroup = Event.None;
+        this.onDidChangeGroups = Event.None;
+        this.onDidShow = Event.None;
+        this.onDidChangePanelOrientation = Event.None;
+        this.createGroup = unsupported;
+        this.getGroupForInstance = unsupported;
+        this.moveGroup = unsupported;
+        this.moveGroupToEnd = unsupported;
+        this.moveInstance = unsupported;
+        this.unsplitInstance = unsupported;
+        this.joinInstances = unsupported;
+        this.instanceIsSplit = unsupported;
+        this.getGroupLabels = unsupported;
+        this.setActiveGroupByIndex = unsupported;
+        this.setActiveGroupToNext = unsupported;
+        this.setActiveGroupToPrevious = unsupported;
+        this.setActiveInstanceByIndex = unsupported;
+        this.setContainer = unsupported;
+        this.showPanel = unsupported;
+        this.hidePanel = unsupported;
+        this.focusTabs = unsupported;
+        this.focusHover = unsupported;
+        this.showTabs = unsupported;
+        this.updateVisibility = unsupported;
+        this.onDidDisposeInstance = Event.None;
+        this.onDidFocusInstance = Event.None;
+        this.onDidChangeActiveInstance = Event.None;
+        this.onDidChangeInstances = Event.None;
+        this.onDidChangeInstanceCapability = Event.None;
+        this.setActiveInstance = unsupported;
+        this.focusActiveInstance = unsupported;
+        this.getInstanceFromResource = unsupported;
+    }
+}, 1 );
+registerSingleton(ITerminalInstanceService, class TerminalInstanceService {
+    constructor() {
+        this.getRegisteredBackends = () => ( [].values());
+        this.onDidCreateInstance = Event.None;
+        this.convertProfileToShellLaunchConfig = unsupported;
+        this.createInstance = unsupported;
+        this.getBackend = unsupported;
+        this.didRegisterBackend = unsupported;
+    }
+}, 1 );
+registerSingleton(ITerminalProfileService, class TerminalProfileService {
+    constructor() {
+        this.availableProfiles = [];
+        this.contributedProfiles = [];
+        this.profilesReady = Promise.resolve();
+        this.getPlatformKey = unsupported;
+        this.refreshAvailableProfiles = unsupported;
+        this.getDefaultProfileName = () => undefined;
+        this.getDefaultProfile = () => undefined;
+        this.onDidChangeAvailableProfiles = Event.None;
+        this.getContributedDefaultProfile = unsupported;
+        this.registerContributedProfile = unsupported;
+        this.getContributedProfileProvider = unsupported;
+        this.registerTerminalProfileProvider = unsupported;
+    }
+}, 1 );
+registerSingleton(ITerminalLogService, class TerminalLogService {
+    constructor() {
+        this.onDidChangeLogLevel = Event.None;
+        this.getLevel = unsupported;
+        this.setLevel = unsupported;
+        this.trace = unsupported;
+        this.debug = unsupported;
+        this.info = unsupported;
+        this.warn = unsupported;
+        this.error = unsupported;
+        this.flush = unsupported;
+        this.dispose = unsupported;
+    }
+}, 1 );
+registerSingleton(ITerminalLinkProviderService, class TerminalLinkProviderService {
+    constructor() {
+        this.linkProviders = new Set([]);
+        this.onDidAddLinkProvider = Event.None;
+        this.onDidRemoveLinkProvider = Event.None;
+        this.registerLinkProvider = unsupported;
+    }
+}, 1 );
+registerSingleton(ITerminalContributionService, class TerminalContributionService {
+    constructor() {
+        this.terminalProfiles = [];
+    }
+}, 1 );
+registerSingleton(ITerminalProfileResolverService, class TerminalProfileResolverService {
+    constructor() {
+        this.resolveIcon = unsupported;
+        this.resolveShellLaunchConfig = unsupported;
+        this.getDefaultProfile = async () => ({
+            profileName: 'bash',
+            path: '/bin/bash',
+            isDefault: true
+        });
+        this.getDefaultShell = unsupported;
+        this.getDefaultShellArgs = unsupported;
+        this.getDefaultIcon = unsupported;
+        this.getEnvironment = unsupported;
+        this.createProfileFromShellAndShellArgs = unsupported;
+    }
+}, 1 );
+registerSingleton(IEnvironmentVariableService, class EnvironmentVariableService {
+    constructor() {
+        this.collections = new Map();
+        this.onDidChangeCollections = Event.None;
+        this.set = unsupported;
+        this.delete = unsupported;
+    }
+    get mergedCollection() {
+        return unsupported();
+    }
+}, 1 );
+registerSingleton(ITerminalQuickFixService, class TerminalQuickFixService {
+    constructor() {
+        this.onDidRegisterProvider = Event.None;
+        this.onDidRegisterCommandSelector = Event.None;
+        this.onDidUnregisterProvider = Event.None;
+        this.extensionQuickFixes = Promise.resolve([]);
+        this.providers = new Map();
+        this.registerQuickFixProvider = unsupported;
+        this.registerCommandSelector = unsupported;
+    }
+}, 1 );
+registerSingleton(IExtensionManagementService, class ExtensionManagementService {
+    constructor() {
+        this.toggleAppliationScope = async (extension) => extension;
+        this.installGalleryExtensions = unsupported;
+        this.onInstallExtension = Event.None;
+        this.onDidInstallExtensions = Event.None;
+        this.onUninstallExtension = Event.None;
+        this.onDidUninstallExtension = Event.None;
+        this.onDidUpdateExtensionMetadata = Event.None;
+        this.zip = unsupported;
+        this.unzip = unsupported;
+        this.getManifest = unsupported;
+        this.install = unsupported;
+        this.canInstall = unsupported;
+        this.installFromGallery = unsupported;
+        this.installFromLocation = unsupported;
+        this.installExtensionsFromProfile = unsupported;
+        this.uninstall = unsupported;
+        this.reinstallFromGallery = unsupported;
+        this.getInstalled = async () => [];
+        this.getExtensionsControlManifest = unsupported;
+        this.copyExtensions = unsupported;
+        this.updateMetadata = unsupported;
+        this.download = unsupported;
+        this.registerParticipant = unsupported;
+        this.getTargetPlatform = unsupported;
+        this.cleanUp = unsupported;
+    }
+}, 1 );
+registerSingleton(IUserDataSyncWorkbenchService, class UserDataSyncWorkbenchService {
+    constructor() {
+        this.enabled = false;
+        this.authenticationProviders = [];
+        this.all = [];
+        this.current = undefined;
+        this.accountStatus = "unavailable" ;
+        this.onDidChangeAccountStatus = Event.None;
+        this.turnOn = unsupported;
+        this.turnoff = unsupported;
+        this.signIn = unsupported;
+        this.resetSyncedData = unsupported;
+        this.showSyncActivity = unsupported;
+        this.syncNow = unsupported;
+        this.synchroniseUserDataSyncStoreType = unsupported;
+        this.showConflicts = unsupported;
+        this.accept = unsupported;
+        this.getAllLogResources = unsupported;
+        this.downloadSyncActivity = unsupported;
+    }
+}, 1 );
+registerSingleton(IUserDataSyncEnablementService, class UserDataSyncEnablementService {
+    constructor() {
+        this.onDidChangeEnablement = Event.None;
+        this.isEnabled = () => false;
+        this.canToggleEnablement = () => false;
+        this.setEnablement = unsupported;
+        this.onDidChangeResourceEnablement = Event.None;
+        this.isResourceEnabled = () => false;
+        this.setResourceEnablement = unsupported;
+        this.getResourceSyncStateVersion = () => undefined;
+    }
+}, 1 );
+registerSingleton(IKeybindingEditingService, class KeybindingEditingService {
+    constructor() {
+        this.addKeybinding = unsupported;
+        this.editKeybinding = unsupported;
+        this.removeKeybinding = unsupported;
+        this.resetKeybinding = unsupported;
+    }
+}, 1 );
+registerSingleton(IPreferencesSearchService, class PreferencesSearchService {
+    constructor() {
+        this.getLocalSearchProvider = unsupported;
+        this.getRemoteSearchProvider = unsupported;
+    }
+}, 1 );
+registerSingleton(INotebookService, class NotebookService {
+    constructor() {
+        this.canResolve = async () => false;
+        this.onAddViewType = Event.None;
+        this.onWillRemoveViewType = Event.None;
+        this.onDidChangeOutputRenderers = Event.None;
+        this.onWillAddNotebookDocument = Event.None;
+        this.onDidAddNotebookDocument = Event.None;
+        this.onWillRemoveNotebookDocument = Event.None;
+        this.onDidRemoveNotebookDocument = Event.None;
+        this.registerNotebookSerializer = unsupported;
+        this.withNotebookDataProvider = unsupported;
+        this.getOutputMimeTypeInfo = unsupported;
+        this.getViewTypeProvider = () => undefined;
+        this.getRendererInfo = () => undefined;
+        this.getRenderers = () => [];
+        this.getStaticPreloads = unsupported;
+        this.updateMimePreferredRenderer = unsupported;
+        this.saveMimeDisplayOrder = unsupported;
+        this.createNotebookTextModel = unsupported;
+        this.getNotebookTextModel = () => undefined;
+        this.getNotebookTextModels = unsupported;
+        this.listNotebookDocuments = () => [];
+        this.registerContributedNotebookType = unsupported;
+        this.getContributedNotebookType = unsupported;
+        this.getContributedNotebookTypes = () => [];
+        this.getNotebookProviderResourceRoots = () => [];
+        this.setToCopy = unsupported;
+        this.getToCopy = unsupported;
+        this.clearEditorCache = unsupported;
+    }
+}, 1 );
+registerSingleton(IReplaceService, class ReplaceService {
+    constructor() {
+        this.replace = unsupported;
+        this.openReplacePreview = unsupported;
+        this.updateReplacePreview = unsupported;
+    }
+}, 1 );
+registerSingleton(ISearchHistoryService, class SearchHistoryService {
+    constructor() {
+        this.onDidClearHistory = Event.None;
+        this.clearHistory = unsupported;
+        this.load = unsupported;
+        this.save = unsupported;
+    }
+}, 1 );
+registerSingleton(INotebookEditorService, class NotebookEditorService {
+    constructor() {
+        this.retrieveWidget = unsupported;
+        this.retrieveExistingWidgetFromURI = () => undefined;
+        this.retrieveAllExistingWidgets = () => [];
+        this.onDidAddNotebookEditor = Event.None;
+        this.onDidRemoveNotebookEditor = Event.None;
+        this.addNotebookEditor = unsupported;
+        this.removeNotebookEditor = unsupported;
+        this.getNotebookEditor = () => undefined;
+        this.listNotebookEditors = () => [];
+    }
+}, 1 );
+registerSingleton(ISearchViewModelWorkbenchService, class SearchWorkbenchService {
+    get searchModel() {
+        return unsupported();
+    }
+}, 1 );
+registerSingleton(INotebookEditorModelResolverService, class NotebookEditorModelResolverService {
+    constructor() {
+        this.onDidSaveNotebook = Event.None;
+        this.onDidChangeDirty = Event.None;
+        this.onWillFailWithConflict = Event.None;
+        this.isDirty = unsupported;
+        this.resolve = unsupported;
+    }
+}, 1 );
+registerSingleton(IWorkingCopyEditorService, WorkingCopyEditorService, 1 );
+registerSingleton(IUserActivityService, UserActivityService, 1 );
+registerSingleton(ICanonicalUriService, CanonicalUriService, 1 );
+registerSingleton(IExtensionStatusBarItemService, ExtensionStatusBarItemService, 1 );
+registerSingleton(IWorkbenchAssignmentService, class WorkbenchAssignmentService {
+    constructor() {
+        this.getCurrentExperiments = async () => [];
+        this.getTreatment = async () => undefined;
+    }
+}, 1 );
+registerSingleton(IChatService, class ChatService {
+    constructor() {
+        this.transferredSessionData = undefined;
+        this.onDidSubmitSlashCommand = Event.None;
+        this.getSessionId = () => undefined;
+        this.transferredSessionId = undefined;
+        this.transferChatSession = unsupported;
+        this.registerProvider = unsupported;
+        this.registerSlashCommandProvider = unsupported;
+        this.getProviderInfos = () => [];
+        this.startSession = unsupported;
+        this.getSession = () => undefined;
+        this.getOrRestoreSession = () => undefined;
+        this.loadSessionFromContent = () => undefined;
+        this.sendRequest = unsupported;
+        this.removeRequest = unsupported;
+        this.cancelCurrentRequestForSession = unsupported;
+        this.getSlashCommands = unsupported;
+        this.clearSession = unsupported;
+        this.addRequest = unsupported;
+        this.addCompleteRequest = unsupported;
+        this.sendRequestToProvider = unsupported;
+        this.getHistory = () => [];
+        this.removeHistoryEntry = unsupported;
+        this.onDidPerformUserAction = Event.None;
+        this.notifyUserAction = unsupported;
+    }
+}, 1 );
+registerSingleton(IQuickChatService, class QuickChatService {
+    constructor() {
+        this.onDidClose = Event.None;
+        this.enabled = false;
+        this.toggle = unsupported;
+        this.focus = unsupported;
+        this.open = unsupported;
+        this.close = unsupported;
+        this.openInChatView = unsupported;
+    }
+}, 1 );
+registerSingleton(IChatAgentService, class QuickChatService {
+    constructor() {
+        this._serviceBrand = undefined;
+        this.onDidChangeAgents = Event.None;
+        this.registerAgentData = unsupported;
+        this.registerAgentCallback = unsupported;
+        this.registerAgent = unsupported;
+        this.invokeAgent = unsupported;
+        this.getAgents = unsupported;
+        this.getAgent = unsupported;
+        this.hasAgent = unsupported;
+    }
+}, 1 );
+registerSingleton(IEmbedderTerminalService, class EmbedderTerminalService {
+    constructor() {
+        this.onDidCreateTerminal = Event.None;
+        this.createTerminal = unsupported;
+    }
+}, 1 );
+registerSingleton(ICustomEditorService, class CustomEditorService {
+    constructor() {
+        this.getCustomEditor = unsupported;
+        this.getAllCustomEditors = unsupported;
+        this.getContributedCustomEditors = unsupported;
+        this.getUserConfiguredCustomEditors = unsupported;
+        this.registerCustomEditorCapabilities = unsupported;
+        this.getCustomEditorCapabilities = unsupported;
+    }
+    get models() {
+        return unsupported();
+    }
+}, 1 );
+registerSingleton(IWebviewService, class WebviewService {
+    constructor() {
+        this.webviews = [];
+        this.onDidChangeActiveWebview = Event.None;
+        this.createWebviewElement = unsupported;
+        this.createWebviewOverlay = unsupported;
+    }
+}, 1 );
+registerSingleton(IWebviewViewService, class WebviewService {
+    constructor() {
+        this.onNewResolverRegistered = Event.None;
+        this.register = unsupported;
+        this.resolve = unsupported;
+    }
+}, 1 );
+registerSingleton(IWebviewWorkbenchService, class WebviewWorkbenchService {
+    constructor() {
+        this.onDidChangeActiveWebviewEditor = Event.None;
+        this.openWebview = unsupported;
+        this.openRevivedWebview = unsupported;
+        this.revealWebview = unsupported;
+        this.registerResolver = () => Disposable.None;
+        this.shouldPersist = unsupported;
+        this.resolveWebview = unsupported;
+    }
+    get iconManager() {
+        return unsupported();
+    }
+}, 1 );
+registerSingleton(IEditorDropService, class EditorDropService {
+    constructor() {
+        this.createEditorDropTarget = unsupported;
+    }
+}, 1 );
+registerSingleton(IRemoteAuthorityResolverService, class RemoteAuthorityResolverService {
+    constructor() {
+        this.onDidChangeConnectionData = Event.None;
+        this.resolveAuthority = unsupported;
+        this.getConnectionData = unsupported;
+        this.getCanonicalURI = unsupported;
+        this._clearResolvedAuthority = unsupported;
+        this._setResolvedAuthority = unsupported;
+        this._setResolvedAuthorityError = unsupported;
+        this._setAuthorityConnectionToken = unsupported;
+        this._setCanonicalURIProvider = unsupported;
+    }
+}, 1 );
+registerSingleton(IExternalUriOpenerService, ExternalUriOpenerService, 1 );
+registerSingleton(IAccessibleViewService, class AccessibleViewService {
+    constructor() {
+        this.showAccessibleViewHelp = unsupported;
+        this.goToSymbol = unsupported;
+        this.disableHint = unsupported;
+        this.next = unsupported;
+        this.previous = unsupported;
+        this.getOpenAriaHint = unsupported;
+        this.show = unsupported;
+        this.registerProvider = unsupported;
+        this.getPosition = unsupported;
+        this.setPosition = unsupported;
+        this.getLastPosition = unsupported;
+    }
+}, 1 );
+registerSingleton(IWorkbenchExtensionManagementService, class WorkbenchExtensionManagementService {
+    constructor() {
+        this.toggleAppliationScope = async (extension) => extension;
+        this.onInstallExtension = Event.None;
+        this.onDidInstallExtensions = Event.None;
+        this.onUninstallExtension = Event.None;
+        this.onDidUninstallExtension = Event.None;
+        this.onDidChangeProfile = Event.None;
+        this.installVSIX = unsupported;
+        this.installFromLocation = unsupported;
+        this.updateFromGallery = unsupported;
+        this.onDidUpdateExtensionMetadata = Event.None;
+        this.zip = unsupported;
+        this.unzip = unsupported;
+        this.getManifest = unsupported;
+        this.install = unsupported;
+        this.canInstall = unsupported;
+        this.installFromGallery = unsupported;
+        this.installGalleryExtensions = unsupported;
+        this.installExtensionsFromProfile = unsupported;
+        this.uninstall = unsupported;
+        this.reinstallFromGallery = unsupported;
+        this.getInstalled = unsupported;
+        this.getExtensionsControlManifest = unsupported;
+        this.copyExtensions = unsupported;
+        this.updateMetadata = unsupported;
+        this.download = unsupported;
+        this.registerParticipant = unsupported;
+        this.getTargetPlatform = unsupported;
+        this.cleanUp = unsupported;
+    }
+}, 1 );
+registerSingleton(IExtensionManifestPropertiesService, class ExtensionManifestPropertiesService {
+    constructor() {
+        this.prefersExecuteOnUI = unsupported;
+        this.prefersExecuteOnWorkspace = unsupported;
+        this.prefersExecuteOnWeb = unsupported;
+        this.canExecuteOnUI = unsupported;
+        this.canExecuteOnWorkspace = unsupported;
+        this.canExecuteOnWeb = unsupported;
+        this.getExtensionKind = unsupported;
+        this.getUserConfiguredExtensionKind = unsupported;
+        this.getExtensionUntrustedWorkspaceSupportType = unsupported;
+        this.getExtensionVirtualWorkspaceSupportType = unsupported;
+    }
+}, 1 );
+registerSingleton(IWorkspaceTrustEnablementService, class WorkspaceTrustEnablementService {
+    isWorkspaceTrustEnabled() {
+        return false;
+    }
+}, 1 );
+registerSingleton(IRemoteExtensionsScannerService, class RemoteExtensionsScannerService {
+    whenExtensionsReady() {
+        throw new Error('Method not implemented.');
+    }
+    async scanExtensions() {
+        return [];
+    }
+    async scanSingleExtension() {
+        return null;
+    }
+}, 1 );
+registerSingleton(IURLService, BrowserURLService, 1 );
+registerSingleton(IRemoteSocketFactoryService, class RemoteSocketFactoryService {
+    constructor() {
+        this.register = unsupported;
+        this.connect = unsupported;
+    }
+}, 1 );
+registerSingleton(IQuickDiffService, class QuickDiffService {
+    constructor() {
+        this.onDidChangeQuickDiffProviders = Event.None;
+        this.addQuickDiffProvider = unsupported;
+        this.getQuickDiffs = unsupported;
+    }
+}, 1 );
+registerSingleton(ISCMService, class SCMService {
+    constructor() {
+        this.onDidAddRepository = Event.None;
+        this.onDidRemoveRepository = Event.None;
+        this.repositories = [];
+        this.repositoryCount = 0;
+        this.registerSCMProvider = unsupported;
+        this.getRepository = unsupported;
+    }
+}, 1 );
+registerSingleton(IDownloadService, class DownloadService {
+    constructor() {
+        this.download = unsupported;
+    }
+}, 1 );
+registerSingleton(IExtensionUrlHandler, class ExtensionUrlHandler {
+    constructor() {
+        this.registerExtensionHandler = unsupported;
+        this.unregisterExtensionHandler = unsupported;
+    }
+}, 1 );
+registerSingleton(ICommentService, class CommentService {
+    constructor() {
+        this.onDidSetResourceCommentInfos = Event.None;
+        this.onDidSetAllCommentThreads = Event.None;
+        this.onDidUpdateCommentThreads = Event.None;
+        this.onDidUpdateNotebookCommentThreads = Event.None;
+        this.onDidChangeActiveCommentThread = Event.None;
+        this.onDidChangeCurrentCommentThread = Event.None;
+        this.onDidUpdateCommentingRanges = Event.None;
+        this.onDidChangeActiveCommentingRange = Event.None;
+        this.onDidSetDataProvider = Event.None;
+        this.onDidDeleteDataProvider = Event.None;
+        this.onDidChangeCommentingEnabled = Event.None;
+        this.isCommentingEnabled = false;
+        this.setDocumentComments = unsupported;
+        this.setWorkspaceComments = unsupported;
+        this.removeWorkspaceComments = unsupported;
+        this.registerCommentController = unsupported;
+        this.unregisterCommentController = () => { };
+        this.getCommentController = unsupported;
+        this.createCommentThreadTemplate = unsupported;
+        this.updateCommentThreadTemplate = unsupported;
+        this.getCommentMenus = unsupported;
+        this.updateComments = unsupported;
+        this.updateNotebookComments = unsupported;
+        this.disposeCommentThread = unsupported;
+        this.getDocumentComments = unsupported;
+        this.getNotebookComments = unsupported;
+        this.updateCommentingRanges = unsupported;
+        this.hasReactionHandler = unsupported;
+        this.toggleReaction = unsupported;
+        this.setActiveCommentThread = unsupported;
+        this.setCurrentCommentThread = unsupported;
+        this.enableCommenting = unsupported;
+        this.registerContinueOnCommentProvider = unsupported;
+        this.removeContinueOnComment = unsupported;
+    }
+}, 1 );
+registerSingleton(INotebookCellStatusBarService, class NotebookCellStatusBarService {
+    constructor() {
+        this.onDidChangeProviders = Event.None;
+        this.onDidChangeItems = Event.None;
+        this.registerCellStatusBarItemProvider = unsupported;
+        this.getStatusBarItemsForCell = unsupported;
+    }
+}, 1 );
+registerSingleton(INotebookKernelService, class NotebookKernelService {
+    constructor() {
+        this.onDidAddKernel = Event.None;
+        this.onDidRemoveKernel = Event.None;
+        this.onDidChangeSelectedNotebooks = Event.None;
+        this.onDidChangeNotebookAffinity = Event.None;
+        this.registerKernel = unsupported;
+        this.getMatchingKernel = unsupported;
+        this.getSelectedOrSuggestedKernel = unsupported;
+        this.selectKernelForNotebook = unsupported;
+        this.preselectKernelForNotebook = unsupported;
+        this.updateKernelNotebookAffinity = unsupported;
+        this.onDidChangeKernelDetectionTasks = Event.None;
+        this.registerNotebookKernelDetectionTask = unsupported;
+        this.getKernelDetectionTasks = unsupported;
+        this.onDidChangeSourceActions = Event.None;
+        this.getSourceActions = unsupported;
+        this.getRunningSourceActions = unsupported;
+        this.registerKernelSourceActionProvider = unsupported;
+        this.getKernelSourceActions2 = unsupported;
+    }
+}, 1 );
+registerSingleton(INotebookRendererMessagingService, class NotebookRendererMessagingService {
+    constructor() {
+        this.onShouldPostMessage = Event.None;
+        this.prepare = unsupported;
+        this.getScoped = unsupported;
+        this.receiveMessage = unsupported;
+    }
+}, 1 );
+registerSingleton(IInteractiveDocumentService, class InteractiveDocumentService {
+    constructor() {
+        this.onWillAddInteractiveDocument = Event.None;
+        this.onWillRemoveInteractiveDocument = Event.None;
+        this.willCreateInteractiveDocument = unsupported;
+        this.willRemoveInteractiveDocument = unsupported;
+    }
+}, 1 );
+registerSingleton(IInlineChatService, class InlineChatService {
+    constructor() {
+        this.onDidChangeProviders = Event.None;
+        this.addProvider = unsupported;
+        this.getAllProvider = () => [];
+    }
+}, 1 );
+registerSingleton(IChatWidgetService, class ChatWidgetService {
+    constructor() {
+        this.getWidgetBySessionId = () => undefined;
+        this.lastFocusedWidget = undefined;
+        this.revealViewForProvider = unsupported;
+        this.getWidgetByInputUri = unsupported;
+    }
+}, 1 );
+registerSingleton(IRemoteExplorerService, class RemoteExplorerService {
+    constructor() {
+        this.onDidChangeTargetType = Event.None;
+        this.targetType = [];
+        this.onDidChangeEditable = Event.None;
+        this.setEditable = unsupported;
+        this.getEditableData = unsupported;
+        this.forward = unsupported;
+        this.close = unsupported;
+        this.setTunnelInformation = unsupported;
+        this.setCandidateFilter = unsupported;
+        this.onFoundNewCandidates = unsupported;
+        this.restore = unsupported;
+        this.enablePortsFeatures = unsupported;
+        this.onEnabledPortsFeatures = Event.None;
+        this.portsFeaturesEnabled = false;
+        this.namedProcesses = new Map();
+    }
+    get tunnelModel() {
+        return unsupported();
+    }
+}, 1 );
+registerSingleton(IAuthenticationService, class AuthenticationService {
+    constructor() {
+        this.isAuthenticationProviderRegistered = () => false;
+        this.getProviderIds = () => [];
+        this.registerAuthenticationProvider = unsupported;
+        this.unregisterAuthenticationProvider = unsupported;
+        this.isAccessAllowed = () => false;
+        this.updateAllowedExtension = unsupported;
+        this.updateSessionPreference = unsupported;
+        this.getSessionPreference = () => undefined;
+        this.removeSessionPreference = unsupported;
+        this.showGetSessionPrompt = unsupported;
+        this.selectSession = unsupported;
+        this.requestSessionAccess = unsupported;
+        this.completeSessionAccessRequest = unsupported;
+        this.requestNewSession = unsupported;
+        this.sessionsUpdate = unsupported;
+        this.onDidRegisterAuthenticationProvider = Event.None;
+        this.onDidUnregisterAuthenticationProvider = Event.None;
+        this.onDidChangeSessions = Event.None;
+        this.declaredProviders = [];
+        this.onDidChangeDeclaredProviders = Event.None;
+        this.getSessions = async () => [];
+        this.getLabel = unsupported;
+        this.supportsMultipleAccounts = () => false;
+        this.createSession = unsupported;
+        this.removeSession = unsupported;
+        this.manageTrustedExtensionsForAccount = unsupported;
+        this.removeAccountSessions = unsupported;
+    }
+}, 1 );
+registerSingleton(ITimelineService, class TimelineService {
+    constructor() {
+        this.onDidChangeProviders = Event.None;
+        this.onDidChangeTimeline = Event.None;
+        this.onDidChangeUri = Event.None;
+        this.registerTimelineProvider = unsupported;
+        this.unregisterTimelineProvider = unsupported;
+        this.getSources = () => [];
+        this.getTimeline = unsupported;
+        this.setUri = unsupported;
+    }
+}, 1 );
+registerSingleton(ITestService, class TestService {
+    constructor() {
+        this.onDidCancelTestRun = Event.None;
+        this.onWillProcessDiff = Event.None;
+        this.onDidProcessDiff = Event.None;
+        this.registerTestController = unsupported;
+        this.getTestController = () => undefined;
+        this.refreshTests = unsupported;
+        this.cancelRefreshTests = unsupported;
+        this.startContinuousRun = unsupported;
+        this.runTests = unsupported;
+        this.runResolvedTests = unsupported;
+        this.syncTests = unsupported;
+        this.cancelTestRun = unsupported;
+        this.publishDiff = unsupported;
+    }
+    get excluded() {
+        return unsupported();
+    }
+    get collection() {
+        return unsupported();
+    }
+    get showInlineOutput() {
+        return unsupported();
+    }
+}, 1 );
+registerSingleton(ISecretStorageService, class SecretStorageService {
+    constructor() {
+        this.onDidChangeSecret = Event.None;
+        this.type = 'in-memory';
+        this.get = async () => undefined;
+        this.set = unsupported;
+        this.delete = unsupported;
+    }
+}, 1 );
+registerSingleton(IShareService, class ShareService {
+    constructor() {
+        this.registerShareProvider = unsupported;
+        this.getShareActions = () => [];
+        this.provideShare = async () => undefined;
+    }
+}, 1 );
+registerSingleton(IUserDataProfileImportExportService, class UserDataProfileImportExportService {
+    constructor() {
+        this.createProfile = unsupported;
+        this.editProfile = unsupported;
+        this.registerProfileContentHandler = unsupported;
+        this.unregisterProfileContentHandler = unsupported;
+        this.exportProfile = unsupported;
+        this.importProfile = unsupported;
+        this.showProfileContents = unsupported;
+        this.createFromCurrentProfile = unsupported;
+        this.createTroubleshootProfile = unsupported;
+        this.setProfile = unsupported;
+    }
+}, 1 );
+registerSingleton(IWorkbenchIssueService, class WorkbenchIssueService {
+    constructor() {
+        this.openReporter = unsupported;
+        this.openProcessExplorer = unsupported;
+        this.registerIssueUriRequestHandler = unsupported;
+    }
+}, 1 );
+registerSingleton(ISCMViewService, class SCMViewService {
+    constructor() {
+        this.repositories = [];
+        this.onDidChangeRepositories = Event.None;
+        this.visibleRepositories = [];
+        this.onDidChangeVisibleRepositories = Event.None;
+        this.isVisible = () => false;
+        this.toggleVisibility = unsupported;
+        this.toggleSortKey = unsupported;
+        this.focusedRepository = undefined;
+        this.onDidFocusRepository = Event.None;
+        this.focus = unsupported;
+    }
+    get menus() {
+        return unsupported();
+    }
+}, 1 );
+registerSingleton(INotebookExecutionStateService, class NotebookExecutionStateService {
+    constructor() {
+        this.onDidChangeExecution = Event.None;
+        this.onDidChangeLastRunFailState = Event.None;
+        this.forceCancelNotebookExecutions = unsupported;
+        this.getCellExecutionsForNotebook = unsupported;
+        this.getCellExecutionsByHandleForNotebook = unsupported;
+        this.getCellExecution = unsupported;
+        this.createCellExecution = unsupported;
+        this.getExecution = unsupported;
+        this.createExecution = unsupported;
+        this.getLastFailedCellForNotebook = unsupported;
+    }
+}, 1 );
+registerSingleton(IChatContributionService, class ChatContributionService {
+    constructor() {
+        this.registeredProviders = [];
+        this.getViewIdForProvider = unsupported;
+        this.registerChatProvider = unsupported;
+        this.deregisterChatProvider = unsupported;
+    }
+}, 1 );
+registerSingleton(ITestProfileService, class TestProfileService {
+    constructor() {
+        this.onDidChange = Event.None;
+        this.addProfile = unsupported;
+        this.updateProfile = unsupported;
+        this.removeProfile = unsupported;
+        this.capabilitiesForTest = unsupported;
+        this.configure = unsupported;
+        this.all = () => [];
+        this.getGroupDefaultProfiles = () => [];
+        this.setGroupDefaultProfiles = unsupported;
+        this.getControllerProfiles = () => [];
+    }
+}, 1 );
+registerSingleton(IEncryptionService, class EncryptionService {
+    constructor() {
+        this.setUsePlainTextEncryption = unsupported;
+        this.getKeyStorageProvider = unsupported;
+        this.encrypt = unsupported;
+        this.decrypt = unsupported;
+        this.isEncryptionAvailable = unsupported;
+    }
+}, 1 );
+registerSingleton(ITestResultService, class TestResultService {
+    constructor() {
+        this.onResultsChanged = Event.None;
+        this.onTestChanged = Event.None;
+        this.results = [];
+        this.clear = unsupported;
+        this.createLiveResult = unsupported;
+        this.push = unsupported;
+        this.getResult = () => undefined;
+        this.getStateById = () => undefined;
+    }
+}, 1 );
+registerSingleton(IUserDataInitializationService, class UserDataInitializationService {
+    constructor() {
+        this.requiresInitialization = async () => false;
+        this.whenInitializationFinished = async () => { };
+        this.initializeRequiredResources = async () => { };
+        this.initializeInstalledExtensions = async () => { };
+        this.initializeOtherResources = async () => { };
+    }
+}, 1 );
+registerSingleton(IDiagnosticsService, NullDiagnosticsService, 1 );
+registerSingleton(INotebookSearchService, class NotebookSearchService {
+    notebookSearch() {
+        return {
+            openFilesToScan: new ResourceSet(),
+            completeData: Promise.resolve({
+                results: [],
+                messages: []
+            }),
+            allScannedFiles: Promise.resolve(new ResourceSet())
+        };
+    }
+}, 1 );
+registerSingleton(IChatProviderService, class ChatProviderService {
+    constructor() {
+        this.registerChatResponseProvider = unsupported;
+        this.fetchChatResponse = unsupported;
+    }
+}, 1 );
+registerSingleton(IChatSlashCommandService, class ChatSlashCommandService {
+    constructor() {
+        this.onDidChangeCommands = unsupported;
+        this.registerSlashData = unsupported;
+        this.registerSlashCallback = unsupported;
+        this.registerSlashCommand = unsupported;
+        this.executeCommand = unsupported;
+        this.getCommands = unsupported;
+        this.hasCommand = unsupported;
+    }
+}, 1 );
+registerSingleton(IChatVariablesService, class ChatVariablesService {
+    constructor() {
+        this.registerVariable = unsupported;
+        this.getVariables = unsupported;
+        this.resolveVariables = unsupported;
+        this.hasVariable = unsupported;
+    }
+}, 1 );
+registerSingleton(IAiRelatedInformationService, class AiRelatedInformationService {
+    constructor() {
+        this.isEnabled = () => false;
+        this.getRelatedInformation = unsupported;
+        this.registerAiRelatedInformationProvider = unsupported;
+    }
+}, 1 );
+registerSingleton(IAiEmbeddingVectorService, class AiEmbeddingVectorService {
+    constructor() {
+        this.isEnabled = () => false;
+        this.getEmbeddingVector = unsupported;
+        this.registerAiEmbeddingVectorProvider = unsupported;
+    }
+}, 1 );
+registerSingleton(ISignService, (_a = class SignService {
+        async createNewMessage(value) {
+            const id = String(_a._nextId++);
+            return {
+                id,
+                data: value
+            };
+        }
+        async validate() {
+            return true;
+        }
+        async sign(value) {
+            return value;
+        }
+    },
+    _a._nextId = 1,
+    _a), 1 );