@codingame/monaco-vscode-api 23.2.2 → 24.1.0

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

@@ -0,0 +1,237 @@
+
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { EditorResourceAccessor, SideBySideEditor } from '../../../common/editor.js';
+import { FileChangeType } from '../../../../platform/files/common/files.js';
+import { IFileService } from '../../../../platform/files/common/files.service.js';
+import { RawContextKey, ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
+import { Disposable, MutableDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { IModelService } from '../../../../editor/common/services/model.service.js';
+import { ILanguageService } from '../../../../editor/common/languages/language.service.js';
+import { ITextFileService } from '../../../services/textfile/common/textfiles.service.js';
+import { InputFocusedContextKey } from '../../../../platform/contextkey/common/contextkeys.js';
+import { Event } from '../../../../base/common/event.js';
+import { localize } from '../../../../nls.js';
+
+var TextFileContentProvider_1;
+const VIEWLET_ID = 'workbench.view.explorer';
+const VIEW_ID = 'workbench.explorer.fileView';
+const ExplorerViewletVisibleContext = ( new RawContextKey(
+    'explorerViewletVisible',
+    true,
+    { type: 'boolean', description: ( localize(8229, "True when the EXPLORER viewlet is visible.")) }
+));
+const FoldersViewVisibleContext = ( new RawContextKey('foldersViewVisible', true, { type: 'boolean', description: ( localize(
+    8230,
+    "True when the FOLDERS view (the file tree within the explorer view container) is visible."
+)) }));
+const ExplorerFolderContext = ( new RawContextKey(
+    'explorerResourceIsFolder',
+    false,
+    { type: 'boolean', description: ( localize(8231, "True when the focused item in the EXPLORER is a folder.")) }
+));
+const ExplorerResourceReadonlyContext = ( new RawContextKey(
+    'explorerResourceReadonly',
+    false,
+    { type: 'boolean', description: ( localize(8232, "True when the focused item in the EXPLORER is read-only.")) }
+));
+const ExplorerResourceWritableContext = ( ExplorerResourceReadonlyContext.toNegated());
+const ExplorerResourceParentReadOnlyContext = ( new RawContextKey(
+    'explorerResourceParentReadonly',
+    false,
+    { type: 'boolean', description: ( localize(8233, "True when the focused item in the EXPLORER's parent is read-only.")) }
+));
+const ExplorerResourceAvailableEditorIdsContext = ( new RawContextKey('explorerResourceAvailableEditorIds', ''));
+const ExplorerRootContext = ( new RawContextKey(
+    'explorerResourceIsRoot',
+    false,
+    { type: 'boolean', description: ( localize(8234, "True when the focused item in the EXPLORER is a root folder.")) }
+));
+const ExplorerResourceCut = ( new RawContextKey(
+    'explorerResourceCut',
+    false,
+    { type: 'boolean', description: ( localize(8235, "True when an item in the EXPLORER has been cut for cut and paste.")) }
+));
+const ExplorerResourceMoveableToTrash = ( new RawContextKey(
+    'explorerResourceMoveableToTrash',
+    false,
+    { type: 'boolean', description: ( localize(8236, "True when the focused item in the EXPLORER can be moved to trash.")) }
+));
+const FilesExplorerFocusedContext = ( new RawContextKey('filesExplorerFocus', true, { type: 'boolean', description: ( localize(8237, "True when the focus is inside the EXPLORER view.")) }));
+const OpenEditorsFocusedContext = ( new RawContextKey('openEditorsFocus', true, { type: 'boolean', description: ( localize(8238, "True when the focus is inside the OPEN EDITORS view.")) }));
+const ExplorerFocusedContext = ( new RawContextKey(
+    'explorerViewletFocus',
+    true,
+    { type: 'boolean', description: ( localize(8239, "True when the focus is inside the EXPLORER viewlet.")) }
+));
+const ExplorerFindProviderActive = ( new RawContextKey(
+    'explorerFindProviderActive',
+    false,
+    { type: 'boolean', description: ( localize(8240, "True when the explorer tree is using the explorer find provider.")) }
+));
+const ExplorerCompressedFocusContext = ( new RawContextKey(
+    'explorerViewletCompressedFocus',
+    true,
+    { type: 'boolean', description: ( localize(8241, "True when the focused item in the EXPLORER view is a compact item.")) }
+));
+const ExplorerCompressedFirstFocusContext = ( new RawContextKey(
+    'explorerViewletCompressedFirstFocus',
+    true,
+    { type: 'boolean', description: ( localize(
+        8242,
+        "True when the focus is inside a compact item's first part in the EXPLORER view."
+    )) }
+));
+const ExplorerCompressedLastFocusContext = ( new RawContextKey(
+    'explorerViewletCompressedLastFocus',
+    true,
+    { type: 'boolean', description: ( localize(
+        8243,
+        "True when the focus is inside a compact item's last part in the EXPLORER view."
+    )) }
+));
+const ViewHasSomeCollapsibleRootItemContext = ( new RawContextKey(
+    'viewHasSomeCollapsibleItem',
+    false,
+    { type: 'boolean', description: ( localize(
+        8244,
+        "True when a workspace in the EXPLORER view has some collapsible root child."
+    )) }
+));
+const FilesExplorerFocusCondition = ( ContextKeyExpr.and(
+    FoldersViewVisibleContext,
+    FilesExplorerFocusedContext,
+    ContextKeyExpr.not(InputFocusedContextKey)
+));
+const ExplorerFocusCondition = ( ContextKeyExpr.and(
+    FoldersViewVisibleContext,
+    ExplorerFocusedContext,
+    ContextKeyExpr.not(InputFocusedContextKey)
+));
+const TEXT_FILE_EDITOR_ID = 'workbench.editors.files.textFileEditor';
+const FILE_EDITOR_INPUT_ID = 'workbench.editors.files.fileEditorInput';
+const BINARY_FILE_EDITOR_ID = 'workbench.editors.files.binaryFileEditor';
+const BINARY_TEXT_FILE_MODE = 'code-text-binary';
+var SortOrder;
+(function (SortOrder) {
+    SortOrder["Default"] = "default";
+    SortOrder["Mixed"] = "mixed";
+    SortOrder["FilesFirst"] = "filesFirst";
+    SortOrder["Type"] = "type";
+    SortOrder["Modified"] = "modified";
+    SortOrder["FoldersNestsFiles"] = "foldersNestsFiles";
+})(SortOrder || (SortOrder = {}));
+var UndoConfirmLevel;
+(function (UndoConfirmLevel) {
+    UndoConfirmLevel["Verbose"] = "verbose";
+    UndoConfirmLevel["Default"] = "default";
+    UndoConfirmLevel["Light"] = "light";
+})(UndoConfirmLevel || (UndoConfirmLevel = {}));
+var LexicographicOptions;
+(function (LexicographicOptions) {
+    LexicographicOptions["Default"] = "default";
+    LexicographicOptions["Upper"] = "upper";
+    LexicographicOptions["Lower"] = "lower";
+    LexicographicOptions["Unicode"] = "unicode";
+})(LexicographicOptions || (LexicographicOptions = {}));
+let TextFileContentProvider = TextFileContentProvider_1 = class TextFileContentProvider extends Disposable {
+    constructor(textFileService, fileService, languageService, modelService) {
+        super();
+        this.textFileService = textFileService;
+        this.fileService = fileService;
+        this.languageService = languageService;
+        this.modelService = modelService;
+        this.fileWatcherDisposable = this._register(( new MutableDisposable()));
+    }
+    static async open(resource, scheme, label, editorService, options) {
+        await editorService.openEditor({
+            original: { resource: TextFileContentProvider_1.resourceToTextFile(scheme, resource) },
+            modified: { resource },
+            label,
+            options
+        });
+    }
+    static resourceToTextFile(scheme, resource) {
+        return resource.with({ scheme, query: JSON.stringify({ scheme: resource.scheme, query: resource.query }) });
+    }
+    static textFileToResource(resource) {
+        const { scheme, query } = JSON.parse(resource.query);
+        return resource.with({ scheme, query });
+    }
+    async provideTextContent(resource) {
+        if (!resource.query) {
+            return null;
+        }
+        const savedFileResource = TextFileContentProvider_1.textFileToResource(resource);
+        const codeEditorModel = await this.resolveEditorModel(resource);
+        if (!this.fileWatcherDisposable.value) {
+            const disposables = ( new DisposableStore());
+            this.fileWatcherDisposable.value = disposables;
+            disposables.add(this.fileService.onDidFilesChange(changes => {
+                if (changes.contains(savedFileResource, FileChangeType.UPDATED)) {
+                    this.resolveEditorModel(resource, false );
+                }
+            }));
+            if (codeEditorModel) {
+                disposables.add(Event.once(codeEditorModel.onWillDispose)(() => this.fileWatcherDisposable.clear()));
+            }
+        }
+        return codeEditorModel;
+    }
+    async resolveEditorModel(resource, createAsNeeded = true) {
+        const savedFileResource = TextFileContentProvider_1.textFileToResource(resource);
+        const content = await this.textFileService.readStream(savedFileResource);
+        let codeEditorModel = this.modelService.getModel(resource);
+        if (codeEditorModel) {
+            this.modelService.updateModel(codeEditorModel, content.value);
+        }
+        else if (createAsNeeded) {
+            const textFileModel = this.modelService.getModel(savedFileResource);
+            let languageSelector;
+            if (textFileModel) {
+                languageSelector = this.languageService.createById(textFileModel.getLanguageId());
+            }
+            else {
+                languageSelector = this.languageService.createByFilepathOrFirstLine(savedFileResource);
+            }
+            codeEditorModel = this.modelService.createModel(content.value, languageSelector, resource);
+        }
+        return codeEditorModel;
+    }
+};
+TextFileContentProvider = TextFileContentProvider_1 = ( __decorate([
+    ( __param(0, ITextFileService)),
+    ( __param(1, IFileService)),
+    ( __param(2, ILanguageService)),
+    ( __param(3, IModelService))
+], TextFileContentProvider));
+class OpenEditor {
+    static { this.COUNTER = 0; }
+    constructor(_editor, _group) {
+        this._editor = _editor;
+        this._group = _group;
+        this.id = OpenEditor.COUNTER++;
+    }
+    get editor() {
+        return this._editor;
+    }
+    get group() {
+        return this._group;
+    }
+    get groupId() {
+        return this._group.id;
+    }
+    getId() {
+        return `openeditor:${this.groupId}:${this.id}`;
+    }
+    isPreview() {
+        return !this._group.isPinned(this.editor);
+    }
+    isSticky() {
+        return this._group.isSticky(this.editor);
+    }
+    getResource() {
+        return EditorResourceAccessor.getOriginalUri(this.editor, { supportSideBySide: SideBySideEditor.PRIMARY });
+    }
+}
+
+export { BINARY_FILE_EDITOR_ID, BINARY_TEXT_FILE_MODE, ExplorerCompressedFirstFocusContext, ExplorerCompressedFocusContext, ExplorerCompressedLastFocusContext, ExplorerFindProviderActive, ExplorerFocusCondition, ExplorerFocusedContext, ExplorerFolderContext, ExplorerResourceAvailableEditorIdsContext, ExplorerResourceCut, ExplorerResourceMoveableToTrash, ExplorerResourceParentReadOnlyContext, ExplorerResourceReadonlyContext, ExplorerResourceWritableContext, ExplorerRootContext, ExplorerViewletVisibleContext, FILE_EDITOR_INPUT_ID, FilesExplorerFocusCondition, FilesExplorerFocusedContext, FoldersViewVisibleContext, LexicographicOptions, OpenEditor, OpenEditorsFocusedContext, SortOrder, TEXT_FILE_EDITOR_ID, TextFileContentProvider, UndoConfirmLevel, VIEWLET_ID, VIEW_ID, ViewHasSomeCollapsibleRootItemContext };

package/vscode/src/vs/workbench/contrib/folding/browser/folding.contribution.js

@@ -32,8 +32,8 @@ let DefaultFoldingRangeProvider = class DefaultFoldingRangeProvider extends Disp
         DefaultFoldingRangeProvider_1.extensionItemLabels.length = 0;
         DefaultFoldingRangeProvider_1.extensionDescriptions.length = 0;
         DefaultFoldingRangeProvider_1.extensionIds.push(null);
-        DefaultFoldingRangeProvider_1.extensionItemLabels.push(( localize(8110, 'All')));
-        DefaultFoldingRangeProvider_1.extensionDescriptions.push(( localize(8111, "All active folding range providers")));
+        DefaultFoldingRangeProvider_1.extensionItemLabels.push(( localize(8245, 'All')));
+        DefaultFoldingRangeProvider_1.extensionDescriptions.push(( localize(8246, "All active folding range providers")));
         const languageExtensions = [];
         const otherExtensions = [];
         for (const extension of this._extensionService.extensions) {
@@ -75,7 +75,7 @@ DefaultFoldingRangeProvider = DefaultFoldingRangeProvider_1 = ( __decorate([
     properties: {
         [DefaultFoldingRangeProvider.configName]: {
             description: ( localize(
-                8112,
+                8247,
                 "Defines a default folding range provider that takes precedence over all other folding range providers. Must be the identifier of an extension contributing a folding range provider."
             )),
             type: ['string', 'null'],

package/vscode/src/vs/workbench/contrib/format/browser/formatActionsMultiple.js

@@ -57,13 +57,36 @@ let DefaultFormatter = class DefaultFormatter extends Disposable {
         this._store.add(_editorService.onDidActiveEditorChange(this._updateStatus, this));
         this._store.add(_languageFeaturesService.documentFormattingEditProvider.onDidChange(this._updateStatus, this));
         this._store.add(_languageFeaturesService.documentRangeFormattingEditProvider.onDidChange(this._updateStatus, this));
+        this._store.add(_languageFeaturesService.documentFormattingEditProvider.onDidChange(this._updateConfigValues, this));
+        this._store.add(_languageFeaturesService.documentRangeFormattingEditProvider.onDidChange(this._updateConfigValues, this));
         this._store.add(_configService.onDidChangeConfiguration(e => e.affectsConfiguration(DefaultFormatter_1.configName) && this._updateStatus()));
         this._updateConfigValues();
     }
     async _updateConfigValues() {
         await this._extensionService.whenInstalledExtensionsRegistered();
         let extensions = [...this._extensionService.extensions];
+        const documentFormatters = this._languageFeaturesService.documentFormattingEditProvider.allNoModel();
+        const rangeFormatters = this._languageFeaturesService.documentRangeFormattingEditProvider.allNoModel();
+        const formatterExtensionIds = ( new Set());
+        for (const formatter of documentFormatters) {
+            if (formatter.extensionId) {
+                formatterExtensionIds.add(ExtensionIdentifier.toKey(formatter.extensionId));
+            }
+        }
+        for (const formatter of rangeFormatters) {
+            if (formatter.extensionId) {
+                formatterExtensionIds.add(ExtensionIdentifier.toKey(formatter.extensionId));
+            }
+        }
         extensions = extensions.sort((a, b) => {
+            const contributesFormatterA = ( formatterExtensionIds.has(ExtensionIdentifier.toKey(a.identifier)));
+            const contributesFormatterB = ( formatterExtensionIds.has(ExtensionIdentifier.toKey(b.identifier)));
+            if (contributesFormatterA && !contributesFormatterB) {
+                return -1;
+            }
+            else if (!contributesFormatterA && contributesFormatterB) {
+                return 1;
+            }
             const boostA = a.categories?.find(cat => cat === 'Formatters' || cat === 'Programming Languages');
             const boostB = b.categories?.find(cat => cat === 'Formatters' || cat === 'Programming Languages');
             if (boostA && !boostB) {
@@ -80,8 +103,8 @@ let DefaultFormatter = class DefaultFormatter extends Disposable {
         DefaultFormatter_1.extensionItemLabels.length = 0;
         DefaultFormatter_1.extensionDescriptions.length = 0;
         DefaultFormatter_1.extensionIds.push(null);
-        DefaultFormatter_1.extensionItemLabels.push(( localize(8113, 'None')));
-        DefaultFormatter_1.extensionDescriptions.push(( localize(8114, "None")));
+        DefaultFormatter_1.extensionItemLabels.push(( localize(8248, 'None')));
+        DefaultFormatter_1.extensionDescriptions.push(( localize(8249, "None")));
         for (const extension of extensions) {
             if (extension.main || extension.browser) {
                 DefaultFormatter_1.extensionIds.push(extension.identifier.value);
@@ -108,13 +131,13 @@ let DefaultFormatter = class DefaultFormatter extends Disposable {
                 const langName = this._languageService.getLanguageName(document.getLanguageId()) || document.getLanguageId();
                 const detail = kind === FormattingKind.File
                     ? ( localize(
-                    8115,
+                    8250,
                     "Extension '{0}' is configured as formatter but it cannot format '{1}'-files",
                     extension.displayName || extension.name,
                     langName
                 ))
                     : ( localize(
-                    8116,
+                    8251,
                     "Extension '{0}' is configured as formatter but it can only format '{1}'-files as a whole, not selections or parts of it.",
                     extension.displayName || extension.name,
                     langName
@@ -128,12 +151,12 @@ let DefaultFormatter = class DefaultFormatter extends Disposable {
         const langName = this._languageService.getLanguageName(document.getLanguageId()) || document.getLanguageId();
         const message = !defaultFormatterId
             ? ( localize(
-            8117,
+            8252,
             "There are multiple formatters for '{0}' files. One of them should be configured as default formatter.",
             DefaultFormatter_1._maybeQuotes(langName)
         ))
             : ( localize(
-            8118,
+            8253,
             "Extension '{0}' is configured as formatter but not available. Select a different default formatter to continue.",
             defaultFormatterId
         ));
@@ -146,16 +169,16 @@ let DefaultFormatter = class DefaultFormatter extends Disposable {
         }
         if (mode !== FormattingMode.Silent) {
             const { confirmed } = await this._dialogService.confirm({
-                message: ( localize(8119, "Configure Default Formatter")),
+                message: ( localize(8254, "Configure Default Formatter")),
                 detail: formatterOrMessage,
-                primaryButton: ( localize(8120, "&&Configure..."))
+                primaryButton: ( localize(8255, "&&Configure..."))
             });
             if (confirmed) {
                 return this._pickAndPersistDefaultFormatter(formatter, document);
             }
         }
         else {
-            this._notificationService.prompt(Severity$1.Info, formatterOrMessage, [{ label: ( localize(8121, "Configure...")), run: () => this._pickAndPersistDefaultFormatter(formatter, document) }], { priority: NotificationPriority.SILENT });
+            this._notificationService.prompt(Severity$1.Info, formatterOrMessage, [{ label: ( localize(8256, "Configure...")), run: () => this._pickAndPersistDefaultFormatter(formatter, document) }], { priority: NotificationPriority.SILENT });
         }
         return undefined;
     }
@@ -169,7 +192,7 @@ let DefaultFormatter = class DefaultFormatter extends Disposable {
         }));
         const langName = this._languageService.getLanguageName(document.getLanguageId()) || document.getLanguageId();
         const pick = await this._quickInputService.pick(picks, { placeHolder: ( localize(
-            8122,
+            8257,
             "Select a default formatter for '{0}' files",
             DefaultFormatter_1._maybeQuotes(langName)
         )) });
@@ -202,14 +225,14 @@ let DefaultFormatter = class DefaultFormatter extends Disposable {
             if (typeof result !== 'string') {
                 return;
             }
-            const command = { id: `formatter/configure/dfl/${generateUuid()}`, title: ( localize(8123, "Configure...")) };
+            const command = { id: `formatter/configure/dfl/${generateUuid()}`, title: ( localize(8258, "Configure...")) };
             this._languageStatusStore.add(CommandsRegistry.registerCommand(command.id, () => this._pickAndPersistDefaultFormatter(formatter, document)));
             this._languageStatusStore.add(this._languageStatusService.addStatus({
                 id: 'formatter.conflict',
-                name: ( localize(8124, "Formatter Conflicts")),
+                name: ( localize(8259, "Formatter Conflicts")),
                 selector: { language: document.getLanguageId(), pattern: document.uri.fsPath },
                 severity: Severity$1.Error,
-                label: ( localize(8125, "Formatting")),
+                label: ( localize(8260, "Formatting")),
                 detail: result,
                 busy: false,
                 source: '',
@@ -237,7 +260,7 @@ DefaultFormatter = DefaultFormatter_1 = ( __decorate([
     properties: {
         [DefaultFormatter.configName]: {
             description: ( localize(
-                8126,
+                8261,
                 "Defines a default formatter which takes precedence over all other formatter settings. Must be the identifier of an extension contributing a formatter."
             )),
             type: ['string', 'null'],
@@ -260,7 +283,7 @@ async function showFormatterPick(accessor, model, formatters) {
         const pick = {
             index,
             label: provider.displayName || '',
-            description: isDefault ? ( localize(8127, "(default)")) : undefined,
+            description: isDefault ? ( localize(8262, "(default)")) : undefined,
         };
         if (isDefault) {
             defaultFormatterPick = pick;
@@ -268,10 +291,10 @@ async function showFormatterPick(accessor, model, formatters) {
         return pick;
     }));
     const configurePick = {
-        label: ( localize(8128, "Configure Default Formatter..."))
+        label: ( localize(8263, "Configure Default Formatter..."))
     };
     const pick = await quickPickService.pick([...picks, { type: 'separator' }, configurePick], {
-        placeHolder: ( localize(8129, "Select a formatter")),
+        placeHolder: ( localize(8264, "Select a formatter")),
         activeItem: defaultFormatterPick
     });
     if (!pick) {
@@ -280,7 +303,7 @@ async function showFormatterPick(accessor, model, formatters) {
     else if (pick === configurePick) {
         const langName = languageService.getLanguageName(model.getLanguageId()) || model.getLanguageId();
         const pick = await quickPickService.pick(picks, { placeHolder: ( localize(
-            8122,
+            8257,
             "Select a default formatter for '{0}' files",
             DefaultFormatter._maybeQuotes(langName)
         )) });
@@ -297,7 +320,7 @@ registerEditorAction(class FormatDocumentMultipleAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.formatDocument.multiple',
-            label: ( localize(8130, "Format Document With...")),
+            label: ( localize(8265, "Format Document With...")),
             alias: 'Format Document...',
             precondition: ( ContextKeyExpr.and(
                 EditorContextKeys.writable,
@@ -327,7 +350,7 @@ registerEditorAction(class FormatSelectionMultipleAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.formatSelection.multiple',
-            label: ( localize(8131, "Format Selection With...")),
+            label: ( localize(8266, "Format Selection With...")),
             alias: 'Format Code...',
             precondition: ( ContextKeyExpr.and(( ContextKeyExpr.and(EditorContextKeys.writable)), EditorContextKeys.hasMultipleDocumentSelectionFormattingProvider)),
             contextMenuOpts: {

package/vscode/src/vs/workbench/contrib/format/browser/formatActionsNone.js

@@ -15,7 +15,7 @@ registerEditorAction(class FormatDocumentMultipleAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.formatDocument.none',
-            label: ( localize2(8132, "Format Document")),
+            label: ( localize2(8267, "Format Document")),
             precondition: ( ContextKeyExpr.and(EditorContextKeys.writable, ( EditorContextKeys.hasDocumentFormattingProvider.toNegated()))),
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,
@@ -43,14 +43,14 @@ registerEditorAction(class FormatDocumentMultipleAction extends EditorAction {
             return commandService.executeCommand('editor.action.formatDocument');
         }
         else if (model.isTooLargeForSyncing()) {
-            notificationService.warn(( localize(8133, "This file cannot be formatted because it is too large")));
+            notificationService.warn(( localize(8268, "This file cannot be formatted because it is too large")));
         }
         else {
             const langName = model.getLanguageId();
-            const message = ( localize(8134, "There is no formatter for '{0}' files installed.", langName));
+            const message = ( localize(8269, "There is no formatter for '{0}' files installed.", langName));
             const { confirmed } = await dialogService.confirm({
                 message,
-                primaryButton: ( localize(8135, "&&Install Formatter..."))
+                primaryButton: ( localize(8270, "&&Install Formatter..."))
             });
             if (confirmed) {
                 extensionsWorkbenchService.openSearch(`category:formatters ${langName}`);

package/vscode/src/vs/workbench/contrib/format/browser/formatModified.js

@@ -19,7 +19,7 @@ registerEditorAction(class FormatModifiedAction extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.formatChanges',
-            label: ( localize2(8136, "Format Modified Lines")),
+            label: ( localize2(8271, "Format Modified Lines")),
             precondition: ( ContextKeyExpr.and(
                 EditorContextKeys.writable,
                 EditorContextKeys.hasDocumentSelectionFormattingProvider

package/vscode/src/vs/workbench/contrib/inlayHints/browser/inlayHintsAccessibilty.js

@@ -24,7 +24,7 @@ let InlayHintsAccessibility = class InlayHintsAccessibility {
     static { this.IsReading = ( new RawContextKey(
         'isReadingLineWithInlayHints',
         false,
-        { type: 'boolean', description: ( localize(8137, "Whether the current line and its inlay hints are currently focused")) }
+        { type: 'boolean', description: ( localize(8272, "Whether the current line and its inlay hints are currently focused")) }
     )); }
     static { this.ID = 'editor.contrib.InlayHintsAccessibility'; }
     static get(editor) {
@@ -39,7 +39,7 @@ let InlayHintsAccessibility = class InlayHintsAccessibility {
         this._ariaElement.style.position = 'fixed';
         this._ariaElement.className = 'inlayhint-accessibility-element';
         this._ariaElement.tabIndex = 0;
-        this._ariaElement.setAttribute('aria-description', ( localize(8138, "Code with Inlay Hint Information")));
+        this._ariaElement.setAttribute('aria-description', ( localize(8273, "Code with Inlay Hint Information")));
         this._ctxIsReading = InlayHintsAccessibility_1.IsReading.bindTo(contextKeyService);
     }
     dispose() {
@@ -139,7 +139,7 @@ registerAction2(class StartReadHints extends EditorAction2 {
     constructor() {
         super({
             id: 'inlayHints.startReadingLineWithHint',
-            title: ( localize2(8139, "Read Line with Inlay Hints")),
+            title: ( localize2(8274, "Read Line with Inlay Hints")),
             precondition: EditorContextKeys.hasInlayHintsProvider,
             f1: true
         });
@@ -153,7 +153,7 @@ registerAction2(class StopReadHints extends EditorAction2 {
     constructor() {
         super({
             id: 'inlayHints.stopReadingLineWithHint',
-            title: ( localize2(8140, "Stop Inlay Hints Reading")),
+            title: ( localize2(8275, "Stop Inlay Hints Reading")),
             precondition: InlayHintsAccessibility.IsReading,
             f1: true,
             keybinding: {

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatSessionService.service.d.ts

@@ -5,8 +5,8 @@ import { URI } from "../../../../base/common/uri.js";
 import { IActiveCodeEditor, ICodeEditor } from "../../../../editor/browser/editorBrowser.js";
 import { IRange } from "../../../../editor/common/core/range.js";
 import { IValidEditOperation } from "../../../../editor/common/model.js";
-import { Session, StashedSession } from "@codingame/monaco-vscode-a793b3ee-7ba9-5176-a019-30ec806fdd95-common/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSession";
-import { IInlineChatSessionEvent, IInlineChatSessionEndEvent, ISessionKeyComputer, IInlineChatSession2 } from "@codingame/monaco-vscode-a793b3ee-7ba9-5176-a019-30ec806fdd95-common/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSessionService";
+import { Session, StashedSession } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSession";
+import { IInlineChatSessionEvent, IInlineChatSessionEndEvent, ISessionKeyComputer, IInlineChatSession2 } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSessionService";
 export declare const IInlineChatSessionService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IInlineChatSessionService>;
 export interface IInlineChatSessionService {
     _serviceBrand: undefined;
@@ -28,6 +28,6 @@ export interface IInlineChatSessionService {
     dispose(): void;
     createSession2(editor: ICodeEditor, uri: URI, token: CancellationToken): Promise<IInlineChatSession2>;
     getSession2(uri: URI): IInlineChatSession2 | undefined;
-    getSession2(sessionId: string): IInlineChatSession2 | undefined;
+    getSessionBySessionUri(uri: URI): IInlineChatSession2 | undefined;
     readonly onDidChangeSessions: Event<this>;
 }

package/vscode/src/vs/workbench/contrib/interactive/browser/interactiveCommon.d.ts

@@ -0,0 +1,7 @@
+import { RawContextKey } from "../../../../platform/contextkey/common/contextkey.js";
+export declare const INTERACTIVE_INPUT_CURSOR_BOUNDARY: RawContextKey<"top" | "none" | "bottom" | "both">;
+export declare const ReplEditorSettings: {
+    interactiveWindowAlwaysScrollOnNewCell: string;
+    executeWithShiftEnter: string;
+    showExecutionHint: string;
+};

package/vscode/src/vs/workbench/contrib/interactive/browser/interactiveCommon.js

@@ -0,0 +1,11 @@
+
+import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
+
+const INTERACTIVE_INPUT_CURSOR_BOUNDARY = ( new RawContextKey('interactiveInputCursorAtBoundary', 'none'));
+const ReplEditorSettings = {
+    interactiveWindowAlwaysScrollOnNewCell: 'interactiveWindow.alwaysScrollOnNewCell',
+    executeWithShiftEnter: 'interactiveWindow.executeWithShiftEnter',
+    showExecutionHint: 'interactiveWindow.showExecutionHint',
+};
+
+export { INTERACTIVE_INPUT_CURSOR_BOUNDARY, ReplEditorSettings };

package/vscode/src/vs/workbench/contrib/interactive/browser/interactiveEditorInput.d.ts

@@ -0,0 +1,55 @@
+import { URI } from "../../../../base/common/uri.js";
+import { ITextModelService } from "../../../../editor/common/services/resolverService.service.js";
+import { IConfigurationService } from "../../../../platform/configuration/common/configuration.service.js";
+import { IFileDialogService } from "../../../../platform/dialogs/common/dialogs.service.js";
+import { IInstantiationService } from "../../../../platform/instantiation/common/instantiation.js";
+import { EditorInputCapabilities, GroupIdentifier, IRevertOptions, ISaveOptions, IUntypedEditorInput } from "../../../common/editor.js";
+import { EditorInput } from "../../../common/editor/editorInput.js";
+import { IInteractiveDocumentService } from "./interactiveDocumentService.service.js";
+import { IInteractiveHistoryService } from "./interactiveHistoryService.service.js";
+import { IResolvedNotebookEditorModel } from "../../notebook/common/notebookCommon.js";
+import { ICompositeNotebookEditorInput, NotebookEditorInput } from "../../notebook/common/notebookEditorInput.js";
+import { INotebookService } from "../../notebook/common/notebookService.service.js";
+export declare class InteractiveEditorInput extends EditorInput implements ICompositeNotebookEditorInput {
+    private readonly _notebookService;
+    private readonly _fileDialogService;
+    static create(instantiationService: IInstantiationService, resource: URI, inputResource: URI, title?: string, language?: string): InteractiveEditorInput;
+    private static windowNames;
+    static setName(notebookUri: URI, title: string | undefined): void;
+    static readonly ID: string;
+    get editorId(): string;
+    get typeId(): string;
+    private name;
+    private readonly isScratchpad;
+    get language(): string | undefined;
+    private _initLanguage?;
+    private _notebookEditorInput;
+    get notebookEditorInput(): NotebookEditorInput;
+    get editorInputs(): NotebookEditorInput[];
+    private _resource;
+    get resource(): URI;
+    private _inputResource;
+    get inputResource(): URI;
+    private _inputResolver;
+    private _editorModelReference;
+    private _inputModelRef;
+    get primary(): EditorInput;
+    private _textModelService;
+    private _interactiveDocumentService;
+    private _historyService;
+    constructor(resource: URI, inputResource: URI, title: string | undefined, languageId: string | undefined, instantiationService: IInstantiationService, textModelService: ITextModelService, interactiveDocumentService: IInteractiveDocumentService, historyService: IInteractiveHistoryService, _notebookService: INotebookService, _fileDialogService: IFileDialogService, configurationService: IConfigurationService);
+    private _registerListeners;
+    get capabilities(): EditorInputCapabilities;
+    private _resolveEditorModel;
+    resolve(): Promise<IResolvedNotebookEditorModel | null>;
+    resolveInput(language?: string): Promise<import("../../../../editor/common/model.js").ITextModel>;
+    save(group: GroupIdentifier, options?: ISaveOptions): Promise<EditorInput | IUntypedEditorInput | undefined>;
+    saveAs(group: GroupIdentifier, options?: ISaveOptions): Promise<IUntypedEditorInput | undefined>;
+    matches(otherInput: EditorInput | IUntypedEditorInput): boolean;
+    getName(): string;
+    isDirty(): boolean;
+    isModified(): boolean;
+    revert(_group: GroupIdentifier, options?: IRevertOptions): Promise<void>;
+    dispose(): void;
+    get historyService(): IInteractiveHistoryService;
+}