@codingame/monaco-vscode-api 1.85.0-next.2 → 1.85.1

package/vscode/src/vs/workbench/contrib/inlineChat/browser/utils.js

@@ -0,0 +1,19 @@
+import { LineRange } from 'monaco-editor/esm/vs/editor/common/core/lineRange.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+function invertLineRange(range, model) {
+    if (range.isEmpty) {
+        return [];
+    }
+    const result = [];
+    if (range.startLineNumber > 1) {
+        result.push(( new LineRange(1, range.startLineNumber)));
+    }
+    if (range.endLineNumberExclusive < model.getLineCount() + 1) {
+        result.push(( new LineRange(range.endLineNumberExclusive, model.getLineCount() + 1)));
+    }
+    return result.filter(r => !r.isEmpty);
+}
+function lineRangeAsRange(r) {
+    return ( new Range(r.startLineNumber, 1, r.endLineNumberExclusive - 1, 1));
+}
+export { invertLineRange, lineRangeAsRange };

package/vscode/src/vs/workbench/contrib/inlineChat/common/inlineChat.js

@@ -1,17 +1,136 @@
 import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
 import { Extensions as Extensions$1 } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
 import { registerColor, editorWidgetBackground, editorWidgetBorder, widgetShadow, editorHoverHighlight, focusBorder, inputPlaceholderForeground, inputBackground, transparent, diffInserted, diffRemoved } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
 import { Extensions } from '../../../common/configuration.js';
 const IInlineChatService = ( createDecorator('IInlineChatService'));
