@codingame/monaco-vscode-api 1.69.24 → 1.76.0-next.2

package/dist/missing-services.js

@@ -1,20 +1,26 @@
-import { E as Emitter, _ as __decorate, a as __param } from './workspace.js';
-import './polyfill.js';
+import { E as Emitter, _ as __decorate, a as __param } from './contextkey.js';
+import { I as IPolicyService } from './polyfill.js';
 import { b as IEditorService, f as IPaneCompositePartService, k as IUriIdentityService, j as ITextFileService, c as IFileService, I as IEditorGroupsService, l as IWorkbenchEnvironmentService, m as IWorkingCopyFileService, g as IPathService, S as Services, h as IProductService, e as ILanguageStatusService, d as IHostService, r as IUserDataProfilesService, i as ISnippetsService, s as refineServiceDecorator } from './services2.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { USLayoutResolvedKeybinding } from 'monaco-editor/esm/vs/platform/keybinding/common/usLayoutResolvedKeybinding.js';
-import { SimpleKeybinding } from 'monaco-editor/esm/vs/base/common/keybindings.js';
 import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
 import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { addMatchMediaChangeListener } from 'monaco-editor/esm/vs/base/browser/browser.js';
+import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { Promises } from 'monaco-editor/esm/vs/base/common/async.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { Keybinding, KeyCodeChord } from 'monaco-editor/esm/vs/base/common/keybindings.js';
+import { USLayoutResolvedKeybinding } from 'monaco-editor/esm/vs/platform/keybinding/common/usLayoutResolvedKeybinding.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { isNumber } from 'monaco-editor/esm/vs/base/common/types.js';
 import { registerSingleton } from 'monaco-editor/esm/vs/platform/instantiation/common/extensions.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 { ExtUri } from 'monaco-editor/esm/vs/base/common/resources.js';
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { IProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
 import { LanguageFeatureRegistry } from 'monaco-editor/esm/vs/editor/common/languageFeatureRegistry.js';
 import { compare } from 'monaco-editor/esm/vs/base/common/strings.js';
@@ -22,14 +28,148 @@ import { trackFocus } from 'monaco-editor/esm/vs/base/browser/dom.js';
 import { DomEmitter } from 'monaco-editor/esm/vs/base/browser/event.js';
 import { OS } from 'monaco-editor/esm/vs/base/common/platform.js';
 import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-const IPolicyService = ( (createDecorator('policy')));
-class NullPolicyService {
+const ILoggerService = ( (createDecorator('loggerService')));
+function isLogLevel(thing) {
+    return isNumber(thing);
+}
+var LogLevel;
+( ((function(LogLevel) {
+    LogLevel[LogLevel["Off"] = 0] = "Off";
+    LogLevel[LogLevel["Trace"] = 1] = "Trace";
+    LogLevel[LogLevel["Debug"] = 2] = "Debug";
+    LogLevel[LogLevel["Info"] = 3] = "Info";
+    LogLevel[LogLevel["Warning"] = 4] = "Warning";
+    LogLevel[LogLevel["Error"] = 5] = "Error";
+})(LogLevel || (LogLevel = {}))));
+class AbstractLoggerService extends Disposable {
+    constructor(logLevel, loggerResources) {
+        super();
+        this.logLevel = logLevel;
+        this._loggers = ( (new ResourceMap()));
+        this._loggerResources = ( (new ResourceMap()));
+        this._onDidChangeLoggers = this._register(( (new Emitter())));
+        this.onDidChangeLoggers = this._onDidChangeLoggers.event;
+        this._onDidChangeLogLevel = this._register(( (new Emitter())));
+        this.onDidChangeLogLevel = this._onDidChangeLogLevel.event;
+        this._onDidChangeVisibility = this._register(( (new Emitter())));
+        this.onDidChangeVisibility = this._onDidChangeVisibility.event;
+        if (loggerResources) {
+            for (const loggerResource of loggerResources) {
+                this._loggerResources.set(loggerResource.resource, loggerResource);
+            }
+        }
+    }
+    getLogger(resource) {
+        return this._loggers.get(resource);
+    }
+    createLogger(resource, options) {
+        let logger = this._loggers.get(resource);
+        const logLevel = options?.logLevel === 'always' ? LogLevel.Trace : options?.logLevel;
+        if (!logger) {
+            logger = this.doCreateLogger(resource, logLevel ?? this.getLogLevel(resource) ?? this.logLevel, options);
+            this._loggers.set(resource, logger);
+        }
+        this.registerLogger({ resource, id: options?.id ?? ( (resource.toString())), logLevel, name: options?.name, hidden: options?.hidden, extensionId: options?.extensionId });
+        return logger;
+    }
+    setLogLevel(arg1, arg2) {
+        if (URI.isUri(arg1)) {
+            const resource = arg1;
+            const logLevel = arg2;
+            const loggerResource = this._loggerResources.get(resource);
+            if (loggerResource && logLevel !== loggerResource.logLevel) {
+                loggerResource.logLevel = logLevel === this.logLevel ? undefined : logLevel;
+                this._loggers.get(resource)?.setLevel(logLevel);
+                this._loggerResources.set(loggerResource.resource, loggerResource);
+                this._onDidChangeLogLevel.fire([resource, logLevel]);
+            }
+        }
+        else {
+            this.logLevel = arg1;
+            for (const [resource, logger] of this._loggers.entries()) {
+                if (this._loggerResources.get(resource)?.logLevel === undefined) {
+                    logger.setLevel(this.logLevel);
+                }
+            }
+            this._onDidChangeLogLevel.fire(this.logLevel);
+        }
+    }
+    setVisibility(resource, visibility) {
+        const loggerResource = this._loggerResources.get(resource);
+        if (loggerResource && visibility !== !loggerResource.hidden) {
+            loggerResource.hidden = !visibility;
+            this._loggerResources.set(loggerResource.resource, loggerResource);
+            this._onDidChangeVisibility.fire([resource, visibility]);
+        }
+    }
+    getLogLevel(resource) {
+        let logLevel;
+        if (resource) {
+            logLevel = this._loggerResources.get(resource)?.logLevel;
+        }
+        return logLevel ?? this.logLevel;
+    }
+    registerLogger(resource) {
+        const existing = this._loggerResources.get(resource.resource);
+        if (existing) {
+            if (existing.hidden !== resource.hidden) {
+                this.setVisibility(resource.resource, !resource.hidden);
+            }
+        }
+        else {
+            this._loggerResources.set(resource.resource, resource);
+            this._onDidChangeLoggers.fire({ added: [resource], removed: [] });
+        }
+    }
+    deregisterLogger(resource) {
+        const existing = this._loggerResources.get(resource);
+        if (existing) {
+            this._loggerResources.delete(resource);
+            const logger = this._loggers.get(resource);
+            if (logger) {
+                this._loggers.delete(resource);
+                logger.dispose();
+            }
+            this._onDidChangeLoggers.fire({ added: [], removed: [existing] });
+        }
+    }
+    getRegisteredLoggers() {
+        return (
+             (this._loggerResources.values())
+        );
+    }
+    getRegisteredLogger(resource) {
+        return this._loggerResources.get(resource);
+    }
+    dispose() {
+        this._loggers.forEach(logger => logger.dispose());
+        this._loggers.clear();
+        this._loggerResources.clear();
+        super.dispose();
+    }
+}
+class NullLogger {
     constructor() {
-        this.onDidChange = Event.None;
+        this.onDidChangeLogLevel = ( (new Emitter())).event;
+    }
+    setLevel(level) { }
+    getLevel() { return LogLevel.Info; }
+    trace(message, ...args) { }
+    debug(message, ...args) { }
+    info(message, ...args) { }
+    warn(message, ...args) { }
+    error(message, ...args) { }
+    critical(message, ...args) { }
+    dispose() { }
+    flush() { }
+}
+class NullLoggerService extends AbstractLoggerService {
+    constructor() { super(LogLevel.Info); }
+    doCreateLogger(resource, logLevel, options) {
+        return (
+             (new NullLogger())
+        );
     }
-    async registerPolicyDefinitions() { return {}; }
-    getPolicyValue() { return undefined; }
-    serialize() { return undefined; }
 }
 const IExtensionService = ( (createDecorator('extensionService')));
 function isProposedApiEnabled(extension, proposal) {
@@ -50,11 +190,11 @@ class NullExtensionService {
         this.onDidChangeExtensions = Event.None;
         this.onWillActivateByEvent = Event.None;
         this.onDidChangeResponsiveChange = Event.None;
+        this.extensions = [];
     }
     activateByEvent(_activationEvent) { return Promise.resolve(undefined); }
     activationEventIsDone(_activationEvent) { return false; }
     whenInstalledExtensionsRegistered() { return Promise.resolve(true); }
-    getExtensions() { return Promise.resolve([]); }
     getExtension() { return Promise.resolve(undefined); }
     readExtensionPointContributions(_extPoint) { return Promise.resolve(Object.create(null)); }
     getExtensionsStatus() { return Object.create(null); }
@@ -66,10 +206,10 @@ class NullExtensionService {
     async setRemoteEnvironment(_env) { }
     canAddExtension() { return false; }
     canRemoveExtension() { return false; }
-    _activateById(_extensionId, _reason) { return Promise.resolve(); }
 }
 const ILifecycleService = ( (createDecorator('lifecycleService')));
 const ILanguageDetectionService = ( (createDecorator('ILanguageDetectionService')));
+const LanguageDetectionLanguageEventSource = 'languageDetection';
 const IKeyboardLayoutService = ( (createDecorator('keyboardLayoutService')));
 function getKeyboardLayoutId(layout) {
     if (layout.name) {
@@ -80,32 +220,6 @@ function getKeyboardLayoutId(layout) {
     }
     return layout.layout;
 }
-class MacLinuxFallbackKeyboardMapper {
-    constructor(OS) {
-        this._OS = OS;
-    }
-    dumpDebugInfo() {
-        return 'FallbackKeyboardMapper dispatching on keyCode';
-    }
-    resolveKeybinding(keybinding) {
-        return [( (new USLayoutResolvedKeybinding(keybinding, this._OS)))];
-    }
-    resolveKeyboardEvent(keyboardEvent) {
-        const keybinding = ( (new SimpleKeybinding(
-            keyboardEvent.ctrlKey,
-            keyboardEvent.shiftKey,
-            keyboardEvent.altKey,
-            keyboardEvent.metaKey,
-            keyboardEvent.keyCode
-        )));
-        return (
-             (new USLayoutResolvedKeybinding(keybinding.toChord(), this._OS))
-        );
-    }
-    resolveUserBinding(input) {
-        return USLayoutResolvedKeybinding.resolveUserBinding(input, this._OS);
-    }
-}
 const IBrowserWorkbenchEnvironmentService = refineServiceDecorator(IEnvironmentService);
 const IUserDataInitializationService = ( (createDecorator('IUserDataInitializationService')));
 const IHostColorSchemeService = ( (createDecorator('hostColorSchemeService')));
@@ -143,9 +257,10 @@ class BrowserHostColorSchemeService extends Disposable {
     }
 }
 const IPreferencesService = ( (createDecorator('preferencesService')));
-const ITextMateService = ( (createDecorator('textMateService')));
 const IUserDataProfileService = ( (createDecorator('IUserDataProfileService')));
+const defaultUserDataProfileIcon = registerIcon('defaultProfile-icon', Codicon.settings, ( (localize('defaultProfileIcon', 'Icon for Default Profile.'))));
 let UserDataProfileService = class UserDataProfileService extends Disposable {
+    get currentProfile() { return this._currentProfile; }
     constructor(currentProfile, userDataProfilesService) {
         super();
         this._onDidChangeCurrentProfile = this._register(( (new Emitter())));
@@ -154,10 +269,6 @@ let UserDataProfileService = class UserDataProfileService extends Disposable {
         this.onDidUpdateCurrentProfile = this._onDidUpdateCurrentProfile.event;
         this._currentProfile = currentProfile;
         this._register(userDataProfilesService.onDidChangeProfiles(e => {
-            if (this._currentProfile.isDefault) {
-                this._currentProfile = userDataProfilesService.defaultProfile;
-                return;
-            }
             const updatedCurrentProfile = e.updated.find(p => this._currentProfile.id === p.id);
             if (updatedCurrentProfile) {
                 this._currentProfile = updatedCurrentProfile;
@@ -165,7 +276,6 @@ let UserDataProfileService = class UserDataProfileService extends Disposable {
             }
         }));
     }
-    get currentProfile() { return this._currentProfile; }
     async updateCurrentProfile(userDataProfile, preserveData) {
         if (this._currentProfile.id === userDataProfile.id) {
             return;
@@ -183,13 +293,46 @@ let UserDataProfileService = class UserDataProfileService extends Disposable {
         });
         await Promises.settled(joiners);
     }
+    getShortName(profile) {
+        if (!profile.isDefault && profile.shortName && ThemeIcon.fromId(profile.shortName)) {
+            return profile.shortName;
+        }
+        return `$(${defaultUserDataProfileIcon.id})`;
+    }
 };
 UserDataProfileService = ( (__decorate([
     ( (__param(1, IUserDataProfilesService)))
 ], UserDataProfileService)));
+class FallbackKeyboardMapper {
+    constructor(_mapAltGrToCtrlAlt, _OS) {
+        this._mapAltGrToCtrlAlt = _mapAltGrToCtrlAlt;
+        this._OS = _OS;
+    }
+    dumpDebugInfo() {
+        return 'FallbackKeyboardMapper dispatching on keyCode';
+    }
+    resolveKeyboardEvent(keyboardEvent) {
+        const ctrlKey = keyboardEvent.ctrlKey || (this._mapAltGrToCtrlAlt && keyboardEvent.altGraphKey);
+        const altKey = keyboardEvent.altKey || (this._mapAltGrToCtrlAlt && keyboardEvent.altGraphKey);
+        const chord = ( (new KeyCodeChord(
+            ctrlKey,
+            keyboardEvent.shiftKey,
+            altKey,
+            keyboardEvent.metaKey,
+            keyboardEvent.keyCode
+        )));
+        const result = this.resolveKeybinding(( (new Keybinding([chord]))));
+        return result[0];
+    }
+    resolveKeybinding(keybinding) {
+        return USLayoutResolvedKeybinding.resolveKeybinding(keybinding, this._OS);
+    }
+}
+const ITextMateTokenizationService = ( (createDecorator('textMateTokenizationFeature')));
 function unsupported() {
     throw new Error('unsupported');
 }
+registerSingleton(ILoggerService, NullLoggerService, 0 );
 registerSingleton(IEditorService, class EditorService {
     constructor() {
         this._serviceBrand = undefined;
@@ -220,7 +363,7 @@ registerSingleton(IEditorService, class EditorService {
         this.revertAll = async () => false;
     }
     get activeTextEditorControl() { return StandaloneServices.get(ICodeEditorService).getFocusedCodeEditor() ?? undefined; }
-});
+}, 0 );
 registerSingleton(IPaneCompositePartService, class PaneCompositePartService {
     constructor() {
         this._serviceBrand = undefined;
@@ -237,7 +380,7 @@ registerSingleton(IPaneCompositePartService, class PaneCompositePartService {
         this.getLastActivePaneCompositeId = unsupported;
         this.showActivity = unsupported;
     }
-});
+}, 0 );
 registerSingleton(IUriIdentityService, class UriIdentityService {
     constructor() {
         this._serviceBrand = undefined;
@@ -246,7 +389,7 @@ registerSingleton(IUriIdentityService, class UriIdentityService {
     asCanonicalUri(uri) {
         return uri;
     }
-});
+}, 0 );
 const onDidSave = new Emitter();
 class TextFileEditorModelManager {
     constructor() {
@@ -292,7 +435,7 @@ registerSingleton(ITextFileService, class TextFileService {
     get encoding() { return unsupported(); }
     dispose() {
     }
-});
+}, 0 );
 registerSingleton(IFileService, class FileService {
     constructor() {
         this._serviceBrand = undefined;
@@ -332,7 +475,7 @@ registerSingleton(IFileService, class FileService {
     }
     dispose() {
     }
-});
+}, 0 );
 class EmptyEditorGroup {
     constructor() {
         this.onDidModelChange = Event.None;
@@ -426,7 +569,7 @@ registerSingleton(IEditorGroupsService, class EditorGroupsService {
     get contentDimension() { return unsupported(); }
     get sideGroup() { return unsupported(); }
     get partOptions() { return unsupported(); }
-});
+}, 0 );
 class WorkbenchEnvironmentService {
     constructor() {
         this._serviceBrand = undefined;
@@ -444,6 +587,8 @@ class WorkbenchEnvironmentService {
         this.isBuilt = true;
         this.disableTelemetry = false;
     }
+    get windowLogsPath() { return unsupported(); }
+    get extHostTelemetryLogFile() { return unsupported(); }
     get logFile() { return unsupported(); }
     get extHostLogsPath() { return unsupported(); }
     get webviewExternalEndpoint() { return unsupported(); }
@@ -462,9 +607,9 @@ class WorkbenchEnvironmentService {
     get stateResource() { return unsupported(); }
     get editSessionsLogResource() { return unsupported(); }
 }
-registerSingleton(IWorkbenchEnvironmentService, WorkbenchEnvironmentService);
-registerSingleton(IEnvironmentService, WorkbenchEnvironmentService);
-registerSingleton(IBrowserWorkbenchEnvironmentService, WorkbenchEnvironmentService);
+registerSingleton(IWorkbenchEnvironmentService, WorkbenchEnvironmentService, 0 );
+registerSingleton(IEnvironmentService, WorkbenchEnvironmentService, 0 );
+registerSingleton(IBrowserWorkbenchEnvironmentService, WorkbenchEnvironmentService, 0 );
 registerSingleton(IWorkingCopyFileService, class WorkingCopyFileService {
     constructor() {
         this._serviceBrand = undefined;
@@ -483,7 +628,7 @@ registerSingleton(IWorkingCopyFileService, class WorkingCopyFileService {
         this.registerWorkingCopyProvider = unsupported;
         this.getDirty = unsupported;
     }
-});
+}, 0 );
 registerSingleton(IPathService, class PathService {
     constructor() {
         this._serviceBrand = undefined;
@@ -496,7 +641,7 @@ registerSingleton(IPathService, class PathService {
     async fileURI(path) {
         return URI.file(path);
     }
-});
+}, 0 );
 registerSingleton(IProgressService, class ProgressService {
     constructor() {
         this._serviceBrand = undefined;
@@ -508,11 +653,11 @@ registerSingleton(IProgressService, class ProgressService {
         }
         return task({ report: () => { } });
     }
-});
+}, 0 );
 registerSingleton(IProductService, class ProductService {
     constructor() {
         this._serviceBrand = undefined;
-        this.version = "1.69.0";
+        this.version = "1.76.0";
         this.nameShort = 'Code - OSS Dev';
         this.nameLong = 'Code - OSS Dev';
         this.applicationName = 'code-oss';
@@ -523,7 +668,7 @@ registerSingleton(IProductService, class ProductService {
         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();
@@ -544,7 +689,7 @@ registerSingleton(ILanguageStatusService, class LanguageStatusServiceImpl {
             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())));
@@ -573,7 +718,7 @@ registerSingleton(IHostService, class HostService {
             await document.exitFullscreen();
         }
     }
-});
+}, 0 );
 registerSingleton(ILifecycleService, class LifecycleService {
     constructor() {
         this.startupKind = 1 ;
@@ -587,7 +732,7 @@ registerSingleton(ILifecycleService, class LifecycleService {
     }
     async when() {
     }
-});
+}, 0 );
 registerSingleton(ILanguageDetectionService, class LanguageDetectionService {
     isEnabledForLanguage() {
         return false;
@@ -595,18 +740,18 @@ registerSingleton(ILanguageDetectionService, class LanguageDetectionService {
     async detectLanguage() {
         return undefined;
     }
-});
-registerSingleton(IExtensionService, NullExtensionService);
+}, 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 MacLinuxFallbackKeyboardMapper(OS);
+        this.getKeyboardMapper = () => new FallbackKeyboardMapper(false, OS);
         this.validateCurrentKeyboardMapping = () => { };
     }
-});
+}, 0 );
 registerSingleton(IUserDataInitializationService, class NullUserDataInitializationService {
     async requiresInitialization() {
         return false;
@@ -615,8 +760,8 @@ registerSingleton(IUserDataInitializationService, class NullUserDataInitializati
     async initializeRequiredResources() { }
     async initializeInstalledExtensions() { }
     async initializeOtherResources() { }
-});
-registerSingleton(IHostColorSchemeService, BrowserHostColorSchemeService);
+}, 0 );
+registerSingleton(IHostColorSchemeService, BrowserHostColorSchemeService, 0 );
 registerSingleton(IPreferencesService, class PreferencesService {
     constructor() {
         this.workspaceSettingsResource = null;
@@ -638,14 +783,14 @@ registerSingleton(IPreferencesService, class PreferencesService {
         this.openLanguageSpecificSettings = unsupported;
     }
     get userSettingsResource() { return unsupported(); }
-});
-registerSingleton(ITextMateService, class NullTextMateService {
+}, 0 );
+registerSingleton(ITextMateTokenizationService, class NullTextMateService {
     constructor() {
         this.onDidEncounterLanguage = Event.None;
         this.createGrammar = unsupported;
         this.startDebugMode = unsupported;
     }
-});
+}, 0 );
 const profile = {
     id: 'default',
     isDefault: true,
@@ -656,10 +801,17 @@ const profile = {
     keybindingsResource: ( URI.from({ scheme: 'user', path: '/keybindings.json' })),
     get tasksResource() { return unsupported(); },
     get snippetsHome() { return ( URI.from({ scheme: 'user', path: '/snippets' })); },
-    extensionsResource: undefined
+    get extensionsResource() { return unsupported(); }
 };
 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];
@@ -670,7 +822,7 @@ registerSingleton(IUserDataProfilesService, class UserDataProfilesService {
         this.removeProfile = unsupported;
     }
     get profilesHome() { return unsupported(); }
-});
+}, 0 );
 let InjectedUserDataProfileService = class InjectedUserDataProfileService extends UserDataProfileService {
     constructor(userDataProfilesService) {
         super(profile, userDataProfilesService);
@@ -679,15 +831,16 @@ let InjectedUserDataProfileService = class InjectedUserDataProfileService extend
 InjectedUserDataProfileService = ( __decorate([
     ( __param(0, IUserDataProfilesService))
 ], InjectedUserDataProfileService));
-registerSingleton(IUserDataProfileService, 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;
@@ -697,5 +850,5 @@ registerSingleton(ISnippetsService, class SnippetsService {
         this.getSnippets = async () => [];
         this.getSnippetsSync = unsupported;
     }
-});
-export { ILifecycleService as I, MacLinuxFallbackKeyboardMapper as M, NullPolicyService as N, ILanguageDetectionService as a, IPolicyService as b, IKeyboardLayoutService as c, IExtensionService as d, IPreferencesService as e, IUserDataProfileService as f, getKeyboardLayoutId as g, ITextMateService as h, isProposedApiEnabled as i, IBrowserWorkbenchEnvironmentService as j, IHostColorSchemeService as k, IUserDataInitializationService as l, checkProposedApiEnabled as m, unsupported as u };
+}, 0 );
+export { FallbackKeyboardMapper as F, ILifecycleService as I, LanguageDetectionLanguageEventSource as L, ILanguageDetectionService as a, IKeyboardLayoutService as b, IExtensionService as c, IPreferencesService as d, IUserDataProfileService as e, ITextMateTokenizationService as f, getKeyboardLayoutId as g, IBrowserWorkbenchEnvironmentService as h, isProposedApiEnabled as i, IHostColorSchemeService as j, IUserDataInitializationService as k, checkProposedApiEnabled as l, ILoggerService as m, isLogLevel as n, unsupported as u };

package/dist/modelEditor.d.ts

@@ -38,14 +38,10 @@ declare enum EditorResolution {
      * Displays a picker and allows the user to decide which editor to use.
      */
     PICK = 0,
-    /**
-     * Disables editor resolving.
-     */
-    DISABLED = 1,
     /**
      * Only exclusive editors are considered.
      */
-    EXCLUSIVE_ONLY = 2
+    EXCLUSIVE_ONLY = 1
 }
 declare enum EditorOpenSource {
     /**