@codingame/monaco-vscode-api 25.1.2 → 26.0.1

package/vscode/src/vs/editor/standalone/browser/standaloneServices.js

@@ -25,6 +25,8 @@ import { StandardKeyboardEvent } from '../../../base/browser/keyboardEvent.js';
 import { decodeKeybinding, KeyCodeChord } from '../../../base/common/keybindings.js';
 import Severity$1 from '../../../base/common/severity.js';
 import { URI } from '../../../base/common/uri.js';
+import { NullRenameSymbolTrackerService } from '../../browser/services/renameSymbolTrackerService.js';
+import { IRenameSymbolTrackerService } from '../../browser/services/renameSymbolTrackerService.service.js';
 import { ResourceEdit, ResourceTextEdit } from '../../browser/services/bulkEditService.js';
 import { IBulkEditService } from '../../browser/services/bulkEditService.service.js';
 import { isEditorConfigurationKey, isDiffEditorConfigurationKey } from '../../common/config/editorConfigurationSchema.js';
@@ -153,22 +155,22 @@ let StandaloneTextModelService = class StandaloneTextModelService {
     }
     registerTextModelContentProvider(scheme, provider) {
         return {
-            dispose: function () { }
+            dispose: function() {}
         };
     }
     canHandleResource(resource) {
         return false;
     }
 };
