} } catch (error) { addToSkipped.push(e); <del> if (error instanceof ExtensionManagementError && [ExtensionManagementErrorCode.Incompatible, ExtensionManagementErrorCode.IncompatiblePreRelease, ExtensionManagementErrorCode.IncompatibleTargetPlatform].includes(error.code)) { this.logService.info(`${syncResourceLogLabel}: Skipped synchronizing extension because the compatible extension is not found.`, extension.displayName || extension.identifier.id); } else { this.logService.error(error); this.logService.info(`${syncResourceLogLabel}: Skipped synchronizing extension`, extension.displayName || extension.identifier.id); } </del> <ins> this.logService.error(error); this.logService.info(`${syncResourceLogLabel}: Skipped synchronizing extension`, extension.displayName || extension.identifier.id); </ins> } } else { addToSkipped.push(e); this.logService.info(`${syncResourceLogLabel}: Skipped synchronizing extension because the extension is not found.`, e.identifier.id); } })); <del> } </del> <ins> }); } </ins> <del> const newSkippedExtensions: ISyncExtension[] = []; for (const skippedExtension of skippedExtensions) { if (!removeFromSkipped.some(e => areSameExtensions(e, skippedExtension.identifier))) { newSkippedExtensions.push(skippedExtension); </del> <ins> // 2. Next uninstall the removed extensions if (removed.length) { const extensionsToRemove = installedExtensions.filter(({ identifier, isBuiltin }) => !isBuiltin && removed.some(r => areSameExtensions(identifier, r))); await Promises.settled(extensionsToRemove.map(async extensionToRemove => { this.logService.trace(`${syncResourceLogLabel}: Uninstalling local extension...`, extensionToRemove.identifier.id); await this.extensionManagementService.uninstall(extensionToRemove, { donotIncludePack: true, donotCheckDependents: true, profileLocation: profile.extensionsResource }); this.logService.info(`${syncResourceLogLabel}: Uninstalled local extension.`, extensionToRemove.identifier.id); removeFromSkipped.push(extensionToRemove.identifier); })); } // 3. Install extensions at the end for (const [e, extension] of extensionsToInstall) { try { this.logService.trace(`${syncResourceLogLabel}: Installing extension...`, extension.identifier.id, extension.version); await this.extensionManagementService.installFromGallery(extension, { isMachineScoped: false/* set isMachineScoped value to prevent install and sync dialog in web */, donotIncludePackAndDependencies: true, installPreReleaseVersion: e.preRelease, profileLocation: profile.extensionsResource, context: { [EXTENSIONS_SYNC_CONTEXT_KEY]: true } }); this.logService.info(`${syncResourceLogLabel}: Installed extension.`, extension.identifier.id, extension.version); removeFromSkipped.push(extension.identifier); } catch (error) { addToSkipped.push(e); if (error instanceof ExtensionManagementError && [ExtensionManagementErrorCode.Incompatible, ExtensionManagementErrorCode.IncompatiblePreRelease, ExtensionManagementErrorCode.IncompatibleTargetPlatform].includes(error.code)) { this.logService.info(`${syncResourceLogLabel}: Skipped synchronizing extension because the compatible extension is not found.`, extension.displayName || extension.identifier.id); } else { this.logService.error(error); this.logService.info(`${syncResourceLogLabel}: Skipped synchronizing extension`, extension.displayName || extension.identifier.id); </ins> } } <del> for (const skippedExtension of addToSkipped) { if (!newSkippedExtensions.some(e => areSameExtensions(e.identifier, skippedExtension.identifier))) { newSkippedExtensions.push(skippedExtension); } </del> <ins> } const newSkippedExtensions: ISyncExtension[] = []; for (const skippedExtension of skippedExtensions) { if (!removeFromSkipped.some(e => areSameExtensions(e, skippedExtension.identifier))) { newSkippedExtensions.push(skippedExtension); </ins> } <del> return newSkippedExtensions; }); </del> <ins> } for (const skippedExtension of addToSkipped) { if (!newSkippedExtensions.some(e => areSameExtensions(e.identifier, skippedExtension.identifier))) { newSkippedExtensions.push(skippedExtension); } } return newSkippedExtensions; </ins> } private updateExtensionState(state: IStringDictionary<any>, extension: ILocalExtension | IGalleryExtension, version: string | undefined, extensionStorageService: IExtensionStorageService): void {


import { DisposableStore, dispose, IDisposable } from 'vs/base/common/lifecycle'; import { ScrollEvent } from 'vs/base/common/scrollable'; import { IThemable } from 'vs/base/common/styler'; <ins> import { isIterable } from 'vs/base/common/types'; </ins> interface IAsyncDataTreeNode<TInput, T> { element: TInput | T;


}); } <del> private static _createItemKindFilter(editor: ICodeEditor): Set<CompletionItemKind> { </del> <ins> private static _createSuggestFilter(editor: ICodeEditor): { itemKind: Set<CompletionItemKind>; showDeprecated: boolean } { </ins> // kind filter and snippet sort rules const result = new Set<CompletionItemKind>();


assertSelections(editor, new Selection(1, 22, 1, 22)); }); <del> test('A little confusing visual effect of highlighting for snippet tabstop #43270', async function () { </del> <ins> test('User defined snippet tab stops ignored #72862', function () { </ins> const ctrl = new SnippetController2(editor, logService, contextKeys); model.setValue(''); editor.setSelection(new Selection(1, 1, 1, 1)); <del> ctrl.insert('background-color: ${1:fff};$0'); assertSelections(editor, new Selection(1, 19, 1, 22)); editor.setSelection(new Selection(1, 22, 1, 22)); </del> <ins> ctrl.insert('export default $1'); </ins> assertContextKeys(contextKeys, true, false, true); <del> editor.trigger('', 'deleteRight', null); assert.equal(model.getValue(), 'background-color: fff'); await timeout(0); // this depends on re-scheduling of events... assertContextKeys(contextKeys, false, false, false); </del> }); });


if (!model) { return false; } <del> if (model.uri.scheme === 'output') { // in output editor return false; } </del> if (editor.getOption(EditorOption.inDiffEditor)) { // this editor belongs to a diff editor for (const diffEditor of codeEditorService.listDiffEditors()) {


'libdrm2 (>= 2.4.38)', 'libexpat1 (>= 2.0.1)', 'libgbm1 (>= 8.1~0)', <del> 'libgcc-s1 (>= 3.0)', 'libgcc-s1 (>= 3.5)', </del> 'libglib2.0-0 (>= 2.16.0)', 'libglib2.0-0 (>= 2.39.4)', 'libgtk-3-0 (>= 3.9.10)',


# means the user re-exported the PS1 so we should re-wrap it if [[ "$__vsc_custom_PS1" == "" || "$__vsc_custom_PS1" != "$PS1" ]]; then __vsc_original_PS1=$PS1 <del> __vsc_custom_PS1="[$(__vsc_prompt_start)]$PREFIX$__vsc_original_PS1[$(__vsc_prompt_end)]" </del> <ins> __vsc_custom_PS1="[$(__vsc_prompt_start)]$__vsc_original_PS1[$(__vsc_prompt_end)]" </ins> PS1="$__vsc_custom_PS1" fi if [[ "$__vsc_custom_PS2" == "" || "$__vsc_custom_PS2" != "$PS2" ]]; then


registry.registerWorkbenchAction(new SyncActionDescriptor(SaveAllAction, SaveAllAction.ID, SaveAllAction.LABEL), category, ['save', 'all', 'files']); registry.registerWorkbenchAction(new SyncActionDescriptor(SaveFilesAction, SaveFilesAction.ID, null /* only for programmatic trigger */)); registry.registerWorkbenchAction(new SyncActionDescriptor(RevertFileAction, RevertFileAction.ID, RevertFileAction.LABEL), category, ['revert', 'file']); <ins> registry.registerWorkbenchAction(new SyncActionDescriptor(GlobalNewFileAction, GlobalNewFileAction.ID, GlobalNewFileAction.LABEL), category, ['new', 'file']); </ins> registry.registerWorkbenchAction(new SyncActionDescriptor(GlobalNewFolderAction, GlobalNewFolderAction.ID, GlobalNewFolderAction.LABEL), category, ['new', 'folder']); registry.registerWorkbenchAction(new SyncActionDescriptor(GlobalCompareResourcesAction, GlobalCompareResourcesAction.ID, GlobalCompareResourcesAction.LABEL), category, ['compare', 'files']); registry.registerWorkbenchAction(new SyncActionDescriptor(CloseFileAction, CloseFileAction.ID, CloseFileAction.LABEL, { primary: KeyMod.chord(KeyMod.CtrlCmd | KeyCode.KEY_K, KeyCode.KEY_W) }), category, ['close', 'file']);


} } <del> class TreeMenus extends Disposable implements IDisposable { </del> <ins> class TreeMenus implements IDisposable { </ins> private contextKeyService: IContextKeyService | undefined; private _onDidChange = new Emitter<ITreeItem>(); public readonly onDidChange = this._onDidChange.event;


} private _layout(): void { <del> const windowWidth = window.innerWidth; const width = windowWidth * DIMENSION_DEFAULT.WIDTH; this._editorWidget.layout({ width, height: this._editorWidget.getContentHeight() }); const left = Math.round((windowWidth - width) / 2); this._editorContainer.style.left = `${left}px`; </del> <ins> this._editorWidget.layout({ width: DIMENSION_DEFAULT.WIDTH, height: this._editorWidget.getContentHeight() }); </ins> } private async _getTextModel(resource: URI): Promise<ITextModel | null> {


super.render(container); addClass(container, 'switch-output'); this._register(attachStylerCallback(this.themeService, { selectBorder }, colors => { <del> container.style.border = colors.selectBorder ? `1px solid ${colors.selectBorder}` : ''; </del> <ins> container.style.borderColor = colors.selectBorder ? `${colors.selectBorder}` : ''; </ins> })); }


<ins> /*--------------------------------------------------------------------------------------------- *  Copyright (c) Microsoft Corporation. All rights reserved. *  Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ import * as assert from 'assert'; import { ContentHoverController } from 'vs/editor/contrib/hover/browser/contentHover'; import { Range } from 'vs/editor/common/core/range'; import { Position } from 'vs/editor/common/core/position'; import { IHoverPart } from 'vs/editor/contrib/hover/browser/hoverTypes'; suite('Content Hover', () => { test('issue #151235: Gitlens hover shows up in the wrong place', () => { const actual = ContentHoverController.computeHoverRanges( new Range(5, 5, 5, 5), [<IHoverPart>{ range: new Range(4, 1, 5, 6) }] ); assert.deepStrictEqual( actual, { showAtPosition: new Position(5, 5), showAtRange: new Range(5, 5, 5, 5), highlightRange: new Range(4, 1, 5, 6) } ); }); }); </ins>


<del> a010e3d6e90e3ae1d7df517044510db0419500c25b0243ac371b2cdc34264fe5 *chromedriver-v30.5.0-darwin-arm64.zip bb5444359e6214a393ab2b9ee6d096e4202fd32050c05bc0868d3f220501efb9 *chromedriver-v30.5.0-darwin-x64.zip bb02fee91d901cd2ff24200c6488691330d946277cb8fbd5681eb7fe04d6b70a *chromedriver-v30.5.0-linux-arm64.zip 3337363abe08a74d30c0a4eb990c35c97bb5692e1c28afd2ab732ac9c51fcf10 *chromedriver-v30.5.0-linux-armv7l.zip bb9c1b5b11712b52e7cbdbf38aa6f180bd4acc9866a3c9a023d443ac93a1bfd3 *chromedriver-v30.5.0-linux-x64.zip c81eec95055c6fc553cddcbe405ce6a4aa9b2e397f65f551ce8a69772dacc80e *chromedriver-v30.5.0-mas-arm64.zip cce049c0bcaeeb82656971363cf2dcce9eae38cbbee558a5204085cac2b700fa *chromedriver-v30.5.0-mas-x64.zip 474cee6b6ab8d8ff4d5beb834981b694aedfa6434e89c77391fb50fd9940421f *chromedriver-v30.5.0-win32-arm64.zip e841d999d224c6562422657a669b1e807f9e1fd99fbfdad9275e86637ee77a2b *chromedriver-v30.5.0-win32-ia32.zip 3e62f30a511ae9058a4e665e56613b7412af1640e15e9b0cbf7237fa0fa5ac1b *chromedriver-v30.5.0-win32-x64.zip 928586b78c1b59cdeab32542c0dcc7763a3eacaa2b21f3fcb6345af522e2600a *electron-api.json 12f0d3689ac7be36b312ef81cffb99ac2ed35eecd6650aefc691085317942bce *electron-v30.5.0-darwin-arm64-dsym-snapshot.zip 84eb4590e500f85ec854fed4e2ea479c118b075a546e3398ac95d093cdd4f49c *electron-v30.5.0-darwin-arm64-dsym.zip bac4837a937f620ae3f6290bb2e2c0d29f051d10b968e3e247751b727ceaf3d3 *electron-v30.5.0-darwin-arm64-symbols.zip 1715379e74d5c5983cf74059eae174cc59bb48ef774d32d6a23fa2e52ae8f8da *electron-v30.5.0-darwin-arm64.zip f1849de448bd973118572dd0e70ea6f8b862e0ed09879323a872f4d4d8c84ff0 *electron-v30.5.0-darwin-x64-dsym-snapshot.zip 1d2677b2b01cda73480d87a02dfbf8ef3b39c0d9c7f785b88edc0bbb9ded0bf4 *electron-v30.5.0-darwin-x64-dsym.zip 34592256b3d940fb6828edcb23cd0f241605dbaa9423d429aa2472143a6c908f *electron-v30.5.0-darwin-x64-symbols.zip 135aaa5c7b9cbd6128a6fb43df522d9bc4894c6ceb115e1db5caa2b2e2f2c9f4 *electron-v30.5.0-darwin-x64.zip 7115b03c3aed17f5d9b1b134f7daf3ffb838f5180f4223358acf3061cf7e8eea *electron-v30.5.0-linux-arm64-debug.zip 75c9532cf91c468dd37c2c961d1e7dbce133f8fe3565cc391f5eea66ae843b4f *electron-v30.5.0-linux-arm64-symbols.zip a3857bdf84379d8a4984955368b3940df9b1b1d098ed6c6120d34cde950e41c6 *electron-v30.5.0-linux-arm64.zip 7115b03c3aed17f5d9b1b134f7daf3ffb838f5180f4223358acf3061cf7e8eea *electron-v30.5.0-linux-armv7l-debug.zip 6de5b4aee19b2da78444cca76d35a3a20d72252dd9e31055ab96c727629007be *electron-v30.5.0-linux-armv7l-symbols.zip ba4cad948732d39242d934dade317785ea8239fed6175fe143f7ad747c8524d9 *electron-v30.5.0-linux-armv7l.zip 2b447d516777af53809ee80820a7c93e704ebaa3b253e7d5b4ecf5f104f2b855 *electron-v30.5.0-linux-x64-debug.zip 9abc7246ab2e29424700ff30c03a72d9f8508d7819ea5d924a606b4ee16e74fd *electron-v30.5.0-linux-x64-symbols.zip 167d48e0c6b9714d3e1bcf66cc37f81a886694038e12c754866db313c1c7c90e *electron-v30.5.0-linux-x64.zip 5aef36099d1fd316c6593bcf9895641fe79e97d3e2191a6c00e63a033e9d628b *electron-v30.5.0-mas-arm64-dsym-snapshot.zip cafae0c4d8b00424a7edf1234587a4a5f49ed209c649a5773131eb805790fdc4 *electron-v30.5.0-mas-arm64-dsym.zip c859b5d4e0fb117e6666db858878efbe77e9cf835125ba69b68099ad3d8975c0 *electron-v30.5.0-mas-arm64-symbols.zip 7458cd6f830640fcfbf262bf207113ff7a4ff62951f3ee2f24075059b141821b *electron-v30.5.0-mas-arm64.zip 894697a4588bcac62565c5416f43e3ea96efe65436c660c0473e382d6ff7075d *electron-v30.5.0-mas-x64-dsym-snapshot.zip 37ef7ac94c20a30be8a53346fb2949429e3adbd5485e9c7cd440b821bd8e3a49 *electron-v30.5.0-mas-x64-dsym.zip b18452e34e0569adc647ebf749712bbe1c7ac60d63624015607f1eb4d3d8f3f6 *electron-v30.5.0-mas-x64-symbols.zip 3fbff016735efd6313be0fcfcbf1856d1e0b25329c9219e7da3fa3585f075f04 *electron-v30.5.0-mas-x64.zip fdf4e69f7601dbe12eb09cca968ff261e3efc8c718f5a74f5805108420abb7b8 *electron-v30.5.0-win32-arm64-pdb.zip e0ce8ed7dc7cb633ed2fcd8f9d2a28dfbd180235b4e2f20747a12eaf397b8808 *electron-v30.5.0-win32-arm64-symbols.zip 7351fa5cb892853a7d4b67d8858d0f9cc6506c554a2e42c9ad7e8d5e29ae2743 *electron-v30.5.0-win32-arm64-toolchain-profile.zip 61ea193db53d4f5ae95a758b53fbd8675e9b87d5e8c97549ce716eb7830f71a3 *electron-v30.5.0-win32-arm64.zip 3f3133f4db5384a10611f778b3e4d8f759d88d0f93fc1226066bd2324805cef2 *electron-v30.5.0-win32-ia32-pdb.zip 206f84d0a1a4096e793e4152609792fbd6e118d9b3fe96db40b22c6c83f822f8 *electron-v30.5.0-win32-ia32-symbols.zip 7351fa5cb892853a7d4b67d8858d0f9cc6506c554a2e42c9ad7e8d5e29ae2743 *electron-v30.5.0-win32-ia32-toolchain-profile.zip 8ab671665fad3eb50c0ba79201944dc6a1cc08dd1ec89a5aa458415671307178 *electron-v30.5.0-win32-ia32.zip adc776f542ae6c8f2030a99a0eb4c55857d065708620d52119cc067c264cc08a *electron-v30.5.0-win32-x64-pdb.zip b1fa7b22af5e31f49278ece5cb60d1ce310547db154802c74baa30264b9aaf69 *electron-v30.5.0-win32-x64-symbols.zip 7351fa5cb892853a7d4b67d8858d0f9cc6506c554a2e42c9ad7e8d5e29ae2743 *electron-v30.5.0-win32-x64-toolchain-profile.zip 2b9007396722c03d6b064e7f277b502990bc2a060066ed202dea4f4ede77a820 *electron-v30.5.0-win32-x64.zip 4acb73a8e98f769c14910e6a16f7902e1281291ecec0c80598ce07bf97878238 *electron.d.ts dded5f95e489ec68829ba2ea2f851601ecc30e534c5fb16c9bee97c196e6eba0 *ffmpeg-v30.5.0-darwin-arm64.zip 3b26980535e45e6fd23b34f464f85263edf434e749722bec70f07a5538dadaf3 *ffmpeg-v30.5.0-darwin-x64.zip 93f433080429f0edffb838a1655c4faacdb49efae24acf97b35c9eccd87abc63 *ffmpeg-v30.5.0-linux-arm64.zip 4f7583513d48b48c44a2cbc4430cbc9a33d8f9728622166db688e3de61190821 *ffmpeg-v30.5.0-linux-armv7l.zip 42aa45bcfebac623904082fbe74a94a9d115237118493baa9845bb4ed63a1ffe *ffmpeg-v30.5.0-linux-x64.zip dded5f95e489ec68829ba2ea2f851601ecc30e534c5fb16c9bee97c196e6eba0 *ffmpeg-v30.5.0-mas-arm64.zip 3b26980535e45e6fd23b34f464f85263edf434e749722bec70f07a5538dadaf3 *ffmpeg-v30.5.0-mas-x64.zip 418ac6118a1d0f4fe245bfd3f7db59293629db0c81ad4dcf27a15197c49b0835 *ffmpeg-v30.5.0-win32-arm64.zip c5980cb28dcef56e7674c754b8863c9b5e67ecdb6684f71e32d10a335b92c5fb *ffmpeg-v30.5.0-win32-ia32.zip 7dffa8b18aa0a7941a2d03d8ac393b865a39dd93ad408e9efdd8e51061798c12 *ffmpeg-v30.5.0-win32-x64.zip 2abc27d8460ca60a336767634ab608b9c5450d0ac9720a6fbbdd9e83f837163d *hunspell_dictionaries.zip 7d3254bf7242ea858cadc17686c2ba1c2b7239e00628c8ae260373e9e35617b2 *libcxx-objects-v30.5.0-linux-arm64.zip 94cc5ba1b3fe4e1db1b4f0ce4140cc3cdf42d54d6e8150d4c1dc98508f7cdad2 *libcxx-objects-v30.5.0-linux-armv7l.zip 21193d743044c1f3052d69efaf11fc1475e5d27f014d0f701127e6da1501bee3 *libcxx-objects-v30.5.0-linux-x64.zip 24ec523a5a5bac709f0df9bb198f52fa786be4b6c828a7cf0117012ffa28f1ce *libcxx_headers.zip </del> <ins> 3de7da4462c7690f75680aecac8fddedc4b998d0da769136d8eff2932b36004e *chromedriver-v30.5.1-darwin-arm64.zip d89b89f7c2ba45cb10df7fc23722bacf6f77e13002c42648762cd18ae3fa9182 *chromedriver-v30.5.1-darwin-x64.zip 3722d46929fd2c7b33c17d37464a08150e60d9269053eb67195795254fb5e947 *chromedriver-v30.5.1-linux-arm64.zip a786d51f834c24b768bd415bf9a2fc5c1d9abdf9dc0b1a091bf9a8ff101becfe *chromedriver-v30.5.1-linux-armv7l.zip 688e4da8dbcb7dbfacab6f29341d96736e6d06e4c8029835b83ef30b69885b01 *chromedriver-v30.5.1-linux-x64.zip 786a7c2659ad97d5a09866b9aafd55edc015cb17a87bd8d72aa5925f2bfcf55a *chromedriver-v30.5.1-mas-arm64.zip 398759d1dc02fc4928d48ff0f8fbade8811347e1a51d1cedcb2ba9350fbed04d *chromedriver-v30.5.1-mas-x64.zip 65766f1270d1876e2a81acfb4b1130dc4a41eb7165842afa8f41ea438bf2fecb *chromedriver-v30.5.1-win32-arm64.zip ca9fe0abd1032ebd51497049cb1bb2ae1dd9592697b278f6b1ee2a1a25148891 *chromedriver-v30.5.1-win32-ia32.zip b6b6ea2202e0139ea436288add736d19078bfb190fc0b22937283927f3024bb9 *chromedriver-v30.5.1-win32-x64.zip 50e8b2d59916bc180873324fdbeb8227dbb8b2375cc936e58b7c9885fb23376d *electron-api.json 595db4fa3f755432bf59cbbaf591ee44b576e15952d014d83d3748646b2e338c *electron-v30.5.1-darwin-arm64-dsym-snapshot.zip c1beb80553f3c9575e638625ce0ffbfdb87b6f8b23799eb132954b2bb74a9a2f *electron-v30.5.1-darwin-arm64-dsym.zip cba315d6d6f607a2ee6cfc437b46f92da88daded86f0130d85129adb4742bc48 *electron-v30.5.1-darwin-arm64-symbols.zip d312544ea29844cf328b44b9dbde12f4fdced90cb442dfca6df36c098dbb6e7a *electron-v30.5.1-darwin-arm64.zip fd24d585d28909c082d703db3fcc5ffa0b55e1077ff320e25ed510f36e6a3761 *electron-v30.5.1-darwin-x64-dsym-snapshot.zip 4d1a2adea4b98c4d0b03c6561fca146aab102d636d359e48ce418c465df891ae *electron-v30.5.1-darwin-x64-dsym.zip d9065eaf659f4c3e8a75f5453ceb65269763b2e57110bdcc01904b9a1e33a62c *electron-v30.5.1-darwin-x64-symbols.zip faf9dcc20d525607ea205f2f6a1dfe3270f6268aa439bb0ba5646c7e4fbbd842 *electron-v30.5.1-darwin-x64.zip b85dba1cdb49591542dcecff3e710f29b81285569c8c5db8c1181c3ed818ba44 *electron-v30.5.1-linux-arm64-debug.zip 5e97cc105282783d1c20d8e8dd4ca1134342839235288840cb50f314ca7a6ede *electron-v30.5.1-linux-arm64-symbols.zip eb31470c0d7cd6e23e7ce0d89cc93a2356c9dac8bcc997e335353b8aa995afa0 *electron-v30.5.1-linux-arm64.zip b85dba1cdb49591542dcecff3e710f29b81285569c8c5db8c1181c3ed818ba44 *electron-v30.5.1-linux-armv7l-debug.zip 137548cd73cd648107f6e01c777e411838173309848a492b42825857cec7d110 *electron-v30.5.1-linux-armv7l-symbols.zip 224bd46983e503101c756c72d10b195f14712a7a56438718acb126017dd04edf *electron-v30.5.1-linux-armv7l.zip 1f87fadebc444c9c0de43f52972a3f61af83ca0594c3de368f7579ce613fcb60 *electron-v30.5.1-linux-x64-debug.zip aae78654f599a68310bdbdc0e3de8db644320ef44e58a5c6e5c693dff5cd1970 *electron-v30.5.1-linux-x64-symbols.zip ec4707783d39e86005f42899e30ae59e50dd5d9c7f28531ed494eb43f2361403 *electron-v30.5.1-linux-x64.zip c61f3121e52fd29987814b7805b597ef3fc78b2ce891eba5e3fc6bbe14128f23 *electron-v30.5.1-mas-arm64-dsym-snapshot.zip f934e55ef6c986d3ec56626b2605fed16030efc45efcd8b05afa9322d625ec56 *electron-v30.5.1-mas-arm64-dsym.zip 3cc36e99f2cd59d7cb2f47b52d19609c2a2358f6ddde35fd832872abe241cc8d *electron-v30.5.1-mas-arm64-symbols.zip c5085ab1fb74dfa4a4e463dcb688989bc63baf44007419fd96db4e7c974fb6db *electron-v30.5.1-mas-arm64.zip 47102b6dcd5892de734be2b48e40bbbdbc5e0a228bf5fec33071661d2724d946 *electron-v30.5.1-mas-x64-dsym-snapshot.zip 607091ddfd313ed27bb5a0acb6fa58b0d65cb87e6c6ce9b373949b4b152476d8 *electron-v30.5.1-mas-x64-dsym.zip ac49568635d41e1075bca39c97aca1f2fcede702f721ddce5d80f18cc2dd1067 *electron-v30.5.1-mas-x64-symbols.zip 3746bc4ba32ab9c11398a393d54ba81733088729ae7cef4e5dccf1e64dc82b0a *electron-v30.5.1-mas-x64.zip 930ad941c8bc0aa5e4e3457b235f104846939974d71bde5b42a8980de2d4a35d *electron-v30.5.1-win32-arm64-pdb.zip 11c1252547b381ab6e40cc032ee60c5209dee9ea1102d1b47ad3fcd4da03049f *electron-v30.5.1-win32-arm64-symbols.zip 7351fa5cb892853a7d4b67d8858d0f9cc6506c554a2e42c9ad7e8d5e29ae2743 *electron-v30.5.1-win32-arm64-toolchain-profile.zip f18baa98ba9c04b346fda9f40fc3150a57b539d0cd510971a073983f78e0a20c *electron-v30.5.1-win32-arm64.zip b03c7297dc61aa234ab2273c419d9ae064e52c2c0c3dd56f09135f81964630b5 *electron-v30.5.1-win32-ia32-pdb.zip 8fc570c7f4d97eb6b745fb4af5932311d1da57058da8f39a3d97d6e099cd6982 *electron-v30.5.1-win32-ia32-symbols.zip 7351fa5cb892853a7d4b67d8858d0f9cc6506c554a2e42c9ad7e8d5e29ae2743 *electron-v30.5.1-win32-ia32-toolchain-profile.zip 20845163bf9d5a4ead03c5f0280c9bae71f0ab1fc03362f3406ed12620e4d9cd *electron-v30.5.1-win32-ia32.zip 019f3ae97a69dc837d89c44d25e0e5dadc88564b74202c5a3524fc6ab59490bc *electron-v30.5.1-win32-x64-pdb.zip 2eb4889fe275e5ea42cf6f51821bcceb833d5714aa1b45ad7915495afb447e94 *electron-v30.5.1-win32-x64-symbols.zip 7351fa5cb892853a7d4b67d8858d0f9cc6506c554a2e42c9ad7e8d5e29ae2743 *electron-v30.5.1-win32-x64-toolchain-profile.zip 443119bb559fc2ca297a57cf79f2bce532e853ada070c1e71460c9657c13b4b3 *electron-v30.5.1-win32-x64.zip deecdc1f3f5ea9548ef73774f412c7af489afeb7dca1c394b5add10e929aff42 *electron.d.ts 14319b51118a5c94e108731f6b5c4e701c700212e790198ba22242eb9674a334 *ffmpeg-v30.5.1-darwin-arm64.zip bfd5110457438fa8b113a8806db45f30b8975304d95e5efb1b71b0f5e46757fe *ffmpeg-v30.5.1-darwin-x64.zip 44ebf3185fc24404647da0c1f9e496effefd32ff3dbc2499c022164b919d06ed *ffmpeg-v30.5.1-linux-arm64.zip 4f7583513d48b48c44a2cbc4430cbc9a33d8f9728622166db688e3de61190821 *ffmpeg-v30.5.1-linux-armv7l.zip 154900e5db5810f63e38fd4551cfff3d88d6eac39226e06e12e1e43558d360a4 *ffmpeg-v30.5.1-linux-x64.zip 14319b51118a5c94e108731f6b5c4e701c700212e790198ba22242eb9674a334 *ffmpeg-v30.5.1-mas-arm64.zip bfd5110457438fa8b113a8806db45f30b8975304d95e5efb1b71b0f5e46757fe *ffmpeg-v30.5.1-mas-x64.zip f2169c4b6b9f073c20652953599f2453947936e851ff25c9f2719e7d889faea3 *ffmpeg-v30.5.1-win32-arm64.zip 90745f1422ae0431b295cb5d27ff03e69c890f3572ef6c4655774b892419e94f *ffmpeg-v30.5.1-win32-ia32.zip 567fe8952f17b224d4492980af741b470e86b31d58e7c6a9262258eeae490122 *ffmpeg-v30.5.1-win32-x64.zip 8bbbadb52a19f074d9f8bd533891e2bacbe4813101ae6c344cfc88e28b1429a3 *hunspell_dictionaries.zip 61137508aee6837c70a2ead2e31dd106d753ec5fac01b49e7e8701be0e09e7aa *libcxx-objects-v30.5.1-linux-arm64.zip 3c285f012f256f767e777550a1f18054cfcffc4e13ad6fa4e4e90dd58ec22069 *libcxx-objects-v30.5.1-linux-armv7l.zip 9b96b53c8dfbc70a0f617f78dde89a1e8510ae2261bcddfbf7c12c61eb5a3d73 *libcxx-objects-v30.5.1-linux-x64.zip 1b5cbe24d6356a388e166bff60d7452583019ea7dec85f593c552eb287346f43 *libcxx_headers.zip </ins> eae200a0d1fd0d4b881358bdef600111891c75ecc4db679b680b0cbaf87ecfc3 *libcxxabi_headers.zip <del> cdd3c02c5998ae39eda53af1627a7f069db29dc13b0287bcfba6197bd9a1f52e *mksnapshot-v30.5.0-darwin-arm64.zip 4212dc901cdaa3e65a905a69c246efe8012318ad9e4141b0e1508f7befadc615 *mksnapshot-v30.5.0-darwin-x64.zip 41ba980d159d59705187fc9a383014cb68a642044c8c39c68f9396bab4fda168 *mksnapshot-v30.5.0-linux-arm64-x64.zip fa2b974e8016ab576c23262c89aa910208542ecec3a2d4344df3f79a0bbb0b30 *mksnapshot-v30.5.0-linux-armv7l-x64.zip cdb205f80890cccc0e3c23bbe8bfa4777171b989f10c532ff488c5a4657a9cf2 *mksnapshot-v30.5.0-linux-x64.zip be468e8c0a3175541e1234d66b50db2932434e77a22d6a6ad3649f36c530aff1 *mksnapshot-v30.5.0-mas-arm64.zip f0bb8d110295ccc0cd0938a63f6a372cf6e80dd511cc1309fd4a7a1bde23dce2 *mksnapshot-v30.5.0-mas-x64.zip 65ed62069016fa0ae0928d394c55678fa530978d1d7fa74a8b02b6b09d7a6e50 *mksnapshot-v30.5.0-win32-arm64-x64.zip 918bf0cc88f4830af21bc7621fde1e32df8869751d898af0ad34e19c63f677a7 *mksnapshot-v30.5.0-win32-ia32.zip 6d6badd9e8ea6df7531e3c1533939686e78c33983cf24e9c98357c2a6d7e6206 *mksnapshot-v30.5.0-win32-x64.zip </del> <ins> ed1f7463b5869acf57dd388208918652182b049b2846f572d52ed47e7c091d54 *mksnapshot-v30.5.1-darwin-arm64.zip bc80de1f29b869cdb2676d2dc08cbb4bd6228a6825b1b0bfc13acee0b070ac3e *mksnapshot-v30.5.1-darwin-x64.zip 5e526ca4f4250a9b9b040d6eb60f1d2b8db974ab68c27e46198f4bf8dc1ef347 *mksnapshot-v30.5.1-linux-arm64-x64.zip c40ca2a45cc9ab4e1668f063860ba243baef8c192a253638e4c93aaccb0ef8da *mksnapshot-v30.5.1-linux-armv7l-x64.zip a3134e0b0980547167dd3ca2f17dd2f40a7db697ab563ba6257534f9ad0d256d *mksnapshot-v30.5.1-linux-x64.zip 82776eafcb3e4d053e275ad50d84151f41a651986baacda20c6ed722854cb8fb *mksnapshot-v30.5.1-mas-arm64.zip 9d6d95d4cb121a29fd68d64557edd8c9859345ac37d0645de8aff518391755ed *mksnapshot-v30.5.1-mas-x64.zip 94b9ce6cb40ae001962b77525d12483c3458776066a69a4e714b327bab1decfc *mksnapshot-v30.5.1-win32-arm64-x64.zip 4d89d06c2e85b25d52bb64f48258ad5d05b98ac21697ae9c49ccd19bad9d7d94 *mksnapshot-v30.5.1-win32-ia32.zip ccfd322bafde0485a0ac6b0acc3669c7b08f30003a1c2e044eebc1bf02289de3 *mksnapshot-v30.5.1-win32-x64.zip </ins>


j:number, lastIncludedCharIndex:number, len:number, <del> characterClasses = getCharacterClasses(), characterClassesLength = characterClasses.length, </del> linkBeginIndex:number, state:number, ch:string,


})); this.nextBtn = this._register(new SimpleButton({ <del> label: NLS_NEXT_MATCH_BTN_LABEL, </del> <ins> label: NLS_NEXT_MATCH_BTN_LABEL + (options.nextMatchActionId ? this._getKeybinding(options.nextMatchActionId) : ''), </ins> icon: findNextMatchIcon, onTrigger: () => { this.find(false);


content.push(`.monaco-list${suffix}:not(.drop-target):not(.dragging) .monaco-list-row:hover:not(.selected):not(.focused) { color:  ${styles.listHoverForeground}; }`); } <del> if (styles.listSelectionOutline) { content.push(`.monaco-list${suffix} .monaco-list-row.selected { outline: 1px dotted ${styles.listSelectionOutline}; outline-offset: -1px; }`); </del> <ins> /** * Outlines */ const focusAndSelectionOutline = asCssValueWithDefault(styles.listFocusAndSelectionOutline, asCssValueWithDefault(styles.listSelectionOutline, styles.listFocusOutline ?? '')); if (focusAndSelectionOutline) { // default: listFocusOutline content.push(`.monaco-list${suffix}:focus .monaco-list-row.focused.selected { outline: 1px solid ${focusAndSelectionOutline}; outline-offset: -1px;}`); </ins> } <del> if (styles.listFocusOutline) { </del> <ins> if (styles.listFocusOutline) { // default: set </ins> content.push(` .monaco-drag-image, .monaco-list${suffix}:focus .monaco-list-row.focused { outline: 1px solid ${styles.listFocusOutline}; outline-offset: -1px; }


// Don't dispose editor when instance is torn down on shutdown to avoid extra work and so // the editor/tabs don't disappear <del> this._lifecycleService.onWillShutdown(() => { </del> <ins> this._lifecycleService.onWillShutdown((e: WillShutdownEvent) => { </ins> this._isShuttingDown = true; dispose(disposeListeners); <ins> // Don't touch processes if the shutdown was a result of reload as they will be reattached const shouldPersistTerminals = this._configurationService.getValue<boolean>(TerminalSettingId.EnablePersistentSessions) && e.reason === ShutdownReason.RELOAD; if (shouldPersistTerminals) { instance.detachProcessAndDispose(TerminalExitReason.Shutdown); } else { instance.dispose(TerminalExitReason.Shutdown); } </ins> }); }


return c; } clientSnippetSupport = getClientCapability('textDocument.completion.completionItem.snippetSupport', false); dynamicFormatterRegistration = getClientCapability('textDocument.rangeFormatting.dynamicRegistration', false) && (typeof initializationOptions.provideFormatter !== 'boolean'); foldingRangeLimitDefault = getClientCapability('textDocument.foldingRange.rangeLimit', Number.MAX_VALUE); hierarchicalDocumentSymbolSupport = getClientCapability('textDocument.documentSymbol.hierarchicalDocumentSymbolSupport', false); formatterMaxNumberOfEdits = initializationOptions.customCapabilities?.rangeFormatting?.editLimit || Number.MAX_VALUE; <del> const pullDiagnosticSupport = getClientCapability('textDocument.diagnostic', undefined); if (pullDiagnosticSupport === undefined) { </del> <ins> const supportsDiagnosticPull = getClientCapability('textDocument.diagnostic', undefined); if (supportsDiagnosticPull === undefined) { </ins> diagnosticsSupport = registerDiagnosticsPushSupport(documents, connection, runtime, validateTextDocument); } else { diagnosticsSupport = registerDiagnosticsPullSupport(documents, connection, runtime, validateTextDocument); } const capabilities: ServerCapabilities = { textDocumentSync: TextDocumentSyncKind.Incremental, completionProvider: clientSnippetSupport ? {


import { ICodeEditor } from 'vs/editor/browser/editorBrowser'; import { NullLogService } from 'vs/platform/log/common/log'; import { Handler } from 'vs/editor/common/editorCommon'; <del> import { timeout } from 'vs/base/common/async'; </del> suite('SnippetController2', function () {


import { ITerminalInstance, IXtermTerminal } from 'vs/workbench/contrib/terminal/browser/terminal'; import { TerminalCommandId } from 'vs/workbench/contrib/terminal/common/terminal'; import type { Terminal } from '@xterm/xterm'; <ins> import { IConfigurationService } from 'vs/platform/configuration/common/configuration'; </ins> export const enum ClassName { Active = 'active',


res = path.substr(0, pos); } res += encodeTable[code]; <del> } else { if (res !== undefined) { res += path[pos]; } </del> <ins> } else if (res !== undefined) { res += path[pos]; </ins> } } return res !== undefined ? res : path;


default: 'openOnFirstSessionStart', description: nls.localize('openDebug', "Controls whether debug view should be open on debugging session start.") }, <ins> 'debug.enableAllHovers': { type: 'boolean', description: nls.localize({ comment: ['This is the description for a setting'], key: 'enableAllHovers' }, "Controls if the non debug hovers should be enabled while debugging. If true the hover providers will be called to provide a hover. Regular hovers will not be shown even if this setting is true."), default: false }, </ins> 'launch': { type: 'object', description: nls.localize({ comment: ['This is the description for a setting'], key: 'launch' }, "Global debug launch configuration. Should be used as an alternative to 'launch.json' that is shared across workspaces"),


class TestTerminalContributionService implements ITerminalContributionService { _serviceBrand: undefined; terminalProfiles: readonly IExtensionTerminalProfile[] = []; <del> quickFixes: ITerminalCommandSelector[] = []; </del> <ins> quickFixes: Promise<ITerminalCommandSelector[]> = new Promise((r) => { r([]); }); </ins> setProfiles(profiles: IExtensionTerminalProfile[]): void { this.terminalProfiles = profiles; }


this._isChangingDecorations = false; this._shouldFocus = false; this._colorPicker = null; <ins> this._preferBelow = this._editor.getOption(EditorOption.hover).below; </ins> this._hoverOperation = new HoverOperation( this._computer,


MoveToEditorInstance = 'workbench.action.terminal.moveToEditorInstance', MoveToTerminalPanel = 'workbench.action.terminal.moveToTerminalPanel', SetDimensions = 'workbench.action.terminal.setDimensions', <del> ClearCommandHistory = 'workbench.action.terminal.clearCommandHistory', </del> <ins> ClearPreviousSessionHistory = 'workbench.action.terminal.clearPreviousSessionHistory', </ins> WriteDataToTerminal = 'workbench.action.terminal.writeDataToTerminal', ShowTextureAtlas = 'workbench.action.terminal.showTextureAtlas', ShowTerminalAccessibilityHelp = 'workbench.action.terminal.showAccessibilityHelp',


background-color: var(--vscode-inlineChat-regionHighlight); } <del> .monaco-workbench .inline-chat-slash-command { </del> <ins> .monaco-workbench .interactive-session .interactive-input-and-execute-toolbar .monaco-editor .inline-chat-slash-command { </ins> background-color: var(--vscode-chat-slashCommandBackground); <del> color: var(--vscode-chat-slashCommandForeground); </del> <ins> color: var(--vscode-chat-slashCommandForeground); /* Overrides the foreground color rule in chat.css */ </ins> border-radius: 4px; padding: 1px; }


break; } } <del> characterBounds.push(new DOMRect(parentBounds.left + contentLeft + left, top, width, lineHeight)); </del> <ins> characterBounds.push(new DOMRect(parentBounds.left + contentLeft + left - editorScrollLeft, top, width, lineHeight)); </ins> } this._editContext.updateCharacterBounds(e.rangeStart, characterBounds); }


readonly shortStats?: boolean; readonly author?: string; readonly refNames?: string[]; <ins> readonly maxParents?: number; </ins> } export interface CommitOptions {


override updateOptions(options: IWorkbenchDataTreeOptionsUpdate = {}): void { super.updateOptions(options); <del> if (options.overrideStyles) { </del> <ins> if (options.overrideStyles !== undefined) { </ins> this.internals.updateStyleOverrides(options.overrideStyles); }


await this._stageChanges(textEditor, [changes[index]]); <del> const firstStagedLine = changes[index].modifiedStartLineNumber - 1; </del> <ins> const firstStagedLine = changes[index].modifiedStartLineNumber; </ins> textEditor.selections = [new Selection(firstStagedLine, 0, firstStagedLine, 0)]; }


} const config = workspace.getConfiguration('git', Uri.file(this.repository.root)); <del> const fetchBeforeCheckout = config.get<boolean>('fetchBeforeCheckout', false) === true; </del> <ins> const pullBeforeCheckout = config.get<boolean>('pullBeforeCheckout', false) === true; </ins> <del> if (fetchBeforeCheckout) { </del> <ins> if (pullBeforeCheckout) { </ins> await this.repository.fastForwardBranch(this.ref.name!); }


export function keybindingForAction(id: string): Keybinding { switch (id) { <del> case GlobalNewFileAction.ID: </del> <ins> case GlobalNewUntitledFileAction.ID: </ins> return new Keybinding(KeyMod.CtrlCmd | KeyCode.KEY_N); case TriggerRenameFileAction.ID: return new Keybinding(isMacintosh ? KeyCode.Enter : KeyCode.F2);


} .merge-editor-block:not(.handled):not(.focused) { <del> border: 1px dashed var(--vscode-mergeEditor-conflict-unhandledUnfocused-border); </del> <ins> border: 1px solid var(--vscode-mergeEditor-conflict-unhandledUnfocused-border); </ins> } .merge-editor-block:not(.handled).focused { <del> border: 1px dashed var(--vscode-mergeEditor-conflict-unhandledFocused-border); </del> <ins> border: 1px solid var(--vscode-mergeEditor-conflict-unhandledFocused-border); </ins> } .merge-editor-block.handled:not(.focused) {


collapseByDefault: true, expandOnlyOnTwistieClick: true, multipleSelectionSupport: false, <ins> showNotFoundMessage: false </ins> } ); }


return this.sendAllBreakpoints(); } <del> addBreakpoints(uri: uri, rawBreakpoints: IBreakpointData[]): TPromise<IBreakpoint[]> { </del> <ins> addBreakpoints(uri: uri, rawBreakpoints: IBreakpointData[], context: string): TPromise<IBreakpoint[]> { </ins> const breakpoints = this.model.addBreakpoints(uri, rawBreakpoints); breakpoints.forEach(bp => aria.status(nls.localize('breakpointAdded', "Added breakpoint, line {0}, file {1}", bp.lineNumber, uri.fsPath))); <ins> breakpoints.forEach(bp => this.telemetryDebugAddBreakpoint(bp, context)); </ins> return this.sendBreakpoints(uri).then(() => breakpoints); }


export const listInactiveFocusOutline = registerColor('list.inactiveFocusOutline', { dark: null, light: null, hc: null }, nls.localize('listInactiveFocusOutline', "List/Tree outline color for the focused item when the list/tree is inactive. An active list/tree has keyboard focus, an inactive does not.")); export const listHoverBackground = registerColor('list.hoverBackground', { dark: '#2A2D2E', light: '#F0F0F0', hc: null }, nls.localize('listHoverBackground', "List/Tree background when hovering over items using the mouse.")); export const listHoverForeground = registerColor('list.hoverForeground', { dark: null, light: null, hc: null }, nls.localize('listHoverForeground', "List/Tree foreground when hovering over items using the mouse.")); <del> export const listDropBackground = registerColor('list.dropBackground', { dark: listFocusBackground, light: listFocusBackground, hc: null }, nls.localize('listDropBackground', "List/Tree drag and drop background when moving items around using the mouse.")); </del> <ins> export const listDropBackground = registerColor('list.dropBackground', { dark: '#062F4A', light: '#D6EBFF', hc: null }, nls.localize('listDropBackground', "List/Tree drag and drop background when moving items around using the mouse.")); </ins> export const listHighlightForeground = registerColor('list.highlightForeground', { dark: '#0097fb', light: '#0066BF', hc: focusBorder }, nls.localize('highlight', 'List/Tree foreground color of the match highlights when searching inside the list/tree.')); export const listInvalidItemForeground = registerColor('list.invalidItemForeground', { dark: '#B89500', light: '#B89500', hc: '#B89500' }, nls.localize('invalidItemForeground', 'List/Tree foreground color for invalid items, for example an unresolved root in explorer.')); export const listErrorForeground = registerColor('list.errorForeground', { dark: '#F88070', light: '#B01011', hc: null }, nls.localize('listErrorForeground', 'Foreground color of list items containing errors.'));


"@vscode/windows-mutex": "^0.5.0", "@vscode/windows-process-tree": "^0.6.0", "@vscode/windows-registry": "^1.1.0", <del> "@xterm/addon-clipboard": "0.2.0-beta.39", "@xterm/addon-image": "0.9.0-beta.56", "@xterm/addon-search": "0.16.0-beta.56", "@xterm/addon-serialize": "0.14.0-beta.56", "@xterm/addon-unicode11": "0.9.0-beta.56", "@xterm/addon-webgl": "0.19.0-beta.56", "@xterm/headless": "5.6.0-beta.56", "@xterm/xterm": "5.6.0-beta.56", </del> <ins> "@xterm/addon-clipboard": "^0.2.0-beta.47", "@xterm/addon-image": "^0.9.0-beta.64", "@xterm/addon-search": "^0.16.0-beta.64", "@xterm/addon-serialize": "^0.14.0-beta.64", "@xterm/addon-unicode11": "^0.9.0-beta.64", "@xterm/addon-webgl": "^0.19.0-beta.64", "@xterm/headless": "^5.6.0-beta.64", "@xterm/xterm": "^5.6.0-beta.64", </ins> "http-proxy-agent": "^7.0.0", "https-proxy-agent": "^7.0.2", "jschardet": "3.1.3",


import { ContextScopedFindInput } from 'vs/platform/history/browser/contextScopedHistoryWidget'; import { widgetClose } from 'vs/platform/theme/common/iconRegistry'; import * as strings from 'vs/base/common/strings'; <del> import { TerminalCommandId } from 'vs/workbench/contrib/terminal/common/terminal'; </del> import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding'; import { showHistoryKeybindingHint } from 'vs/platform/history/browser/historyWidgetKeybindingHint'; import { status } from 'vs/base/browser/ui/aria/aria';


import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding'; import { AccessibilityVerbositySettingId, accessibilityHelpIsShown, accessibleViewIsShown } from 'vs/workbench/contrib/accessibility/browser/accessibilityConfiguration'; import { ILayoutService } from 'vs/platform/layout/browser/layoutService'; <del> import { Action2, MenuId } from 'vs/platform/actions/common/actions'; </del> <ins> import { Action2, MenuId, registerAction2 } from 'vs/platform/actions/common/actions'; </ins> import { KeybindingWeight } from 'vs/platform/keybinding/common/keybindingsRegistry';


this._resourceContentProvider.deleteAndDispose(handle); } <del> $onVirtualDocumentChange(uri: UriComponents, value: string): void { </del> <ins> async $onVirtualDocumentChange(uri: UriComponents, value: string): Promise<void> { </ins> const model = this._modelService.getModel(URI.revive(uri)); if (!model) { return;


label?: string; /** <ins> * The optional state of a comment thread, which may affect how the comment is displayed. */ state?: CommentThreadState; /** </ins> * Dispose this comment thread. * * Once disposed, this comment thread will be removed from visible editors and Comment Panel when appropriate.


keybinding: { primary: KeyMod.Alt | KeyCode.KeyR, mac: { primary: KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.KeyR }, <del> when: ContextKeyExpr.or(TerminalContextKeys.focusInAny, TerminalContextKeys.findFocus), </del> <ins> when: TerminalContextKeys.findVisible, </ins> weight: KeybindingWeight.WorkbenchContrib }, precondition: ContextKeyExpr.or(TerminalContextKeys.processSupported, TerminalContextKeys.terminalHasBeenCreated),


} @command('git.clone') <del> async clone(url?: string, parentPath?: string): Promise<void> { await this.cloneRepository(url, parentPath); </del> <ins> async clone(url?: string, parentPath?: string, options?: { ref?: string }): Promise<void> { await this.cloneRepository(url, parentPath, options); </ins> } @command('git.cloneRecursive')


) { } } <del> class CodeLensCache implements ICodeLensCache { </del> <ins> export class CodeLensCache implements ICodeLensCache { </ins> _serviceBrand: any;


break; } <del> const itemKindFilter = SuggestModel._createItemKindFilter(this._editor); </del> <ins> const { itemKind: itemKindFilter, showDeprecated } = SuggestModel._createSuggestFilter(this._editor); </ins> const wordDistance = WordDistance.create(this._editorWorkerService, this._editor); const completions = provideSuggestionItems( model, this._editor.getPosition(), <del> new CompletionOptions(snippetSortOrder, itemKindFilter, onlyFrom), </del> <ins> new CompletionOptions(snippetSortOrder, itemKindFilter, onlyFrom, showDeprecated), </ins> suggestCtx, this._requestToken.token );


const pendingCommentText = (this._pendingNewCommentCache[uniqueOwner] && this._pendingNewCommentCache[uniqueOwner][thread.threadId]) ?? continueOnCommentText; const pendingEdits = this._pendingEditsCache[uniqueOwner] && this._pendingEditsCache[uniqueOwner][thread.threadId]; <del> const isThreadTemplateOrEmpty = (thread.isTemplate || (!thread.comments || (thread.comments.length === 0))); const shouldReveal = thread.canReply && isThreadTemplateOrEmpty && (!thread.editorId || (thread.editorId === editorId)); </del> <ins> const shouldReveal = thread.canReply && thread.isTemplate && (!thread.comments || (thread.comments.length === 0)) && (!thread.editorId || (thread.editorId === editorId)); </ins> await this.displayCommentThread(uniqueOwner, thread, shouldReveal, pendingCommentText, pendingEdits); this._commentInfos.filter(info => info.uniqueOwner === uniqueOwner)[0].threads.push(thread); this.tryUpdateReservedSpace();


import { SettingsEditor2 } from 'vs/workbench/parts/preferences/browser/settingsEditor2'; import { DefaultPreferencesEditorInput, PreferencesEditorInput, KeybindingsEditorInput, SettingsEditor2Input } from 'vs/workbench/services/preferences/common/preferencesEditorInput'; import { KeybindingsEditor } from 'vs/workbench/parts/preferences/browser/keybindingsEditor'; <del> import { OpenRawDefaultSettingsAction, OpenSettingsAction, OpenGlobalSettingsAction, OpenGlobalKeybindingsFileAction, OpenWorkspaceSettingsAction, OpenFolderSettingsAction, ConfigureLanguageBasedSettingsAction, OPEN_FOLDER_SETTINGS_COMMAND, OpenGlobalKeybindingsAction, OpenSettings2Action } from 'vs/workbench/parts/preferences/browser/preferencesActions'; </del> <ins> import { OpenRawDefaultSettingsAction, OpenSettingsAction, OpenGlobalSettingsAction, OpenGlobalKeybindingsFileAction, OpenWorkspaceSettingsAction, OpenFolderSettingsAction, ConfigureLanguageBasedSettingsAction, OPEN_FOLDER_SETTINGS_COMMAND, OpenGlobalKeybindingsAction, OpenSettings2Action, OpenRawUserSettingsAction } from 'vs/workbench/parts/preferences/browser/preferencesActions'; </ins> import { IKeybindingsEditor, IPreferencesSearchService, CONTEXT_KEYBINDING_FOCUS, CONTEXT_KEYBINDINGS_EDITOR, CONTEXT_KEYBINDINGS_SEARCH_FOCUS, KEYBINDINGS_EDITOR_COMMAND_DEFINE, KEYBINDINGS_EDITOR_COMMAND_REMOVE, KEYBINDINGS_EDITOR_COMMAND_SEARCH, KEYBINDINGS_EDITOR_COMMAND_COPY, KEYBINDINGS_EDITOR_COMMAND_RESET, KEYBINDINGS_EDITOR_COMMAND_COPY_COMMAND, KEYBINDINGS_EDITOR_COMMAND_SHOW_SIMILAR, KEYBINDINGS_EDITOR_COMMAND_FOCUS_KEYBINDINGS, KEYBINDINGS_EDITOR_COMMAND_CLEAR_SEARCH_RESULTS


"editor.background": "#1f1f1f", "editor.findMatchBackground": "#9e6a03", "editor.foreground": "#ffffffd3", <del> "editorCursor.foreground": "#0078d4", </del> "editorGroup.border": "#ffffff17", "editorGroupHeader.tabsBackground": "#181818", "editorGroupHeader.tabsBorder": "#ffffff15",


return false; } <del> let rootPath = root.fsPath + (root.fsPath.endsWith(sep) ? '' : sep); let resourceFsPath = resource.fsPath; </del> <ins> let resourceFsPath = normalize(resource.fsPath); let rootPath = normalize(root.fsPath + (root.fsPath.endsWith(sep) ? '' : sep)); </ins> if (isUNC(root.fsPath) && isUNC(resource.fsPath)) { rootPath = rootPath.toLowerCase();


// Ask for confirmation const { confirmed } = await dialogService.confirm({ <del> message: localize('confirmClearMessage', "Do you want to clear the history of recently used commands?"), </del> <ins> message: localize('confirmClearMessage', "Do you want to clear the previous session command history?"), </ins> detail: localize('confirmClearDetail', "This action is irreversible!"), primaryButton: localize({ key: 'clearButtonLabel', comment: ['&& denotes a mnemonic'] }, "&&Clear"), type: 'warning'


switchSides = localize('switchSidesNoKb', "Run the command Diff Editor: Switch Side, which is currently not triggerable via keybinding, to toggle between the original and modified editors."); } <ins> const diffEditorActiveAnnouncement = localize('msg5', "The setting, accessibility.verbosity.diffEditorActive, controls if a diff editor announcement is made when it becomes the active editor."); </ins> const keys = ['accessibility.signals.diffLineDeleted', 'accessibility.signals.diffLineInserted', 'accessibility.signals.diffLineModified']; const content = [ localize('msg1', "You are in a diff editor."), localize('msg2', "View the next ({0}) or previous ({1}) diff in diff review mode, which is optimized for screen readers.", next, previous), switchSides, <ins> diffEditorActiveAnnouncement, </ins> localize('msg4', "To control which accessibility signals should be played, the following settings can be configured: {0}.", keys.join(', ')), ]; const commentCommandInfo = getCommentCommandInfo(keybindingService, contextKeyService, codeEditor);


}; const spanElement = (this.message.formatContent <del> ? renderFormattedText(this.message.content, renderOptions) : renderText(this.message.content, renderOptions)); </del> <ins> ? renderFormattedText(this.message.content!, renderOptions) : renderText(this.message.content!, renderOptions)); </ins> spanElement.classList.add(this.classForType(this.message.type)); const styles = this.stylesForType(this.message.type);


{ "name": "code-oss-dev", "version": "1.94.0", <del> "distro": "0e2e9472d115a44f86c2cc3ea26fcea692643ec3", </del> <ins> "distro": "a27dc893952c71fcdc7dc52f9ea3fe51add4fe83", </ins> "author": { "name": "Microsoft Corporation" },


return editor.getContribution<EditorDictation>(EditorDictation.ID); } <del> private readonly widget = this._register(new DictationWidget(this.editor)); </del> <ins> private readonly widget = this._register(new DictationWidget(this.editor, this.keybindingService)); </ins> private readonly editorDictationInProgress = EDITOR_DICTATION_IN_PROGRESS.bindTo(this.contextKeyService); private sessionDisposables = this._register(new MutableDisposable());


const toRender = this._render(visibleStartLineNumber, visibleEndLineNumber, decorationsToRender, this._glyphMarginDecorationLaneCount); const lineHeight = this._lineHeight.toString(); <del> const width = this._glyphMarginWidth.toString(); </del> <ins> const width = (Math.round(this._glyphMarginWidth / this._glyphMarginDecorationLaneCount)).toString(); </ins> const common = '" style="width:' + width + 'px' + ';height:' + lineHeight + 'px;'; const output: string[] = [];


import { Selection } from 'vs/editor/common/core/selection'; import { SingleTextEdit, TextEdit } from 'vs/editor/common/core/textEdit'; import { TextLength } from 'vs/editor/common/core/textLength'; <ins> import { ScrollType } from 'vs/editor/common/editorCommon'; </ins> import { Command, InlineCompletionContext, InlineCompletionTriggerKind, PartialAcceptTriggerKind } from 'vs/editor/common/languages'; import { ILanguageConfigurationService } from 'vs/editor/common/languages/languageConfigurationRegistry'; import { EndOfLinePreference, ITextModel } from 'vs/editor/common/model';


return this._commentThread; } <ins> public get expanded(): boolean | undefined { return this._isExpanded; } </ins> private _commentOptions: languages.CommentOptions | undefined; constructor(


getDefaultShell(options: IShellLaunchConfigResolveOptions): Promise<string>; getDefaultShellArgs(options: IShellLaunchConfigResolveOptions): Promise<string | string[]>; getEnvironment(remoteAuthority: string | undefined): Promise<IProcessEnvironment>; <del> createProfileFromShellAndShellArgs(shell?: unknown, shellArgs?: unknown): Promise<ITerminalProfile | undefined>; </del> <ins> createProfileFromShellAndShellArgs(shell?: unknown, shellArgs?: unknown): Promise<ITerminalProfile | string>; </ins> } export interface IShellLaunchConfigResolveOptions {


this._matchesCount.className = 'matchesCount'; } this._matchesCount.innerText = ''; <del> const label = count === undefined || count.resultCount === 0 ? `No Results` : `${count.resultIndex + 1} of ${count.resultCount}`; </del> <ins> let label; if (count?.resultCount === -1) { label = ''; } else { label = count === undefined || count.resultCount === 0 ? NLS_NO_RESULTS : strings.format(NLS_MATCHES_LOCATION, count.resultIndex + 1, count?.resultCount); } </ins> this._matchesCount.appendChild(document.createTextNode(label)); this._matchesCount.classList.toggle('no-results', !count || count.resultCount === 0); this._findInput?.domNode.insertAdjacentElement('afterend', this._matchesCount);


getSelection(): (MarkerTableItem | null)[] { const selection = this.table.getSelection(); <del> return selection.length > 0 ? [this.table.row(selection[0])] : []; </del> <ins> return selection.length > 0 ? [...selection.map(i => this.table.row(i))] : []; </ins> } getVisibleItemCount(): number {


"@typescript-eslint/eslint-plugin": "^5.57.0", "@typescript-eslint/experimental-utils": "^5.57.0", "@typescript-eslint/parser": "^5.57.0", <del> "@vscode/gulp-electron": "^1.35.0", </del> <ins> "@vscode/gulp-electron": "^1.36.0", </ins> "@vscode/l10n-dev": "0.0.21", "@vscode/telemetry-extractor": "^1.9.9", "@vscode/test-web": "^0.0.41",


getFocus(): (MarkerTableItem | null)[] { const focus = this.table.getFocus(); <del> return focus.length > 0 ? [this.table.row(focus[0])] : []; </del> <ins> return focus.length > 0 ? [...focus.map(f => this.table.row(f))] : []; </ins> } getHTMLElement(): HTMLElement {


async resetLocal(): Promise<void> { this.checkEnablement(); this.storageService.remove(LAST_SYNC_TIME_KEY, StorageScope.APPLICATION); <del> if (this.activeProfileSynchronizers) { for (const [synchronizer] of this.activeProfileSynchronizers.values()) { try { await synchronizer.resetLocal(); } catch (e) { this.logService.error(e); } </del> <ins> for (const [synchronizer] of this.activeProfileSynchronizers.values()) { try { await synchronizer.resetLocal(); } catch (e) { this.logService.error(e); </ins> } <del> this.clearActiveProfileSynchronizers(); </del> } <ins> this.clearActiveProfileSynchronizers(); </ins> this._onDidResetLocal.fire(); this.logService.info('Did reset the local sync state.'); }


"cssnano": "^4.1.11", "debounce": "^1.0.0", "deemon": "^1.4.0", <del> "electron": "19.0.11", </del> <ins> "electron": "19.0.12", </ins> "eslint": "8.7.0", "eslint-plugin-header": "3.1.1", "eslint-plugin-jsdoc": "^39.3.2",


if (temp) { return this.userDataProfilesService.createNamedProfile(`${profileName} ${this.getProfileNameIndex(profileName)}`, { ...options, transient: temp }); } <del> enum ImportProfileChoice { Overwrite = 0, CreateNew = 1, Cancel = 2 } const { result } = await this.dialogService.prompt<ImportProfileChoice>({ </del> <ins> const { confirmed } = await this.dialogService.confirm({ </ins> type: Severity.Info, <del> message: localize('profile already exists', "Profile with name '{0}' already exists. Do you want to overwrite it?", profileName), buttons: [ { label: localize({ key: 'overwrite', comment: ['&& denotes a mnemonic'] }, "&&Overwrite"), run: () => ImportProfileChoice.Overwrite }, { label: localize({ key: 'create new', comment: ['&& denotes a mnemonic'] }, "&&Create New Profile"), run: () => ImportProfileChoice.CreateNew }, ], cancelButton: { run: () => ImportProfileChoice.Cancel } }); if (result === ImportProfileChoice.Overwrite) { return profile; } if (result === ImportProfileChoice.Cancel) { return undefined; } // Create new profile const name = await this.quickInputService.input({ placeHolder: localize('name', "Profile name"), title: localize('create new title', "Create New Profile"), value: `${profileName} ${this.getProfileNameIndex(profileName)}`, validateInput: async (value: string) => { if (this.userDataProfilesService.profiles.some(p => p.name === value)) { return localize('profileExists', "Profile with name {0} already exists.", value); } return undefined; } </del> <ins> message: localize('profile already exists', "Profile with name '{0}' already exists. Do you want to replace its contents?", profileName), primaryButton: localize({ key: 'overwrite', comment: ['&& denotes a mnemonic'] }, "&&Replace") </ins> }); <del> if (!name) { </del> <ins> if (!confirmed) { </ins> return undefined; } <del> return this.userDataProfilesService.createNamedProfile(name); </del> <ins> return profile.isDefault ? profile : this.userDataProfilesService.updateProfile(profile, options); </ins> } else { return this.userDataProfilesService.createNamedProfile(profileName, { ...options, transient: temp }); }


{ link: 'foo 339', prefix: undefined, suffix: ' 339', hasRow: true, hasCol: false }, { link: 'foo 339:12', prefix: undefined, suffix: ' 339:12', hasRow: true, hasCol: true }, { link: 'foo 339.12', prefix: undefined, suffix: ' 339.12', hasRow: true, hasCol: true }, <ins> { link: 'foo 339.12-14', prefix: undefined, suffix: ' 339.12-14', hasRow: true, hasCol: true, hasRowEnd: false, hasColEnd: true }, { link: 'foo 339.12-341.14', prefix: undefined, suffix: ' 339.12-341.14', hasRow: true, hasCol: true, hasRowEnd: true, hasColEnd: true }, </ins> // Double quotes { link: '"foo",339', prefix: '"', suffix: '",339', hasRow: true, hasCol: false },


// Do not trigger state if current state is manual and incoming state is automatic if (!isManualToAutoTransition) { this.setState(newState); <ins> } else { // Reset the new state after getting code actions back. setTimeout(() => { this.setState(newState); }, 500); </ins> } }, undefined); this._codeActionOracle.value.trigger({ type: CodeActionTriggerType.Auto, triggerAction: CodeActionTriggerSource.Default });


{ "name": "code-oss-dev", "version": "1.88.0", <del> "distro": "37f287ed9d23ce03684ef672b6b295c13afc9fa5", </del> <ins> "distro": "340432a8308f66007779ec2133ee39e6995006cb", </ins> "author": { "name": "Microsoft Corporation" },


import { IKeyboardEvent } from 'vs/base/browser/keyboardEvent'; import { KeyCode } from 'vs/base/common/keyCodes'; <del> import { Disposable, toDisposable } from 'vs/base/common/lifecycle'; </del> <ins> import { Disposable, DisposableStore, toDisposable } from 'vs/base/common/lifecycle'; </ins> import { URI } from 'vs/base/common/uri'; import { IEditorConstructionOptions } from 'vs/editor/browser/config/editorConfiguration'; import { EditorExtensionsRegistry } from 'vs/editor/browser/editorExtensions';


background-size: 16px; } <del> @keyframes shift { 0% { transform: translateX(0px); } 33%{ transform: translateX(0.5px); } 66% { transform: translateX(-0.5px); } } .monaco-toolbar.config .monaco-action-bar .action-item { animation-duration: 1.2s; animation-iteration-count: infinite; animation-name: shift; } .monaco-toolbar.config .monaco-action-bar .action-item:nth-child(odd) { animation-delay: 0.6s; } </del> .monaco-dropdown-with-default { display: flex !important; flex-direction: row;


registerThemingParticipant((theme, collector) => { let editorGuideColor = theme.getColor(editorIndentGuides); if (editorGuideColor) { <del> collector.addRule(`.monaco-editor .lines-content .cigr { background-color: ${editorGuideColor}; }`); </del> <ins> collector.addRule(`.monaco-editor .lines-content .cigr { --box-shadow-color: ${editorGuideColor}; }`); </ins> } });


const disposable = new DisposableStore(); const notebook = workingCopy.model.notebookModel; <ins> // get initial cursor positions const activeCellEditor = getActiveCellCodeEditor(this.editorService); let selections; if (activeCellEditor) { selections = activeCellEditor.getSelections() ?? []; } </ins> try { const allCellEdits = await Promise.all(notebook.cells.map(async (cell) => { if (cell.cellKind !== CellKind.Code) {


isInMemory(): boolean { return this.options.hint === StorageHint.STORAGE_IN_MEMORY; } <del> override dispose(): void { this.flushDelayer.dispose(); super.dispose(); } </del> } export class InMemoryStorageDatabase implements IStorageDatabase {


context.subscriptions.push(cleaner); } <del> // Update new file contribution vscode.extensions.onDidChange(() => { vscode.commands.executeCommand('setContext', 'jupyterEnabled', vscode.extensions.getExtension('ms-toolsai.jupyter')); }); vscode.commands.executeCommand('setContext', 'jupyterEnabled', vscode.extensions.getExtension('ms-toolsai.jupyter')); </del> return { get dropCustomMetadata() { return !useCustomPropertyInMetadata();


cacheHitVar: NODE_MODULES_RESTORED displayName: Restore node_modules cache <del> - script: tar -xvzf .build/node_modules_cache/cache.tgz </del> <ins> - script: tar -xzf .build/node_modules_cache/cache.tgz </ins> condition: and(succeeded(), eq(variables.NODE_MODULES_RESTORED, 'true')) displayName: Extract node_modules cache


// ---- end view event handlers <ins> private _updateAnchorsViewPositions(): void { const keys = Object.keys(this._widgets); for (const widgetId of keys) { this._widgets[widgetId].updateAnchorViewPosition(); } } </ins> public addWidget(_widget: IContentWidget): void { const myWidget = new Widget(this._context, this._viewDomNode, _widget); this._widgets[myWidget.id] = myWidget;


private readonly pendingUpdates = new Map<string, number>(); private readonly throttle = 50; <del> private previousEditorInfo = new Map<string, LastScrollLocation>(); public isPrevEditorCustom = false; </del> <ins> private previousTextEditorInfo = new Map<string, LastScrollLocation>(); private previousStaticEditorInfo = new Map<string, LastScrollLocation>(); </ins> constructor() { super(); if (vscode.window.activeTextEditor) { const line = getVisibleLine(vscode.window.activeTextEditor); <del> this.setPreviousEditorLine({ uri: vscode.window.activeTextEditor.document.uri, line: line ?? 0 }); </del> <ins> this.setPreviousTextEditorLine({ uri: vscode.window.activeTextEditor.document.uri, line: line ?? 0 }); </ins> } this._register(vscode.window.onDidChangeTextEditorVisibleRanges(event => {


compositeSwitcherBar.push(this.compositeOverflowAction, { label: false, icon: true }); } <del> this._onDidChange.fire(); </del> <ins> if (!donotTrigger) { this._onDidChange.fire(); } </ins> } private getOverflowingComposites(): { id: string; name?: string }[] {


message += 'n'; } } <del> this._currentContent = message + provider.provideContent() + readMoreLink + disableHelpHint; </del> <ins> const exitThisDialogHint = localize('exit', 'nnExit this dialog (Escape).'); this._currentContent = message + provider.provideContent() + readMoreLink + disableHelpHint + exitThisDialogHint; </ins> this._updateContextKeys(provider, true); this._getTextModel(URI.from({ path: `accessible-view-${provider.verbositySettingKey}`, scheme: 'accessible-view', fragment: this._currentContent })).then((model) => {


public provideCompletionItems(document: TextDocument, position: Position, token: CancellationToken): Promise<CompletionItem[]> { let result: CompletionItem[] = []; <ins> let shouldProvideCompletionItems = workspace.getConfiguration('php').get<boolean>('builtInCompletions.enable', true); if (!shouldProvideCompletionItems) { return Promise.resolve(result); } </ins> var range = document.getWordRangeAtPosition(position); var prefix = range ? document.getText(range) : ''; if (!range) {


readonly persistentProcessId: number | undefined; /** <del> * The id of a persistent process during the shutdown process */ shutdownPersistentProcessId: number | undefined; /** </del> * Whether the process should be persisted across reloads. */ readonly shouldPersist: boolean;


} private onModelAdded(model: ITextModel): void { <del> const uri = model.uri; const supportedSchemes = [Schemas.untitled, Schemas.file, Schemas.vscodeRemote, Schemas.vscodeNotebookCell]; </del> <ins> const uri = model.uri.scheme === Schemas.vscodeNotebookCell ? CellUri.parse(model.uri)?.notebook : model.uri; const supportedSchemes = [Schemas.untitled, Schemas.file, Schemas.vscodeRemote]; </ins> if (!uri || !supportedSchemes.includes(uri.scheme)) { return; }


'libdrm2 (>= 2.4.38)', 'libexpat1 (>= 2.0.1)', 'libgbm1 (>= 8.1~0)', <del> 'libgcc-s1 (>= 3.0)', </del> 'libglib2.0-0 (>= 2.16.0)', 'libglib2.0-0 (>= 2.39.4)', 'libgtk-3-0 (>= 3.9.10)',


} export default class LinkProvider implements vscode.DocumentLinkProvider { <del> private readonly linkPattern = /([((![[^]]*?](s*)([^s()]+?)s*)]|(?:]|[^]])*])(s*)(([^s()]|(S*?))+)s*(".*?")?)/g; </del> <ins> private readonly linkPattern = /([((![[^]]*?](s*)([^s()]+?)s*)]|(?:]|[^]])*])(s*)(([^s()]|([^s()]*?))+)s*(".*?")?)/g; </ins> private readonly referenceLinkPattern = /([((?:]|[^]])+)][s*?)([^s]]*?)]/g; private readonly definitionPattern = /^([t ]*[(?!^)((?:]|[^]])+)]:s*)(S+)/gm;


]; return toDisposable(() => { <del> if (!ignoreDisposeAndBlur) { blurDisposable.dispose(); done(false); } </del> <ins> blurDisposable.dispose(); done(false, false); </ins> }); }