-MenuId.for('inlineChatWidget');
-MenuId.for('inlineChatWidget.markdownMessage');
-MenuId.for('inlineChatWidget.status');
-MenuId.for('inlineChatWidget.feedback');
-MenuId.for('inlineChatWidget.undo');
-MenuId.for('inlineChatWidget.toggle');
+const INLINE_CHAT_ID = 'interactiveEditor';
+const INTERACTIVE_EDITOR_ACCESSIBILITY_HELP_ID = 'interactiveEditorAccessiblityHelp';
+const INLINE_CHAT_DECORATIONS_ID = 'interactiveEditorDecorations';
+const CTX_INLINE_CHAT_HAS_PROVIDER = ( new RawContextKey('inlineChatHasProvider', false, ( localizeWithPath(
+    'vs/workbench/contrib/inlineChat/common/inlineChat',
+    'inlineChatHasProvider',
+    "Whether a provider for interactive editors exists"
+))));
+const CTX_INLINE_CHAT_VISIBLE = ( new RawContextKey('inlineChatVisible', false, ( localizeWithPath(
+    'vs/workbench/contrib/inlineChat/common/inlineChat',
+    'inlineChatVisible',
+    "Whether the interactive editor input is visible"
+))));
+const CTX_INLINE_CHAT_FOCUSED = ( new RawContextKey('inlineChatFocused', false, ( localizeWithPath(
+    'vs/workbench/contrib/inlineChat/common/inlineChat',
+    'inlineChatFocused',
+    "Whether the interactive editor input is focused"
+))));
+const CTX_INLINE_CHAT_RESPONSE_FOCUSED = ( new RawContextKey('inlineChatResponseFocused', false, ( localizeWithPath(
+    'vs/workbench/contrib/inlineChat/common/inlineChat',
+    'inlineChatResponseFocused',
+    "Whether the interactive widget's response is focused"
+))));
+const CTX_INLINE_CHAT_EMPTY = ( new RawContextKey('inlineChatEmpty', false, ( localizeWithPath(
+    'vs/workbench/contrib/inlineChat/common/inlineChat',
+    'inlineChatEmpty',
+    "Whether the interactive editor input is empty"
+))));
+const CTX_INLINE_CHAT_INNER_CURSOR_FIRST = ( new RawContextKey('inlineChatInnerCursorFirst', false, ( localizeWithPath(
+    'vs/workbench/contrib/inlineChat/common/inlineChat',
+    'inlineChatInnerCursorFirst',
+    "Whether the cursor of the iteractive editor input is on the first line"
+))));
+const CTX_INLINE_CHAT_INNER_CURSOR_LAST = ( new RawContextKey('inlineChatInnerCursorLast', false, ( localizeWithPath(
+    'vs/workbench/contrib/inlineChat/common/inlineChat',
+    'inlineChatInnerCursorLast',
+    "Whether the cursor of the iteractive editor input is on the last line"
+))));
+const CTX_INLINE_CHAT_INNER_CURSOR_START = ( new RawContextKey('inlineChatInnerCursorStart', false, ( localizeWithPath(
+    'vs/workbench/contrib/inlineChat/common/inlineChat',
+    'inlineChatInnerCursorStart',
+    "Whether the cursor of the iteractive editor input is on the start of the input"
+))));
+const CTX_INLINE_CHAT_INNER_CURSOR_END = ( new RawContextKey('inlineChatInnerCursorEnd', false, ( localizeWithPath(
+    'vs/workbench/contrib/inlineChat/common/inlineChat',
+    'inlineChatInnerCursorEnd',
+    "Whether the cursor of the iteractive editor input is on the end of the input"
+))));
+const CTX_INLINE_CHAT_MESSAGE_CROP_STATE = ( new RawContextKey('inlineChatMarkdownMessageCropState', 'not_cropped', ( localizeWithPath(
+    'vs/workbench/contrib/inlineChat/common/inlineChat',
+    'inlineChatMarkdownMessageCropState',
+    "Whether the interactive editor message is cropped, not cropped or expanded"
+))));
+const CTX_INLINE_CHAT_OUTER_CURSOR_POSITION = ( new RawContextKey('inlineChatOuterCursorPosition', '', ( localizeWithPath(
+    'vs/workbench/contrib/inlineChat/common/inlineChat',
+    'inlineChatOuterCursorPosition',
+    "Whether the cursor of the outer editor is above or below the interactive editor input"
+))));
+const CTX_INLINE_CHAT_HAS_ACTIVE_REQUEST = ( new RawContextKey('inlineChatHasActiveRequest', false, ( localizeWithPath(
+    'vs/workbench/contrib/inlineChat/common/inlineChat',
+    'inlineChatHasActiveRequest',
+    "Whether interactive editor has an active request"
+))));
+const CTX_INLINE_CHAT_HAS_STASHED_SESSION = ( new RawContextKey('inlineChatHasStashedSession', false, ( localizeWithPath(
+    'vs/workbench/contrib/inlineChat/common/inlineChat',
+    'inlineChatHasStashedSession',
+    "Whether interactive editor has kept a session for quick restore"
+))));
+const CTX_INLINE_CHAT_LAST_RESPONSE_TYPE = ( new RawContextKey('inlineChatLastResponseType', undefined, ( localizeWithPath(
+    'vs/workbench/contrib/inlineChat/common/inlineChat',
+    'inlineChatResponseType',
+    "What type was the last response of the current interactive editor session"
+))));
+const CTX_INLINE_CHAT_RESPONSE_TYPES = ( new RawContextKey('inlineChatResponseTypes', undefined, ( localizeWithPath(
+    'vs/workbench/contrib/inlineChat/common/inlineChat',
+    'inlineChatResponseTypes',
+    "What type was the responses have been receieved"
+))));
+const CTX_INLINE_CHAT_DID_EDIT = ( new RawContextKey('inlineChatDidEdit', undefined, ( localizeWithPath(
+    'vs/workbench/contrib/inlineChat/common/inlineChat',
+    'inlineChatDidEdit',
+    "Whether interactive editor did change any code"
+))));
+const CTX_INLINE_CHAT_USER_DID_EDIT = ( new RawContextKey('inlineChatUserDidEdit', undefined, ( localizeWithPath(
+    'vs/workbench/contrib/inlineChat/common/inlineChat',
+    'inlineChatUserDidEdit',
+    "Whether the user did changes ontop of the inline chat"
+))));
+const CTX_INLINE_CHAT_LAST_FEEDBACK = ( new RawContextKey('inlineChatLastFeedbackKind', '', ( localizeWithPath(
+    'vs/workbench/contrib/inlineChat/common/inlineChat',
+    'inlineChatLastFeedbackKind',
+    "The last kind of feedback that was provided"
+))));
+const CTX_INLINE_CHAT_SUPPORT_ISSUE_REPORTING = ( new RawContextKey('inlineChatSupportIssueReporting', false, ( localizeWithPath(
+    'vs/workbench/contrib/inlineChat/common/inlineChat',
+    'inlineChatSupportIssueReporting',
+    "Whether the interactive editor supports issue reporting"
+))));
+const CTX_INLINE_CHAT_DOCUMENT_CHANGED = ( new RawContextKey('inlineChatDocumentChanged', false, ( localizeWithPath(
+    'vs/workbench/contrib/inlineChat/common/inlineChat',
+    'inlineChatDocumentChanged',
+    "Whether the document has changed concurrently"
+))));
+const CTX_INLINE_CHAT_CHANGE_HAS_DIFF = ( new RawContextKey('inlineChatChangeHasDiff', false, ( localizeWithPath(
+    'vs/workbench/contrib/inlineChat/common/inlineChat',
+    'inlineChatChangeHasDiff',
+    "Whether the current change supports showing a diff"
+))));
+const CTX_INLINE_CHAT_CHANGE_SHOWS_DIFF = ( new RawContextKey('inlineChatChangeShowsDiff', false, ( localizeWithPath(
+    'vs/workbench/contrib/inlineChat/common/inlineChat',
+    'inlineChatChangeShowsDiff',
+    "Whether the current change showing a diff"
+))));
+const CTX_INLINE_CHAT_EDIT_MODE = ( new RawContextKey('config.inlineChat.mode', "live" ));
+const CTX_INLINE_CHAT_TOOLBAR_ICON_ENABLED = ( new RawContextKey('config.inlineChat.showToolbarIcon', false));
+const ACTION_ACCEPT_CHANGES = 'interactive.acceptChanges';
+const ACTION_REGENERATE_RESPONSE = 'inlineChat.regenerate';
+const ACTION_VIEW_IN_CHAT = 'inlineChat.viewInChat';
+const MENU_INLINE_CHAT_WIDGET = MenuId.for('inlineChatWidget');
+const MENU_INLINE_CHAT_WIDGET_MARKDOWN_MESSAGE = MenuId.for('inlineChatWidget.markdownMessage');
+const MENU_INLINE_CHAT_WIDGET_STATUS = MenuId.for('inlineChatWidget.status');
+const MENU_INLINE_CHAT_WIDGET_FEEDBACK = MenuId.for('inlineChatWidget.feedback');
+const MENU_INLINE_CHAT_WIDGET_DISCARD = MenuId.for('inlineChatWidget.undo');
+const MENU_INLINE_CHAT_WIDGET_TOGGLE = MenuId.for('inlineChatWidget.toggle');
 registerColor('inlineChat.background', { dark: editorWidgetBackground, light: editorWidgetBackground, hcDark: editorWidgetBackground, hcLight: editorWidgetBackground }, ( localizeWithPath(
     'vs/workbench/contrib/inlineChat/common/inlineChat',
     'inlineChat.background',
@@ -27,7 +146,7 @@ registerColor('inlineChat.shadow', { dark: widgetShadow, light: widgetShadow, hc
     'inlineChat.shadow',
     "Shadow color of the interactive editor widget"
 )));
-registerColor('inlineChat.regionHighlight', { dark: editorHoverHighlight, light: editorHoverHighlight, hcDark: editorHoverHighlight, hcLight: editorHoverHighlight }, ( localizeWithPath(
+const inlineChatRegionHighlight = registerColor('inlineChat.regionHighlight', { dark: editorHoverHighlight, light: editorHoverHighlight, hcDark: editorHoverHighlight, hcLight: editorHoverHighlight }, ( localizeWithPath(
     'vs/workbench/contrib/inlineChat/common/inlineChat',
     'inlineChat.regionHighlight',
     "Background highlighting of the current interactive region. Must be transparent."
@@ -52,12 +171,12 @@ registerColor('inlineChatInput.background', { dark: inputBackground, light: inpu
     'inlineChatInput.background',
     "Background color of the interactive editor input"
 )));
-registerColor('inlineChatDiff.inserted', { dark: ( transparent(diffInserted, .5)), light: ( transparent(diffInserted, .5)), hcDark: ( transparent(diffInserted, .5)), hcLight: ( transparent(diffInserted, .5)) }, ( localizeWithPath(
+const inlineChatDiffInserted = registerColor('inlineChatDiff.inserted', { dark: ( transparent(diffInserted, .5)), light: ( transparent(diffInserted, .5)), hcDark: ( transparent(diffInserted, .5)), hcLight: ( transparent(diffInserted, .5)) }, ( localizeWithPath(
     'vs/workbench/contrib/inlineChat/common/inlineChat',
     'inlineChatDiff.inserted',
     "Background color of inserted text in the interactive editor input"
 )));
-registerColor('inlineChatDiff.removed', { dark: ( transparent(diffRemoved, .5)), light: ( transparent(diffRemoved, .5)), hcDark: ( transparent(diffRemoved, .5)), hcLight: ( transparent(diffRemoved, .5)) }, ( localizeWithPath(
+const inlineChatDiffRemoved = registerColor('inlineChatDiff.removed', { dark: ( transparent(diffRemoved, .5)), light: ( transparent(diffRemoved, .5)), hcDark: ( transparent(diffRemoved, .5)), hcLight: ( transparent(diffRemoved, .5)) }, ( localizeWithPath(
     'vs/workbench/contrib/inlineChat/common/inlineChat',
     'inlineChatDiff.removed',
     "Background color of removed text in the interactive editor input"
@@ -144,4 +263,4 @@ registerColor('inlineChatDiff.removed', { dark: ( transparent(diffRemoved, .5)),
         }
     }
 });
-export { IInlineChatService };
+export { ACTION_ACCEPT_CHANGES, ACTION_REGENERATE_RESPONSE, ACTION_VIEW_IN_CHAT, CTX_INLINE_CHAT_CHANGE_HAS_DIFF, CTX_INLINE_CHAT_CHANGE_SHOWS_DIFF, CTX_INLINE_CHAT_DID_EDIT, CTX_INLINE_CHAT_DOCUMENT_CHANGED, CTX_INLINE_CHAT_EDIT_MODE, CTX_INLINE_CHAT_EMPTY, CTX_INLINE_CHAT_FOCUSED, CTX_INLINE_CHAT_HAS_ACTIVE_REQUEST, CTX_INLINE_CHAT_HAS_PROVIDER, CTX_INLINE_CHAT_HAS_STASHED_SESSION, CTX_INLINE_CHAT_INNER_CURSOR_END, CTX_INLINE_CHAT_INNER_CURSOR_FIRST, CTX_INLINE_CHAT_INNER_CURSOR_LAST, CTX_INLINE_CHAT_INNER_CURSOR_START, CTX_INLINE_CHAT_LAST_FEEDBACK, CTX_INLINE_CHAT_LAST_RESPONSE_TYPE, CTX_INLINE_CHAT_MESSAGE_CROP_STATE, CTX_INLINE_CHAT_OUTER_CURSOR_POSITION, CTX_INLINE_CHAT_RESPONSE_FOCUSED, CTX_INLINE_CHAT_RESPONSE_TYPES, CTX_INLINE_CHAT_SUPPORT_ISSUE_REPORTING, CTX_INLINE_CHAT_TOOLBAR_ICON_ENABLED, CTX_INLINE_CHAT_USER_DID_EDIT, CTX_INLINE_CHAT_VISIBLE, IInlineChatService, INLINE_CHAT_DECORATIONS_ID, INLINE_CHAT_ID, INTERACTIVE_EDITOR_ACCESSIBILITY_HELP_ID, MENU_INLINE_CHAT_WIDGET, MENU_INLINE_CHAT_WIDGET_DISCARD, MENU_INLINE_CHAT_WIDGET_FEEDBACK, MENU_INLINE_CHAT_WIDGET_MARKDOWN_MESSAGE, MENU_INLINE_CHAT_WIDGET_STATUS, MENU_INLINE_CHAT_WIDGET_TOGGLE, inlineChatDiffInserted, inlineChatDiffRemoved, inlineChatRegionHighlight };

package/vscode/src/vs/workbench/contrib/markdown/browser/markdownDocumentRenderer.js

@@ -0,0 +1,205 @@
+import { hookDomPurifyHrefAndSrcSanitizer, basicMarkupHtmlTags } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import * as dompurify from 'monaco-editor/esm/vs/base/browser/dompurify/dompurify.js';
+import { allowedMarkdownAttr } from 'monaco-editor/esm/vs/base/browser/markdownRenderer.js';
+import { marked } from 'monaco-editor/esm/vs/base/common/marked/marked.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { tokenizeToString } from 'monaco-editor/esm/vs/editor/common/languages/textToHtmlTokenizer.js';
+import { escape } from 'monaco-editor/esm/vs/base/common/strings.js';
+const DEFAULT_MARKDOWN_STYLES = `
+body {
+	padding: 10px 20px;
+	line-height: 22px;
+	max-width: 882px;
+	margin: 0 auto;
+}
+
+body *:last-child {
+	margin-bottom: 0;
+}
+
+img {
+	max-width: 100%;
+	max-height: 100%;
+}
+
+a {
+	text-decoration: none;
+}
+
+a:hover {
+	text-decoration: underline;
+}
+
+a:focus,
+input:focus,
+select:focus,
+textarea:focus {
+	outline: 1px solid -webkit-focus-ring-color;
+	outline-offset: -1px;
+}
+
+hr {
+	border: 0;
+	height: 2px;
+	border-bottom: 2px solid;
+}
+
+h1 {
+	padding-bottom: 0.3em;
+	line-height: 1.2;
+	border-bottom-width: 1px;
+	border-bottom-style: solid;
+}
+
+h1, h2, h3 {
+	font-weight: normal;
+}
+
+table {
+	border-collapse: collapse;
+}
+
+th {
+	text-align: left;
+	border-bottom: 1px solid;
+}
+
+th,
+td {
+	padding: 5px 10px;
+}
+
+table > tbody > tr + tr > td {
+	border-top-width: 1px;
+	border-top-style: solid;
+}
+
+blockquote {
+	margin: 0 7px 0 5px;
+	padding: 0 16px 0 10px;
+	border-left-width: 5px;
+	border-left-style: solid;
+}
+
+code {
+	font-family: "SF Mono", Monaco, Menlo, Consolas, "Ubuntu Mono", "Liberation Mono", "DejaVu Sans Mono", "Courier New", monospace;
+}
+
+pre {
+	padding: 16px;
+	border-radius: 3px;
+	overflow: auto;
+}
+
+pre code {
+	font-family: var(--vscode-editor-font-family);
+	font-weight: var(--vscode-editor-font-weight);
+	font-size: var(--vscode-editor-font-size);
+	line-height: 1.5;
+	color: var(--vscode-editor-foreground);
+	tab-size: 4;
+}
+
+.monaco-tokenized-source {
+	white-space: pre;
+}
+
+/** Theming */
+
+.pre {
+	background-color: var(--vscode-textCodeBlock-background);
+}
+
+.vscode-high-contrast h1 {
+	border-color: rgb(0, 0, 0);
+}
+
+.vscode-light th {
+	border-color: rgba(0, 0, 0, 0.69);
+}
+
+.vscode-dark th {
+	border-color: rgba(255, 255, 255, 0.69);
+}
+
+.vscode-light h1,
+.vscode-light hr,
+.vscode-light td {
+	border-color: rgba(0, 0, 0, 0.18);
+}
+
+.vscode-dark h1,
+.vscode-dark hr,
+.vscode-dark td {
+	border-color: rgba(255, 255, 255, 0.18);
+}
+
+@media (forced-colors: active) and (prefers-color-scheme: light){
+	body {
+		forced-color-adjust: none;
+	}
+}
+
+@media (forced-colors: active) and (prefers-color-scheme: dark){
+	body {
+		forced-color-adjust: none;
+	}
+}
+`;
+const allowedProtocols = [Schemas.http, Schemas.https, Schemas.command];
+function sanitize(documentContent, allowUnknownProtocols) {
+    const hook = hookDomPurifyHrefAndSrcSanitizer(allowedProtocols, true);
+    try {
+        return dompurify.sanitize(documentContent, {
+            ...{
+                ALLOWED_TAGS: [
+                    ...basicMarkupHtmlTags,
+                    'checkbox',
+                    'checklist',
+                ],
+                ALLOWED_ATTR: [
+                    ...allowedMarkdownAttr,
+                    'data-command', 'name', 'id', 'role', 'tabindex',
+                    'x-dispatch',
+                    'required', 'checked', 'placeholder', 'when-checked', 'checked-on',
+                ],
+            },
+            ...(allowUnknownProtocols ? { ALLOW_UNKNOWN_PROTOCOLS: true } : {}),
+        });
+    }
+    finally {
+        hook.dispose();
+    }
+}
+async function renderMarkdownDocument(text, extensionService, languageService, shouldSanitize = true, allowUnknownProtocols = false, token) {
+    const highlight = (code, lang, callback) => {
+        if (!callback) {
+            return code;
+        }
+        if (typeof lang !== 'string') {
+            callback(null, `<code>${escape(code)}</code>`);
+            return '';
+        }
+        extensionService.whenInstalledExtensionsRegistered().then(async () => {
+            if (token?.isCancellationRequested) {
+                callback(null, '');
+                return;
+            }
+            const languageId = languageService.getLanguageIdByLanguageName(lang);
+            const html = await tokenizeToString(languageService, code, languageId);
+            callback(null, `<code>${html}</code>`);
+        });
+        return '';
+    };
+    return ( new Promise((resolve, reject) => {
+        marked(text, { highlight }, (err, value) => err ? reject(err) : resolve(value));
+    })).then(raw => {
+        if (shouldSanitize) {
+            return sanitize(raw, allowUnknownProtocols);
+        }
+        else {
+            return raw;
+        }
+    });
+}
+export { DEFAULT_MARKDOWN_STYLES, renderMarkdownDocument };

package/vscode/src/vs/workbench/contrib/mergeEditor/browser/mergeEditorInput.js

@@ -0,0 +1,150 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { assertFn } from 'monaco-editor/esm/vs/base/common/assert.js';
+import { autorun } from 'monaco-editor/esm/vs/base/common/observable.js';
+import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { isDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { DEFAULT_EDITOR_ASSOCIATION, isResourceMergeEditorInput } from '../../../common/editor.js';
+import { AbstractTextResourceEditorInput } from '../../../common/editor/textResourceEditorInput.js';
+import { TempFileMergeEditorModeFactory, WorkspaceMergeEditorModeFactory } from './mergeEditorInputModel.js';
+import { MergeEditorTelemetry } from './telemetry.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { IFilesConfigurationService } from '../../../services/filesConfiguration/common/filesConfigurationService.js';
+import { ITextFileService } from '../../../services/textfile/common/textfiles.js';
+var MergeEditorInput_1;
+class MergeEditorInputData {
+    constructor(uri, title, detail, description) {
+        this.uri = uri;
+        this.title = title;
+        this.detail = detail;
+        this.description = description;
+    }
+}
+let MergeEditorInput = class MergeEditorInput extends AbstractTextResourceEditorInput {
+    static { MergeEditorInput_1 = this; }
+    static { this.ID = 'mergeEditor.Input'; }
+    get useWorkingCopy() {
+        return this.configurationService.getValue('mergeEditor.useWorkingCopy') ?? false;
+    }
+    constructor(base, input1, input2, result, _instaService, editorService, textFileService, labelService, fileService, configurationService, filesConfigurationService) {
+        super(result, undefined, editorService, textFileService, labelService, fileService, filesConfigurationService);
+        this.base = base;
+        this.input1 = input1;
+        this.input2 = input2;
+        this.result = result;
+        this._instaService = _instaService;
+        this.configurationService = configurationService;
+        this.closeHandler = {
+            showConfirm: () => this._inputModel?.shouldConfirmClose() ?? false,
+            confirm: async (editors) => {
+                assertFn(() => editors.every(e => e.editor instanceof MergeEditorInput_1));
+                const inputModels = ( editors.map(e => e.editor._inputModel)).filter(isDefined);
+                return await this._inputModel.confirmClose(inputModels);
+            },
+        };
+        this.mergeEditorModeFactory = this._instaService.createInstance(this.useWorkingCopy
+            ? TempFileMergeEditorModeFactory
+            : WorkspaceMergeEditorModeFactory, this._instaService.createInstance(MergeEditorTelemetry));
+    }
+    dispose() {
+        super.dispose();
+    }
+    get typeId() {
+        return MergeEditorInput_1.ID;
+    }
+    get editorId() {
+        return DEFAULT_EDITOR_ASSOCIATION.id;
+    }
+    get capabilities() {
+        let capabilities = super.capabilities | 256 ;
+        if (this.useWorkingCopy) {
+            capabilities |= 4 ;
+        }
+        return capabilities;
+    }
+    getName() {
+        return ( localizeWithPath(
+            'vs/workbench/contrib/mergeEditor/browser/mergeEditorInput',
+            'name',
+            "Merging: {0}",
+            super.getName()
+        ));
+    }
+    async resolve() {
+        if (!this._inputModel) {
+            const inputModel = this._register(await this.mergeEditorModeFactory.createInputModel({
+                base: this.base,
+                input1: this.input1,
+                input2: this.input2,
+                result: this.result,
+            }));
+            this._inputModel = inputModel;
+            this._register(autorun(reader => {
+                inputModel.isDirty.read(reader);
+                this._onDidChangeDirty.fire();
+            }));
+            await this._inputModel.model.onInitialized;
+        }
+        return this._inputModel;
+    }
+    async accept() {
+        await this._inputModel?.accept();
+    }
+    async save(group, options) {
+        await this._inputModel?.save(options);
+        return undefined;
+    }
+    toUntyped() {
+        return {
+            input1: { resource: this.input1.uri, label: this.input1.title, description: this.input1.description, detail: this.input1.detail },
+            input2: { resource: this.input2.uri, label: this.input2.title, description: this.input2.description, detail: this.input2.detail },
+            base: { resource: this.base },
+            result: { resource: this.result },
+            options: {
+                override: this.typeId
+            }
+        };
+    }
+    matches(otherInput) {
+        if (this === otherInput) {
+            return true;
+        }
+        if (otherInput instanceof MergeEditorInput_1) {
+            return isEqual(this.base, otherInput.base)
+                && isEqual(this.input1.uri, otherInput.input1.uri)
+                && isEqual(this.input2.uri, otherInput.input2.uri)
+                && isEqual(this.result, otherInput.result);
+        }
+        if (isResourceMergeEditorInput(otherInput)) {
+            return (this.editorId === otherInput.options?.override || otherInput.options?.override === undefined)
+                && isEqual(this.base, otherInput.base.resource)
+                && isEqual(this.input1.uri, otherInput.input1.resource)
+                && isEqual(this.input2.uri, otherInput.input2.resource)
+                && isEqual(this.result, otherInput.result.resource);
+        }
+        return false;
+    }
+    async revert(group, options) {
+        return this._inputModel?.revert(options);
+    }
+    isDirty() {
+        return this._inputModel?.isDirty.get() ?? false;
+    }
+    setLanguageId(languageId, source) {
+        this._inputModel?.model.setLanguageId(languageId, source);
+    }
+};
+MergeEditorInput = MergeEditorInput_1 = ( __decorate([
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IEditorService)),
+    ( __param(6, ITextFileService)),
+    ( __param(7, ILabelService)),
+    ( __param(8, IFileService)),
+    ( __param(9, IConfigurationService)),
+    ( __param(10, IFilesConfigurationService))
+], MergeEditorInput));
+export { MergeEditorInput, MergeEditorInputData };