-StandaloneTextModelService = ( __decorate([
-    ( __param(0, IModelService))
-], StandaloneTextModelService));
+StandaloneTextModelService = ( __decorate([( __param(0, IModelService))], StandaloneTextModelService));
 class StandaloneEditorProgressService {
-    static { this.NULL_PROGRESS_RUNNER = {
-        done: () => { },
-        total: () => { },
-        worked: () => { }
-    }; }
+    static {
+        this.NULL_PROGRESS_RUNNER = {
+            done: () => {},
+            total: () => {},
+            worked: () => {}
+        };
+    }
     show() {
         return StandaloneEditorProgressService.NULL_PROGRESS_RUNNER;
     }
@@ -179,25 +181,59 @@ class StandaloneEditorProgressService {
 class StandaloneProgressService {
     withProgress(_options, task, onDidCancel) {
         return task({
-            report: () => { },
+            report: () => {}
         });
     }
 }
 class StandaloneEnvironmentService {
     constructor() {
-        this.stateResource = ( URI.from({ scheme: 'monaco', authority: 'stateResource' }));
-        this.userRoamingDataHome = ( URI.from({ scheme: 'monaco', authority: 'userRoamingDataHome' }));
-        this.keyboardLayoutResource = ( URI.from({ scheme: 'monaco', authority: 'keyboardLayoutResource' }));
-        this.argvResource = ( URI.from({ scheme: 'monaco', authority: 'argvResource' }));
-        this.untitledWorkspacesHome = ( URI.from({ scheme: 'monaco', authority: 'untitledWorkspacesHome' }));
-        this.workspaceStorageHome = ( URI.from({ scheme: 'monaco', authority: 'workspaceStorageHome' }));
-        this.localHistoryHome = ( URI.from({ scheme: 'monaco', authority: 'localHistoryHome' }));
-        this.cacheHome = ( URI.from({ scheme: 'monaco', authority: 'cacheHome' }));
-        this.userDataSyncHome = ( URI.from({ scheme: 'monaco', authority: 'userDataSyncHome' }));
+        this.stateResource = ( URI.from({
+            scheme: "monaco",
+            authority: "stateResource"
+        }));
+        this.userRoamingDataHome = ( URI.from({
+            scheme: "monaco",
+            authority: "userRoamingDataHome"
+        }));
+        this.keyboardLayoutResource = ( URI.from({
+            scheme: "monaco",
+            authority: "keyboardLayoutResource"
+        }));
+        this.argvResource = ( URI.from({
+            scheme: "monaco",
+            authority: "argvResource"
+        }));
+        this.untitledWorkspacesHome = ( URI.from({
+            scheme: "monaco",
+            authority: "untitledWorkspacesHome"
+        }));
+        this.builtinWorkbenchModesHome = ( URI.from({
+            scheme: "monaco",
+            authority: "builtinWorkbenchModesHome"
+        }));
+        this.workspaceStorageHome = ( URI.from({
+            scheme: "monaco",
+            authority: "workspaceStorageHome"
+        }));
+        this.localHistoryHome = ( URI.from({
+            scheme: "monaco",
+            authority: "localHistoryHome"
+        }));
+        this.cacheHome = ( URI.from({
+            scheme: "monaco",
+            authority: "cacheHome"
+        }));
+        this.userDataSyncHome = ( URI.from({
+            scheme: "monaco",
+            authority: "userDataSyncHome"
+        }));
         this.sync = undefined;
         this.continueOn = undefined;
         this.editSessionId = undefined;
-        this.debugExtensionHost = { port: null, break: false };
+        this.debugExtensionHost = {
+            port: null,
+            break: false
+        };
         this.isExtensionDevelopment = false;
         this.disableExtensions = false;
         this.disableExperiments = false;
@@ -205,13 +241,19 @@ class StandaloneEnvironmentService {
         this.extensionDevelopmentLocationURI = undefined;
         this.extensionDevelopmentKind = undefined;
         this.extensionTestsLocationURI = undefined;
-        this.logsHome = ( URI.from({ scheme: 'monaco', authority: 'logsHome' }));
+        this.logsHome = ( URI.from({
+            scheme: "monaco",
+            authority: "logsHome"
+        }));
         this.logLevel = undefined;
         this.extensionLogLevel = undefined;
         this.verbose = false;
         this.isBuilt = false;
         this.disableTelemetry = false;
-        this.serviceMachineIdResource = ( URI.from({ scheme: 'monaco', authority: 'serviceMachineIdResource' }));
+        this.serviceMachineIdResource = ( URI.from({
+            scheme: "monaco",
+            authority: "serviceMachineIdResource"
+        }));
         this.policyFile = undefined;
     }
 }
@@ -230,7 +272,7 @@ class StandaloneDialogService {
     doConfirm(message, detail) {
         let messageText = message;
         if (detail) {
-            messageText = messageText + '\n\n' + detail;
+            messageText = messageText + "\n\n" + detail;
         }
         return mainWindow.confirm(messageText);
     }
@@ -239,24 +281,42 @@ class StandaloneDialogService {
         const confirmed = this.doConfirm(prompt.message, prompt.detail);
         if (confirmed) {
             const promptButtons = [...(prompt.buttons ?? [])];
-            if (prompt.cancelButton && typeof prompt.cancelButton !== 'string' && typeof prompt.cancelButton !== 'boolean') {
+            if (prompt.cancelButton && typeof prompt.cancelButton !== "string" && typeof prompt.cancelButton !== "boolean") {
                 promptButtons.push(prompt.cancelButton);
             }
-            result = await promptButtons[0]?.run({ checkboxChecked: false });
+            result = await promptButtons[0]?.run({
+                checkboxChecked: false
+            });
         }
-        return { result };
+        return {
+            result
+        };
     }
     async info(message, detail) {
-        await this.prompt({ type: Severity$1.Info, message, detail });
+        await this.prompt({
+            type: Severity$1.Info,
+            message,
+            detail
+        });
     }
     async warn(message, detail) {
-        await this.prompt({ type: Severity$1.Warning, message, detail });
+        await this.prompt({
+            type: Severity$1.Warning,
+            message,
+            detail
+        });
     }
     async error(message, detail) {
-        await this.prompt({ type: Severity$1.Error, message, detail });
+        await this.prompt({
+            type: Severity$1.Error,
+            message,
+            detail
+        });
     }
     input() {
-        return Promise.resolve({ confirmed: false });
+        return Promise.resolve({
+            confirmed: false
+        });
     }
     about() {
         return Promise.resolve(undefined);
@@ -266,27 +326,38 @@ class StandaloneNotificationService {
     constructor() {
         this.onDidChangeFilter = Event.None;
     }
-    static { this.NO_OP = ( new NoOpNotification()); }
+    static {
+        this.NO_OP = ( new NoOpNotification());
+    }
     info(message) {
-        return this.notify({ severity: Severity$1.Info, message });
+        return this.notify({
+            severity: Severity$1.Info,
+            message
+        });
     }
     warn(message) {
-        return this.notify({ severity: Severity$1.Warning, message });
+        return this.notify({
+            severity: Severity$1.Warning,
+            message
+        });
     }
     error(error) {
-        return this.notify({ severity: Severity$1.Error, message: error });
+        return this.notify({
+            severity: Severity$1.Error,
+            message: error
+        });
     }
     notify(notification) {
         switch (notification.severity) {
-            case Severity$1.Error:
-                console.error(notification.message);
-                break;
-            case Severity$1.Warning:
-                console.warn(notification.message);
-                break;
-            default:
-                console.log(notification.message);
-                break;
+        case Severity$1.Error:
+            console.error(notification.message);
+            break;
+        case Severity$1.Warning:
+            console.warn(notification.message);
+            break;
+        default:
+            console.log(notification.message);
+            break;
         }
         return StandaloneNotificationService.NO_OP;
     }
@@ -294,16 +365,18 @@ class StandaloneNotificationService {
         return StandaloneNotificationService.NO_OP;
     }
     status(message, options) {
-        return { close: () => { } };
+        return {
+            close: () => {}
+        };
     }
-    setFilter(filter) { }
+    setFilter(filter) {}
     getFilter(source) {
         return NotificationsFilter.OFF;
     }
     getFilters() {
         return [];
     }
-    removeFilter(sourceId) { }
+    removeFilter(sourceId) {}
 }
 let StandaloneCommandService = class StandaloneCommandService {
     constructor(instantiationService) {
@@ -319,29 +392,45 @@ let StandaloneCommandService = class StandaloneCommandService {
             return Promise.reject(( new Error(`command '${id}' not found`)));
         }
         try {
-            this._onWillExecuteCommand.fire({ commandId: id, args });
+            this._onWillExecuteCommand.fire({
+                commandId: id,
+                args
+            });
             const result = this._instantiationService.invokeFunction.apply(this._instantiationService, [command.handler, ...args]);
-            this._onDidExecuteCommand.fire({ commandId: id, args });
+            this._onDidExecuteCommand.fire({
+                commandId: id,
+                args
+            });
             return Promise.resolve(result);
-        }
-        catch (err) {
+        } catch (err) {
             return Promise.reject(err);
         }
     }
 };
-StandaloneCommandService = ( __decorate([
-    ( __param(0, IInstantiationService))
-], StandaloneCommandService));
+StandaloneCommandService = ( __decorate([( __param(0, IInstantiationService))], StandaloneCommandService));
 let StandaloneKeybindingService = class StandaloneKeybindingService extends AbstractKeybindingService {
-    constructor(contextKeyService, commandService, telemetryService, notificationService, logService, codeEditorService) {
-        super(contextKeyService, commandService, telemetryService, notificationService, logService);
+    constructor(
+        contextKeyService,
+        commandService,
+        telemetryService,
+        notificationService,
+        logService,
+        codeEditorService
+    ) {
+        super(
+            contextKeyService,
+            commandService,
+            telemetryService,
+            notificationService,
+            logService
+        );
         this._cachedResolver = null;
         this._dynamicKeybindings = [];
         this._domNodeListeners = [];
     }
     registerContainer(container) {
         const disposables = ( new DisposableStore());
-        disposables.add(addDisposableListener(container, EventType.KEY_DOWN, (e) => {
+        disposables.add(addDisposableListener(container, EventType.KEY_DOWN, e => {
             const keyEvent = ( new StandardKeyboardEvent(e));
             const shouldPreventDefault = this._dispatch(keyEvent, keyEvent.target);
             if (shouldPreventDefault) {
@@ -349,7 +438,7 @@ let StandaloneKeybindingService = class StandaloneKeybindingService extends Abst
                 keyEvent.stopPropagation();
             }
         }));
-        disposables.add(addDisposableListener(container, EventType.KEY_UP, (e) => {
+        disposables.add(addDisposableListener(container, EventType.KEY_UP, e => {
             const keyEvent = ( new StandardKeyboardEvent(e));
             const shouldPreventDefault = this._singleModifierDispatch(keyEvent, keyEvent.target);
             if (shouldPreventDefault) {
@@ -369,14 +458,17 @@ let StandaloneKeybindingService = class StandaloneKeybindingService extends Abst
         return disposables;
     }
     addDynamicKeybinding(command, keybinding, handler, when) {
-        return combinedDisposable(CommandsRegistry.registerCommand(command, handler), this.addDynamicKeybindings([{
+        return combinedDisposable(
+            CommandsRegistry.registerCommand(command, handler),
+            this.addDynamicKeybindings([{
                 keybinding,
                 command,
                 when
-            }]));
+            }])
+        );
     }
     addDynamicKeybindings(rules) {
-        const entries = ( rules.map((rule) => {
+        const entries = ( rules.map(rule => {
             const keybinding = decodeKeybinding(rule.keybinding, OS);
             return {
                 keybinding,
@@ -412,7 +504,7 @@ let StandaloneKeybindingService = class StandaloneKeybindingService extends Abst
         if (!this._cachedResolver) {
             const defaults = this._toNormalizedKeybindingItems(KeybindingsRegistry.getDefaultKeybindings(), true);
             const overrides = this.getUserKeybindingItems();
-            this._cachedResolver = ( new KeybindingResolver(defaults, overrides, (str) => this._log(str)));
+            this._cachedResolver = ( new KeybindingResolver(defaults, overrides, str => this._log(str)));
         }
         return this._cachedResolver;
     }
@@ -427,8 +519,7 @@ let StandaloneKeybindingService = class StandaloneKeybindingService extends Abst
             const keybinding = item.keybinding;
             if (!keybinding) {
                 result[resultLen++] = ( new ResolvedKeybindingItem(undefined, item.command, item.commandArgs, when, isDefault, null, false));
-            }
-            else {
+            } else {
                 const resolvedKeybindings = this.resolveKeybinding(keybinding);
                 for (const resolvedKeybinding of resolvedKeybindings) {
                     result[resultLen++] = ( new ResolvedKeybindingItem(
@@ -462,10 +553,10 @@ let StandaloneKeybindingService = class StandaloneKeybindingService extends Abst
         return [];
     }
     _dumpDebugInfo() {
-        return '';
+        return "";
     }
     _dumpDebugInfoJSON() {
-        return '';
+        return "";
     }
     registerSchemaContribution(contribution) {
         return Disposable.None;
@@ -474,14 +565,7 @@ let StandaloneKeybindingService = class StandaloneKeybindingService extends Abst
         return undefined;
     }
 };
-StandaloneKeybindingService = ( __decorate([
-    ( __param(0, IContextKeyService)),
-    ( __param(1, ICommandService)),
-    ( __param(2, ITelemetryService)),
-    ( __param(3, INotificationService)),
-    ( __param(4, ILogService)),
-    ( __param(5, ICodeEditorService))
-], StandaloneKeybindingService));
+StandaloneKeybindingService = ( __decorate([( __param(0, IContextKeyService)), ( __param(1, ICommandService)), ( __param(2, ITelemetryService)), ( __param(3, INotificationService)), ( __param(4, ILogService)), ( __param(5, ICodeEditorService))], StandaloneKeybindingService));
 class DomNodeListeners extends Disposable {
     constructor(domNode, disposables) {
         super();
@@ -490,10 +574,7 @@ class DomNodeListeners extends Disposable {
     }
 }
 function isConfigurationOverrides(thing) {
-    return !!thing
-        && typeof thing === 'object'
-        && (!thing.overrideIdentifier || typeof thing.overrideIdentifier === 'string')
-        && (!thing.resource || thing.resource instanceof URI);
+    return !!thing && typeof thing === "object" && (!thing.overrideIdentifier || typeof thing.overrideIdentifier === "string") && (!thing.resource || thing.resource instanceof URI);
 }
 let StandaloneConfigurationService = class StandaloneConfigurationService {
     constructor(logService) {
@@ -516,12 +597,14 @@ let StandaloneConfigurationService = class StandaloneConfigurationService {
         defaultConfiguration.dispose();
     }
     getValue(arg1, arg2) {
-        const section = typeof arg1 === 'string' ? arg1 : undefined;
+        const section = typeof arg1 === "string" ? arg1 : undefined;
         const overrides = isConfigurationOverrides(arg1) ? arg1 : isConfigurationOverrides(arg2) ? arg2 : {};
         return this._configuration.getValue(section, overrides, undefined);
     }
     updateValues(values) {
-        const previous = { data: this._configuration.toData() };
+        const previous = {
+            data: this._configuration.toData()
+        };
         const changedKeys = [];
         for (const entry of values) {
             const [key, value] = entry;
@@ -532,13 +615,10 @@ let StandaloneConfigurationService = class StandaloneConfigurationService {
             changedKeys.push(key);
         }
         if (changedKeys.length > 0) {
-            const configurationChangeEvent = ( new ConfigurationChangeEvent(
-                { keys: changedKeys, overrides: [] },
-                previous,
-                this._configuration,
-                undefined,
-                this.logService
-            ));
+            const configurationChangeEvent = ( new ConfigurationChangeEvent({
+                keys: changedKeys,
+                overrides: []
+            }, previous, this._configuration, undefined, this.logService));
             configurationChangeEvent.source = ConfigurationTarget.MEMORY;
             this._onDidChangeConfiguration.fire(configurationChangeEvent);
         }
@@ -573,9 +653,7 @@ let StandaloneConfigurationService = class StandaloneConfigurationService {
         };
     }
 };
-StandaloneConfigurationService = ( __decorate([
-    ( __param(0, ILogService))
-], StandaloneConfigurationService));
+StandaloneConfigurationService = ( __decorate([( __param(0, ILogService))], StandaloneConfigurationService));
 let StandaloneResourceConfigurationService = class StandaloneResourceConfigurationService {
     constructor(configurationService, modelService, languageService) {
         this.configurationService = configurationService;
@@ -583,15 +661,18 @@ let StandaloneResourceConfigurationService = class StandaloneResourceConfigurati
         this.languageService = languageService;
         this._onDidChangeConfiguration = ( new Emitter());
         this.onDidChangeConfiguration = this._onDidChangeConfiguration.event;
-        this.configurationService.onDidChangeConfiguration((e) => {
-            this._onDidChangeConfiguration.fire({ affectedKeys: e.affectedKeys, affectsConfiguration: (resource, configuration) => e.affectsConfiguration(configuration) });
+        this.configurationService.onDidChangeConfiguration(e => {
+            this._onDidChangeConfiguration.fire({
+                affectedKeys: e.affectedKeys,
+                affectsConfiguration: (resource, configuration) => e.affectsConfiguration(configuration)
+            });
         });
     }
     getValue(resource, arg2, arg3) {
         const position = Position.isIPosition(arg2) ? arg2 : null;
-        const section = position ? (typeof arg3 === 'string' ? arg3 : undefined) : (typeof arg2 === 'string' ? arg2 : undefined);
+        const section = position ? (typeof arg3 === "string" ? arg3 : undefined) : (typeof arg2 === "string" ? arg2 : undefined);
         const language = resource ? this.getLanguage(resource, position) : undefined;
-        if (typeof section === 'undefined') {
+        if (typeof section === "undefined") {
             return this.configurationService.getValue({
                 resource,
                 overrideIdentifier: language
@@ -604,7 +685,10 @@ let StandaloneResourceConfigurationService = class StandaloneResourceConfigurati
     }
     inspect(resource, position, section) {
         const language = resource ? this.getLanguage(resource, position) : undefined;
-        return this.configurationService.inspect(section, { resource, overrideIdentifier: language });
+        return this.configurationService.inspect(section, {
+            resource,
+            overrideIdentifier: language
+        });
     }
     getLanguage(resource, position) {
         const model = this.modelService.getModel(resource);
@@ -614,48 +698,49 @@ let StandaloneResourceConfigurationService = class StandaloneResourceConfigurati
         return this.languageService.guessLanguageIdByFilepathOrFirstLine(resource);
     }
     updateValue(resource, key, value, configurationTarget) {
-        return this.configurationService.updateValue(key, value, { resource }, configurationTarget);
+        return this.configurationService.updateValue(key, value, {
+            resource
+        }, configurationTarget);
     }
 };
-StandaloneResourceConfigurationService = ( __decorate([
-    ( __param(0, IConfigurationService)),
-    ( __param(1, IModelService)),
-    ( __param(2, ILanguageService))
-], StandaloneResourceConfigurationService));
+StandaloneResourceConfigurationService = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, IModelService)), ( __param(2, ILanguageService))], StandaloneResourceConfigurationService));
 let StandaloneResourcePropertiesService = class StandaloneResourcePropertiesService {
     constructor(configurationService) {
         this.configurationService = configurationService;
     }
     getEOL(resource, language) {
-        const eol = this.configurationService.getValue('files.eol', { overrideIdentifier: language, resource });
-        if (eol && typeof eol === 'string' && eol !== 'auto') {
+        const eol = this.configurationService.getValue("files.eol", {
+            overrideIdentifier: language,
+            resource
+        });
+        if (eol && typeof eol === "string" && eol !== "auto") {
             return eol;
         }
-        return (isLinux || isMacintosh) ? '\n' : '\r\n';
+        return (isLinux || isMacintosh) ? "\n" : "\r\n";
     }
 };
-StandaloneResourcePropertiesService = ( __decorate([
-    ( __param(0, IConfigurationService))
-], StandaloneResourcePropertiesService));
+StandaloneResourcePropertiesService = ( __decorate([( __param(0, IConfigurationService))], StandaloneResourcePropertiesService));
 class StandaloneTelemetryService {
     constructor() {
         this.telemetryLevel = TelemetryLevel.NONE;
-        this.sessionId = 'someValue.sessionId';
-        this.machineId = 'someValue.machineId';
-        this.sqmId = 'someValue.sqmId';
-        this.devDeviceId = 'someValue.devDeviceId';
-        this.firstSessionDate = 'someValue.firstSessionDate';
+        this.sessionId = "someValue.sessionId";
+        this.machineId = "someValue.machineId";
+        this.sqmId = "someValue.sqmId";
+        this.devDeviceId = "someValue.devDeviceId";
+        this.firstSessionDate = "someValue.firstSessionDate";
         this.sendErrorTelemetry = false;
     }
-    setEnabled() { }
-    setExperimentProperty() { }
-    publicLog() { }
-    publicLog2() { }
-    publicLogError() { }
-    publicLogError2() { }
+    setEnabled() {}
+    setExperimentProperty() {}
+    publicLog() {}
+    publicLog2() {}
+    publicLogError() {}
+    publicLogError2() {}
 }
 class StandaloneWorkspaceContextService {
-    static { this.SCHEME = 'inmemory'; }
+    static {
+        this.SCHEME = "inmemory";
+    }
     constructor() {
         this._onDidChangeWorkspaceName = ( new Emitter());
         this.onDidChangeWorkspaceName = this._onDidChangeWorkspaceName.event;
@@ -665,10 +750,19 @@ class StandaloneWorkspaceContextService {
         this.onDidChangeWorkspaceFolders = this._onDidChangeWorkspaceFolders.event;
         this._onDidChangeWorkbenchState = ( new Emitter());
         this.onDidChangeWorkbenchState = this._onDidChangeWorkbenchState.event;
-        const resource = ( URI.from(
-            { scheme: StandaloneWorkspaceContextService.SCHEME, authority: 'model', path: '/' }
-        ));
-        this.workspace = { id: STANDALONE_EDITOR_WORKSPACE_ID, folders: [( new WorkspaceFolder({ uri: resource, name: '', index: 0 }))] };
+        const resource = ( URI.from({
+            scheme: StandaloneWorkspaceContextService.SCHEME,
+            authority: "model",
+            path: "/"
+        }));
+        this.workspace = {
+            id: STANDALONE_EDITOR_WORKSPACE_ID,
+            folders: [( new WorkspaceFolder({
+                uri: resource,
+                name: "",
+                index: 0
+            }))]
+        };
     }
     getCompleteWorkspace() {
         return Promise.resolve(this.getWorkspace());
@@ -703,7 +797,7 @@ function updateConfigurationService(configurationService, source, isDiffEditor)
         return;
     }
     const toUpdate = [];
-    ( Object.keys(source)).forEach((key) => {
+    ( Object.keys(source)).forEach(key => {
         if (isEditorConfigurationKey(key)) {
             toUpdate.push([`editor.${key}`, source[key]]);
         }
@@ -730,21 +824,23 @@ let StandaloneBulkEditService = class StandaloneBulkEditService {
         const textEdits = ( new Map());
         for (const edit of edits) {
             if (!(edit instanceof ResourceTextEdit)) {
-                throw ( new Error('bad edit - only text edits are supported'));
+                throw ( new Error("bad edit - only text edits are supported"));
             }
             const model = this._modelService.getModel(edit.resource);
             if (!model) {
-                throw ( new Error('bad edit - model not found'));
+                throw ( new Error("bad edit - model not found"));
             }
-            if (typeof edit.versionId === 'number' && model.getVersionId() !== edit.versionId) {
-                throw ( new Error('bad state - model changed in the meantime'));
+            if (typeof edit.versionId === "number" && model.getVersionId() !== edit.versionId) {
+                throw ( new Error("bad state - model changed in the meantime"));
             }
             let array = textEdits.get(model);
             if (!array) {
                 array = [];
                 textEdits.set(model, array);
             }
-            array.push(EditOperation.replaceMove(Range.lift(edit.textEdit.range), edit.textEdit.text));
+            array.push(
+                EditOperation.replaceMove(Range.lift(edit.textEdit.range), edit.textEdit.text)
+            );
         }
         let totalEdits = 0;
         let totalFiles = 0;
@@ -761,15 +857,13 @@ let StandaloneBulkEditService = class StandaloneBulkEditService {
         };
     }
 };
-StandaloneBulkEditService = ( __decorate([
-    ( __param(0, IModelService))
-], StandaloneBulkEditService));
+StandaloneBulkEditService = ( __decorate([( __param(0, IModelService))], StandaloneBulkEditService));
 class StandaloneUriLabelService {
     constructor() {
         this.onDidChangeFormatters = Event.None;
     }
     getUriLabel(resource, options) {
-        if (resource.scheme === 'file') {
+        if (resource.scheme === "file") {
             return resource.fsPath;
         }
         return resource.path;
@@ -778,19 +872,19 @@ class StandaloneUriLabelService {
         return basename(resource);
     }
     getWorkspaceLabel(workspace, options) {
-        return '';
+        return "";
     }
     getSeparator(scheme, authority) {
-        return '/';
+        return "/";
     }
     registerFormatter(formatter) {
-        throw ( new Error('Not implemented'));
+        throw ( new Error("Not implemented"));
     }
     registerCachedFormatter(formatter) {
         return this.registerFormatter(formatter);
     }
     getHostLabel() {
-        return '';
+        return "";
     }
     getHostTooltip() {
         return undefined;
@@ -811,10 +905,7 @@ let StandaloneContextViewService = class StandaloneContextViewService extends Co
         return super.showContextView(delegate, container, shadowRoot);
     }
 };
-StandaloneContextViewService = ( __decorate([
-    ( __param(0, ILayoutService)),
-    ( __param(1, ICodeEditorService))
-], StandaloneContextViewService));
+StandaloneContextViewService = ( __decorate([( __param(0, ILayoutService)), ( __param(1, ICodeEditorService))], StandaloneContextViewService));
 class StandaloneWorkspaceTrustManagementService {
     constructor() {
         this._neverEmitter = ( new Emitter());
@@ -833,25 +924,21 @@ class StandaloneWorkspaceTrustManagementService {
     canSetParentFolderTrust() {
         return false;
     }
-    async setParentFolderTrust(trusted) {
-    }
+    async setParentFolderTrust(trusted) {}
     canSetWorkspaceTrust() {
         return false;
     }
-    async setWorkspaceTrust(trusted) {
-    }
+    async setWorkspaceTrust(trusted) {}
     getUriTrustInfo(uri) {
-        throw ( new Error('Method not supported.'));
-    }
-    async setUrisTrust(uri, trusted) {
+        throw ( new Error("Method not supported."));
     }
+    async setUrisTrust(uri, trusted) {}
     getTrustedUris() {
         return [];
     }
-    async setTrustedUris(uris) {
-    }
+    async setTrustedUris(uris) {}
     addWorkspaceTrustTransitionParticipant(participant) {
-        throw ( new Error('Method not supported.'));
+        throw ( new Error("Method not supported."));
     }
 }
 class StandaloneLanguageService extends LanguageService {
@@ -865,24 +952,31 @@ class StandaloneLogService extends LogService {
     }
 }
 let StandaloneContextMenuService = class StandaloneContextMenuService extends ContextMenuService {
-    constructor(telemetryService, notificationService, contextViewService, keybindingService, menuService, contextKeyService) {
-        super(telemetryService, notificationService, contextViewService, keybindingService, menuService, contextKeyService);
-        this.configure({ blockMouse: false });
+    constructor(
+        telemetryService,
+        notificationService,
+        contextViewService,
+        keybindingService,
+        menuService,
+        contextKeyService
+    ) {
+        super(
+            telemetryService,
+            notificationService,
+            contextViewService,
+            keybindingService,
+            menuService,
+            contextKeyService
+        );
+        this.configure({
+            blockMouse: false
+        });
     }
 };
-StandaloneContextMenuService = ( __decorate([
-    ( __param(0, ITelemetryService)),
-    ( __param(1, INotificationService)),
-    ( __param(2, IContextViewService)),
-    ( __param(3, IKeybindingService)),
-    ( __param(4, IMenuService)),
-    ( __param(5, IContextKeyService))
-], StandaloneContextMenuService));
+StandaloneContextMenuService = ( __decorate([( __param(0, ITelemetryService)), ( __param(1, INotificationService)), ( __param(2, IContextViewService)), ( __param(3, IKeybindingService)), ( __param(4, IMenuService)), ( __param(5, IContextKeyService))], StandaloneContextMenuService));
 class StandaloneAccessbilitySignalService {
-    async playSignal(cue, options) {
-    }
-    async playSignals(cues) {
-    }
+    async playSignal(cue, options) {}
+    async playSignals(cues) {}
     getEnabledState(signal, userGesture, modality) {
         return ValueWithChangeEvent.const(false);
     }
@@ -898,44 +992,89 @@ class StandaloneAccessbilitySignalService {
     onSoundEnabledChanged(cue) {
         return Event.None;
     }
-    async playSound(cue, allowManyInParallel) {
-    }
+    async playSound(cue, allowManyInParallel) {}
     playSignalLoop(cue) {
-        return toDisposable(() => { });
+        return toDisposable(() => {});
     }
 }
 class StandaloneDefaultAccountService {
     constructor() {
         this.onDidChangeDefaultAccount = Event.None;
+        this.onDidChangePolicyData = Event.None;
+        this.policyData = null;
     }
     async getDefaultAccount() {
         return null;
     }
-    setDefaultAccount(account) {
+    setDefaultAccountProvider() {}
+    async refresh() {
+        return null;
+    }
+    getDefaultAccountAuthenticationProvider() {
+        return {
+            id: "default",
+            name: "Default",
+            enterprise: false
+        };
+    }
+    async signIn() {
+        return null;
     }
 }
 registerSingleton(IWebWorkerService, StandaloneWebWorkerService, InstantiationType.Eager);
 registerSingleton(ILogService, StandaloneLogService, InstantiationType.Eager);
-registerSingleton(IConfigurationService, StandaloneConfigurationService, InstantiationType.Eager);
-registerSingleton(ITextResourceConfigurationService, StandaloneResourceConfigurationService, InstantiationType.Eager);
-registerSingleton(ITextResourcePropertiesService, StandaloneResourcePropertiesService, InstantiationType.Eager);
-registerSingleton(IWorkspaceContextService, StandaloneWorkspaceContextService, InstantiationType.Eager);
+registerSingleton(
+    IConfigurationService,
+    StandaloneConfigurationService,
+    InstantiationType.Eager
+);
+registerSingleton(
+    ITextResourceConfigurationService,
+    StandaloneResourceConfigurationService,
+    InstantiationType.Eager
+);
+registerSingleton(
+    ITextResourcePropertiesService,
+    StandaloneResourcePropertiesService,
+    InstantiationType.Eager
+);
+registerSingleton(
+    IWorkspaceContextService,
+    StandaloneWorkspaceContextService,
+    InstantiationType.Eager
+);
 registerSingleton(ILabelService, StandaloneUriLabelService, InstantiationType.Eager);
 registerSingleton(ITelemetryService, StandaloneTelemetryService, InstantiationType.Eager);
 registerSingleton(IDialogService, StandaloneDialogService, InstantiationType.Eager);
 registerSingleton(IEnvironmentService, StandaloneEnvironmentService, InstantiationType.Eager);
-registerSingleton(INotificationService, StandaloneNotificationService, InstantiationType.Eager);
+registerSingleton(
+    INotificationService,
+    StandaloneNotificationService,
+    InstantiationType.Eager
+);
 registerSingleton(IMarkerService, MarkerService, InstantiationType.Eager);
 registerSingleton(ILanguageService, StandaloneLanguageService, InstantiationType.Eager);
 registerSingleton(IStandaloneThemeService, StandaloneThemeService, InstantiationType.Eager);
 registerSingleton(IModelService, ModelService, InstantiationType.Eager);
-registerSingleton(IMarkerDecorationsService, MarkerDecorationsService, InstantiationType.Eager);
+registerSingleton(
+    IMarkerDecorationsService,
+    MarkerDecorationsService,
+    InstantiationType.Eager
+);
 registerSingleton(IContextKeyService, ContextKeyService, InstantiationType.Eager);
 registerSingleton(IProgressService, StandaloneProgressService, InstantiationType.Eager);
-registerSingleton(IEditorProgressService, StandaloneEditorProgressService, InstantiationType.Eager);
+registerSingleton(
+    IEditorProgressService,
+    StandaloneEditorProgressService,
+    InstantiationType.Eager
+);
 registerSingleton(IStorageService, InMemoryStorageService, InstantiationType.Eager);
 registerSingleton(IBulkEditService, StandaloneBulkEditService, InstantiationType.Eager);
-registerSingleton(IWorkspaceTrustManagementService, StandaloneWorkspaceTrustManagementService, InstantiationType.Eager);
+registerSingleton(
+    IWorkspaceTrustManagementService,
+    StandaloneWorkspaceTrustManagementService,
+    InstantiationType.Eager
+);
 registerSingleton(ITextModelService, StandaloneTextModelService, InstantiationType.Eager);
 registerSingleton(IAccessibilityService, AccessibilityService, InstantiationType.Eager);
 registerSingleton(IListService, ListService, InstantiationType.Eager);
@@ -947,13 +1086,30 @@ registerSingleton(IOpenerService, OpenerService, InstantiationType.Eager);
 registerSingleton(IClipboardService, BrowserClipboardService, InstantiationType.Eager);
 registerSingleton(IContextMenuService, StandaloneContextMenuService, InstantiationType.Eager);
 registerSingleton(IMenuService, MenuService, InstantiationType.Eager);
-registerSingleton(IAccessibilitySignalService, StandaloneAccessbilitySignalService, InstantiationType.Eager);
-registerSingleton(ITreeSitterLibraryService, StandaloneTreeSitterLibraryService, InstantiationType.Eager);
+registerSingleton(
+    IAccessibilitySignalService,
+    StandaloneAccessbilitySignalService,
+    InstantiationType.Eager
+);
+registerSingleton(
+    ITreeSitterLibraryService,
+    StandaloneTreeSitterLibraryService,
+    InstantiationType.Eager
+);
 registerSingleton(ILoggerService, NullLoggerService, InstantiationType.Eager);
 registerSingleton(IDataChannelService, NullDataChannelService, InstantiationType.Eager);
-registerSingleton(IDefaultAccountService, StandaloneDefaultAccountService, InstantiationType.Eager);
+registerSingleton(
+    IDefaultAccountService,
+    StandaloneDefaultAccountService,
+    InstantiationType.Eager
+);
+registerSingleton(
+    IRenameSymbolTrackerService,
+    NullRenameSymbolTrackerService,
+    InstantiationType.Eager
+);
 var StandaloneServices;
-(function (StandaloneServices) {
+(function(StandaloneServices) {
     const serviceCollection = ( new ServiceCollection());
     for (const [id, descriptor] of getSingletonServiceDescriptors()) {
         serviceCollection.set(id, descriptor);
@@ -966,12 +1122,11 @@ var StandaloneServices;
         }
         const r = serviceCollection.get(serviceId);
         if (!r) {
-            throw ( new Error('Missing service ' + serviceId));
+            throw ( new Error("Missing service " + serviceId));
         }
         if (r instanceof SyncDescriptor) {
-            return instantiationService.invokeFunction((accessor) => accessor.get(serviceId));
-        }
-        else {
+            return instantiationService.invokeFunction(accessor => accessor.get(serviceId));
+        } else {
             return r;
         }
     }