@codingame/monaco-vscode-api 1.85.6 → 2.0.0-v2.1

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

@@ -0,0 +1,968 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import '../../common/languages/languageConfigurationRegistry.js';
+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 { format } from '../../../base/common/strings.js';
+import { addDisposableListener, EventType } from '../../../base/browser/dom.js';
+import { StandardKeyboardEvent } from '../../../base/browser/keyboardEvent.js';
+import { Event, Emitter } from '../../../base/common/event.js';
+import { decodeKeybinding, KeyCodeChord } from '../../../base/common/keybindings.js';
+import { Disposable, ImmortalReference, combinedDisposable, toDisposable, DisposableStore } 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 { IBulkEditService, ResourceTextEdit, ResourceEdit } 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 as Configuration$1, ConfigurationModel, ConfigurationChangeEvent } from '../../../platform/configuration/common/configurationModels.js';
+import { IContextKeyService } from '../../../platform/contextkey/common/contextkey.js';
+import '../../../../../../override/vs/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 { NoOpNotification, INotificationService } from '../../../platform/notification/common/notification.js';
+import { IProgressService, IEditorProgressService } from '../../../platform/progress/common/progress.js';
+import { ITelemetryService } from '../../../platform/telemetry/common/telemetry.js';
+import { STANDALONE_EDITOR_WORKSPACE_ID, WorkspaceFolder, 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, 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, IAccessibleNotificationService } 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 as DefaultConfiguration$1 } from '../../../platform/configuration/common/configurations.js';
+import { IAudioCueService } from '../../../platform/audioCues/browser/audioCueService.js';
+import { LogService } from '../../../platform/log/common/logService.js';
+import { IEnvironmentService } from '../../../platform/environment/common/environment.js';
+import { mainWindow } from '../../../base/browser/window.js';
+import { IDialogService } from '../../../platform/dialogs/common/dialogs.js';
+class SimpleModel {
+    constructor(model) {
+        this.disposed = false;
+        this.model = model;
+        this._onWillDispose = ( new Emitter());
+    }
+    get onWillDispose() {
+        return this._onWillDispose.event;
+    }
+    resolve() {
+        return Promise.resolve();
+    }
+    get textEditorModel() {
+        return this.model;
+    }
+    createSnapshot() {
+        return this.model.createSnapshot();
+    }
+    isReadonly() {
+        return false;
+    }
+    dispose() {
+        this.disposed = true;
+        this._onWillDispose.fire();
+    }
+    isDisposed() {
+        return this.disposed;
+    }
+    isResolved() {
+        return true;
+    }
+    getLanguageId() {
+        return this.model.getLanguageId();
+    }
+}
+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)))));
+    }
+    registerTextModelContentProvider(scheme, provider) {
+        return {
+            dispose: function () { }
+        };
+    }
+    canHandleResource(resource) {
+        return false;
+    }
+};
+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.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.sync = undefined;
+        this.continueOn = undefined;
+        this.editSessionId = undefined;
+        this.debugExtensionHost = { port: null, break: false };
+        this.isExtensionDevelopment = false;
+        this.disableExtensions = false;
+        this.enableExtensions = undefined;
+        this.extensionDevelopmentLocationURI = undefined;
+        this.extensionDevelopmentKind = undefined;
+        this.extensionTestsLocationURI = undefined;
+        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.policyFile = undefined;
+    }
+}
+class StandaloneDialogService {
+    constructor() {
+        this.onWillShowDialog = Event.None;
+        this.onDidShowDialog = Event.None;
+    }
+    async confirm(confirmation) {
+        const confirmed = this.doConfirm(confirmation.message, confirmation.detail);
+        return {
+            confirmed,
+            checkboxChecked: false
+        };
+    }
+    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 info(message, detail) {
+        await this.prompt({ type: Severity.Info, message, detail });
+    }
+    async warn(message, detail) {
+        await this.prompt({ type: Severity.Warning, message, detail });
+    }
+    async error(message, detail) {
+        await this.prompt({ type: Severity.Error, message, detail });
+    }
+    input() {
+        return Promise.resolve({ confirmed: false });
+    }
+    about() {
+        return Promise.resolve(undefined);
+    }
+}
+class StandaloneNotificationService {
+    constructor() {
+        this.onDidAddNotification = Event.None;
+        this.onDidRemoveNotification = Event.None;
+        this.onDidChangeDoNotDisturbMode = Event.None;
+        this.doNotDisturbMode = false;
+    }
+    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 Disposable.None;
+    }
+}
+let StandaloneCommandService = class StandaloneCommandService {
+    constructor(instantiationService) {
+        this._onWillExecuteCommand = ( new Emitter());
+        this._onDidExecuteCommand = ( new Emitter());
+        this.onWillExecuteCommand = this._onWillExecuteCommand.event;
+        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());
+            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();
+                }
+            }));
+            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(61 )) {
+                return;
+            }
+            addContainer(codeEditor.getContainerDomNode());
+        };
+        const removeCodeEditor = (codeEditor) => {
+            if (codeEditor.getOption(61 )) {
+                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(() => {
+            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();
+    }
+    getUserKeybindingItems() {
+        return this._toNormalizedKeybindingItems(this._dynamicKeybindings, false);
+    }
+    _getResolver() {
+        if (!this._cachedResolver) {
+            const defaults = this._toNormalizedKeybindingItems(KeybindingsRegistry.getDefaultKeybindings(), true);
+            const overrides = this.getUserKeybindingItems();
+            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) {
+                result[resultLen++] = ( new ResolvedKeybindingItem(undefined, item.command, item.commandArgs, when, isDefault, null, false));
+            }
+            else {
+                const resolvedKeybindings = this.resolveKeybinding(keybinding);
+                for (const resolvedKeybinding of resolvedKeybindings) {
+                    result[resultLen++] = ( new ResolvedKeybindingItem(
+                        resolvedKeybinding,
+                        item.command,
+                        item.commandArgs,
+                        when,
+                        isDefault,
+                        null,
+                        false
+                    ));
+                }
+            }
+        }
+        return result;
+    }
+    resolveKeybinding(keybinding) {
+        return USLayoutResolvedKeybinding.resolveKeybinding(keybinding, OS);
+    }
+    resolveKeyboardEvent(keyboardEvent) {
+        const chord = ( new KeyCodeChord(
+            keyboardEvent.ctrlKey,
+            keyboardEvent.shiftKey,
+            keyboardEvent.altKey,
+            keyboardEvent.metaKey,
+            keyboardEvent.keyCode
+        ));
+        return ( new USLayoutResolvedKeybinding([chord], OS));
+    }
+    resolveUserBinding(userBinding) {
+        return [];
+    }
+    _dumpDebugInfo() {
+        return '';
+    }
+    _dumpDebugInfoJSON() {
+        return '';
+    }
+    registerSchemaContribution(contribution) {
+    }
+};
+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);
+}
+class StandaloneConfigurationService {
+    constructor() {
+        this._onDidChangeConfiguration = ( new Emitter());
+        this.onDidChangeConfiguration = this._onDidChangeConfiguration.event;
+        const defaultConfiguration = ( new DefaultConfiguration$1());
+        this._configuration = ( new Configuration$1(defaultConfiguration.reload(), ( new ConfigurationModel()), ( new ConfigurationModel()), ( new ConfigurationModel())));
+        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));
+            configurationChangeEvent.source = 8 ;
+            configurationChangeEvent.sourceConfig = null;
+            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);
+    }
+    keys() {
+        return ( this._configuration.keys(undefined));
+    }
+    reloadConfiguration() {
+        return Promise.resolve(undefined);
+    }
+    getConfigurationData() {
+        const emptyModel = {
+            contents: {},
+            keys: [],
+            overrides: []
+        };
+        return {
+            defaults: emptyModel,
+            policy: emptyModel,
+            application: emptyModel,
+            user: emptyModel,
+            workspace: emptyModel,
+            folders: []
+        };
+    }
+}
+let StandaloneResourceConfigurationService = class StandaloneResourceConfigurationService {
+    constructor(configurationService, modelService, languageService) {
+        this.configurationService = configurationService;
+        this.modelService = modelService;
+        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) });
+        });
+    }
+    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
+        });
+    }
+    inspect(resource, position, section) {
+        const language = resource ? this.getLanguage(resource, position) : undefined;
+        return this.configurationService.inspect(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);
+    }
+    updateValue(resource, key, value, configurationTarget) {
+        return this.configurationService.updateValue(key, value, { resource }, configurationTarget);
+    }
+};
+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 {
+    constructor() {
+        this.telemetryLevel = 0 ;
+        this.sessionId = 'someValue.sessionId';
+        this.machineId = 'someValue.machineId';
+        this.sqmId = 'someValue.sqmId';
+        this.firstSessionDate = 'someValue.firstSessionDate';
+        this.sendErrorTelemetry = false;
+    }
+    setEnabled() { }
+    setExperimentProperty() { }
+    publicLog() { }
+    publicLog2() { }
+    publicLogError() { }
+    publicLogError2() { }
+}
+class StandaloneWorkspaceContextService {
+    static { this.SCHEME = 'inmemory'; }
+    constructor() {
+        this._onDidChangeWorkspaceName = ( new Emitter());
+        this.onDidChangeWorkspaceName = this._onDidChangeWorkspaceName.event;
+        this._onWillChangeWorkspaceFolders = ( new Emitter());
+        this.onWillChangeWorkspaceFolders = this._onWillChangeWorkspaceFolders.event;
+        this._onDidChangeWorkspaceFolders = ( new Emitter());
+        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 }))] };
+    }
+    getCompleteWorkspace() {
+        return Promise.resolve(this.getWorkspace());
+    }
+    getWorkspace() {
+        return this.workspace;
+    }
+    getWorkbenchState() {
+        if (this.workspace) {
+            if (this.workspace.configuration) {
+                return 3 ;
+            }
+            return 2 ;
+        }
+        return 1 ;
+    }
+    getWorkspaceFolder(resource) {
+        return resource && resource.scheme === StandaloneWorkspaceContextService.SCHEME ? this.workspace.folders[0] : null;
+    }
+    isInsideWorkspace(resource) {
+        return resource && resource.scheme === StandaloneWorkspaceContextService.SCHEME;
+    }
+    isCurrentWorkspace(workspaceIdOrFolder) {
+        return true;
+    }
+}
+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;
+    }
+    setPreviewHandler() {
+        return Disposable.None;
+    }
+    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 {
+    constructor() {
+        this.onDidChangeFormatters = Event.None;
+    }
+    getUriLabel(resource, options) {
+        if (resource.scheme === 'file') {
+            return resource.fsPath;
+        }
+        return resource.path;
+    }
+    getUriBasenameLabel(resource) {
+        return basename(resource);
+    }
+    getWorkspaceLabel(workspace, options) {
+        return '';
+    }
+    getSeparator(scheme, authority) {
+        return '/';
+    }
+    registerFormatter(formatter) {
+        throw new Error('Not implemented');
+    }
+    registerCachedFormatter(formatter) {
+        return this.registerFormatter(formatter);
+    }
+    getHostLabel() {
+        return '';
+    }
+    getHostTooltip() {
+        return undefined;
+    }
+}
+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;
+        this.onDidChangeTrustedFolders = this._neverEmitter.event;
+        this.workspaceResolved = Promise.resolve();
+        this.workspaceTrustInitialized = Promise.resolve();
+        this.acceptsOutOfWorkspaceFiles = true;
+    }
+    isWorkspaceTrusted() {
+        return true;
+    }
+    isWorkspaceTrustForced() {
+        return false;
+    }
+    canSetParentFolderTrust() {
+        return false;
+    }
+    async setParentFolderTrust(trusted) {
+    }
+    canSetWorkspaceTrust() {
+        return false;
+    }
+    async setWorkspaceTrust(trusted) {
+    }
+    getUriTrustInfo(uri) {
+        throw new Error('Method not supported.');
+    }
+    async setUrisTrust(uri, trusted) {
+    }
+    getTrustedUris() {
+        return [];
+    }
+    async setTrustedUris(uris) {
+    }
+    addWorkspaceTrustTransitionParticipant(participant) {
+        throw new Error('Method not supported.');
+    }
+}
+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 });
+    }
+};
+StandaloneContextMenuService = ( __decorate([
+    ( __param(0, ITelemetryService)),
+    ( __param(1, INotificationService)),
+    ( __param(2, IContextViewService)),
+    ( __param(3, IKeybindingService)),
+    ( __param(4, IMenuService)),
+    ( __param(5, IContextKeyService))
+], StandaloneContextMenuService));
+class StandaloneAudioService {
+    async playAudioCue(cue, options) {
+    }
+    async playAudioCues(cues) {
+    }
+    isEnabled(cue) {
+        return false;
+    }
+    onEnabledChanged(cue) {
+        return Event.None;
+    }
+    async playSound(cue, allowManyInParallel) {
+    }
+    playAudioCueLoop(cue) {
+        return toDisposable(() => { });
+    }
+}
+class StandaloneAccessibleNotificationService {
+    notify(event, userGesture) {
+    }
+}
+registerSingleton(IConfigurationService, StandaloneConfigurationService, 0 );
+registerSingleton(ITextResourceConfigurationService, StandaloneResourceConfigurationService, 0 );
+registerSingleton(ITextResourcePropertiesService, StandaloneResourcePropertiesService, 0 );
+registerSingleton(IWorkspaceContextService, StandaloneWorkspaceContextService, 0 );
+registerSingleton(ILabelService, StandaloneUriLabelService, 0 );
+registerSingleton(ITelemetryService, StandaloneTelemetryService, 0 );
+registerSingleton(IDialogService, StandaloneDialogService, 0 );
+registerSingleton(IEnvironmentService, StandaloneEnvironmentService, 0 );
+registerSingleton(INotificationService, StandaloneNotificationService, 0 );
+registerSingleton(IMarkerService, MarkerService, 0 );
+registerSingleton(ILanguageService, StandaloneLanguageService, 0 );
+registerSingleton(IStandaloneThemeService, StandaloneThemeService, 0 );
+registerSingleton(ILogService, StandaloneLogService, 0 );
+registerSingleton(IModelService, ModelService, 0 );
+registerSingleton(IMarkerDecorationsService, MarkerDecorationsService, 0 );
+registerSingleton(IContextKeyService, ContextKeyService, 0 );
+registerSingleton(IProgressService, StandaloneProgressService, 0 );
+registerSingleton(IEditorProgressService, StandaloneEditorProgressService, 0 );
+registerSingleton(IStorageService, InMemoryStorageService, 0 );
+registerSingleton(IEditorWorkerService, EditorWorkerService, 0 );
+registerSingleton(IBulkEditService, StandaloneBulkEditService, 0 );
+registerSingleton(IWorkspaceTrustManagementService, StandaloneWorkspaceTrustManagementService, 0 );
+registerSingleton(ITextModelService, StandaloneTextModelService, 0 );
+registerSingleton(IAccessibilityService, AccessibilityService, 0 );
+registerSingleton(IListService, ListService, 0 );
+registerSingleton(ICommandService, StandaloneCommandService, 0 );
+registerSingleton(IKeybindingService, StandaloneKeybindingService, 0 );
+registerSingleton(IQuickInputService, StandaloneQuickInputService, 0 );
+registerSingleton(IContextViewService, StandaloneContextViewService, 0 );
+registerSingleton(IOpenerService, OpenerService, 0 );
+registerSingleton(IClipboardService, BrowserClipboardService, 0 );
+registerSingleton(IContextMenuService, StandaloneContextMenuService, 0 );
+registerSingleton(IMenuService, MenuService, 0 );
+registerSingleton(IAudioCueService, StandaloneAudioService, 0 );
+registerSingleton(IAccessibleNotificationService, StandaloneAccessibleNotificationService, 0 );
+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;
+        for (const [id, descriptor] of getSingletonServiceDescriptors()) {
+            if (!serviceCollection.get(id)) {
+                serviceCollection.set(id, descriptor);
+            }
+        }
+        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]);
+                }
+            }
+        }
+        onDidInitialize.fire();
+        return instantiationService;
+    }
+    StandaloneServices.initialize = initialize;
+    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 };