@codingame/monaco-vscode-api 1.78.4 → 1.78.5

package/dist/vscode-services/missing-services.js

@@ -0,0 +1,959 @@
+import { __decorate, __param } from '../node_modules/tslib/tslib.es6.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { DomEmitter } from 'monaco-editor/esm/vs/base/browser/event.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { trackFocus } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { IEditorService } from '../vscode/vs/workbench/services/editor/common/editorService.js';
+import { IPaneCompositePartService } from '../vscode/vs/workbench/services/panecomposite/browser/panecomposite.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { ITextFileService } from '../vscode/vs/workbench/services/textfile/common/textfiles.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IEditorGroupsService } from '../vscode/vs/workbench/services/editor/common/editorGroupsService.js';
+import { IWorkbenchEnvironmentService } from '../vscode/vs/workbench/services/environment/common/environmentService.js';
+import { IWorkingCopyFileService, WorkingCopyFileService } from '../vscode/vs/workbench/services/workingCopy/common/workingCopyFileService.js';
+import { IPathService } from '../vscode/vs/workbench/services/path/common/pathService.js';
+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/vs/workbench/services/languageStatus/common/languageStatusService.js';
+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/vs/workbench/services/host/browser/host.js';
+import { ILifecycleService } from '../vscode/vs/workbench/services/lifecycle/common/lifecycle.js';
+import { ILanguageDetectionService } from '../vscode/vs/workbench/services/languageDetection/common/languageDetectionWorkerService.js';
+import { IExtensionService, NullExtensionService } from '../vscode/vs/workbench/services/extensions/common/extensions.js';
+import { IKeyboardLayoutService } from '../vscode/vs/platform/keyboardLayout/common/keyboardLayout.js';
+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/vs/workbench/services/userData/browser/userDataInit.js';
+import { IBrowserWorkbenchEnvironmentService } from '../vscode/vs/workbench/services/environment/browser/environmentService.js';
+import { BrowserHostColorSchemeService } from '../vscode/vs/workbench/services/themes/browser/browserHostColorSchemeService.js';
+import { IHostColorSchemeService } from '../vscode/vs/workbench/services/themes/common/hostColorSchemeService.js';
+import { IPreferencesService } from '../vscode/vs/workbench/services/preferences/common/preferences.js';
+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 } from 'monaco-editor/esm/vs/platform/userDataProfile/common/userDataProfile.js';
+import { IPolicyService } from 'monaco-editor/esm/vs/platform/policy/common/policy.js';
+import { IUserDataProfileService } from '../vscode/vs/workbench/services/userDataProfile/common/userDataProfile.js';
+import { UserDataProfileService } from '../vscode/vs/workbench/services/userDataProfile/common/userDataProfileService.js';
+import { ISnippetsService } from '../vscode/vs/workbench/contrib/snippets/browser/snippets.js';
+import { ILoggerService, AbstractLoggerService, LogLevel, NullLogger } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { FallbackKeyboardMapper } from '../vscode/vs/workbench/services/keybinding/common/fallbackKeyboardMapper.js';
+import { ITextMateTokenizationService } from '../vscode/vs/workbench/services/textMate/browser/textMateTokenizationFeature.js';
+import { IDebugService } from '../vscode/vs/workbench/contrib/debug/common/debug.js';
+import { IWorkspaceTrustRequestService } from 'monaco-editor/esm/vs/platform/workspace/common/workspaceTrust.js';
+import { IActivityService } from '../vscode/vs/workbench/services/activity/common/activity.js';
+import { IExtensionHostDebugService } from '../vscode/vs/platform/debug/common/extensionHostDebug.js';
+import { IViewsService, IViewDescriptorService } from '../vscode/vs/workbench/common/views.js';
+import { IHistoryService } from '../vscode/vs/workbench/services/history/common/history.js';
+import { ITaskService } from '../vscode/vs/workbench/contrib/tasks/common/taskService.js';
+import { IURITransformerService, URITransformerService } from '../vscode/vs/workbench/api/common/extHostUriTransformerService.js';
+import { IConfigurationResolverService } from '../vscode/vs/workbench/services/configurationResolver/common/configurationResolver.js';
+import { BrowserPathService } from '../vscode/vs/workbench/services/path/browser/pathService.js';
+import { IRemoteAgentService } from '../vscode/vs/workbench/services/remote/common/remoteAgentService.js';
+import { ICustomEndpointTelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { NullEndpointTelemetryService } from '../vscode/vs/platform/telemetry/common/telemetryUtils.js';
+import { SearchService } from '../vscode/vs/workbench/services/search/common/searchService.js';
+import { ISearchService } from '../vscode/vs/workbench/services/search/common/search.js';
+import { IRequestService } from '../vscode/vs/platform/request/common/request.js';
+import { IEditSessionIdentityService } from '../vscode/vs/platform/workspace/common/editSessions.js';
+import { IWorkspaceEditingService } from '../vscode/vs/workbench/services/workspaces/common/workspaceEditing.js';
+import { ITimerService } from '../vscode/vs/workbench/services/timer/browser/timerService.js';
+import { IExtensionsWorkbenchService } from '../vscode/vs/workbench/contrib/extensions/common/extensions.js';
+import { IWorkbenchExtensionEnablementService } from '../vscode/vs/workbench/services/extensionManagement/common/extensionManagement.js';
+import { ITunnelService } from '../vscode/vs/platform/tunnel/common/tunnel.js';
+import { IWorkingCopyBackupService } from '../vscode/vs/workbench/services/workingCopy/common/workingCopyBackup.js';
+import { IWorkingCopyService, WorkingCopyService } from '../vscode/vs/workbench/services/workingCopy/common/workingCopyService.js';
+import { IFilesConfigurationService, FilesConfigurationService } from '../vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService.js';
+import { IUntitledTextEditorService } from '../vscode/vs/workbench/services/untitled/common/untitledTextEditorService.js';
+import { IFileDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+import { IElevatedFileService } from '../vscode/vs/workbench/services/files/common/elevatedFileService.js';
+import { BrowserElevatedFileService } from '../vscode/vs/workbench/services/files/browser/elevatedFileService.js';
+import { IDecorationsService } from '../vscode/vs/workbench/services/decorations/common/decorations.js';
+import { Disposable } from '../vscode/vs/workbench/api/common/extHostTypes.js';
+import { RequestService } from '../vscode/vs/platform/request/browser/requestService.js';
+import { InMemoryWorkingCopyBackupService } from '../vscode/vs/workbench/services/workingCopy/common/workingCopyBackupService.js';
+import { BrowserTextFileService } from '../vscode/vs/workbench/services/textfile/browser/browserTextFileService.js';
+import { DecorationsService } from '../vscode/vs/workbench/services/decorations/browser/decorationsService.js';
+import { UriIdentityService } from '../vscode/vs/platform/uriIdentity/common/uriIdentityService.js';
+import { IJSONEditingService } from '../vscode/vs/workbench/services/configuration/common/jsonEditing.js';
+import { JSONEditingService } from '../vscode/vs/workbench/services/configuration/common/jsonEditingService.js';
+import { IWorkspacesService } from '../vscode/vs/platform/workspaces/common/workspaces.js';
+import { ITextEditorService } from '../vscode/vs/workbench/services/textfile/common/textEditorService.js';
+import { IEditorResolverService } from '../vscode/vs/workbench/services/editor/common/editorResolverService.js';
+import { AbstractLifecycleService } from '../vscode/vs/workbench/services/lifecycle/common/lifecycleService.js';
+import { IOutputService } from '../vscode/vs/workbench/services/output/common/output.js';
+import { OutputService } from '../vscode/vs/workbench/contrib/output/browser/outputServices.js';
+import { IOutputChannelModelService, OutputChannelModelService } from '../vscode/vs/workbench/contrib/output/common/outputChannelModelService.js';
+import { IExtensionResourceLoaderService, AbstractExtensionResourceLoaderService } from '../vscode/vs/platform/extensionResourceLoader/common/extensionResourceLoader.js';
+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 { unsupported } from '../tools.js';
+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 () => false;
+        this.saveAll = async () => false;
+        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 = unsupported;
+    }
+}, 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.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 = unsupported;
+        this.findEditors = unsupported;
+        this.getEditorByIndex = unsupported;
+        this.getIndexOfEditor = unsupported;
+        this.openEditor = unsupported;
+        this.openEditors = unsupported;
+        this.isPinned = unsupported;
+        this.isSticky = unsupported;
+        this.isActive = unsupported;
+        this.contains = unsupported;
+        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 = () => true;
+        this.isLast = () => true;
+    }
+    get scopedContextKeyService() { return StandaloneServices.get(IContextKeyService); }
+    focus() {
+    }
+}
+registerSingleton(IEditorGroupsService, class EditorGroupsService {
+    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 = new EmptyEditorGroup();
+        this.groups = [];
+        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.onDidChangeEditorPartOptions = Event.None;
+        this.enforcePartOptions = unsupported;
+    }
+    get contentDimension() { return unsupported(); }
+    get sideGroup() { return unsupported(); }
+    get partOptions() { return unsupported(); }
+}, 0 );
+class WorkbenchEnvironmentService {
+    constructor() {
+        this.logsHome = ( URI.from({ scheme: 'logs', path: '/' }));
+        this.windowLogsPath = ( URI.from({ scheme: 'logs', path: '/window.log' }));
+        this._serviceBrand = undefined;
+        this.skipReleaseNotes = true;
+        this.skipWelcome = true;
+        this.disableWorkspaceTrust = true;
+        this.debugRenderer = false;
+        this.userRoamingDataHome = ( URI.from({ scheme: 'user', path: '/userRoamingDataHome' }));
+        this.keyboardLayoutResource = ( URI.from({ scheme: 'user', path: '/keyboardLayout.json' }));
+        this.snippetsHome = ( URI.from({ scheme: 'user', path: '/snippets' }));
+        this.untitledWorkspacesHome = ( URI.from({ scheme: 'user', path: '/untitledWorkspacesHome' }));
+        this.cacheHome = ( URI.from({ scheme: 'cache', path: '/' }));
+        this.sync = undefined;
+        this.debugExtensionHost = {
+            port: null,
+            break: false
+        };
+        this.isExtensionDevelopment = false;
+        this.disableExtensions = false;
+        this.logsPath = '';
+        this.verbose = false;
+        this.isBuilt = true;
+        this.disableTelemetry = false;
+    }
+    get extHostTelemetryLogFile() { return unsupported(); }
+    get logFile() { return unsupported(); }
+    get extHostLogsPath() { return unsupported(); }
+    get webviewExternalEndpoint() { return unsupported(); }
+    get argvResource() { return unsupported(); }
+    get globalStorageHome() { return unsupported(); }
+    get workspaceStorageHome() { return unsupported(); }
+    get localHistoryHome() { return unsupported(); }
+    get userDataSyncHome() { return unsupported(); }
+    get userDataSyncLogResource() { return unsupported(); }
+    get telemetryLogResource() { return unsupported(); }
+    get serviceMachineIdResource() { return unsupported(); }
+    get stateResource() { return unsupported(); }
+    get editSessionsLogResource() { return unsupported(); }
+}
+registerSingleton(IWorkbenchEnvironmentService, WorkbenchEnvironmentService, 0 );
+registerSingleton(IEnvironmentService, WorkbenchEnvironmentService, 0 );
+registerSingleton(IBrowserWorkbenchEnvironmentService, WorkbenchEnvironmentService, 0 );
+registerSingleton(IWorkingCopyFileService, WorkingCopyFileService, 0 );
+registerSingleton(IPathService, BrowserPathService, 1 );
+registerSingleton(IProductService, class ProductService {
+    constructor() {
+        this._serviceBrand = undefined;
+        this.version = "1.78.0";
+        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 );
+const focusTracker = trackFocus(window);
+const onVisibilityChange = new DomEmitter(window.document, 'visibilitychange');
+const onDidChangeFocus = Event.latch(Event.any(( Event.map(focusTracker.onDidFocus, () => document.hasFocus())), ( Event.map(focusTracker.onDidBlur, () => document.hasFocus())), ( Event.map(onVisibilityChange.event, () => document.hasFocus()))));
+registerSingleton(IHostService, class HostService {
+    constructor() {
+        this.onDidChangeFocus = onDidChangeFocus;
+        this.openWindow = unsupported;
+        this.restart = unsupported;
+        this.reload = unsupported;
+        this.close = unsupported;
+    }
+    get hasFocus() {
+        return document.hasFocus();
+    }
+    async hadLastFocus() {
+        return true;
+    }
+    async focus() {
+        window.focus();
+    }
+    async toggleFullScreen() {
+        if (document.fullscreenEnabled) {
+            await document.body.requestFullscreen();
+        }
+        else {
+            await document.exitFullscreen();
+        }
+    }
+}, 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 );
+registerSingleton(IPreferencesService, class PreferencesService {
+    constructor() {
+        this.userSettingsResource = profile.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;
+    }
+}, 0 );
+registerSingleton(ITextMateTokenizationService, class NullTextMateService {
+    constructor() {
+        this.onDidEncounterLanguage = Event.None;
+        this.createGrammar = unsupported;
+        this.startDebugMode = unsupported;
+    }
+}, 0 );
+const profile = {
+    id: 'default',
+    isDefault: true,
+    name: 'default',
+    location: ( URI.from({ scheme: 'user', path: '/profile.json' })),
+    get globalStorageHome() { return unsupported(); },
+    settingsResource: ( URI.from({ scheme: 'user', path: '/settings.json' })),
+    keybindingsResource: ( URI.from({ scheme: 'user', path: '/keybindings.json' })),
+    tasksResource: ( URI.from({ scheme: 'user', path: '/tasks.json' })),
+    snippetsHome: ( URI.from({ scheme: 'user', path: '/snippets' })),
+    get extensionsResource() { return unsupported(); },
+    cacheHome: ( URI.from({ scheme: 'cache', path: '/' }))
+};
+registerSingleton(IUserDataProfilesService, class UserDataProfilesService {
+    constructor() {
+        this.onDidResetWorkspaces = Event.None;
+        this.isEnabled = () => false;
+        this.createNamedProfile = unsupported;
+        this.createTransientProfile = unsupported;
+        this.resetWorkspaces = unsupported;
+        this.cleanUp = unsupported;
+        this.cleanUpTransientProfiles = unsupported;
+        this.defaultProfile = profile;
+        this.onDidChangeProfiles = Event.None;
+        this.profiles = [profile];
+        this.createProfile = unsupported;
+        this.updateProfile = unsupported;
+        this.setProfileForWorkspace = unsupported;
+        this.getProfile = () => profile;
+        this.removeProfile = unsupported;
+    }
+    get profilesHome() { return unsupported(); }
+}, 0 );
+let InjectedUserDataProfileService = class InjectedUserDataProfileService extends UserDataProfileService {
+    constructor(userDataProfilesService) {
+        super(profile, userDataProfilesService);
+    }
+};
+InjectedUserDataProfileService = __decorate([
+    ( __param(0, IUserDataProfilesService))
+], 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.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 = () => new Disposable(() => { });
+        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 = unsupported;
+        this.cancelWorkspaceTrustRequest = unsupported;
+        this.completeWorkspaceTrustRequest = unsupported;
+        this.requestWorkspaceTrust = async () => true;
+        this.requestWorkspaceTrustOnStartup = () => null;
+    }
+}, 0 );
+registerSingleton(IActivityService, class ActivityService {
+    constructor() {
+        this.showViewContainerActivity = unsupported;
+        this.showViewActivity = unsupported;
+        this.showAccountsActivity = unsupported;
+        this.showGlobalActivity = unsupported;
+    }
+}, 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.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 = unsupported;
+        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 = unsupported;
+        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 = unsupported;
+        this.onDidChangeTaskSystemInfo = Event.None;
+        this.hasTaskSystemInfo = false;
+        this.registerSupportedExecutions = unsupported;
+        this.extensionCallbackTaskComplete = unsupported;
+    }
+}, 0 );
+registerSingleton(IURITransformerService, class InjectedURITransformerService extends URITransformerService {
+    constructor() {
+        super(null);
+    }
+}, 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 );
+class SocketFactory {
+    constructor() {
+        this.connect = unsupported;
+    }
+}
+registerSingleton(IRemoteAgentService, class RemoteAgentService {
+    constructor() {
+        this.socketFactory = new SocketFactory();
+        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 );
+registerSingleton(ISearchService, SearchService, 0 );
+registerSingleton(IEditSessionIdentityService, class EditSessionIdentityService {
+    constructor() {
+        this.registerEditSessionIdentityProvider = unsupported;
+        this.getEditSessionIdentifier = unsupported;
+        this.provideEditSessionIdentityMatch = unsupported;
+        this.addEditSessionIdentityCreateParticipant = unsupported;
+        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.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 = unsupported;
+        this.getEnablementStates = unsupported;
+        this.getDependenciesEnablementStates = unsupported;
+        this.canChangeEnablement = unsupported;
+        this.canChangeWorkspaceEnablement = unsupported;
+        this.isEnabled = unsupported;
+        this.isEnabledEnablementState = unsupported;
+        this.isDisabledGlobally = unsupported;
+        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.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.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 = unsupported;
+    }
+    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 );