body { padding: 10px 20px; line-height: 22px; <del> max-width: 780px; </del> <ins> max-width: 882px; </ins> margin: 0 auto; }


registration.dispose(); }); <del> let c = commands.executeCommand('vscode.diff').then(() => assert.ok(false), () => assert.ok(true)); let d = commands.executeCommand('vscode.diff', 1, 2, 3).then(() => assert.ok(false), () => assert.ok(true)); </del> <ins> let c = commands.executeCommand('vscode.diff', Uri.parse('sc:a'), Uri.parse('sc:b'), 'Title', { selection: new Range(new Position(1, 1), new Position(1, 2)) }).then(value => { assert.ok(value === void 0); registration.dispose(); }); </ins> <del> return Promise.all([a, b, c, d]); </del> <ins> let d = commands.executeCommand('vscode.diff').then(() => assert.ok(false), () => assert.ok(true)); let e = commands.executeCommand('vscode.diff', 1, 2, 3).then(() => assert.ok(false), () => assert.ok(true)); return Promise.all([a, b, c, d, e]); </ins> }); test('api-command: vscode.open', function () {


@IExtHostExtensionService extensionService: IExtHostExtensionService, @IExtHostConfiguration configurationService: IExtHostConfiguration, @IExtHostTerminalService private _terminalService: IExtHostTerminalService, <ins> @IExtHostTerminalShellIntegration private _terminalShellIntegrationService: IExtHostTerminalShellIntegration, </ins> @IExtHostEditorTabs editorTabs: IExtHostEditorTabs, @IExtHostVariableResolverProvider variableResolver: IExtHostVariableResolverProvider, @IExtHostCommands commands: IExtHostCommands,


return; // already initialized } <del> const quality = env.quality || 'stable'; let feedUrl = UpdateManager.getUpdateFeedUrl(quality); </del> <ins> const channel = UpdateManager.getUpdateChannel(); const feedUrl = UpdateManager.getUpdateFeedUrl(channel); </ins> if (!feedUrl) { return; // updates not available } <del> this._channel = quality; </del> <ins> this._channel = channel; </ins> this._feedUrl = feedUrl; this.raw.setFeedURL(feedUrl);


set -e node build/azure-pipelines/common/listNodeModules.js .build/node_modules_list.txt mkdir -p .build/node_modules_cache <del> tar -cvzf .build/node_modules_cache/cache.tgz --files-from .build/node_modules_list.txt </del> <ins> tar -czf .build/node_modules_cache/cache.tgz --files-from .build/node_modules_list.txt </ins> condition: and(succeeded(), ne(variables.NODE_MODULES_RESTORED, 'true')) displayName: Create node_modules archive


export const allApiProposals = Object.freeze({ authSession: 'https://raw.githubusercontent.com/microsoft/vscode/main/src/vscode-dts/vscode.proposed.authSession.d.ts', codiconDecoration: 'https://raw.githubusercontent.com/microsoft/vscode/main/src/vscode-dts/vscode.proposed.codiconDecoration.d.ts', <del> commentsResolvedState: 'https://raw.githubusercontent.com/microsoft/vscode/main/src/vscode-dts/vscode.proposed.commentsResolvedState.d.ts', </del> contribCommentEditorActionsMenu: 'https://raw.githubusercontent.com/microsoft/vscode/main/src/vscode-dts/vscode.proposed.contribCommentEditorActionsMenu.d.ts', contribCommentPeekContext: 'https://raw.githubusercontent.com/microsoft/vscode/main/src/vscode-dts/vscode.proposed.contribCommentPeekContext.d.ts', contribCommentThreadAdditionalMenu: 'https://raw.githubusercontent.com/microsoft/vscode/main/src/vscode-dts/vscode.proposed.contribCommentThreadAdditionalMenu.d.ts',


// reset selection to placeholder session.next(); <del> assert.equal(session.isSelectionWithinPlaceholders(), false); </del> <ins> assert.equal(session.isSelectionWithinPlaceholders(), true); </ins> assert.equal(session.isAtLastPlaceholder, true); assertSelections(editor, new Selection(1, 13, 1, 13), new Selection(2, 17, 2, 17)); });


* Defaults to true. */ sticky?: boolean; <ins> /** * Should the hover be shown below the line if possible? * Defaults to false. */ below?: boolean; </ins> } /**


"browser": "./dist/browser/cssServerMain", "dependencies": { "vscode-css-languageservice": "^6.0.1", <del> "vscode-languageserver": "^8.0.1", </del> <ins> "vscode-languageserver": "^8.0.2-next.4", </ins> "vscode-uri": "^3.0.3" }, "devDependencies": {


disturl "https://electronjs.org/headers" <del> target "22.3.5" </del> <ins> target "22.3.6" </ins> runtime "electron" build_from_source "true"


"@vscode/iconv-lite-umd": "0.7.0", "@vscode/policy-watcher": "^1.1.4", "@vscode/proxy-agent": "^0.14.1", <del> "@vscode/ripgrep": "^1.15.4", </del> <ins> "@vscode/ripgrep": "^1.15.5", </ins> "@vscode/spdlog": "^0.13.10", "@vscode/sqlite3": "5.1.6-vscode", "@vscode/sudo-prompt": "9.3.1",


} // If there is more than one agent with this name, and the user picked it from the suggest widget, then the selected agent should be in the <del> // context and we use that one. Otherwise just pick the first. </del> <ins> // context and we use that one. </ins> const agent = agents.length > 1 && context?.selectedAgent ? context.selectedAgent : <del> agents[0]; if (!agent || !agent.locations.includes(location)) { </del> <ins> agents.find((a) => a.locations.includes(location)); if (!agent) { </ins> return; }


const nextKeybinding = this._keybindingService.lookupKeybinding(AccessibilityCommandId.ShowNext)?.getAriaLabel(); const previousKeybinding = this._keybindingService.lookupKeybinding(AccessibilityCommandId.ShowPrevious)?.getAriaLabel(); if (nextKeybinding && previousKeybinding) { <del> hint = localize('accessibleViewNextPreviousHint', "Show the next ({0}) or previous ({1}) item", nextKeybinding, previousKeybinding); </del> <ins> hint = localize('accessibleViewNextPreviousHint', "Show the next ({0}) or previous ({1}) item.", nextKeybinding, previousKeybinding); </ins> } else { <del> hint = localize('chatAccessibleViewNextPreviousHintNoKb', "Show the next or previous item by configuring keybindings for the Show Next & Previous in Accessible View commands"); </del> <ins> hint = localize('chatAccessibleViewNextPreviousHintNoKb', "Show the next or previous item by configuring keybindings for the Show Next & Previous in Accessible View commands."); </ins> } return hint; }


const lineHeight = this.editor.getOption(EditorOption.lineHeight); const width = this.editor.getLayoutInfo().contentWidth * 0.7; <del> this.elements.main.style.setProperty('--vscode-editor-dictation-widget-height', `${lineHeight}px`); this.elements.main.style.setProperty('--vscode-editor-dictation-widget-width', `${width}px`); </del> <ins> this.domNode.style.setProperty('--vscode-editor-dictation-widget-height', `${lineHeight}px`); this.domNode.style.setProperty('--vscode-editor-dictation-widget-width', `${width}px`); </ins> return null; }


"mocha-multi-reporters": "^1.5.1", "npm-run-all": "^4.1.5", "opn": "^6.0.0", <ins> "os-browserify": "^0.3.0", </ins> "p-all": "^1.0.0", "path-browserify": "^1.0.1", <del> "os-browserify": "^0.3.0", </del> "postcss": "^8.4.33", "postcss-nesting": "^12.0.2", "pump": "^1.0.1",


return e instanceof HTMLDivElement || e instanceof getWindow(e as Node).HTMLDivElement; } <ins> export function isSVGElement(e: unknown): e is SVGElement { // eslint-disable-next-line no-restricted-syntax return e instanceof SVGElement || e instanceof getWindow(e as Node).SVGElement; } </ins> export function isMouseEvent(e: unknown): e is MouseEvent { // eslint-disable-next-line no-restricted-syntax return e instanceof MouseEvent || e instanceof getWindow(e as UIEvent).MouseEvent;


}); test('fuzzyScore2 (multiple queries)', function () { <del> const target = 'HeLlo-World'; </del> <ins> const target = 'HelLo-World'; </ins> const [firstSingleScore, firstSingleMatches] = _doScore2(target, 'HelLo'); const [secondSingleScore, secondSingleMatches] = _doScore2(target, 'World');


import * as viewEvents from 'vs/editor/common/view/viewEvents'; import { registerThemingParticipant } from 'vs/platform/theme/common/themeService'; import { editorRuler } from 'vs/editor/common/view/editorColorRegistry'; <del> import * as dom from 'vs/base/browser/dom'; </del> export class Rulers extends ViewPart {


private _renderBadges(historyItem: ISCMHistoryItem, templateData: HistoryItemTemplate): void { templateData.elementDisposables.add(autorun(reader => { const labelConfig = this._badgesConfig.read(reader); <ins> const firstColoredRef = historyItem.references?.find(ref => ref.color); </ins> templateData.labelContainer.textContent = ''; <del> const firstColoredRef = historyItem.references?.find(ref => ref.color); for (const ref of historyItem.references ?? []) { if (!ref.color && labelConfig === 'filter') { </del> <ins> // Group history item references by color const historyItemRefsByColor = groupBy2( (historyItem.references ?? []), ref => ref.color ? ref.color : ''); for (const [key, historyItemRefs] of Object.entries(historyItemRefsByColor)) { // Skip badges with no color if (key === '' && labelConfig !== 'all') { </ins> continue; } <del> if (ref.icon && ThemeIcon.isThemeIcon(ref.icon)) { const elements = h('div.label', { style: { color: ref.color ? asCssVariable(historyItemHoverLabelForeground) : asCssVariable(foreground), backgroundColor: ref.color ? asCssVariable(ref.color) : asCssVariable(historyItemHoverDefaultLabelBackground) } }, [ h('div.icon@icon'), h('div.description@description') ]); elements.icon.classList.add(...ThemeIcon.asClassNameArray(ref.icon)); elements.description.textContent = ref.name; elements.description.style.display = ref === firstColoredRef ? '' : 'none'; </del> <ins> // Group history item references by icon const historyItemRefByIconId = groupBy2(historyItemRefs, ref => ThemeIcon.isThemeIcon(ref.icon) ? ref.icon.id : ''); for (const [key, historyItemRefs] of Object.entries(historyItemRefByIconId)) { if (key === '' || historyItemRefs.length === 0) { continue; } </ins> <del> append(templateData.labelContainer, elements.root); </del> <ins> this._renderBadge(historyItemRefs[0], historyItemRefs[0] === firstColoredRef, templateData); </ins> } } })); } <ins> private _renderBadge(historyItemRef: ISCMHistoryItemRef, showDescription: boolean, templateData: HistoryItemTemplate): void { if (!ThemeIcon.isThemeIcon(historyItemRef.icon)) { return; } const elements = h('div.label', { style: { color: historyItemRef.color ? asCssVariable(historyItemHoverLabelForeground) : asCssVariable(foreground), backgroundColor: historyItemRef.color ? asCssVariable(historyItemRef.color) : asCssVariable(historyItemHoverDefaultLabelBackground) } }, [ h('div.icon@icon'), h('div.description@description') ]); elements.icon.classList.add(...ThemeIcon.asClassNameArray(historyItemRef.icon)); elements.description.textContent = historyItemRef.name; elements.description.style.display = showDescription ? '' : 'none'; append(templateData.labelContainer, elements.root); } </ins> private _getHoverActions(historyItem: ISCMHistoryItem) { return [ {


(progress, token) => this.git.clone(url!, { parentPath: parentPath!, progress, recursive: options.recursive }, token) ); <ins> if (options.ref !== undefined) { const repository = this.model.getRepository(Uri.file(repositoryPath)); await repository?.checkout(options.ref); } </ins> const config = workspace.getConfiguration('git'); const openAfterClone = config.get<'always' | 'alwaysNewWindow' | 'whenNoFolderOpen' | 'prompt'>('openAfterClone');


const disableKeybinding = this._keybindingService.lookupKeybinding('editor.action.accessibleViewDisableHint', this._contextKeyService)?.getAriaLabel(); return !!disableKeybinding ? localize('acessibleViewDisableHint', "Disable the hint to open the accessible view by pressing ({0}).", disableKeybinding) : localize('accessibleViewDisableHintNoKb', 'Add a keybinding for the command Disable Accessible View Hint to disable this hint."'); } <ins> private _getGoToSymbolHint(provider: IAccessibleContentProvider): string { const goToSymbolKb = this._keybindingService.lookupKeybinding('editor.action.accessibleViewGoToSymbol')?.getAriaLabel(); const hasSymbolProvider = provider.options.language === 'markdown' || provider.options.language === undefined || !!provider.getSymbols; let goToSymbolHint = ''; if (hasSymbolProvider) { if (goToSymbolKb) { goToSymbolHint = localize('goToSymbolHint', 'Go to a symbol within the accessible view (({0}).', goToSymbolKb); } else { goToSymbolHint = localize('goToSymbolHintNoKb', 'To go to a symbol within the accessible view, configure a keybinding for the command Go To Symbol in Accessible View.', goToSymbolKb); } } return goToSymbolHint; } </ins> } export class AccessibleViewService extends Disposable implements IAccessibleViewService {


return sorted; } <ins> private extname(file: URI): string { const ext = resources.extname(file); if (ext.length === 0) { const basename = resources.basename(file); if (basename.startsWith('.')) { return basename; } } else { return ext; } return ''; } </ins> private filterFile(file: URI): boolean { if (this.options.filters) { <del> const ext = resources.extname(file); </del> <ins> const ext = this.extname(file); </ins> for (let i = 0; i < this.options.filters.length; i++) { for (let j = 0; j < this.options.filters[i].extensions.length; j++) { const testExt = this.options.filters[i].extensions[j];


[ConsolidatedRunButton]: { description: nls.localize('notebook.consolidatedRunButton.description', "Control whether extra actions are shown in a dropdown next to the run button."), type: 'boolean', <del> default: true, </del> <ins> default: false, </ins> tags: ['notebookLayout'] }, [NotebookCellEditorOptionsCustomizations]: editorOptionsCustomizationSchema


lastIncludedCharIndex = j - 1; do { chCode = line.charCodeAt(lastIncludedCharIndex); <del> chClass = (chCode < characterClassesLength ? characterClasses[chCode] : CharacterClass.None); </del> <ins> chClass = characterClassifier.classify(chCode); </ins> if (chClass !== CharacterClass.CannotEndIn) { break; }


} if (this.extension.deprecationInfo) { <del> const result = await this.dialogService.confirm({ type: 'warning', message: localize('install confirmation', "Are you sure you want to install '{0}'?", this.extension.displayName), detail: localize('deprecated message', "This extension is no longer being maintained and is deprecated."), primaryButton: localize('install anyway', "Install Anyway"), }); if (!result.confirmed) { </del> <ins> const result = await this.dialogService.show( Severity.Warning, localize('install confirmation', "Are you sure you want to install '{0}'?", this.extension.displayName), [ localize('install anyway', "Install Anyway"), localize('open extension', "Open Extension"), localize('cancel', "Cancel"), ], { detail: localize('deprecated message', "This extension is no longer being maintained and is deprecated."), cancelId: 2, }); if (result.choice === 1) { return this.extensionsWorkbenchService.open(this.extension, { showPreReleaseVersion: this.installPreReleaseVersion }); } if (result.choice === 2) { </ins> return; } }


} context.taskLoadIssues = Objects.deepClone(baseLoadIssues); } <del> if ((defaultBuildTask.rank > -1) && (defaultBuildTask.rank < 2) && defaultBuildTask.task) { </del> <ins> // There is some special logic for tasks with the labels "build" and "test". // Even if they are not marked as a task group Build or Test, we automagically group them as such. // However, if they are already grouped as Build or Test, we don't need to add this grouping. const defaultBuildGroupName = Types.isString(defaultBuildTask.task?.configurationProperties.group) ? defaultBuildTask.task?.configurationProperties.group : defaultBuildTask.task?.configurationProperties.group?._id; const defaultTestTaskGroupName = Types.isString(defaultTestTask.task?.configurationProperties.group) ? defaultTestTask.task?.configurationProperties.group : defaultTestTask.task?.configurationProperties.group?._id; if ((defaultBuildGroupName !== Tasks.TaskGroup.Build._id) && (defaultBuildTask.rank > -1) && (defaultBuildTask.rank < 2) && defaultBuildTask.task) { </ins> defaultBuildTask.task.configurationProperties.group = Tasks.TaskGroup.Build; <del> } else if ((defaultTestTask.rank > -1) && (defaultTestTask.rank < 2) && defaultTestTask.task) { </del> <ins> } else if ((defaultTestTaskGroupName !== Tasks.TaskGroup.Test._id) && (defaultTestTask.rank > -1) && (defaultTestTask.rank < 2) && defaultTestTask.task) { </ins> defaultTestTask.task.configurationProperties.group = Tasks.TaskGroup.Test; }


// Note these strings are intentionally not localized // as we want users to file issues in english return { <ins> extensionId: 'vscode.typescript-language-features', </ins> issueTitle: `TS Server fatal error:  ${error.serverMessage}`, issueBody: `**TypeScript Version:** ${error.version.apiVersion?.fullVersionString}


import * as dom from 'vs/base/browser/dom'; import { IActionViewItem } from 'vs/base/browser/ui/actionbar/actionbar'; <del> import { IAction } from 'vs/base/common/actions'; </del> <ins> import { Action, IAction } from 'vs/base/common/actions'; </ins> import { CancellationToken } from 'vs/base/common/cancellation'; import { DropdownWithPrimaryActionViewItem } from 'vs/platform/actions/browser/dropdownWithPrimaryActionViewItem'; import { IMenu, IMenuService, MenuId, MenuItemAction } from 'vs/platform/actions/common/actions';


test('Terminal.sendText should fire Termnial.onInput', (done) => { const reg1 = window.onDidOpenTerminal(terminal => { reg1.dispose(); <del> const reg2 = renderer.onInput(data => { </del> <ins> const reg2 = renderer.onDidAcceptInput(data => { </ins> assert.equal(data, 'bar'); reg2.dispose(); const reg3 = window.onDidCloseTerminal(() => {


"cssnano": "^4.1.11", "debounce": "^1.0.0", "deemon": "^1.8.0", <del> "electron": "22.3.5", </del> <ins> "electron": "22.3.6", </ins> "eslint": "8.36.0", "eslint-plugin-header": "3.1.1", "eslint-plugin-jsdoc": "^39.3.2",


cursor: pointer; appearance: auto; border: none; <ins> border-right: 6px solid transparent; padding-left: 10px; </ins> } .issue-reporter-body #similar-issues {


import { importAMDNodeModule } from 'vs/amdX'; import { $, addDisposableListener, addStandardDisposableListener, getWindow } from 'vs/base/browser/dom'; import { CancelablePromise, createCancelablePromise } from 'vs/base/common/async'; <del> import { debounce, memoize, throttle } from 'vs/base/common/decorators'; </del> <ins> import { memoize, throttle } from 'vs/base/common/decorators'; </ins> import { Event } from 'vs/base/common/event'; import { Disposable, MutableDisposable, combinedDisposable, toDisposable } from 'vs/base/common/lifecycle'; import { removeAnsiEscapeCodes } from 'vs/base/common/strings';


}, { "name": "border-image-width", <del> "desc": "The four values of 'border-image-width' specify offsets that are used to divide the border image area into nine parts. They represent inward distances from the the top, right, bottom, and left sides of the area, respectively.", </del> <ins> "desc": "The four values of 'border-image-width' specify offsets that are used to divide the border image area into nine parts. They represent inward distances from the top, right, bottom, and left sides of the area, respectively.", </ins> "browsers": "FF13,IE11", "restriction": "length, percentage, number", "values": []


} if (keepPosition) { <del> return new ReplaceCommandWithoutChangingPosition(range, beforeText + config.normalizeIndentation(ir.afterEnter), true); </del> <ins> return new ReplaceCommandWithoutChangingPosition(range, 'n' + config.normalizeIndentation(ir.afterEnter), true); </ins> } else { let offset = 0; if (oldEndColumn <= firstNonWhitespace + 1) {


} private set scrollHeight(scrollHeight: number) { <del> this.scrollableElement.setScrollDimensions({ scrollHeight }); </del> <ins> const horizontalScrollHeight = this.horizontalScrolling ? 10 : 0; this.scrollableElement.setScrollDimensions({ scrollHeight: scrollHeight + horizontalScrollHeight }); </ins> } public get viewWidth(): number {


return a.zIndex - b.zIndex; } <ins> public static equals(a: OverviewRulerDecorationsGroup, b: OverviewRulerDecorationsGroup): boolean { return ( a.color === b.color && a.zIndex === b.zIndex && arrays.equals(a.data, b.data) ); } </ins> public static equalsArr(a: OverviewRulerDecorationsGroup[], b: OverviewRulerDecorationsGroup[]): boolean { <del> if (a.length !== b.length) { return false; } for (let i = 0, len = a.length; i < len; i++) { if (OverviewRulerDecorationsGroup.cmp(a[i], b[i]) !== 0) { return false; } } return true; </del> <ins> return arrays.equals(a, b, OverviewRulerDecorationsGroup.equals); </ins> } }


__vsc_precmd } <del> if [[ "$PROMPT_COMMAND" =~ (.+;.+) ]]; then # item1;item2... __vsc_original_prompt_command="$PROMPT_COMMAND" else # (item1, item2...) __vsc_original_prompt_command=${PROMPT_COMMAND[@]} fi </del> <ins> # PROMPT_COMMAND arrays and strings seem to be handled the same (handling only the first entry of # the array?) __vsc_original_prompt_command=$PROMPT_COMMAND </ins> if [[ -z "${bash_preexec_imported:-}" ]]; then if [[ -n "$__vsc_original_prompt_command" && "$__vsc_original_prompt_command" != "__vsc_prompt_cmd" ]]; then


"semver": "4.3.6", "vscode-extension-telemetry": "^0.0.5", "vscode-nls": "^2.0.1", <del> "typescript": "2.1.5-insiders.20161229" </del> <ins> "typescript": "2.1.5" </ins> }, "devDependencies": { "@types/semver": "^5.3.30"


import { Delayer } from 'vs/base/common/async'; import { KeyCode, KeyMod } from 'vs/base/common/keyCodes'; import { FindReplaceState } from 'vs/editor/contrib/find/findState'; <ins> import { IMessage as InputBoxMessage } from 'vs/base/browser/ui/inputbox/inputBox'; </ins> import { SimpleButton } from 'vs/editor/contrib/find/findWidget'; import { IContextKeyService } from 'vs/platform/contextkey/common/contextkey'; import { IContextViewService } from 'vs/platform/contextview/browser/contextView';


import { CancellationToken } from 'vs/base/common/cancellation'; import { KeyCode, KeyMod } from 'vs/base/common/keyCodes'; import { DisposableStore } from 'vs/base/common/lifecycle'; <del> import { assertIsDefined } from 'vs/base/common/types'; </del> <ins> import { assertIsDefined, withNullAsUndefined } from 'vs/base/common/types'; </ins> import { URI } from 'vs/base/common/uri'; import 'vs/css!./media/searchEditor'; import { CodeEditorWidget } from 'vs/editor/browser/widget/codeEditorWidget';


} } // New item was added <del> else if (template.objectWidget.isItemNew(e.originalItem)) { </del> <ins> else if (template.objectWidget.isItemNew(e.originalItem) && e.item.key.data !== '') { </ins> newValue[e.item.key.data] = e.item.value.data; newItems.push(e.item); }


if (!profileContentHandler) { return; } <del> const saveResult = await profileContentHandler.saveProfile(profile.name, JSON.stringify(profile), CancellationToken.None); </del> <ins> const saveResult = await profileContentHandler.saveProfile(profile.name.replace('/', '-'), JSON.stringify(profile), CancellationToken.None); </ins> if (!saveResult) { return; }


} function consumeBlockCommentBackwards() { <del> if (stream.peek() === slash) { </del> <ins> if (!stream.sof() && stream.peek() === slash) { </ins> if (stream.backUp(1) === star) { stream.pos = findOpeningCommentBeforePosition(stream.pos) ?? startOffset; } else {


private toDispose: lifecycle.IDisposable[]; private hoverWidget: DebugHoverWidget; <ins> private nonDebugHoverPosition: Position; </ins> private hoverRange: Range; private breakpointHintDecoration: string[];


breakpoints.forEach(bp => this.debugService.removeBreakpoints(bp.getId())); } } else if (canSetBreakpoints) { <del> this.debugService.addBreakpoints(uri, [{ lineNumber }]); </del> <ins> this.debugService.addBreakpoints(uri, [{ lineNumber }], `debugEditorGutter`); </ins> } } }));


disturl "https://electronjs.org/headers" <del> target "25.8.4" ms_build_id "24154031" </del> <ins> target "25.9.1" ms_build_id "24472542" </ins> runtime "electron" build_from_source "true"


readonly viewType: string, private readonly _workingCopyManager: IFileWorkingCopyManager<NotebookFileWorkingCopyModel, NotebookFileWorkingCopyModel>, @ILifecycleService lifecycleService: ILifecycleService, <del> @IFilesConfigurationService private readonly _filesConfigurationService: IFilesConfigurationService, @IExtensionService extensionService: IExtensionService </del> <ins> @IFilesConfigurationService private readonly _filesConfigurationService: IFilesConfigurationService </ins> ) { super(); if (this.viewType === 'interactive') { lifecycleService.onBeforeShutdown(async e => e.veto(this.onBeforeShutdown(), 'veto.InteractiveWindow')); } <del> this._register(extensionService.onWillStop(e => { if (!this.isDirty()) { return; } e.veto((async () => { const didSave = await this._workingCopy?.save(); if (!didSave) { // Veto return true; } return false; // Don't veto })(), localize('vetoExtHostRestart', "Notebook '{0}' could not be saved.", this._workingCopy?.name)); })); </del> } private async onBeforeShutdown() {


assert.strictEqual(document.getText(), 'foobarhellonworld'); assert.deepStrictEqual(edt.selections, [new vscode.Selection(0, 0, 0, 3)]); }); <ins> test('Support creating binary files in a WorkspaceEdit', async function (): Promise<any> { const fileUri = vscode.Uri.parse(`${testFs.scheme}:/${rndName()}`); const data = Buffer.from('Hello Binary Files'); const ws = new vscode.WorkspaceEdit(); ws.createFile(fileUri, { contents: data, ignoreIfExists: false, overwrite: false }); const success = await vscode.workspace.applyEdit(ws); assert.ok(success); const actual = await vscode.workspace.fs.readFile(fileUri); assert.deepStrictEqual(actual, data); }); </ins> });


border: none !important; } <del> .monaco-workbench .part > .title > .title-actions .switch-terminal > .monaco-select-box { </del> <ins> .monaco-workbench .part.sidebar > .title > .title-actions .switch-terminal > .monaco-select-box { </ins> padding: 0 22px 0 6px; }


"smoketest": "cd test/smoke && node test/index.js", "download-builtin-extensions": "node build/lib/builtInExtensions.js", "monaco-compile-check": "tsc -p src/tsconfig.monaco.json --noEmit", <ins> "tsec-compile-check": "node_modules/tsec/bin/tsec -p src/tsconfig.json --noEmit", </ins> "valid-layers-check": "node build/lib/layersChecker.js", "strict-function-types-watch": "tsc --watch -p src/tsconfig.json --noEmit --strictFunctionTypes", "update-distro": "node build/npm/update-distro.js",


const src = token.attrGet('src'); if (src) { <del> env.containingImages.push({ src }); </del> <ins> env.containingImages?.push({ src }); </ins> const imgHash = hash(src); token.attrSet('id', `image-hash-${imgHash}`); }


dependencies: is-number "^7.0.0" <del> typescript@5.4.3: version "5.4.3" resolved "https://registry.yarnpkg.com/typescript/-/typescript-5.4.3.tgz#5c6fedd4c87bee01cd7a528a30145521f8e0feff" integrity sha512-KrPd3PKaCLr78MalgiwJnA25Nm8HAmdwN3mYUYZgG/wizIo9EainNVQI9/yDavtVFRN2h3k8uf3GLHuhDMgEHg== </del> <ins> typescript@5.4.4: version "5.4.4" resolved "https://registry.yarnpkg.com/typescript/-/typescript-5.4.4.tgz#eb2471e7b0a5f1377523700a21669dce30c2d952" integrity sha512-dGE2Vv8cpVvw28v8HCPqyb08EzbBURxDpuhJvTrusShUfGnhHBafDsLdS1EhhxyL6BJQE+2cT3dDPAv+MQ6oLw== </ins> vscode-grammar-updater@^1.1.0: version "1.1.0"


/* #endregion */ <del> .interactive-response-progress-tree .monaco-tl-row:hover { </del> <ins> .interactive-response-progress-tree .monaco-list-row:not(.selected) .monaco-tl-row:hover { </ins> background-color: var(--vscode-list-hoverBackground); }


protected createEditor(parent: HTMLElement): void { this._rootElement = DOM.append(parent, DOM.$('.notebook-editor')); <ins> this._rootElement.id = `notebook-editor-element-${generateUuid()}`; </ins> } getDomNode() {


<del> <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="3 3 16 16" enable-background="new 3 3 16 16"><polygon fill="#424242" points="12.597,11.042 15.4,13.845 13.844,15.4 11.042,12.598 8.239,15.4 6.683,13.845 9.485,11.042 6.683,8.239 8.238,6.683 11.042,9.486 13.845,6.683 15.4,8.239"/></svg> </del>  No newline at end of file <ins> <svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg"><path d="M9.784 8L13 11.217 11.215 13 8.001 9.786 4.785 13 3 11.216l3.214-3.215L3 4.785 4.784 3 8 6.216 11.216 3 13 4.785 9.784 8.001z" fill="#424242"/></svg> </ins>  No newline at end of file


const position = editor.getPosition(); const uri = editor.getModel().uri; const bpExists = !!(debugService.getModel().getBreakpoints({ column: position.column, lineNumber: position.lineNumber, uri }).length); <del> return (bpExists ? Promise.resolve(null) : <Promise<any>>debugService.addBreakpoints(uri, [{ lineNumber: position.lineNumber, column: position.column }])).then((breakpoints) => { </del> <ins> return (bpExists ? Promise.resolve(null) : <Promise<any>>debugService.addBreakpoints(uri, [{ lineNumber: position.lineNumber, column: position.column }], 'debugEditorActions.runToCursorAction')).then((breakpoints) => { </ins> if (breakpoints && breakpoints.length) { breakpointToRemove = breakpoints[0]; }


public async ensureMarkupCell(info: webviewMessages.IMarkupCellInitialization): Promise<void> { let cell = this._markupCells.get(info.cellId); if (cell) { <del> cell.element.style.visibility = info.visible ? 'visible' : 'hidden'; </del> <ins> cell.element.style.visibility = info.visible ? '' : 'hidden'; </ins> await cell.updateContentAndRender(info.content, info.metadata); } else { cell = await this.createMarkupCell(info, info.offset, info.visible);


return false; } <del> if (allPossibleSelections.has(0)) { // selection overlaps with a final tab stop which means // we done return false; } </del> // add selections from 'this' snippet so that we know all // selections for this placeholder allPossibleSelections.forEach((array, index) => {


async getEnvironment(): Promise<IProcessEnvironment> { return process.env; } getSafeConfigValue(key: string, os: OperatingSystem): unknown | undefined { return undefined; } getSafeConfigValueFullKey(key: string): unknown | undefined { return undefined; } <del> createProfileFromShellAndShellArgs(shell?: unknown, shellArgs?: unknown): Promise<ITerminalProfile | undefined> { throw new Error('Method not implemented.'); } </del> <ins> createProfileFromShellAndShellArgs(shell?: unknown, shellArgs?: unknown): Promise<string | ITerminalProfile> { throw new Error('Method not implemented.'); } </ins> } export class TestLocalTerminalService implements ILocalTerminalService {


resolved "https://registry.yarnpkg.com/xterm-addon-unicode11/-/xterm-addon-unicode11-0.5.0.tgz#41c0d96acc1e3bb6c6596eee64e163b6bca74be7" integrity sha512-Jm4/g4QiTxiKiTbYICQgC791ubhIZyoIwxAIgOW8z8HWFNY+lwk+dwaKEaEeGBfM48Vk8fklsUW9u/PlenYEBg== <del> xterm-addon-webgl@0.15.0-beta.8: version "0.15.0-beta.8" resolved "https://registry.yarnpkg.com/xterm-addon-webgl/-/xterm-addon-webgl-0.15.0-beta.8.tgz#2005198582f6f1f4a9b2612b9354c0bcc9f148d8" integrity sha512-HjTr9bi3FvdOIPaaIpih6qdHX2z+H7sQPluLj5KzwCqRiEVUVRi19dl8SdHjf6dCmN3GahMhjV7D+zxHi2pLTw== </del> <ins> xterm-addon-webgl@0.15.0-beta.10: version "0.15.0-beta.10" resolved "https://registry.yarnpkg.com/xterm-addon-webgl/-/xterm-addon-webgl-0.15.0-beta.10.tgz#39ebbfb1b89c6773a2d8cb8e1d2f3ef1f08b28f9" integrity sha512-JVv4t5q6QGWyLiEAcAk9H2B83hFlIalzEwWu1VVYso0MJyZAlZ0NP5Za03iSKxYi7RQIA5bOe8r7W24esQDjLg== </ins> <del> xterm@5.2.0-beta.35: version "5.2.0-beta.35" resolved "https://registry.yarnpkg.com/xterm/-/xterm-5.2.0-beta.35.tgz#4a0c0aa81c89c42167c22d023648cced44fa3c25" integrity sha512-6x6i61lucRrLWRKFeMO/ZOx5anvYR6FHpReLO2g0y1bp5zYWyZFzM6DepMV50729gubzxSLB8mvbmb9EpeIugQ== </del> <ins> xterm@5.2.0-beta.40: version "5.2.0-beta.40" resolved "https://registry.yarnpkg.com/xterm/-/xterm-5.2.0-beta.40.tgz#c73d5576425dcd4fa6b48ce58b4224a7b5b9dbdf" integrity sha512-7/Db3KPceM0VX4/YAKL+/ArvEHlGBwE3kt1oN9QP5TLaJ6r2ThMS7z7QwG8g2gy60GFnvjfvpcTv6Ewyste4zg== </ins>


private _cancelContextMenu: boolean = false; <ins> private _disposableStore = this._register(new DisposableStore()); </ins> constructor( group: IEditorGroup, @ITelemetryService telemetryService: ITelemetryService,


function focusFirstFocusableOrContainerInOutput(cellOrOutputId: string, alternateId?: string) { const cellOutputContainer = document.getElementById(cellOrOutputId) ?? <del> alternateId ? document.getElementById(alternateId!) : undefined; </del> <ins> (alternateId ? document.getElementById(alternateId!) : undefined); </ins> if (cellOutputContainer) { if (cellOutputContainer.contains(document.activeElement)) { return;


const { options, buttonIndexMap } = this.massageMessageBoxOptions({ message, buttons, <del> type: (severity === Severity.Info) ? 'question' : (severity === Severity.Error) ? 'error' : (severity === Severity.Warning) ? 'warning' : 'none', </del> <ins> type: (severity === Severity.Info) ? 'info' : (severity === Severity.Error) ? 'error' : (severity === Severity.Warning) ? 'warning' : 'none', </ins> cancelId: dialogOptions ? dialogOptions.cancelId : undefined, detail: dialogOptions ? dialogOptions.detail : undefined, checkboxLabel: dialogOptions?.checkbox?.label ?? undefined,


_serviceBrand: undefined; private _accessibilitySupport = AccessibilitySupport.Unknown; <ins> private didSendTelemetry = false; </ins> constructor( <del> @IWorkbenchEnvironmentService private readonly environmentService: IWorkbenchEnvironmentService, @IContextKeyService readonly contextKeyService: IContextKeyService, @IConfigurationService readonly configurationService: IConfigurationService, </del> <ins> @IWorkbenchEnvironmentService environmentService: IWorkbenchEnvironmentService, @IContextKeyService contextKeyService: IContextKeyService, @IConfigurationService configurationService: IConfigurationService, </ins> @ITelemetryService private readonly _telemetryService: ITelemetryService ) { super(contextKeyService, configurationService); <ins> this.setAccessibilitySupport(environmentService.configuration.accessibilitySupport ? AccessibilitySupport.Enabled : AccessibilitySupport.Disabled); </ins> } alwaysUnderlineAccessKeys(): Promise<boolean> {


await outputElement.render(data.content, preloadErrors, signal); // don't hide until after this step so that the height is right <del> outputElement.element.style.visibility = data.initiallyHidden ? 'hidden' : 'visible'; </del> <ins> outputElement.element.style.visibility = data.initiallyHidden ? 'hidden' : ''; </ins> } public clearOutput(outputId: string, rendererId: string | undefined) {


} } <del> async createTemporaryProfile(profile: IUserDataProfile, name: string, extensionsDisabled: boolean): Promise<void> { const userDataProfilesExportState = this.instantiationService.createInstance(UserDataProfileExportState, profile, extensionsDisabled); </del> <ins> async createTroubleshootProfile(): Promise<void> { const userDataProfilesExportState = this.instantiationService.createInstance(UserDataProfileExportState, this.userDataProfileService.currentProfile, true); </ins> try { <del> const profileTemplate = await userDataProfilesExportState.getProfileTemplate(name, undefined); await this.importAndSwitch(profileTemplate, true, true, extensionsDisabled, localize('import', "Create Profile")); </del> <ins> const profileTemplate = await userDataProfilesExportState.getProfileTemplate(localize('troubleshoot issue', "Troubleshoot Issue"), undefined); await this.progressService.withProgress({ location: ProgressLocation.Notification, delay: 1000, sticky: true, }, progress => this.importAndSwitchWithProgress(profileTemplate, true, true, true, message => progress.report({ message: localize('troubleshoot profile progress', "Setting up Troubleshoot Profile: {0}", message) }))); </ins> } finally { userDataProfilesExportState.dispose(); }


import { VIEWLET_ID, ISCMRepository, ISCMService, VIEW_PANE_ID, ISCMProvider, ISCMViewService, REPOSITORIES_VIEW_PANE_ID } from 'vs/workbench/contrib/scm/common/scm'; import { KeyMod, KeyCode } from 'vs/base/common/keyCodes'; import { MenuRegistry, MenuId } from 'vs/platform/actions/common/actions'; <del> import { SCMStatusController } from './activity'; </del> <ins> import { SCMActiveResourceContextKeyController, SCMStatusController } from './activity'; </ins> import { LifecyclePhase } from 'vs/workbench/services/lifecycle/common/lifecycle'; import { IConfigurationRegistry, Extensions as ConfigurationExtensions, ConfigurationScope } from 'vs/platform/configuration/common/configurationRegistry'; import { IContextKeyService, ContextKeyExpr } from 'vs/platform/contextkey/common/contextkey';


super(); this._standaloneColorPickerVisible.set(true); this._standaloneColorPickerParticipant = _instantiationService.createInstance(StandaloneColorPickerParticipant, this._editor); <del> this._position = this._editor._getViewModel()?.getPrimaryCursorState().viewState.position; </del> <ins> this._position = this._editor._getViewModel()?.getPrimaryCursorState().modelState.position; </ins> const editorSelection = this._editor.getSelection(); const selection = editorSelection ? {


}); } else { groupActiveEditorCanSplitInGroupContext.set(false); <del> sideBySideEditorContext.set(false); </del> <ins> groupActiveEditorIsSideBySideEditorContext.set(false); </ins> groupActiveEditorDirtyContext.set(false); }


], { sticky: true, <del> neverShowAgain: { id: 'terminalConfigHelper/launchRecommendationsIgnore', scope: NeverShowAgainScope.WORKSPACE }, </del> <ins> neverShowAgain: { id: 'terminalConfigHelper/launchRecommendationsIgnore', scope: NeverShowAgainScope.GLOBAL }, </ins> onCancel: () => { /* __GDPR__ "terminalLaunchRecommendation:popup" : {


} private refreshTitle(): void { <ins> if (this._disposed) { return; } </ins> if (this.contextService.getWorkbenchState() === WorkbenchState.WORKSPACE) { this.updateTitle(EmptyView.NAME); } else { this.updateTitle(this.title); } } <ins> override dispose(): void { this._disposed = true; super.dispose(); } </ins> }