@theia/monaco 1.67.0-next.56 → 1.67.0-next.59

package/lib/browser/monaco-editor.js

@@ -0,0 +1,638 @@
+"use strict";
+// *****************************************************************************
+// Copyright (C) 2018 TypeFox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MonacoEditor = exports.MonacoEditorServices = void 0;
+const tslib_1 = require("tslib");
+const inversify_1 = require("@theia/core/shared/inversify");
+const domutils_1 = require("@theia/core/shared/@lumino/domutils");
+const context_key_service_1 = require("@theia/core/lib/browser/context-key-service");
+const common_1 = require("@theia/core/lib/common");
+const monaco_to_protocol_converter_1 = require("./monaco-to-protocol-converter");
+const protocol_to_monaco_converter_1 = require("./protocol-to-monaco-converter");
+const encodings_1 = require("@theia/core/lib/common/encodings");
+const monaco = require("@theia/monaco-editor-core");
+const standaloneServices_1 = require("@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices");
+const language_1 = require("@theia/monaco-editor-core/esm/vs/editor/common/languages/language");
+const instantiation_1 = require("@theia/monaco-editor-core/esm/vs/platform/instantiation/common/instantiation");
+const standaloneCodeEditor_1 = require("@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneCodeEditor");
+const serviceCollection_1 = require("@theia/monaco-editor-core/esm/vs/platform/instantiation/common/serviceCollection");
+const editorOptions_1 = require("@theia/monaco-editor-core/esm/vs/editor/common/config/editorOptions");
+const codeEditorService_1 = require("@theia/monaco-editor-core/esm/vs/editor/browser/services/codeEditorService");
+const commands_1 = require("@theia/monaco-editor-core/esm/vs/platform/commands/common/commands");
+const contextkey_1 = require("@theia/monaco-editor-core/esm/vs/platform/contextkey/common/contextkey");
+const keybinding_1 = require("@theia/monaco-editor-core/esm/vs/platform/keybinding/common/keybinding");
+const themeService_1 = require("@theia/monaco-editor-core/esm/vs/platform/theme/common/themeService");
+const notification_1 = require("@theia/monaco-editor-core/esm/vs/platform/notification/common/notification");
+const accessibility_1 = require("@theia/monaco-editor-core/esm/vs/platform/accessibility/common/accessibility");
+const languageConfigurationRegistry_1 = require("@theia/monaco-editor-core/esm/vs/editor/common/languages/languageConfigurationRegistry");
+const languageFeatures_1 = require("@theia/monaco-editor-core/esm/vs/editor/common/services/languageFeatures");
+const objects = require("@theia/monaco-editor-core/esm/vs/base/common/objects");
+const hover_1 = require("@theia/monaco-editor-core/esm/vs/platform/hover/browser/hover");
+const hoverDelegateFactory_1 = require("@theia/monaco-editor-core/esm/vs/base/browser/ui/hover/hoverDelegateFactory");
+const monaco_text_model_service_1 = require("./monaco-text-model-service");
+let MonacoEditorServices = class MonacoEditorServices {
+    constructor(services) {
+        Object.assign(this, services);
+    }
+};
+exports.MonacoEditorServices = MonacoEditorServices;
+tslib_1.__decorate([
+    (0, inversify_1.inject)(monaco_to_protocol_converter_1.MonacoToProtocolConverter),
+    tslib_1.__metadata("design:type", monaco_to_protocol_converter_1.MonacoToProtocolConverter)
+], MonacoEditorServices.prototype, "m2p", void 0);
+tslib_1.__decorate([
+    (0, inversify_1.inject)(protocol_to_monaco_converter_1.ProtocolToMonacoConverter),
+    tslib_1.__metadata("design:type", protocol_to_monaco_converter_1.ProtocolToMonacoConverter)
+], MonacoEditorServices.prototype, "p2m", void 0);
+tslib_1.__decorate([
+    (0, inversify_1.inject)(context_key_service_1.ContextKeyService),
+    tslib_1.__metadata("design:type", Object)
+], MonacoEditorServices.prototype, "contextKeyService", void 0);
+tslib_1.__decorate([
+    (0, inversify_1.inject)(monaco_text_model_service_1.MonacoTextModelService),
+    tslib_1.__metadata("design:type", monaco_text_model_service_1.MonacoTextModelService)
+], MonacoEditorServices.prototype, "monacoModelService", void 0);
+exports.MonacoEditorServices = MonacoEditorServices = tslib_1.__decorate([
+    (0, inversify_1.injectable)(),
+    tslib_1.__param(0, (0, inversify_1.unmanaged)()),
+    tslib_1.__metadata("design:paramtypes", [MonacoEditorServices])
+], MonacoEditorServices);
+class MonacoEditor extends MonacoEditorServices {
+    static async create(uri, document, node, services, options, override, parentEditor) {
+        const instance = new MonacoEditor(uri, document, node, services, options, override, parentEditor);
+        await instance.init();
+        return instance;
+    }
+    constructor(uri, document, node, services, options, override, parentEditor) {
+        super(services);
+        this.uri = uri;
+        this.document = document;
+        this.node = node;
+        this.parentEditor = parentEditor;
+        this.toDispose = new common_1.DisposableCollection();
+        this.onCursorPositionChangedEmitter = new common_1.Emitter();
+        this.onSelectionChangedEmitter = new common_1.Emitter();
+        this.onFocusChangedEmitter = new common_1.Emitter();
+        this.onDocumentContentChangedEmitter = new common_1.Emitter();
+        this.onMouseDownEmitter = new common_1.Emitter();
+        this.onDidChangeReadOnly = this.document.onDidChangeReadOnly;
+        this.onLanguageChangedEmitter = new common_1.Emitter();
+        this.onLanguageChanged = this.onLanguageChangedEmitter.event;
+        this.onScrollChangedEmitter = new common_1.Emitter();
+        this.onEncodingChanged = this.document.onDidChangeEncoding;
+        this.onResizeEmitter = new common_1.Emitter();
+        this.onDidResize = this.onResizeEmitter.event;
+        this.onShouldDisplayDirtyDiffChangedEmitter = new common_1.Emitter;
+        this.onShouldDisplayDirtyDiffChanged = this.onShouldDisplayDirtyDiffChangedEmitter.event;
+        this.documents = new Set();
+        /* `true` because it is derived from an URI during the instantiation */
+        this._languageAutoDetected = true;
+        this._shouldDisplayDirtyDiff = true;
+        this.toDispose.pushAll([
+            this.onCursorPositionChangedEmitter,
+            this.onSelectionChangedEmitter,
+            this.onFocusChangedEmitter,
+            this.onDocumentContentChangedEmitter,
+            this.onMouseDownEmitter,
+            this.onLanguageChangedEmitter,
+            this.onScrollChangedEmitter,
+            this.onShouldDisplayDirtyDiffChangedEmitter
+        ]);
+        this.documents.add(document);
+        this.autoSizing = options && options.autoSizing !== undefined ? options.autoSizing : false;
+        this.minHeight = options && options.minHeight !== undefined ? options.minHeight : -1;
+        this.maxHeight = options && options.maxHeight !== undefined ? options.maxHeight : -1;
+        this.toDispose.push(this.create({
+            ...MonacoEditor.createReadOnlyOptions(document.readOnly),
+            ...options
+        }, override));
+        // Ensure that a valid InstantiationService is responsible for creating hover delegates when the InstantiationService for this widget is disposed.
+        // Cf. https://github.com/eclipse-theia/theia/issues/15102
+        this.toDispose.push(common_1.Disposable.create(() => (0, hoverDelegateFactory_1.setHoverDelegateFactory)((placement, enableInstantHover) => standaloneServices_1.StandaloneServices.get(instantiation_1.IInstantiationService).createInstance(hover_1.WorkbenchHoverDelegate, placement, enableInstantHover, {}))));
+        this.addHandlers(this.editor);
+        this.editor.createContextKey('resource', document.uri);
+    }
+    async init() {
+        this.toDispose.push(await this.monacoModelService.createModelReference(this.uri));
+    }
+    getEncoding() {
+        return this.document.getEncoding() || encodings_1.UTF8;
+    }
+    setEncoding(encoding, mode) {
+        return this.document.setEncoding(encoding, mode);
+    }
+    create(options, override) {
+        const combinedOptions = {
+            ...options,
+            lightbulb: { enabled: editorOptions_1.ShowLightbulbIconMode.On },
+            fixedOverflowWidgets: true,
+            scrollbar: {
+                useShadows: false,
+                verticalHasArrows: false,
+                horizontalHasArrows: false,
+                verticalScrollbarSize: 10,
+                horizontalScrollbarSize: 10,
+                ...options === null || options === void 0 ? void 0 : options.scrollbar,
+            }
+        };
+        const instantiator = this.getInstantiatorWithOverrides(override);
+        /**
+         * @monaco-uplift. Should be guaranteed to work.
+         * Incomparable enums prevent TypeScript from believing that public IStandaloneCodeEditor is satisfied by private StandaloneCodeEditor
+         */
+        return this.editor = (this.parentEditor ?
+            instantiator.createInstance(EmbeddedCodeEditor, this.node, combinedOptions, this.parentEditor.getControl()) :
+            instantiator.createInstance(standaloneCodeEditor_1.StandaloneEditor, this.node, combinedOptions));
+    }
+    getInstantiatorWithOverrides(override) {
+        const instantiator = standaloneServices_1.StandaloneServices.get(instantiation_1.IInstantiationService);
+        if (override) {
+            const overrideServices = new serviceCollection_1.ServiceCollection(...override);
+            const child = instantiator.createChild(overrideServices);
+            this.toDispose.push(child);
+            return child;
+        }
+        return instantiator;
+    }
+    addHandlers(codeEditor) {
+        this.toDispose.push(codeEditor.onDidChangeModelLanguage(e => this.fireLanguageChanged(e.newLanguage)));
+        this.toDispose.push(codeEditor.onDidChangeConfiguration(() => this.refresh()));
+        this.toDispose.push(codeEditor.onDidChangeModel(() => this.refresh()));
+        this.toDispose.push(codeEditor.onDidChangeModelContent(e => {
+            this.refresh();
+            this.onDocumentContentChangedEmitter.fire({ document: this.document, contentChanges: e.changes.map(this.mapModelContentChange.bind(this)) });
+        }));
+        this.toDispose.push(codeEditor.onDidChangeCursorPosition(() => this.onCursorPositionChangedEmitter.fire(this.cursor)));
+        this.toDispose.push(codeEditor.onDidChangeCursorSelection(event => this.onSelectionChangedEmitter.fire({
+            ...this.m2p.asRange(event.selection),
+            direction: event.selection.getDirection() === monaco.SelectionDirection.LTR ? 'ltr' : 'rtl'
+        })));
+        this.toDispose.push(codeEditor.onDidFocusEditorText(() => this.onFocusChangedEmitter.fire(this.isFocused())));
+        this.toDispose.push(codeEditor.onDidBlurEditorText(() => this.onFocusChangedEmitter.fire(this.isFocused())));
+        this.toDispose.push(codeEditor.onMouseDown(e => {
+            const { element, position, range } = e.target;
+            this.onMouseDownEmitter.fire({
+                target: {
+                    type: e.target.type,
+                    element: element || undefined,
+                    mouseColumn: this.m2p.asPosition(undefined, e.target.mouseColumn).character,
+                    range: range && this.m2p.asRange(range) || undefined,
+                    position: position && this.m2p.asPosition(position.lineNumber, position.column) || undefined,
+                    detail: e.target.detail || {},
+                },
+                event: e.event.browserEvent
+            });
+        }));
+        this.toDispose.push(codeEditor.onDidScrollChange(e => {
+            this.onScrollChangedEmitter.fire(undefined);
+        }));
+        this.toDispose.push(this.onDidChangeReadOnly(readOnly => {
+            codeEditor.updateOptions(MonacoEditor.createReadOnlyOptions(readOnly));
+        }));
+    }
+    handleVisibilityChanged(nowVisible) {
+        if (nowVisible) {
+            if (this.model) {
+                this.editor.setModel(this.model);
+                this.editor.restoreViewState(this.savedViewState);
+                this.editor.focus();
+            }
+        }
+        else {
+            this.model = this.editor.getModel();
+            this.savedViewState = this.editor.saveViewState();
+            // eslint-disable-next-line no-null/no-null
+            this.editor.setModel(null); // workaround for https://github.com/eclipse-theia/theia/issues/14880
+        }
+    }
+    getVisibleRanges() {
+        return this.editor.getVisibleRanges().map(range => this.m2p.asRange(range));
+    }
+    mapModelContentChange(change) {
+        return {
+            range: this.m2p.asRange(change.range),
+            rangeLength: change.rangeLength,
+            text: change.text
+        };
+    }
+    get onDispose() {
+        return this.toDispose.onDispose;
+    }
+    get onDocumentContentChanged() {
+        return this.onDocumentContentChangedEmitter.event;
+    }
+    get isReadonly() {
+        return this.document.readOnly;
+    }
+    get cursor() {
+        const { lineNumber, column } = this.editor.getPosition();
+        return this.m2p.asPosition(lineNumber, column);
+    }
+    set cursor(cursor) {
+        const position = this.p2m.asPosition(cursor);
+        this.editor.setPosition(position);
+    }
+    get onCursorPositionChanged() {
+        return this.onCursorPositionChangedEmitter.event;
+    }
+    get selection() {
+        return this.m2p.asSelection(this.editor.getSelection());
+    }
+    set selection(selection) {
+        const range = this.p2m.asRange(selection);
+        this.editor.setSelection(range);
+    }
+    get onSelectionChanged() {
+        return this.onSelectionChangedEmitter.event;
+    }
+    get onScrollChanged() {
+        return this.onScrollChangedEmitter.event;
+    }
+    revealPosition(raw, options = { vertical: 'center' }) {
+        const position = this.p2m.asPosition(raw);
+        switch (options.vertical) {
+            case 'auto':
+                this.editor.revealPosition(position);
+                break;
+            case 'center':
+                this.editor.revealPositionInCenter(position);
+                break;
+            case 'centerIfOutsideViewport':
+                this.editor.revealPositionInCenterIfOutsideViewport(position);
+                break;
+        }
+    }
+    revealRange(raw, options = { at: 'center' }) {
+        const range = this.p2m.asRange(raw);
+        switch (options.at) {
+            case 'top':
+                this.editor.revealRangeAtTop(range);
+                break;
+            case 'center':
+                this.editor.revealRangeInCenter(range);
+                break;
+            case 'centerIfOutsideViewport':
+                this.editor.revealRangeInCenterIfOutsideViewport(range);
+                break;
+            case 'auto':
+                this.editor.revealRange(range);
+                break;
+        }
+    }
+    focus() {
+        /**
+         * `this.editor.focus` forcefully changes the focus editor state,
+         * regardless whether the textarea actually received the focus.
+         * It could lead to issues like https://github.com/eclipse-theia/theia/issues/7902
+         * Instead we focus the underlying textarea.
+         */
+        const node = this.editor.getDomNode();
+        if (node) {
+            const textarea = node.querySelector('textarea');
+            textarea.focus();
+        }
+    }
+    blur() {
+        const node = this.editor.getDomNode();
+        if (node) {
+            const textarea = node.querySelector('textarea');
+            textarea.blur();
+        }
+    }
+    isFocused({ strict } = { strict: false }) {
+        if (!this.editor.hasTextFocus()) {
+            return false;
+        }
+        if (strict) {
+            return !this.isSuggestWidgetVisible() && !this.isFindWidgetVisible() && !this.isRenameInputVisible();
+        }
+        return true;
+    }
+    get onFocusChanged() {
+        return this.onFocusChangedEmitter.event;
+    }
+    get onMouseDown() {
+        return this.onMouseDownEmitter.event;
+    }
+    /**
+     * `true` if the suggest widget is visible in the editor. Otherwise, `false`.
+     */
+    isSuggestWidgetVisible() {
+        return this.contextKeyService.match('suggestWidgetVisible', this.editor.getDomNode() || this.node);
+    }
+    /**
+     * `true` if the find (and replace) widget is visible in the editor. Otherwise, `false`.
+     */
+    isFindWidgetVisible() {
+        return this.contextKeyService.match('findWidgetVisible', this.editor.getDomNode() || this.node);
+    }
+    /**
+     * `true` if the name rename refactoring input HTML element is visible. Otherwise, `false`.
+     */
+    isRenameInputVisible() {
+        return this.contextKeyService.match('renameInputVisible', this.editor.getDomNode() || this.node);
+    }
+    dispose() {
+        this.toDispose.dispose();
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    trigger(source, handlerId, payload) {
+        this.editor.trigger(source, handlerId, payload);
+    }
+    getControl() {
+        return this.editor;
+    }
+    refresh() {
+        this.autoresize();
+    }
+    resizeToFit() {
+        this.autoresize();
+        // eslint-disable-next-line no-null/no-null
+        this.onResizeEmitter.fire(null);
+    }
+    setSize(dimension) {
+        this.resize(dimension);
+        this.onResizeEmitter.fire(dimension);
+    }
+    autoresize() {
+        if (this.autoSizing) {
+            // eslint-disable-next-line no-null/no-null
+            this.resize(null);
+        }
+    }
+    resize(dimension) {
+        if (this.node) {
+            const layoutSize = this.computeLayoutSize(this.node, dimension);
+            this.editor.layout(layoutSize);
+        }
+    }
+    computeLayoutSize(hostNode, dimension) {
+        if (dimension && dimension.width >= 0 && dimension.height >= 0) {
+            return dimension;
+        }
+        const boxSizing = domutils_1.ElementExt.boxSizing(hostNode);
+        const width = (!dimension || dimension.width < 0) ?
+            this.getWidth(hostNode, boxSizing) :
+            dimension.width;
+        const height = (!dimension || dimension.height < 0) ?
+            this.getHeight(hostNode, boxSizing) :
+            dimension.height;
+        return { width, height };
+    }
+    getWidth(hostNode, boxSizing) {
+        return hostNode.offsetWidth - boxSizing.horizontalSum;
+    }
+    getHeight(hostNode, boxSizing) {
+        if (!this.autoSizing) {
+            return hostNode.offsetHeight - boxSizing.verticalSum;
+        }
+        const lineHeight = this.editor.getOption(monaco.editor.EditorOption.lineHeight);
+        const lineCount = this.editor.getModel().getLineCount();
+        const contentHeight = lineHeight * lineCount;
+        const horizontalScrollbarHeight = this.editor.getLayoutInfo().horizontalScrollbarHeight;
+        const editorHeight = contentHeight + horizontalScrollbarHeight;
+        if (this.minHeight >= 0) {
+            const minHeight = lineHeight * this.minHeight + horizontalScrollbarHeight;
+            if (editorHeight < minHeight) {
+                return minHeight;
+            }
+        }
+        if (this.maxHeight >= 0) {
+            const maxHeight = lineHeight * this.maxHeight + horizontalScrollbarHeight;
+            return Math.min(maxHeight, editorHeight);
+        }
+        return editorHeight;
+    }
+    isActionSupported(id) {
+        const action = this.editor.getAction(id);
+        return !!action && action.isSupported();
+    }
+    async runAction(id) {
+        const action = this.editor.getAction(id);
+        if (action && action.isSupported()) {
+            await action.run();
+        }
+    }
+    deltaDecorations(params) {
+        const oldDecorations = params.oldDecorations;
+        const newDecorations = this.toDeltaDecorations(params);
+        return this.editor.deltaDecorations(oldDecorations, newDecorations);
+    }
+    toDeltaDecorations(params) {
+        return params.newDecorations.map(({ options: theiaOptions, range }) => {
+            const options = {
+                ...theiaOptions,
+                hoverMessage: this.fromStringToMarkdownString(theiaOptions.hoverMessage),
+                glyphMarginHoverMessage: this.fromStringToMarkdownString(theiaOptions.glyphMarginHoverMessage)
+            };
+            return {
+                options,
+                range: this.p2m.asRange(range),
+            };
+        });
+    }
+    fromStringToMarkdownString(hoverMessage) {
+        if (typeof hoverMessage === 'string') {
+            return { value: hoverMessage };
+        }
+        return hoverMessage;
+    }
+    fromMarkdownToString(maybeMarkdown) {
+        if (!maybeMarkdown) {
+            return undefined;
+        }
+        if (typeof maybeMarkdown === 'string') {
+            return maybeMarkdown;
+        }
+        if (Array.isArray(maybeMarkdown)) {
+            return maybeMarkdown.map(({ value }) => value).join('\n');
+        }
+        return maybeMarkdown.value;
+    }
+    getLinesDecorations(startLineNumber, endLineNumber) {
+        var _a;
+        const toPosition = (line) => this.p2m.asPosition({ line, character: 0 });
+        const start = toPosition(startLineNumber).lineNumber;
+        const end = toPosition(endLineNumber).lineNumber;
+        return ((_a = this.editor.getModel()) === null || _a === void 0 ? void 0 : _a.getLinesDecorations(start, end).map(this.toEditorDecoration.bind(this))) || [];
+    }
+    toEditorDecoration(decoration) {
+        const range = this.m2p.asRange(decoration.range);
+        const { id, options: monacoOptions } = decoration;
+        const options = {
+            ...monacoOptions,
+            hoverMessage: this.fromMarkdownToString(monacoOptions.hoverMessage),
+            glyphMarginHoverMessage: this.fromMarkdownToString(monacoOptions.hoverMessage),
+        };
+        return {
+            options: (0, common_1.nullToUndefined)(options),
+            range,
+            id
+        };
+    }
+    getVisibleColumn(position) {
+        return this.editor.getVisibleColumnFromPosition(this.p2m.asPosition(position));
+    }
+    async replaceText(params) {
+        const edits = params.replaceOperations.map(param => {
+            const range = monaco.Range.fromPositions(this.p2m.asPosition(param.range.start), this.p2m.asPosition(param.range.end));
+            return {
+                forceMoveMarkers: true,
+                identifier: {
+                    major: range.startLineNumber,
+                    minor: range.startColumn
+                },
+                range,
+                text: param.text
+            };
+        });
+        return this.editor.executeEdits(params.source, edits);
+    }
+    executeEdits(edits) {
+        return this.editor.executeEdits('MonacoEditor', this.p2m.asTextEdits(edits));
+    }
+    storeViewState() {
+        const state = this.editor.saveViewState();
+        if (state) {
+            this.savedViewState = state;
+        }
+        return this.savedViewState;
+    }
+    restoreViewState(state) {
+        this.editor.restoreViewState(state);
+        this.savedViewState = state;
+    }
+    get languageAutoDetected() {
+        return this._languageAutoDetected;
+    }
+    async detectLanguage() {
+        const languageService = standaloneServices_1.StandaloneServices.get(language_1.ILanguageService);
+        const firstLine = this.document.textEditorModel.getLineContent(1);
+        const model = this.getControl().getModel();
+        const language = languageService.createByFilepathOrFirstLine(model && model.uri, firstLine);
+        this.setLanguage(language.languageId);
+        this._languageAutoDetected = true;
+    }
+    setLanguage(languageId) {
+        for (const document of this.documents) {
+            monaco.editor.setModelLanguage(document.textEditorModel, languageId);
+        }
+    }
+    fireLanguageChanged(languageId) {
+        this._languageAutoDetected = false;
+        this.onLanguageChangedEmitter.fire(languageId);
+    }
+    getResourceUri() {
+        return this.uri;
+    }
+    createMoveToUri(resourceUri) {
+        return this.uri.withPath(resourceUri.path);
+    }
+    shouldDisplayDirtyDiff() {
+        return this._shouldDisplayDirtyDiff;
+    }
+    setShouldDisplayDirtyDiff(value) {
+        if (value !== this._shouldDisplayDirtyDiff) {
+            this._shouldDisplayDirtyDiff = value;
+            this.onShouldDisplayDirtyDiffChangedEmitter.fire(value);
+        }
+    }
+}
+exports.MonacoEditor = MonacoEditor;
+(function (MonacoEditor) {
+    function getAll(manager) {
+        return manager.all.map(e => get(e)).filter(e => !!e);
+    }
+    MonacoEditor.getAll = getAll;
+    function getCurrent(manager) {
+        return get(manager.currentEditor);
+    }
+    MonacoEditor.getCurrent = getCurrent;
+    function getActive(manager) {
+        return get(manager.activeEditor);
+    }
+    MonacoEditor.getActive = getActive;
+    function get(editorWidget) {
+        if (editorWidget && editorWidget.editor instanceof MonacoEditor) {
+            return editorWidget.editor;
+        }
+        return undefined;
+    }
+    MonacoEditor.get = get;
+    function findByDocument(manager, document) {
+        return getAll(manager).filter(candidate => candidate.documents.has(document));
+    }
+    MonacoEditor.findByDocument = findByDocument;
+    function getWidgetFor(manager, control) {
+        if (!control) {
+            return undefined;
+        }
+        return manager.all.find(widget => {
+            const candidate = get(widget);
+            return candidate && candidate.getControl() === control;
+        });
+    }
+    MonacoEditor.getWidgetFor = getWidgetFor;
+    function createReadOnlyOptions(readOnly) {
+        if (typeof readOnly === 'boolean') {
+            return { readOnly, readOnlyMessage: undefined };
+        }
+        if (readOnly) {
+            return { readOnly: true, readOnlyMessage: readOnly };
+        }
+        return {};
+    }
+    MonacoEditor.createReadOnlyOptions = createReadOnlyOptions;
+})(MonacoEditor || (exports.MonacoEditor = MonacoEditor = {}));
+// adapted from https://github.com/microsoft/vscode/blob/0bd70d48ad8b3e2fb1922aa54f87c786ff2b4bd8/src/vs/editor/browser/widget/codeEditor/embeddedCodeEditorWidget.ts
+// This class reproduces the logic in EmbeddedCodeEditorWidget but extends StandaloneCodeEditor rather than CodeEditorWidget.
+let EmbeddedCodeEditor = class EmbeddedCodeEditor extends standaloneCodeEditor_1.StandaloneCodeEditor {
+    constructor(domElement, options, parentEditor, instantiationService, codeEditorService, commandService, contextKeyService, keybindingService, themeService, notificationService, accessibilityService, languageConfigurationService, languageFeaturesService, hoverService) {
+        super(domElement, { ...parentEditor.getRawOptions(), overflowWidgetsDomNode: parentEditor.getOverflowWidgetsDomNode() }, instantiationService, codeEditorService, commandService, contextKeyService, hoverService, keybindingService, themeService, notificationService, accessibilityService, languageConfigurationService, languageFeaturesService);
+        this._parentEditor = parentEditor;
+        this._overwriteOptions = options;
+        // Overwrite parent's options
+        super.updateOptions(this._overwriteOptions);
+        this._register(parentEditor.onDidChangeConfiguration((e) => this._onParentConfigurationChanged(e)));
+    }
+    getParentEditor() {
+        return this._parentEditor;
+    }
+    _onParentConfigurationChanged(e) {
+        super.updateOptions(this._parentEditor.getRawOptions());
+        super.updateOptions(this._overwriteOptions);
+    }
+    updateOptions(newOptions) {
+        objects.mixin(this._overwriteOptions, newOptions, true);
+        super.updateOptions(this._overwriteOptions);
+    }
+};
+EmbeddedCodeEditor = tslib_1.__decorate([
+    tslib_1.__param(3, instantiation_1.IInstantiationService),
+    tslib_1.__param(4, codeEditorService_1.ICodeEditorService),
+    tslib_1.__param(5, commands_1.ICommandService),
+    tslib_1.__param(6, contextkey_1.IContextKeyService),
+    tslib_1.__param(7, keybinding_1.IKeybindingService),
+    tslib_1.__param(8, themeService_1.IThemeService),
+    tslib_1.__param(9, notification_1.INotificationService),
+    tslib_1.__param(10, accessibility_1.IAccessibilityService),
+    tslib_1.__param(11, languageConfigurationRegistry_1.ILanguageConfigurationService),
+    tslib_1.__param(12, languageFeatures_1.ILanguageFeaturesService),
+    tslib_1.__param(13, hover_1.IHoverService),
+    tslib_1.__metadata("design:paramtypes", [HTMLElement, Object, Object, Object, Object, Object, Object, Object, Object, Object, Object, Object, Object, Object])
+], EmbeddedCodeEditor);
+//# sourceMappingURL=monaco-editor.js.map