monaco-editor11 1.1.0 → 1.1.2

package/dist/workers/standaloneServices.js

@@ -0,0 +1,787 @@
+import './standaloneCodeEditorService.js';
+import './standaloneLayoutService.js';
+import '../../../platform/undoRedo/common/undoRedoService.js';
+import '../../common/services/languageFeatureDebounce.js';
+import '../../common/services/semanticTokensStylingService.js';
+import '../../common/services/languageFeaturesService.js';
+import '../../../platform/hover/browser/hoverService.js';
+import '../../browser/services/inlineCompletionsService.js';
+import { format } from '../../../base/common/strings.js';
+import { addDisposableListener, EventType } from '../../../base/browser/dom.js';
+import { StandardKeyboardEvent } from '../../../base/browser/keyboardEvent.js';
+import { Emitter } from '../../../base/common/event.js';
+import { decodeKeybinding, KeyCodeChord } from '../../../base/common/keybindings.js';
+import { ImmortalReference, combinedDisposable, toDisposable, DisposableStore, Disposable } from '../../../base/common/lifecycle.js';
+import { OS, isLinux, isMacintosh } from '../../../base/common/platform.js';
+import Severity from '../../../base/common/severity.js';
+import { URI } from '../../../base/common/uri.js';
+import { ResourceEdit, ResourceTextEdit, IBulkEditService } from '../../browser/services/bulkEditService.js';
+import { isEditorConfigurationKey, isDiffEditorConfigurationKey } from '../../common/config/editorConfigurationSchema.js';
+import { EditOperation } from '../../common/core/editOperation.js';
+import { Position } from '../../common/core/position.js';
+import { Range } from '../../common/core/range.js';
+import { IModelService } from '../../common/services/model.js';
+import { ITextModelService } from '../../common/services/resolverService.js';
+import { ITextResourceConfigurationService, ITextResourcePropertiesService } from '../../common/services/textResourceConfiguration.js';
+import { ICommandService, CommandsRegistry } from '../../../platform/commands/common/commands.js';
+import { IConfigurationService } from '../../../platform/configuration/common/configuration.js';
+import { Configuration, ConfigurationModel, ConfigurationChangeEvent } from '../../../platform/configuration/common/configurationModels.js';
+import { IContextKeyService } from '../../../platform/contextkey/common/contextkey.js';
+import { IDialogService } from '../../../platform/dialogs/common/dialogs.js';
+import { IInstantiationService, createDecorator } from '../../../platform/instantiation/common/instantiation.js';
+import { AbstractKeybindingService } from '../../../platform/keybinding/common/abstractKeybindingService.js';
+import { IKeybindingService } from '../../../platform/keybinding/common/keybinding.js';
+import { KeybindingResolver } from '../../../platform/keybinding/common/keybindingResolver.js';
+import { KeybindingsRegistry } from '../../../platform/keybinding/common/keybindingsRegistry.js';
+import { ResolvedKeybindingItem } from '../../../platform/keybinding/common/resolvedKeybindingItem.js';
+import { USLayoutResolvedKeybinding } from '../../../platform/keybinding/common/usLayoutResolvedKeybinding.js';
+import { ILabelService } from '../../../platform/label/common/label.js';
+import { INotificationService, NoOpNotification } from '../../../platform/notification/common/notification.js';
+import { IProgressService, IEditorProgressService } from '../../../platform/progress/common/progress.js';
+import { ITelemetryService } from '../../../platform/telemetry/common/telemetry.js';
+import { WorkspaceFolder, STANDALONE_EDITOR_WORKSPACE_ID, IWorkspaceContextService } from '../../../platform/workspace/common/workspace.js';
+import { ILayoutService } from '../../../platform/layout/browser/layoutService.js';
+import { StandaloneServicesNLS } from '../../common/standaloneStrings.js';
+import { basename } from '../../../base/common/resources.js';
+import { ICodeEditorService } from '../../browser/services/codeEditorService.js';
+import { ILogService, NullLoggerService, ILoggerService, ConsoleLogger } from '../../../platform/log/common/log.js';
+import { IWorkspaceTrustManagementService } from '../../../platform/workspace/common/workspaceTrust.js';
+import { IContextViewService, IContextMenuService } from '../../../platform/contextview/browser/contextView.js';
+import { ContextViewService } from '../../../platform/contextview/browser/contextViewService.js';
+import { LanguageService } from '../../common/services/languageService.js';
+import { ContextMenuService } from '../../../platform/contextview/browser/contextMenuService.js';
+import { getSingletonServiceDescriptors, registerSingleton } from '../../../platform/instantiation/common/extensions.js';
+import { OpenerService } from '../../browser/services/openerService.js';
+import { IEditorWorkerService } from '../../common/services/editorWorker.js';
+import { EditorWorkerService } from '../../browser/services/editorWorkerService.js';
+import { ILanguageService } from '../../common/languages/language.js';
+import { MarkerDecorationsService } from '../../common/services/markerDecorationsService.js';
+import { IMarkerDecorationsService } from '../../common/services/markerDecorations.js';
+import { ModelService } from '../../common/services/modelService.js';
+import { StandaloneQuickInputService } from './quickInput/standaloneQuickInputService.js';
+import { StandaloneThemeService } from './standaloneThemeService.js';
+import { IStandaloneThemeService } from '../common/standaloneTheme.js';
+import { AccessibilityService } from '../../../platform/accessibility/browser/accessibilityService.js';
+import { IAccessibilityService } from '../../../platform/accessibility/common/accessibility.js';
+import { IMenuService } from '../../../platform/actions/common/actions.js';
+import { MenuService } from '../../../platform/actions/common/menuService.js';
+import { BrowserClipboardService } from '../../../platform/clipboard/browser/clipboardService.js';
+import { IClipboardService } from '../../../platform/clipboard/common/clipboardService.js';
+import { ContextKeyService } from '../../../platform/contextkey/browser/contextKeyService.js';
+import { SyncDescriptor } from '../../../platform/instantiation/common/descriptors.js';
+import { InstantiationService } from '../../../platform/instantiation/common/instantiationService.js';
+import { ServiceCollection } from '../../../platform/instantiation/common/serviceCollection.js';
+import { ListService, IListService } from '../../../platform/list/browser/listService.js';
+import { IMarkerService } from '../../../platform/markers/common/markers.js';
+import { MarkerService } from '../../../platform/markers/common/markerService.js';
+import { IOpenerService } from '../../../platform/opener/common/opener.js';
+import { IQuickInputService } from '../../../platform/quickinput/common/quickInput.js';
+import { InMemoryStorageService, IStorageService } from '../../../platform/storage/common/storage.js';
+import { DefaultConfiguration } from '../../../platform/configuration/common/configurations.js';
+import { IAccessibilitySignalService } from '../../../platform/accessibilitySignal/browser/accessibilitySignalService.js';
+import { ILanguageFeaturesService } from '../../common/services/languageFeatures.js';
+import { ILanguageConfigurationService } from '../../common/languages/languageConfigurationRegistry.js';
+import { LogService } from '../../../platform/log/common/logService.js';
+import { getEditorFeatures } from '../../common/editorFeatures.js';
+import { onUnexpectedError } from '../../../base/common/errors.js';
+import { IEnvironmentService } from '../../../platform/environment/common/environment.js';
+import { mainWindow } from '../../../base/browser/window.js';
+import { ResourceMap } from '../../../base/common/map.js';
+import { ITreeSitterLibraryService } from '../../common/services/treeSitter/treeSitterLibraryService.js';
+import { StandaloneTreeSitterLibraryService } from './standaloneTreeSitterLibraryService.js';
+import { NullDataChannelService, IDataChannelService } from '../../../platform/dataChannel/common/dataChannel.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (undefined && undefined.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+class SimpleModel {
+    constructor(model) {
+        this.disposed = false;
+        this.model = model;
+        this._onWillDispose = new Emitter();
+    }
+    get textEditorModel() {
+        return this.model;
+    }
+    dispose() {
+        this.disposed = true;
+        this._onWillDispose.fire();
+    }
+}
+let StandaloneTextModelService = class StandaloneTextModelService {
+    constructor(modelService) {
+        this.modelService = modelService;
+    }
+    createModelReference(resource) {
+        const model = this.modelService.getModel(resource);
+        if (!model) {
+            return Promise.reject(new Error(`Model not found`));
+        }
+        return Promise.resolve(new ImmortalReference(new SimpleModel(model)));
+    }
+};
+StandaloneTextModelService = __decorate([
+    __param(0, IModelService)
+], StandaloneTextModelService);
+class StandaloneEditorProgressService {
+    static { this.NULL_PROGRESS_RUNNER = {
+        done: () => { },
+        total: () => { },
+        worked: () => { }
+    }; }
+    show() {
+        return StandaloneEditorProgressService.NULL_PROGRESS_RUNNER;
+    }
+    async showWhile(promise, delay) {
+        await promise;
+    }
+}
+class StandaloneProgressService {
+    withProgress(_options, task, onDidCancel) {
+        return task({
+            report: () => { },
+        });
+    }
+}
+class StandaloneEnvironmentService {
+    constructor() {
+        this.isExtensionDevelopment = false;
+        this.isBuilt = false;
+    }
+}
+class StandaloneDialogService {
+    async confirm(confirmation) {
+        const confirmed = this.doConfirm(confirmation.message, confirmation.detail);
+        return {
+            confirmed,
+            checkboxChecked: false // unsupported
+        };
+    }
+    doConfirm(message, detail) {
+        let messageText = message;
+        if (detail) {
+            messageText = messageText + '\n\n' + detail;
+        }
+        return mainWindow.confirm(messageText);
+    }
+    async prompt(prompt) {
+        let result = undefined;
+        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') {
+                promptButtons.push(prompt.cancelButton);
+            }
+            result = await promptButtons[0]?.run({ checkboxChecked: false });
+        }
+        return { result };
+    }
+    async error(message, detail) {
+        await this.prompt({ type: Severity.Error, message, detail });
+    }
+}
+class StandaloneNotificationService {
+    static { this.NO_OP = new NoOpNotification(); }
+    info(message) {
+        return this.notify({ severity: Severity.Info, message });
+    }
+    warn(message) {
+        return this.notify({ severity: Severity.Warning, message });
+    }
+    error(error) {
+        return this.notify({ severity: Severity.Error, message: error });
+    }
+    notify(notification) {
+        switch (notification.severity) {
+            case Severity.Error:
+                console.error(notification.message);
+                break;
+            case Severity.Warning:
+                console.warn(notification.message);
+                break;
+            default:
+                console.log(notification.message);
+                break;
+        }
+        return StandaloneNotificationService.NO_OP;
+    }
+    prompt(severity, message, choices, options) {
+        return StandaloneNotificationService.NO_OP;
+    }
+    status(message, options) {
+        return { close: () => { } };
+    }
+}
+let StandaloneCommandService = class StandaloneCommandService {
+    constructor(instantiationService) {
+        this._onWillExecuteCommand = new Emitter();
+        this._onDidExecuteCommand = new Emitter();
+        this.onDidExecuteCommand = this._onDidExecuteCommand.event;
+        this._instantiationService = instantiationService;
+    }
+    executeCommand(id, ...args) {
+        const command = CommandsRegistry.getCommand(id);
+        if (!command) {
+            return Promise.reject(new Error(`command '${id}' not found`));
+        }
+        try {
+            this._onWillExecuteCommand.fire({ commandId: id, args });
+            const result = this._instantiationService.invokeFunction.apply(this._instantiationService, [command.handler, ...args]);
+            this._onDidExecuteCommand.fire({ commandId: id, args });
+            return Promise.resolve(result);
+        }
+        catch (err) {
+            return Promise.reject(err);
+        }
+    }
+};
+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);
+        this._cachedResolver = null;
+        this._dynamicKeybindings = [];
+        this._domNodeListeners = [];
+        const addContainer = (domNode) => {
+            const disposables = new DisposableStore();
+            // for standard keybindings
+            disposables.add(addDisposableListener(domNode, EventType.KEY_DOWN, (e) => {
+                const keyEvent = new StandardKeyboardEvent(e);
+                const shouldPreventDefault = this._dispatch(keyEvent, keyEvent.target);
+                if (shouldPreventDefault) {
+                    keyEvent.preventDefault();
+                    keyEvent.stopPropagation();
+                }
+            }));
+            // for single modifier chord keybindings (e.g. shift shift)
+            disposables.add(addDisposableListener(domNode, EventType.KEY_UP, (e) => {
+                const keyEvent = new StandardKeyboardEvent(e);
+                const shouldPreventDefault = this._singleModifierDispatch(keyEvent, keyEvent.target);
+                if (shouldPreventDefault) {
+                    keyEvent.preventDefault();
+                }
+            }));
+            this._domNodeListeners.push(new DomNodeListeners(domNode, disposables));
+        };
+        const removeContainer = (domNode) => {
+            for (let i = 0; i < this._domNodeListeners.length; i++) {
+                const domNodeListeners = this._domNodeListeners[i];
+                if (domNodeListeners.domNode === domNode) {
+                    this._domNodeListeners.splice(i, 1);
+                    domNodeListeners.dispose();
+                }
+            }
+        };
+        const addCodeEditor = (codeEditor) => {
+            if (codeEditor.getOption(70 /* EditorOption.inDiffEditor */)) {
+                return;
+            }
+            addContainer(codeEditor.getContainerDomNode());
+        };
+        const removeCodeEditor = (codeEditor) => {
+            if (codeEditor.getOption(70 /* EditorOption.inDiffEditor */)) {
+                return;
+            }
+            removeContainer(codeEditor.getContainerDomNode());
+        };
+        this._register(codeEditorService.onCodeEditorAdd(addCodeEditor));
+        this._register(codeEditorService.onCodeEditorRemove(removeCodeEditor));
+        codeEditorService.listCodeEditors().forEach(addCodeEditor);
+        const addDiffEditor = (diffEditor) => {
+            addContainer(diffEditor.getContainerDomNode());
+        };
+        const removeDiffEditor = (diffEditor) => {
+            removeContainer(diffEditor.getContainerDomNode());
+        };
+        this._register(codeEditorService.onDiffEditorAdd(addDiffEditor));
+        this._register(codeEditorService.onDiffEditorRemove(removeDiffEditor));
+        codeEditorService.listDiffEditors().forEach(addDiffEditor);
+    }
+    addDynamicKeybinding(command, keybinding, handler, when) {
+        return combinedDisposable(CommandsRegistry.registerCommand(command, handler), this.addDynamicKeybindings([{
+                keybinding,
+                command,
+                when
+            }]));
+    }
+    addDynamicKeybindings(rules) {
+        const entries = rules.map((rule) => {
+            const keybinding = decodeKeybinding(rule.keybinding, OS);
+            return {
+                keybinding,
+                command: rule.command ?? null,
+                commandArgs: rule.commandArgs,
+                when: rule.when,
+                weight1: 1000,
+                weight2: 0,
+                extensionId: null,
+                isBuiltinExtension: false
+            };
+        });
+        this._dynamicKeybindings = this._dynamicKeybindings.concat(entries);
+        this.updateResolver();
+        return toDisposable(() => {
+            // Search the first entry and remove them all since they will be contiguous
+            for (let i = 0; i < this._dynamicKeybindings.length; i++) {
+                if (this._dynamicKeybindings[i] === entries[0]) {
+                    this._dynamicKeybindings.splice(i, entries.length);
+                    this.updateResolver();
+                    return;
+                }
+            }
+        });
+    }
+    updateResolver() {
+        this._cachedResolver = null;
+        this._onDidUpdateKeybindings.fire();
+    }
+    _getResolver() {
+        if (!this._cachedResolver) {
+            const defaults = this._toNormalizedKeybindingItems(KeybindingsRegistry.getDefaultKeybindings(), true);
+            const overrides = this._toNormalizedKeybindingItems(this._dynamicKeybindings, false);
+            this._cachedResolver = new KeybindingResolver(defaults, overrides, (str) => this._log(str));
+        }
+        return this._cachedResolver;
+    }
+    _documentHasFocus() {
+        return mainWindow.document.hasFocus();
+    }
+    _toNormalizedKeybindingItems(items, isDefault) {
+        const result = [];
+        let resultLen = 0;
+        for (const item of items) {
+            const when = item.when || undefined;
+            const keybinding = item.keybinding;
+            if (!keybinding) {
+                // This might be a removal keybinding item in user settings => accept it
+                result[resultLen++] = new ResolvedKeybindingItem(undefined, item.command, item.commandArgs, when, isDefault, null, false);
+            }
+            else {
+                const resolvedKeybindings = USLayoutResolvedKeybinding.resolveKeybinding(keybinding, OS);
+                for (const resolvedKeybinding of resolvedKeybindings) {
+                    result[resultLen++] = new ResolvedKeybindingItem(resolvedKeybinding, item.command, item.commandArgs, when, isDefault, null, false);
+                }
+            }
+        }
+        return result;
+    }
+    resolveKeyboardEvent(keyboardEvent) {
+        const chord = new KeyCodeChord(keyboardEvent.ctrlKey, keyboardEvent.shiftKey, keyboardEvent.altKey, keyboardEvent.metaKey, keyboardEvent.keyCode);
+        return new USLayoutResolvedKeybinding([chord], OS);
+    }
+};
+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();
+        this.domNode = domNode;
+        this._register(disposables);
+    }
+}
+function isConfigurationOverrides(thing) {
+    return !!thing
+        && typeof thing === 'object'
+        && (!thing.overrideIdentifier || typeof thing.overrideIdentifier === 'string')
+        && (!thing.resource || thing.resource instanceof URI);
+}
+let StandaloneConfigurationService = class StandaloneConfigurationService {
+    constructor(logService) {
+        this.logService = logService;
+        this._onDidChangeConfiguration = new Emitter();
+        this.onDidChangeConfiguration = this._onDidChangeConfiguration.event;
+        const defaultConfiguration = new DefaultConfiguration(logService);
+        this._configuration = new Configuration(defaultConfiguration.reload(), ConfigurationModel.createEmptyModel(logService), ConfigurationModel.createEmptyModel(logService), ConfigurationModel.createEmptyModel(logService), ConfigurationModel.createEmptyModel(logService), ConfigurationModel.createEmptyModel(logService), new ResourceMap(), ConfigurationModel.createEmptyModel(logService), new ResourceMap(), logService);
+        defaultConfiguration.dispose();
+    }
+    getValue(arg1, arg2) {
+        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 changedKeys = [];
+        for (const entry of values) {
+            const [key, value] = entry;
+            if (this.getValue(key) === value) {
+                continue;
+            }
+            this._configuration.updateValue(key, value);
+            changedKeys.push(key);
+        }
+        if (changedKeys.length > 0) {
+            const configurationChangeEvent = new ConfigurationChangeEvent({ keys: changedKeys, overrides: [] }, previous, this._configuration, undefined, this.logService);
+            configurationChangeEvent.source = 8 /* ConfigurationTarget.MEMORY */;
+            this._onDidChangeConfiguration.fire(configurationChangeEvent);
+        }
+        return Promise.resolve();
+    }
+    updateValue(key, value, arg3, arg4) {
+        return this.updateValues([[key, value]]);
+    }
+    inspect(key, options = {}) {
+        return this._configuration.inspect(key, options, undefined);
+    }
+};
+StandaloneConfigurationService = __decorate([
+    __param(0, ILogService)
+], StandaloneConfigurationService);
+let StandaloneResourceConfigurationService = class StandaloneResourceConfigurationService {
+    constructor(configurationService, modelService, languageService) {
+        this.configurationService = configurationService;
+        this.modelService = modelService;
+        this.languageService = languageService;
+        this._onDidChangeConfiguration = new Emitter();
+        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 language = resource ? this.getLanguage(resource, position) : undefined;
+        if (typeof section === 'undefined') {
+            return this.configurationService.getValue({
+                resource,
+                overrideIdentifier: language
+            });
+        }
+        return this.configurationService.getValue(section, {
+            resource,
+            overrideIdentifier: language
+        });
+    }
+    getLanguage(resource, position) {
+        const model = this.modelService.getModel(resource);
+        if (model) {
+            return position ? model.getLanguageIdAtPosition(position.lineNumber, position.column) : model.getLanguageId();
+        }
+        return this.languageService.guessLanguageIdByFilepathOrFirstLine(resource);
+    }
+};
+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') {
+            return eol;
+        }
+        return (isLinux || isMacintosh) ? '\n' : '\r\n';
+    }
+};
+StandaloneResourcePropertiesService = __decorate([
+    __param(0, IConfigurationService)
+], StandaloneResourcePropertiesService);
+class StandaloneTelemetryService {
+    publicLog2() { }
+}
+class StandaloneWorkspaceContextService {
+    static { this.SCHEME = 'inmemory'; }
+    constructor() {
+        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 })] };
+    }
+    getWorkspace() {
+        return this.workspace;
+    }
+    getWorkspaceFolder(resource) {
+        return resource && resource.scheme === StandaloneWorkspaceContextService.SCHEME ? this.workspace.folders[0] : null;
+    }
+}
+function updateConfigurationService(configurationService, source, isDiffEditor) {
+    if (!source) {
+        return;
+    }
+    if (!(configurationService instanceof StandaloneConfigurationService)) {
+        return;
+    }
+    const toUpdate = [];
+    Object.keys(source).forEach((key) => {
+        if (isEditorConfigurationKey(key)) {
+            toUpdate.push([`editor.${key}`, source[key]]);
+        }
+        if (isDiffEditor && isDiffEditorConfigurationKey(key)) {
+            toUpdate.push([`diffEditor.${key}`, source[key]]);
+        }
+    });
+    if (toUpdate.length > 0) {
+        configurationService.updateValues(toUpdate);
+    }
+}
+let StandaloneBulkEditService = class StandaloneBulkEditService {
+    constructor(_modelService) {
+        this._modelService = _modelService;
+        //
+    }
+    hasPreviewHandler() {
+        return false;
+    }
+    async apply(editsIn, _options) {
+        const edits = Array.isArray(editsIn) ? editsIn : ResourceEdit.convert(editsIn);
+        const textEdits = new Map();
+        for (const edit of edits) {
+            if (!(edit instanceof ResourceTextEdit)) {
+                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');
+            }
+            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));
+        }
+        let totalEdits = 0;
+        let totalFiles = 0;
+        for (const [model, edits] of textEdits) {
+            model.pushStackElement();
+            model.pushEditOperations([], edits, () => []);
+            model.pushStackElement();
+            totalFiles += 1;
+            totalEdits += edits.length;
+        }
+        return {
+            ariaSummary: format(StandaloneServicesNLS.bulkEditServiceSummary, totalEdits, totalFiles),
+            isApplied: totalEdits > 0
+        };
+    }
+};
+StandaloneBulkEditService = __decorate([
+    __param(0, IModelService)
+], StandaloneBulkEditService);
+class StandaloneUriLabelService {
+    getUriLabel(resource, options) {
+        if (resource.scheme === 'file') {
+            return resource.fsPath;
+        }
+        return resource.path;
+    }
+    getUriBasenameLabel(resource) {
+        return basename(resource);
+    }
+}
+let StandaloneContextViewService = class StandaloneContextViewService extends ContextViewService {
+    constructor(layoutService, _codeEditorService) {
+        super(layoutService);
+        this._codeEditorService = _codeEditorService;
+    }
+    showContextView(delegate, container, shadowRoot) {
+        if (!container) {
+            const codeEditor = this._codeEditorService.getFocusedCodeEditor() || this._codeEditorService.getActiveCodeEditor();
+            if (codeEditor) {
+                container = codeEditor.getContainerDomNode();
+            }
+        }
+        return super.showContextView(delegate, container, shadowRoot);
+    }
+};
+StandaloneContextViewService = __decorate([
+    __param(0, ILayoutService),
+    __param(1, ICodeEditorService)
+], StandaloneContextViewService);
+class StandaloneWorkspaceTrustManagementService {
+    constructor() {
+        this._neverEmitter = new Emitter();
+        this.onDidChangeTrust = this._neverEmitter.event;
+    }
+    isWorkspaceTrusted() {
+        return true;
+    }
+}
+class StandaloneLanguageService extends LanguageService {
+    constructor() {
+        super();
+    }
+}
+class StandaloneLogService extends LogService {
+    constructor() {
+        super(new ConsoleLogger());
+    }
+}
+let StandaloneContextMenuService = class StandaloneContextMenuService extends ContextMenuService {
+    constructor(telemetryService, notificationService, contextViewService, keybindingService, menuService, contextKeyService) {
+        super(telemetryService, notificationService, contextViewService, keybindingService, menuService, contextKeyService);
+        this.configure({ blockMouse: false }); // we do not want that in the standalone editor
+    }
+};
+StandaloneContextMenuService = __decorate([
+    __param(0, ITelemetryService),
+    __param(1, INotificationService),
+    __param(2, IContextViewService),
+    __param(3, IKeybindingService),
+    __param(4, IMenuService),
+    __param(5, IContextKeyService)
+], StandaloneContextMenuService);
+const standaloneEditorWorkerDescriptor = {
+    esmModuleLocation: undefined,
+    label: 'editorWorkerService'
+};
+let StandaloneEditorWorkerService = class StandaloneEditorWorkerService extends EditorWorkerService {
+    constructor(modelService, configurationService, logService, languageConfigurationService, languageFeaturesService) {
+        super(standaloneEditorWorkerDescriptor, modelService, configurationService, logService, languageConfigurationService, languageFeaturesService);
+    }
+};
+StandaloneEditorWorkerService = __decorate([
+    __param(0, IModelService),
+    __param(1, ITextResourceConfigurationService),
+    __param(2, ILogService),
+    __param(3, ILanguageConfigurationService),
+    __param(4, ILanguageFeaturesService)
+], StandaloneEditorWorkerService);
+class StandaloneAccessbilitySignalService {
+    async playSignal(cue, options) {
+    }
+}
+registerSingleton(ILogService, StandaloneLogService, 0 /* InstantiationType.Eager */);
+registerSingleton(IConfigurationService, StandaloneConfigurationService, 0 /* InstantiationType.Eager */);
+registerSingleton(ITextResourceConfigurationService, StandaloneResourceConfigurationService, 0 /* InstantiationType.Eager */);
+registerSingleton(ITextResourcePropertiesService, StandaloneResourcePropertiesService, 0 /* InstantiationType.Eager */);
+registerSingleton(IWorkspaceContextService, StandaloneWorkspaceContextService, 0 /* InstantiationType.Eager */);
+registerSingleton(ILabelService, StandaloneUriLabelService, 0 /* InstantiationType.Eager */);
+registerSingleton(ITelemetryService, StandaloneTelemetryService, 0 /* InstantiationType.Eager */);
+registerSingleton(IDialogService, StandaloneDialogService, 0 /* InstantiationType.Eager */);
+registerSingleton(IEnvironmentService, StandaloneEnvironmentService, 0 /* InstantiationType.Eager */);
+registerSingleton(INotificationService, StandaloneNotificationService, 0 /* InstantiationType.Eager */);
+registerSingleton(IMarkerService, MarkerService, 0 /* InstantiationType.Eager */);
+registerSingleton(ILanguageService, StandaloneLanguageService, 0 /* InstantiationType.Eager */);
+registerSingleton(IStandaloneThemeService, StandaloneThemeService, 0 /* InstantiationType.Eager */);
+registerSingleton(IModelService, ModelService, 0 /* InstantiationType.Eager */);
+registerSingleton(IMarkerDecorationsService, MarkerDecorationsService, 0 /* InstantiationType.Eager */);
+registerSingleton(IContextKeyService, ContextKeyService, 0 /* InstantiationType.Eager */);
+registerSingleton(IProgressService, StandaloneProgressService, 0 /* InstantiationType.Eager */);
+registerSingleton(IEditorProgressService, StandaloneEditorProgressService, 0 /* InstantiationType.Eager */);
+registerSingleton(IStorageService, InMemoryStorageService, 0 /* InstantiationType.Eager */);
+registerSingleton(IEditorWorkerService, StandaloneEditorWorkerService, 0 /* InstantiationType.Eager */);
+registerSingleton(IBulkEditService, StandaloneBulkEditService, 0 /* InstantiationType.Eager */);
+registerSingleton(IWorkspaceTrustManagementService, StandaloneWorkspaceTrustManagementService, 0 /* InstantiationType.Eager */);
+registerSingleton(ITextModelService, StandaloneTextModelService, 0 /* InstantiationType.Eager */);
+registerSingleton(IAccessibilityService, AccessibilityService, 0 /* InstantiationType.Eager */);
+registerSingleton(IListService, ListService, 0 /* InstantiationType.Eager */);
+registerSingleton(ICommandService, StandaloneCommandService, 0 /* InstantiationType.Eager */);
+registerSingleton(IKeybindingService, StandaloneKeybindingService, 0 /* InstantiationType.Eager */);
+registerSingleton(IQuickInputService, StandaloneQuickInputService, 0 /* InstantiationType.Eager */);
+registerSingleton(IContextViewService, StandaloneContextViewService, 0 /* InstantiationType.Eager */);
+registerSingleton(IOpenerService, OpenerService, 0 /* InstantiationType.Eager */);
+registerSingleton(IClipboardService, BrowserClipboardService, 0 /* InstantiationType.Eager */);
+registerSingleton(IContextMenuService, StandaloneContextMenuService, 0 /* InstantiationType.Eager */);
+registerSingleton(IMenuService, MenuService, 0 /* InstantiationType.Eager */);
+registerSingleton(IAccessibilitySignalService, StandaloneAccessbilitySignalService, 0 /* InstantiationType.Eager */);
+registerSingleton(ITreeSitterLibraryService, StandaloneTreeSitterLibraryService, 0 /* InstantiationType.Eager */);
+registerSingleton(ILoggerService, NullLoggerService, 0 /* InstantiationType.Eager */);
+registerSingleton(IDataChannelService, NullDataChannelService, 0 /* InstantiationType.Eager */);
+/**
+ * We don't want to eagerly instantiate services because embedders get a one time chance
+ * to override services when they create the first editor.
+ */
+var StandaloneServices;
+(function (StandaloneServices) {
+    const serviceCollection = new ServiceCollection();
+    for (const [id, descriptor] of getSingletonServiceDescriptors()) {
+        serviceCollection.set(id, descriptor);
+    }
+    const instantiationService = new InstantiationService(serviceCollection, true);
+    serviceCollection.set(IInstantiationService, instantiationService);
+    function get(serviceId) {
+        if (!initialized) {
+            initialize({});
+        }
+        const r = serviceCollection.get(serviceId);
+        if (!r) {
+            throw new Error('Missing service ' + serviceId);
+        }
+        if (r instanceof SyncDescriptor) {
+            return instantiationService.invokeFunction((accessor) => accessor.get(serviceId));
+        }
+        else {
+            return r;
+        }
+    }
+    StandaloneServices.get = get;
+    let initialized = false;
+    const onDidInitialize = new Emitter();
+    function initialize(overrides) {
+        if (initialized) {
+            return instantiationService;
+        }
+        initialized = true;
+        // Add singletons that were registered after this module loaded
+        for (const [id, descriptor] of getSingletonServiceDescriptors()) {
+            if (!serviceCollection.get(id)) {
+                serviceCollection.set(id, descriptor);
+            }
+        }
+        // Initialize the service collection with the overrides, but only if the
+        // service was not instantiated in the meantime.
+        for (const serviceId in overrides) {
+            if (overrides.hasOwnProperty(serviceId)) {
+                const serviceIdentifier = createDecorator(serviceId);
+                const r = serviceCollection.get(serviceIdentifier);
+                if (r instanceof SyncDescriptor) {
+                    serviceCollection.set(serviceIdentifier, overrides[serviceId]);
+                }
+            }
+        }
+        // Instantiate all editor features
+        const editorFeatures = getEditorFeatures();
+        for (const feature of editorFeatures) {
+            try {
+                instantiationService.createInstance(feature);
+            }
+            catch (err) {
+                onUnexpectedError(err);
+            }
+        }
+        onDidInitialize.fire();
+        return instantiationService;
+    }
+    StandaloneServices.initialize = initialize;
+    /**
+     * Executes callback once services are initialized.
+     */
+    function withServices(callback) {
+        if (initialized) {
+            return callback();
+        }
+        const disposable = new DisposableStore();
+        const listener = disposable.add(onDidInitialize.event(() => {
+            listener.dispose();
+            disposable.add(callback());
+        }));
+        return disposable;
+    }
+    StandaloneServices.withServices = withServices;
+})(StandaloneServices || (StandaloneServices = {}));
+
+export { StandaloneCommandService, StandaloneConfigurationService, StandaloneKeybindingService, StandaloneNotificationService, StandaloneServices, updateConfigurationService };