linkAllowedByRules('https://github.com', ['https://github.com/foo/bar', 'https://github.com']); }); <ins> test('ports', () => { linkNotAllowedByRules('https://x.org:8080/foo/bar', ['https://x.org:8081/foo']); linkAllowedByRules('https://x.org:8080/foo/bar', ['https://x.org:*/foo']); linkAllowedByRules('https://x.org/foo/bar', ['https://x.org:*/foo']); linkAllowedByRules('https://x.org:8080/foo/bar', ['https://x.org:8080/foo']); }); test('ip addresses', () => { linkAllowedByRules('http://192.168.1.7/', ['http://192.168.1.7/']); linkAllowedByRules('http://192.168.1.7/', ['http://192.168.1.7']); linkAllowedByRules('http://192.168.1.7/', ['http://192.168.1.*']); linkNotAllowedByRules('http://192.168.1.7:3000/', ['http://192.168.*.6:*']); linkAllowedByRules('http://192.168.1.7:3000/', ['http://192.168.1.7:3000/']); linkAllowedByRules('http://192.168.1.7:3000/', ['http://192.168.1.7:*']); linkAllowedByRules('http://192.168.1.7:3000/', ['http://192.168.1.*:*']); linkNotAllowedByRules('http://192.168.1.7:3000/', ['http://192.168.*.6:*']); }); </ins> test('case normalization', () => { // https://github.com/microsoft/vscode/issues/99294 linkAllowedByRules('https://github.com/microsoft/vscode/issues/new', ['https://github.com/microsoft']);


} const focused = this.getFocus(); <del> if (!focused.length) { return this.view.updateElementHeight(index, size, null); } const focus = focused[0]; if (focus <= index) { return this.view.updateElementHeight(index, size, focus); } // the `element` is in the viewport, it's very often that the height update is triggerred by user interaction (collapse, run cell) // then we should make sure that the `element`'s visual view position doesn't change. </del> <ins> const focus = focused.length ? focused[0] : null; </ins> <del> if (this.view.elementTop(index) >= this.view.getScrollTop()) { return this.view.updateElementHeight(index, size, index); </del> <ins> const anchorFocusedSetting = this.configurationService.getValue(NotebookSetting.anchorToFocusedCell); const allowScrolling = this.configurationService.getValue(NotebookSetting.scrollToRevealCell) !== 'none'; const anchorToFocusedCell = anchorFocusedSetting === 'true' || (allowScrolling && anchorFocusedSetting !== 'false'); if (focused && anchorToFocusedCell) { this.view.updateElementHeight(index, size, focus); </ins> } <del> this.view.updateElementHeight(index, size, focus); </del> <ins> this.view.updateElementHeight(index, size, null); </ins> } // override


public _serviceBrand: any; <ins> private activePanelContextKey: IContextKey<string>; </ins> private blockOpeningPanel: boolean; private compositeBar: CompositeBar; private compositeActions: { [compositeId: string]: { activityAction: PanelActivityAction, pinnedAction: ToggleCompositePinnedAction } }; private dimension: Dimension; <ins> private disposables: IDisposable[] = []; </ins> constructor( id: string,


private async getAllEditSessions(): Promise<ITreeItem[]> { const allEditSessions = await this.editSessionsStorageService.list(); this.editSessionsCount.set(allEditSessions.length); <del> return allEditSessions.map((session) => { </del> <ins> const editSessions = []; for (const session of allEditSessions) { </ins> const resource = URI.from({ scheme: EDIT_SESSIONS_SCHEME, authority: 'remote-session-content', path: `/${session.ref}` }); <del> return { </del> <ins> const sessionData = await this.editSessionsStorageService.read(session.ref); const label = sessionData?.editSession.folders.map((folder) => folder.name).join(', ') ?? session.ref; const machineId = sessionData?.editSession.machine; const description = machineId === undefined ? fromNow(session.created, true) : `${fromNow(session.created, true)}u00a0u00a0u2022u00a0u00a0${await this.editSessionsStorageService.getMachineById(machineId)}`; editSessions.push({ </ins> handle: resource.toString(), collapsibleState: TreeItemCollapsibleState.Collapsed, <del> label: { label: fromNow(session.created, true) }, description: session.ref, </del> <ins> label: { label }, description: description, </ins> themeIcon: Codicon.repo, contextValue: `edit-session` <del> }; }); </del> <ins> }); } return editSessions; </ins> } private async getEditSession(ref: string): Promise<ITreeItem[]> {


getCommit(ref: string): Promise<Commit>; add(paths: string[]): Promise<void>; <ins> revert(paths: string[]): Promise<void>; </ins> clean(paths: string[]): Promise<void>; apply(patch: string, reverse?: boolean): Promise<void>;


invokeProtocolHandler(); <del> // We cannot know whether the protocol handler succeeded. // Display guidance in case it did not, e.g. the app is not installed locally. if (matchesScheme(href, this.productService.urlProtocol)) { </del> <ins> const showProtocolUrlOpenedDialog = async () => { </ins> const showResult = await this.dialogService.show( Severity.Info, localize('openExternalDialogTitle', "All done. You can close this tab now."),


isFeatureTerminal: withNullAsUndefined(internalOptions?.isFeatureTerminal), isExtensionOwnedTerminal: true, useShellEnvironment: withNullAsUndefined(internalOptions?.useShellEnvironment), <del> location: internalOptions?.location || this._serializeParentTerminal(options.location, internalOptions?.resolvedExtHostIdentifier) </del> <ins> location: internalOptions?.location || this._serializeParentTerminal(options.location, internalOptions?.resolvedExtHostIdentifier), disablePersistence: withNullAsUndefined(options.disablePersistence) </ins> }); }


private readonly notebookEditor: INotebookEditor, @INotebookExecutionStateService private readonly notebookExecutionStateService: INotebookExecutionStateService, @IMarkerService private readonly markerService: IMarkerService, <del> @IInlineChatService private readonly inlineChatService: IInlineChatService, </del> <ins> @IChatAgentService private readonly chatAgentService: IChatAgentService, </ins> @IConfigurationService private readonly configurationService: IConfigurationService ) { super(); this.updateEnabled(); <del> this._register(inlineChatService.onDidChangeProviders(() => this.updateEnabled())); </del> <ins> this._register(chatAgentService.onDidChangeAgents(() => this.updateEnabled())); </ins> this._register(configurationService.onDidChangeConfiguration((e) => { if (e.affectsConfiguration(NotebookSetting.cellFailureDiagnostics)) { this.updateEnabled();


} next(scrollType: ScrollType = ScrollType.Smooth): void { <ins> if (!this.canNavigateNext()) { return; } </ins> this._move(true, scrollType); } previous(scrollType: ScrollType = ScrollType.Smooth): void { <ins> if (!this.canNavigatePrevious()) { return; } </ins> this._move(false, scrollType); } <ins> canNavigateNext(): boolean { return this.canNavigateLoop() || this.nextIdx < this.ranges.length - 1; } canNavigatePrevious(): boolean { return this.canNavigateLoop() || this.nextIdx !== 0; } canNavigateLoop(): boolean { return Boolean(this._options.findResultLoop); } </ins> override dispose(): void { super.dispose(); this.ranges = [];


} } } catch (error) { <del> const fileUri = URI.file(candidate); this.historyMainService.removeFromRecentlyOpened([fileUri]); // since file does not seem to exist anymore, remove from recent </del> <ins> this.historyMainService.removeFromRecentlyOpened([candidate]); // since file does not seem to exist anymore, remove from recent const fileUri = URI.file(candidate); </ins> if (options && options.ignoreFileNotFound) { return { fileUri, createFilePath: true, remoteAuthority }; // assume this is a file that does not yet exist }


dispose(): void { // selectionListener.clear(); <ins> this._entriesDisposables.dispose(); </ins> this._dispoables.dispose(); }


import { Position } from 'vs/editor/common/core/position'; import { withNullAsUndefined } from 'vs/base/common/types'; import { IKeyboardEvent } from 'vs/base/browser/keyboardEvent'; <ins> import { EditorOption } from 'vs/editor/common/config/editorOptions'; </ins> export class GotoDefinitionAtPositionEditorContribution implements IEditorContribution {


}, scope: ConfigurationScope.RESOURCE }, <del> 'search.mode': { </del> <ins> [SEARCH_MODE_CONFIG]: { </ins> type: 'string', enum: ['view', 'reuseEditor', 'newEditor'], default: 'view',


if (this._activeSession) { this._zone.value.updateBackgroundColor(widgetPosition, this._activeSession.wholeRange.value); } <del> if (this._strategy) { needsMargin = this._strategy.needsMargin(); } </del> if (!this._zone.value.position) { <del> this._zone.value.setWidgetMargins(widgetPosition, !needsMargin ? 0 : undefined); </del> <ins> this._zone.value.setWidgetMargins(widgetPosition); </ins> this._zone.value.show(widgetPosition); } else { this._zone.value.updatePositionAndHeight(widgetPosition);


return obj; } <del> export function getCellMetadata(cell: NotebookCell | NotebookCellData) { return { </del> <ins> export function getCellMetadata(cell: NotebookCell | NotebookCellData): CellMetadata { const metadata = { </ins> // it contains the cell id, and the cell metadata, along with other nb cell metadata <del> ...(cell.metadata?.custom ?? {}), // promote the cell attachments to the top level attachments: cell.metadata?.custom?.attachments ?? cell.metadata?.attachments </del> <ins> ...(cell.metadata?.custom ?? {}) </ins> }; <ins> // promote the cell attachments to the top level const attachments = cell.metadata?.custom?.attachments ?? cell.metadata?.attachments; if (attachments) { metadata.attachments = attachments; } return metadata; } export function getVSCodeCellLanguageId(metadata: CellMetadata): string | undefined { return metadata.metadata?.vscode?.languageId; } export function setVSCodeCellLanguageId(metadata: CellMetadata, languageId: string) { metadata.metadata = metadata.metadata || {}; metadata.metadata.vscode = { languageId }; } export function removeVSCodeCellLanguageId(metadata: CellMetadata) { if (metadata.metadata?.vscode) { delete metadata.metadata.vscode; } </ins> } function createCodeCellFromNotebookCell(cell: NotebookCellData, preferredLanguage: string | undefined): nbformat.ICodeCell { <del> const cellMetadata = getCellMetadata(cell); let metadata = cellMetadata?.metadata || {}; // This cannot be empty. </del> <ins> const cellMetadata: CellMetadata = JSON.parse(JSON.stringify(getCellMetadata(cell))); cellMetadata.metadata = cellMetadata.metadata || {}; // This cannot be empty. </ins> if (cell.languageId !== preferredLanguage) { <del> metadata = { ...metadata, vscode: { languageId: cell.languageId } }; } else if (metadata.vscode) { </del> <ins> setVSCodeCellLanguageId(cellMetadata, cell.languageId); } else { </ins> // cell current language is the same as the preferred cell language in the document, flush the vscode custom language id metadata <del> delete metadata.vscode; </del> <ins> removeVSCodeCellLanguageId(cellMetadata); </ins> } const codeCell: any = {


parameters: VSCODE_QUALITY: ${{ variables.VSCODE_QUALITY }} VSCODE_BUILD_MACOS: ${{ parameters.VSCODE_BUILD_MACOS }} <ins> - ${{ if eq(parameters.VSCODE_BUILD_MACOS_ARM64, true) }}: - job: MacOSARM64 pool: vmImage: macOS-11 steps: - template: ./darwin/cli-build-darwin.yml parameters: VSCODE_QUALITY: ${{ variables.VSCODE_QUALITY }} </ins> VSCODE_BUILD_MACOS_ARM64: ${{ parameters.VSCODE_BUILD_MACOS_ARM64 }} <del> - ${{ if eq(variables.VSCODE_BUILD_STAGE_WINDOWS, true) }}: - job: Windows </del> <ins> - ${{ if eq(parameters.VSCODE_BUILD_WIN32, true) }}: - job: WindowsX64 </ins> pool: vscode-1es-windows steps: - template: ./win32/cli-build-win32.yml parameters: VSCODE_QUALITY: ${{ variables.VSCODE_QUALITY }} VSCODE_BUILD_WIN32: ${{ parameters.VSCODE_BUILD_WIN32 }} <ins> - ${{ if eq(parameters.VSCODE_BUILD_WIN32_ARM64, true) }}: - job: WindowsARM64 pool: vscode-1es-windows steps: - template: ./win32/cli-build-win32.yml parameters: VSCODE_QUALITY: ${{ variables.VSCODE_QUALITY }} </ins> VSCODE_BUILD_WIN32_ARM64: ${{ parameters.VSCODE_BUILD_WIN32_ARM64 }} <ins> - ${{ if eq(parameters.VSCODE_BUILD_WIN32_32BIT, true) }}: - job: WindowsX86 pool: vscode-1es-windows steps: - template: ./win32/cli-build-win32.yml parameters: VSCODE_QUALITY: ${{ variables.VSCODE_QUALITY }} </ins> VSCODE_BUILD_WIN32_32BIT: ${{ parameters.VSCODE_BUILD_WIN32_32BIT }} - ${{ if and(eq(parameters.VSCODE_COMPILE_ONLY, false), eq(variables['VSCODE_BUILD_STAGE_WINDOWS'], true)) }}:


private readonly _onRecommendationChange: Emitter<RecommendationChangeNotification> = new Emitter<RecommendationChangeNotification>(); onRecommendationChange: Event<RecommendationChangeNotification> = this._onRecommendationChange.event; <del> private _sessionIgnoredRecommendations: { [id: string]: { reasonId: ExtensionRecommendationReason } } = {}; private _sessionRestoredRecommendations: { [id: string]: { reasonId: ExtensionRecommendationReason } } = {}; </del> <ins> private _sessionIgnoredRecommendations: { [id: string]: { reasonId: ExtensionRecommendationReason, reasonText: string, sources: ExtensionRecommendationSource[] } } = {}; private _sessionRestoredRecommendations: { [id: string]: { reasonId: ExtensionRecommendationReason, reasonText: string, sources: ExtensionRecommendationSource[] } } = {}; </ins> constructor( @IExtensionGalleryService private readonly _galleryService: IExtensionGalleryService,


} })); <del> this._recomputeActive(); </del> <ins> const { changeEventTriggered } = this._recomputeActive(); if (!changeEventTriggered) { this._onDidChange.fire({}); } </ins> } private _recomputeActive(): { changeEventTriggered: boolean } {


import { IColorTheme, ICssStyleCollector, IThemeService, registerThemingParticipant } from 'vs/platform/theme/common/themeService'; import { IContextMenuService } from 'vs/platform/contextview/browser/contextView'; import { IHoverService } from 'vs/workbench/services/hover/browser/hover'; <del> import { IAction } from 'vs/base/common/actions'; </del> <ins> import { IAction, Separator } from 'vs/base/common/actions'; </ins> import { Emitter } from 'vs/base/common/event'; import { MarkdownString } from 'vs/base/common/htmlContent'; import { localize } from 'vs/nls';


} }); <del> // Accessibility navigation commands should only be enabled on windows since they are tuned to what NVDA expects export class CursorWordAccessibilityLeft extends WordLeftCommand { constructor() { super({ inSelectionMode: false, wordNavigationType: WordNavigationType.WordAccessibility, id: 'cursorWordAccessibilityLeft', precondition: undefined, kbOpts: { kbExpr: ContextKeyExpr.and(EditorContextKeys.textInputFocus, CONTEXT_ACCESSIBILITY_MODE_ENABLED, IsWindowsContext, ContextKeyExpr.equals(FocusedViewContext.key, OUTPUT_VIEW_ID)), primary: KeyMod.CtrlCmd | KeyCode.LeftArrow, weight: KeybindingWeight.EditorContrib } }); } protected override _move(wordCharacterClassifier: WordCharacterClassifier, model: ITextModel, position: Position, wordNavigationType: WordNavigationType, hasMulticursor: boolean): Position { return super._move(getMapForWordSeparators(EditorOptions.wordSeparators.defaultValue, wordCharacterClassifier.intlSegmenterLocales), model, position, wordNavigationType, hasMulticursor); } } export class CursorWordAccessibilityLeftSelect extends WordLeftCommand { constructor() { super({ inSelectionMode: true, wordNavigationType: WordNavigationType.WordAccessibility, id: 'cursorWordAccessibilityLeftSelect', precondition: undefined, kbOpts: { kbExpr: ContextKeyExpr.and(EditorContextKeys.textInputFocus, CONTEXT_ACCESSIBILITY_MODE_ENABLED, IsWindowsContext, ContextKeyExpr.equals(FocusedViewContext.key, OUTPUT_VIEW_ID)), primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.LeftArrow, weight: KeybindingWeight.EditorContrib } }); } protected override _move(wordCharacterClassifier: WordCharacterClassifier, model: ITextModel, position: Position, wordNavigationType: WordNavigationType, hasMulticursor: boolean): Position { return super._move(getMapForWordSeparators(EditorOptions.wordSeparators.defaultValue, wordCharacterClassifier.intlSegmenterLocales), model, position, wordNavigationType, hasMulticursor); } } export class CursorWordAccessibilityRight extends WordRightCommand { constructor() { super({ inSelectionMode: false, wordNavigationType: WordNavigationType.WordAccessibility, id: 'cursorWordAccessibilityRight', precondition: undefined, kbOpts: { kbExpr: ContextKeyExpr.and(EditorContextKeys.textInputFocus, CONTEXT_ACCESSIBILITY_MODE_ENABLED, IsWindowsContext, ContextKeyExpr.equals(FocusedViewContext.key, OUTPUT_VIEW_ID)), primary: KeyMod.CtrlCmd | KeyCode.RightArrow, weight: KeybindingWeight.EditorContrib } }); } protected override _move(wordCharacterClassifier: WordCharacterClassifier, model: ITextModel, position: Position, wordNavigationType: WordNavigationType, hasMulticursor: boolean): Position { return super._move(getMapForWordSeparators(EditorOptions.wordSeparators.defaultValue, wordCharacterClassifier.intlSegmenterLocales), model, position, wordNavigationType, hasMulticursor); } } export class CursorWordAccessibilityRightSelect extends WordRightCommand { constructor() { super({ inSelectionMode: true, wordNavigationType: WordNavigationType.WordAccessibility, id: 'cursorWordAccessibilityRightSelect', precondition: undefined, kbOpts: { kbExpr: ContextKeyExpr.and(EditorContextKeys.textInputFocus, CONTEXT_ACCESSIBILITY_MODE_ENABLED, IsWindowsContext, ContextKeyExpr.equals(FocusedViewContext.key, OUTPUT_VIEW_ID)), primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.RightArrow, weight: KeybindingWeight.EditorContrib } }); } protected override _move(wordCharacterClassifier: WordCharacterClassifier, model: ITextModel, position: Position, wordNavigationType: WordNavigationType, hasMulticursor: boolean): Position { return super._move(getMapForWordSeparators(EditorOptions.wordSeparators.defaultValue, wordCharacterClassifier.intlSegmenterLocales), model, position, wordNavigationType, hasMulticursor); } } registerEditorCommand(new CursorWordAccessibilityLeft()); registerEditorCommand(new CursorWordAccessibilityLeftSelect()); registerEditorCommand(new CursorWordAccessibilityRight()); registerEditorCommand(new CursorWordAccessibilityRightSelect()); </del> <ins> KeybindingsRegistry.registerKeybindingRule({ id: 'cursorWordAccessibilityLeft', when: ContextKeyExpr.and(EditorContextKeys.textInputFocus, CONTEXT_ACCESSIBILITY_MODE_ENABLED, IsWindowsContext, ContextKeyExpr.equals(FocusedViewContext.key, OUTPUT_VIEW_ID)), primary: KeyMod.CtrlCmd | KeyCode.LeftArrow, weight: KeybindingWeight.WorkbenchContrib }); KeybindingsRegistry.registerKeybindingRule({ id: 'cursorWordAccessibilityLeftSelect', when: ContextKeyExpr.and(EditorContextKeys.textInputFocus, CONTEXT_ACCESSIBILITY_MODE_ENABLED, IsWindowsContext, ContextKeyExpr.equals(FocusedViewContext.key, OUTPUT_VIEW_ID)), primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.LeftArrow, weight: KeybindingWeight.WorkbenchContrib }); KeybindingsRegistry.registerKeybindingRule({ id: 'cursorWordAccessibilityRight', when: ContextKeyExpr.and(EditorContextKeys.textInputFocus, CONTEXT_ACCESSIBILITY_MODE_ENABLED, IsWindowsContext, ContextKeyExpr.equals(FocusedViewContext.key, OUTPUT_VIEW_ID)), primary: KeyMod.CtrlCmd | KeyCode.RightArrow, weight: KeybindingWeight.WorkbenchContrib }); KeybindingsRegistry.registerKeybindingRule({ id: 'cursorWordAccessibilityRightSelect', when: ContextKeyExpr.and(EditorContextKeys.textInputFocus, CONTEXT_ACCESSIBILITY_MODE_ENABLED, IsWindowsContext, ContextKeyExpr.equals(FocusedViewContext.key, OUTPUT_VIEW_ID)), primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.RightArrow, weight: KeybindingWeight.WorkbenchContrib }); </ins>


// ---- blinking logic private _getCursorBlinking(): TextEditorCursorBlinkingStyle { <del> if (this._isComposingInput) { </del> <ins> // TODO: Remove the following if statement when experimental edit context is made default sole implementation if (this._isComposingInput && !this._experimentalEditContextEnabled) { </ins> // avoid double cursors return TextEditorCursorBlinkingStyle.Hidden; }


out[0] = item.completion.detail; return true; } <del> if (typeof item.completion.documentation === 'string') { const match = ColorExtractor._regexRelaxed.exec(item.completion.documentation); if (match && (match.index === 0 || match.index + match[0].length === item.completion.documentation.length)) { </del> <ins> if (item.completion.documentation) { const value = typeof item.completion.documentation === 'string' ? item.completion.documentation : item.completion.documentation.value; const match = ColorExtractor._regexRelaxed.exec(value); if (match && (match.index === 0 || match.index + match[0].length === value.length)) { </ins> out[0] = match[0]; return true; }


throw new Error('ChatEditor lifecycle issue: no editor widget'); } <del> this.updateModel(editorModel.model); </del> <ins> this.updateModel(editorModel.model, options.viewState); </ins> } <del> private updateModel(model: IChatModel): void { this._memento = new Memento('interactive-session-editor-' + model.sessionId, this.storageService); this._viewState = this._memento.getMemento(StorageScope.WORKSPACE, StorageTarget.MACHINE) as IChatViewState; </del> <ins> private updateModel(model: IChatModel, viewState?: IChatViewState): void { this._memento = new Memento('interactive-session-editor-' + model.providerId, this.storageService); this._viewState = viewState ?? this._memento.getMemento(StorageScope.WORKSPACE, StorageTarget.MACHINE) as IChatViewState; </ins> this.widget.setModel(model, { ...this._viewState }); }


const extension = await this.toScannedExtension(webExtension, true); if (extension.isValid || !scanOptions?.skipInvalidExtensions) { result.push(extension); <ins> } else { this.logService.info(`Skipping invalid additional builtin gallery extension ${webExtension.identifier.id}`); </ins> } } catch (error) { this.logService.info(`Ignoring additional builtin extension ${webExtension.identifier.id} because there is an error while converting it into scanned extension`, getErrorMessage(error));


this._createCommentTheadWidget(info.owner, info.thread); const layoutInfo = (this.currentElement as CodeCellViewModel).layoutInfo; this.container.style.top = `${layoutInfo.outputContainerOffset + layoutInfo.outputTotalHeight}px`; <del> this.currentElement.commentHeight = dom.getClientArea(this._commentThreadWidget!.container).height; </del> <ins> this.currentElement.commentHeight = this._calculateCommentThreadHeight(this._commentThreadWidget!.getDimensions().height); </ins> return; } if (this._commentThreadWidget) { <del> if (info) { this._commentThreadWidget.updateCommentThread(info.thread); this.currentElement.commentHeight = dom.getClientArea(this._commentThreadWidget.container).height; } else { </del> <ins> if (!info) { </ins> this._commentThreadWidget.dispose(); this.currentElement.commentHeight = 0; <ins> return; } if (this._commentThreadWidget.commentThread === info.thread) { this.currentElement.commentHeight = this._calculateCommentThreadHeight(this._commentThreadWidget.getDimensions().height); return; </ins> } <ins> this._commentThreadWidget.updateCommentThread(info.thread); this.currentElement.commentHeight = this._calculateCommentThreadHeight(this._commentThreadWidget.getDimensions().height); </ins> } } })); } <ins> private _calculateCommentThreadHeight(bodyHeight: number) { const layoutInfo = this.notebookEditor.getLayoutInfo(); const headHeight = Math.ceil(layoutInfo.fontInfo.lineHeight * 1.2); const lineHeight = layoutInfo.fontInfo.lineHeight; const arrowHeight = Math.round(lineHeight / 3); const frameThickness = Math.round(lineHeight / 9) * 2; const computedHeight = headHeight + bodyHeight + arrowHeight + frameThickness + 8 /** margin bottom to avoid margin collapse */; return computedHeight; } </ins> private async _getCommentThreadForCell(element: ICellViewModel): Promise<{ thread: languages.CommentThread<ICellRange>; owner: string } | null> { if (this.notebookEditor.hasModel()) { const commentInfos = coalesce(await this.commentService.getNotebookComments(element.uri));


registerNotebookController(viewType: string, extensionData: NotebookExtensionDescription, controller: IMainNotebookController): IDisposable; registerNotebookSerializer(viewType: string, extensionData: NotebookExtensionDescription, serializer: INotebookSerializer): IDisposable; <del> withNotebookDataProvider(resource: URI): Promise<ComplexNotebookProviderInfo | SimpleNotebookProviderInfo>; </del> <ins> withNotebookDataProvider(resource: URI, viewType?: string): Promise<ComplexNotebookProviderInfo | SimpleNotebookProviderInfo>; </ins> getMimeTypeInfo(textModel: NotebookTextModel, output: IOutputDto): readonly IOrderedMimeType[];


} private async getCustomBuiltinExtensionsFromGallery(scanOptions?: ScanOptions): Promise<IScannedExtension[]> { <del> const { extensions } = await this.readCustomBuiltinExtensionsInfoFromEnv(); if (!extensions.length) { return []; } </del> if (!this.galleryService.isEnabled()) { this.logService.info('Ignoring fetching additional builtin extensions from gallery as it is disabled.'); return []; } const result: IScannedExtension[] = []; <ins> const { extensions } = await this.readCustomBuiltinExtensionsInfoFromEnv(); </ins> try { const useCache = this.storageService.get('additionalBuiltinExtensions', StorageScope.APPLICATION, '[]') === JSON.stringify(extensions); const webExtensions = await (useCache ? this.getCustomBuiltinExtensionsFromCache() : this.updateCustomBuiltinExtensionsCache());


this._overlayContainer.style.position = 'absolute'; this._overlayContainer.style.overflow = 'hidden'; <del> this.layoutContainerOverShadowElement(dimension, position); </del> <ins> this.layoutContainerOverShadowElement(dimension, /*position*/ undefined); </ins> if (this._webviewTransparentCover) { this._webviewTransparentCover.style.height = `${dimension.height}px`;


const RevealInSideBarForSearchResultsCommand: ICommandAction = { id: Constants.RevealInSideBarForSearchResults, <del> title: nls.localize('revealInSideBar', "Reveal in Explorer") </del> <ins> title: nls.localize('revealInSideBar', "Reveal in Side Bar") </ins> }; MenuRegistry.appendMenuItem(MenuId.SearchContext, {


import * as nls from 'vs/nls'; import * as DOM from 'vs/base/browser/dom'; <ins> import { lastIndex } from 'vs/base/common/arrays'; </ins> import { IStorageService } from 'vs/platform/storage/common/storage'; import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry'; import { IThemeService, registerThemingParticipant } from 'vs/platform/theme/common/themeService'; import { EditorPaneSelectionChangeReason, EditorPaneSelectionCompareResult, IEditorOpenContext, IEditorPaneSelection, IEditorPaneSelectionChangeEvent, IEditorPaneWithSelection } from 'vs/workbench/common/editor'; <del> import { getDefaultNotebookCreationOptions, NotebookEditorWidget } from 'vs/workbench/contrib/notebook/browser/notebookEditorWidget'; </del> <ins> import { getDefaultNotebookCreationOptions } from 'vs/workbench/contrib/notebook/browser/notebookEditorWidget'; </ins> import { IEditorGroup } from 'vs/workbench/services/editor/common/editorGroupsService'; import { NotebookDiffEditorInput } from '../../common/notebookDiffEditorInput'; import { CancellationToken, CancellationTokenSource } from 'vs/base/common/cancellation';


} else { // automagically convert some argument types <ins> let hasBuffers = false; </ins> const toArgs = cloneAndChange(args, function (value) { if (value instanceof extHostTypes.Position) { return extHostTypeConverter.Position.from(value);


const text = outputInfo.text(); const outputScrolling = scrollingEnabled(outputInfo, ctx.settings); <del> const content = createOutputContent(outputInfo.id, [text], ctx.settings.lineLimit, ctx.settings.outputScrolling, false); </del> <ins> const content = createOutputContent(outputInfo.id, [text], ctx.settings.lineLimit, outputScrolling, false); </ins> content.classList.add('output-plaintext'); if (ctx.settings.outputWordWrap) { content.classList.add('word-wrap');


} } <ins> /* Used to strip brackets from the markdown link <http://example.com> will be transformed to http://example.com */ export function stripAngleBrackets(link: string) { const bracketMatcher = /^<(.*)>$/; return link.replace(bracketMatcher, '$1'); } </ins> export default class LinkProvider implements vscode.DocumentLinkProvider { private readonly linkPattern = /([((![[^]]*?](s*)([^s()]+?)s*)]|(?:]|[^]])*])(s*)(([^s()]|([^s()]*?))+)s*(".*?")?)/g; private readonly referenceLinkPattern = /([((?:]|[^]])+)][s*?)([^s]]*?)]/g;


async function test77735(withOpenedEditor: boolean): Promise<void> { const docUriOriginal = await createRandomFile(); const docUriMoved = docUriOriginal.with({ path: `${docUriOriginal.path}.moved` }); <del> await deleteFile(docUriMoved); // ensure target does not exist </del> <ins> await deleteFile(docUriMoved); </ins> if (withOpenedEditor) { const document = await vscode.workspace.openTextDocument(docUriOriginal);


import { Schemas } from '../../../../base/common/network.js'; import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js'; import { IEditorService } from '../../../services/editor/common/editorService.js'; <ins> import { forcedExpandRecursively } from './searchActionsTopBar.js'; </ins> //#region Interfaces


} export interface IMarkTracker { <del> scrollToPreviousMark(): void; </del> <ins> scrollToPreviousMark(scrollPosition?: ScrollPosition, retainSelection?: boolean, skipEmptyCommands?: boolean): void; </ins> scrollToNextMark(): void; selectToPreviousMark(): void; selectToNextMark(): void;


terminal.xterm.write(chunk.buffer, () => pendingWrites.value--); } } else { <ins> didWriteData = true; </ins> this.writeNotice(terminal, localize('runNoOutputForPast', 'Test output is only available for new test runs.')); }


*--------------------------------------------------------------------------------------------*/ import { deepStrictEqual, doesNotThrow, equal, ok, strictEqual, throws } from 'assert'; <del> import { commands, ConfigurationTarget, Disposable, env, EnvironmentVariableMutator, EnvironmentVariableMutatorOptions, EnvironmentVariableMutatorType, EventEmitter, ExtensionContext, extensions, ExtensionTerminalOptions, GlobalEnvironmentVariableCollection, Pseudoterminal, Terminal, TerminalDimensions, TerminalExitReason, TerminalOptions, TerminalState, UIKind, Uri, window, workspace } from 'vscode'; </del> <ins> import { commands, ConfigurationTarget, Disposable, env, EnvironmentVariableMutator, EnvironmentVariableMutatorOptions, EnvironmentVariableMutatorType, EventEmitter, ExtensionContext, extensions, ExtensionTerminalOptions, Pseudoterminal, Terminal, TerminalDimensions, TerminalExitReason, TerminalOptions, TerminalState, UIKind, Uri, window, workspace } from 'vscode'; </ins> import { assertNoRpc, poll } from '../utils'; // Disable terminal tests:


} let ariaLabel = this.ariaLabel; <del> if (!ariaLabel) { </del> <ins> // Only set aria label to the input box placeholder if we actually have an input box. if (!ariaLabel && visibilities.inputBox) { </ins> ariaLabel = this.placeholder || QuickPick.DEFAULT_ARIA_LABEL; // If we have a title, include it in the aria label. if (this.title) {


extHost.dispose(); this._extHosts.delete(id); }); <ins> // See https://github.com/microsoft/vscode/issues/194477 // We have observed that sometimes the process sends an exit // event, but does not really exit and is stuck in an endless // loop. In these cases we kill the process forcefully after // a certain timeout. setTimeout(() => { try { process.kill(pid, 0); // will throw if the process doesn't exist anymore. this._logService.error(`Extension host with pid ${pid} still exists, forcefully killing it...`); process.kill(pid); } catch (er) { // ignore, as the process is already gone } }, 1000); </ins> }); return { id }; }


import { NotebookTextModel } from 'vs/workbench/contrib/notebook/common/model/notebookTextModel'; import { ICellDto2, INotebookEditorModel, INotebookLoadOptions, IResolvedNotebookEditorModel, NotebookCellsChangeType, NotebookData } from 'vs/workbench/contrib/notebook/common/notebookCommon'; import { INotebookSerializer, INotebookService, SimpleNotebookProviderInfo } from 'vs/workbench/contrib/notebook/common/notebookService'; <ins> import { ILifecycleService } from 'vs/workbench/services/lifecycle/common/lifecycle'; </ins> import { IFileWorkingCopyManager } from 'vs/workbench/services/workingCopy/common/fileWorkingCopyManager'; import { IStoredFileWorkingCopy, IStoredFileWorkingCopyModel, IStoredFileWorkingCopyModelContentChangedEvent, IStoredFileWorkingCopyModelFactory, IStoredFileWorkingCopySaveEvent, StoredFileWorkingCopyState } from 'vs/workbench/services/workingCopy/common/storedFileWorkingCopy'; import { IUntitledFileWorkingCopy, IUntitledFileWorkingCopyModel, IUntitledFileWorkingCopyModelContentChangedEvent, IUntitledFileWorkingCopyModelFactory } from 'vs/workbench/services/workingCopy/common/untitledFileWorkingCopy';


const model = this.model.read(reader); const suggestion = model?.selectedInlineCompletion.read(reader); const ghostText = model?.ghostText.read(reader); <del> const selectedSuggestItem = model?.selectedSuggestItem.read(reader); this.inlineCompletionVisible.set(selectedSuggestItem === undefined && ghostText !== undefined && !ghostText.isEmpty()); </del> <ins> this.inlineCompletionVisible.set(ghostText !== undefined && !ghostText.isEmpty()); </ins> if (ghostText && suggestion) { this.suppressSuggestions.set(suggestion.inlineCompletion.source.inlineCompletions.suppressSuggestions);


this.findInput.inputBox.select(range); } <del> getSelection(): IRange | null { return this.findInput.inputBox.getSelection(); } </del> isSelectionAtEnd(): boolean { return this.findInput.inputBox.isSelectionAtEnd(); }


async getQuickDiffs(uri: URI, language: string = '', isSynchronized: boolean = false): Promise<QuickDiff[]> { const providers = Array.from(this.quickDiffProviders) <del> .filter(provider => !provider.rootUri || isEqualOrParent(uri, provider.rootUri)) </del> <ins> .filter(provider => !provider.rootUri || this.uriIdentityService.extUri.isEqualOrParent(uri, provider.rootUri)) </ins> .sort(createProviderComparer(uri)); const diffs = await Promise.all(providers.map(async provider => {


title: { value: 'Preferences', original: 'Preferences', <del> mnemonicTitle: localize('mPreferences', "Preferences") </del> <ins> mnemonicTitle: localize({ key: 'mPreferences', comment: ['&& denotes a mnemonic'] }, "Preferences") </ins> }, when: IsMacNativeContext, order: 9


const outputElement = (prev.firstChild as HTMLElement | null); if (outputElement && outputElement.getAttribute('output-mime-type') === outputInfo.mime) { // same stream <del> const text = outputInfo.text(); const element = document.createElement('span'); </del> <ins> // find child with same id const existing = outputElement.querySelector(`[output-item-id="${outputInfo.id}"]`) as HTMLElement | null; if (existing) { clearContainer(existing); } const text = outputInfo.text(); const element = existing ?? document.createElement('span'); element.classList.add('output-stream'); element.setAttribute('output-item-id', outputInfo.id); </ins> insertOutput(outputInfo.id, [text], ctx.settings.lineLimit, ctx.settings.outputScrolling, element); outputElement.appendChild(element); return;


})); this._register(this.parentData.parent.onScroll(() => { <del> this.parentData.parent.focus(false); this.cleanupExistingSubmenu(false); </del> <ins> if (this.parentData.submenu === this.mysubmenu) { this.parentData.parent.focus(false); this.cleanupExistingSubmenu(true); } </ins> })); }


const specIcon = gulp.src('resources/linux/rpm/code.xpm', { base: '.' }) .pipe(rename('SOURCES/' + product.applicationName + '.xpm')); <del> const all = es.merge(code, desktop, appdata, icon, spec, specIcon); </del> <ins> const all = es.merge(code, desktop, desktopUrlHandler, appdata, icon, spec, specIcon); </ins> return all.pipe(vfs.dest(getRpmBuildPath(rpmArch))); };


export function incrementFileName(name: string, isFolder: boolean): string { const separators = '[.-_]'; <ins> const maxNumber = Constants.MAX_SAFE_SMALL_INTEGER; </ins> // file.1.txt=>file.2.txt let suffixFileRegex = RegExp('(.*' + separators + ')(d+)(..*)$'); if (!isFolder && name.match(suffixFileRegex)) { return name.replace(suffixFileRegex, (match, g1?, g2?, g3?) => { <del> return g1 + strings.pad(parseInt(g2) + 1, g2.length) + g3; </del> <ins> let number = parseInt(g2); return number < maxNumber ? g1 + strings.pad(number + 1, g2.length) + g3 : strings.format('{0}{1}.1{2}', g1, g2, g3); </ins> }); }


const root = new RootTreeItem(this.debugService.getModel(), this.environmentService, this.contextService); this.tree.setInput(root); <del> let timeout: number; </del> const registerLoadedSourceListener = (session: ISession) => { this.disposables.push(session.onDidLoadedSource(event => { const sessionRoot = root.add(session); sessionRoot.addPath(event.source); <del> clearTimeout(timeout); timeout = setTimeout(() => { if (this.tree) { this.tree.refresh(root, true); } }, 300); </del> <ins> this.shouldRefreshRecursive = true; this.treeRefreshScheduler.schedule(); </ins> })); };


original: 'Run', mnemonicTitle: nls.localize({ key: 'mRun', comment: ['&& denotes a mnemonic'] }, "&&Run") }, <del> when: ContextKeyExpr.or(CONTEXT_DEBUGGERS_AVAILABLE), </del> order: 6 });


const workingCopyAdapter = new class implements IWorkingCopy { readonly resource = input._workingCopyResource; get name() { return input.name; } <del> readonly capabilities = input.capabilities; </del> <ins> readonly capabilities = input.isUntitled() ? WorkingCopyCapabilities.Untitled : input.capabilities; </ins> readonly onDidChangeDirty = input.onDidChangeDirty; readonly onDidChangeContent = input.onDidChangeContent; isDirty(): boolean { return input.isDirty(); }


// Only Launch have a pin trigger button await (launch as Launch).writeConfiguration(config); await this.selectConfiguration(launch, config.name); <ins> this.removeRecentDynamicConfigurations(config.name, config.type); </ins> })); });


import * as path from 'path'; import * as fs from 'fs'; <del> const reAbsolute = /^/+/; </del> <ins> const reAbsolutePosix = /^/+/; const reAbsoluteWin32 = /^+/; const reAbsolute = path.sep === '/' ? reAbsolutePosix : reAbsoluteWin32; </ins> /** * Locates given `filePath` on user’s file system and returns absolute path to it.


import { CharCode } from 'vs/base/common/charCode'; import { Position } from 'vs/editor/common/core/position'; import { Range } from 'vs/editor/common/core/range'; <del> import { SequenceFromIntArray, OffsetRange, SequenceDiff, ISequence } from 'vs/editor/common/diff/algorithms/diffAlgorithm'; </del> <ins> import { OffsetRange, SequenceDiff, ISequence } from 'vs/editor/common/diff/algorithms/diffAlgorithm'; </ins> import { DynamicProgrammingDiffing } from 'vs/editor/common/diff/algorithms/dynamicProgrammingDiffing'; import { optimizeSequenceDiffs } from 'vs/editor/common/diff/algorithms/joinSequenceDiffs'; import { MyersDiffAlgorithm } from 'vs/editor/common/diff/algorithms/myersDiffAlgorithm';


newArgs[newArgs.length - 1] = format(newArgs[newArgs.length - 1], appRoot); // Move .zshrc into $ZDOTDIR as the way to activate the script <del> const zdotdir = path.join(os.tmpdir(), `${os.userInfo().username}-${productService.applicationName}-zsh`); </del> <ins> let username: string; try { username = os.userInfo().username; } catch { username = 'unknown'; } const zdotdir = path.join(os.tmpdir(), `${username}-${productService.applicationName}-zsh`); </ins> envMixin['ZDOTDIR'] = zdotdir; const userZdotdir = env?.ZDOTDIR ?? os.homedir() ?? `~`; envMixin['USER_ZDOTDIR'] = userZdotdir;


resolved "https://registry.yarnpkg.com/@tootallnate/once/-/once-3.0.0.tgz#d52238c9052d746c9689523e650160e70786bc9a" integrity sha512-OAdBVB7rlwvLD+DiecSAyVKzKVmSfXbouCyM5I6wHGi4MGXIyFqErg1IvyJ7PI1e+GYZuZh7cCHV/c4LA8SKMw== <ins> "@vscode/deviceid@^0.1.1": version "0.1.1" resolved "https://registry.yarnpkg.com/@vscode/deviceid/-/deviceid-0.1.1.tgz#750e2930a3a8fbf3fd610096a8b915dfdb493c89" integrity sha512-ErpoMeKKNYAkR1IT3zxB5RtiTqEECdh8fxggupWvzuxpTAX77hwOI2NdJ7um+vupnXRBZVx4ugo0+dVHJWUkag== dependencies: fs-extra "^11.2.0" uuid "^9.0.1" </ins> "@vscode/iconv-lite-umd@0.7.0": version "0.7.0" resolved "https://registry.yarnpkg.com/@vscode/iconv-lite-umd/-/iconv-lite-umd-0.7.0.tgz#d2f1e0664ee6036408f9743fee264ea0699b0e48"


]; private readonly isEnabledCache = new CachedFunction<AudioCue, IObservable<boolean>>((cue) => observableFromEvent( <del> this.audioCueService.onEnabledChanged(AudioCue.onDebugBreak), () => this.audioCueService.isEnabled(AudioCue.onDebugBreak) </del> <ins> this.audioCueService.onEnabledChanged(cue), () => this.audioCueService.isEnabled(cue) </ins> )); constructor(


} else { // command text = result.rawLabel; } <del> instance.sendText(text, !quickPick.keyMods.alt, true); </del> quickPick.hide(); <ins> runCommand(instance, text, !quickPick.keyMods.alt); </ins> if (quickPick.keyMods.alt) { instance.focus(); }


"command": "ipynb.cleanInvalidImageAttachment", "title": "%cleanInvalidImageAttachment.title%" }, <del> { "command": "notebook.cellOutput.copy", "title": "%copyCellOutput.title%" } </del> <ins> { "command": "notebook.cellOutput.copy", "title": "%copyCellOutput.title%" } </ins> ], "notebooks": [ {


template.navbar.push(NavbarSection.ExtensionPack, localize('extensionPack', "Extension Pack"), localize('extensionsPack', "Set of extensions that can be installed together")); } if (manifest && manifest.contributes) { <del> template.navbar.push(NavbarSection.Contributions, localize('contributions', "Contributions"), localize('contributionstooltip', "Lists contributions to VS Code by this extension")); </del> <ins> template.navbar.push(NavbarSection.FeatureContributions, localize('contributions', "Feature Contributions"), localize('contributionstooltip', "Lists contributions to VS Code by this extension")); </ins> } if (extension.hasChangelog()) { template.navbar.push(NavbarSection.Changelog, localize('changelog', "Changelog"), localize('changelogtooltip', "Extension update history, rendered from the extension's 'CHANGELOG.md' file"));


import { IClipboardService } from 'vs/platform/clipboard/common/clipboardService'; import { ansiColorIdentifiers, TERMINAL_BACKGROUND_COLOR, TERMINAL_FOREGROUND_COLOR, TERMINAL_CURSOR_FOREGROUND_COLOR, TERMINAL_CURSOR_BACKGROUND_COLOR, TERMINAL_SELECTION_BACKGROUND_COLOR } from 'vs/workbench/parts/terminal/common/terminalColorRegistry'; import { PANEL_BACKGROUND } from 'vs/workbench/common/theme'; <del> import { IConfigurationService } from 'vs/platform/configuration/common/configuration'; </del> <ins> import { IConfigurationService, ConfigurationTarget } from 'vs/platform/configuration/common/configuration'; </ins> import { IEditorOptions } from 'vs/editor/common/config/editorOptions'; <del> import { INotificationService } from 'vs/platform/notification/common/notification'; </del> <ins> import { INotificationService, Severity, IPromptChoice } from 'vs/platform/notification/common/notification'; </ins> import { ILogService } from 'vs/platform/log/common/log'; import { TerminalCommandTracker } from 'vs/workbench/parts/terminal/node/terminalCommandTracker'; import { TerminalProcessManager } from './terminalProcessManager'; <ins> import { IStorageService, StorageScope } from 'vs/platform/storage/common/storage'; // How long in milliseconds should an average frame take to render for a notification to appear // which suggests the fallback DOM-based renderer const SLOW_CANVAS_RENDER_THRESHOLD = 50; </ins> let Terminal: typeof XTermTerminal;


} }, { <del> "name": "Markup Inline", "scope": "markup.inline.raw", </del> <ins> "name": "Markup: Strong", "scope": "markup.bold", </ins> "settings": { <del> "fontStyle": "", "foreground": "#cd8d8dff" </del> <ins> "fontStyle": "bold" </ins> } }, { <del> "name": "Markup Headings", "scope": "markup.heading", </del> <ins> "name": "Markup: Emphasis", "scope": "markup.italic", </ins> "settings": { <del> "foreground": "#fec758ff" </del> <ins> "fontStyle": "italic" </ins> } }, { <del> "name": "Markup Setext Header", "scope": "markup.heading.setext", </del> <ins> "name": "Markup Inline", "scope": "markup.inline.raw", </ins> "settings": { "fontStyle": "", <ins> "foreground": "#cd8d8dff" } }, { "name": "Headings", "scope": [ "markup.heading", "markup.heading.setext", "punctuation.definition.heading", "entity.name.section" ], "settings": { "fontStyle": "bold", </ins> "foreground": "#fec758ff" } },


{ urlFormat: '{0} ({1}, {2})', line: '5', column: '3' }, { urlFormat: '{0}:{1}', line: '5' }, { urlFormat: '{0}:{1}:{2}', line: '5', column: '3' }, <ins> { urlFormat: '{0} {1}:{2}', line: '5', column: '3' }, </ins> { urlFormat: '{0}[{1}]', line: '5' }, { urlFormat: '{0} [{1}]', line: '5' }, { urlFormat: '{0}[{1},{2}]', line: '5', column: '3' },


} } <del> class RemoveRootFolderAction extends Action2 { </del> <ins> export class RemoveRootFolderAction extends Action2 { </ins> static readonly ID = 'workbench.action.removeRootFolder';


this.centeredEditorLeftMarginRatio = 0.5; // Restore centered layout position and size <del> const centeredLayoutDataString = this.storageServise.get(EditorGroupsControl.CENTERED_EDITOR_LAYOUT_DATA_STORAGE_KEY, StorageScope.GLOBAL); </del> <ins> const centeredLayoutDataString = this.storageService.get(EditorGroupsControl.CENTERED_EDITOR_LAYOUT_DATA_STORAGE_KEY, StorageScope.GLOBAL); </ins> if (centeredLayoutDataString) { const centeredLayout = <CenteredEditorLayoutData>JSON.parse(centeredLayoutDataString); this.centeredEditorLeftMarginRatio = centeredLayout.leftMarginRatio; <del> this.centeredEditorPreferedSize = centeredLayout.size; </del> <ins> this.centeredEditorPreferredSize = centeredLayout.size; </ins> } } }


testExecutionService = new TestExecutionService(); instantiationService.stub(INotebookExecutionStateService, testExecutionService); <del> const chatProviders = instantiationService.get<IInlineChatService>(IInlineChatService); disposables.add(chatProviders.addProvider({} as IInlineChatSessionProvider)); </del> <ins> const agentData = { extensionId: nullExtensionDescription.identifier, extensionDisplayName: '', extensionPublisherId: '', name: 'testEditorAgent', isDefault: true, locations: [ChatAgentLocation.Editor], metadata: {}, slashCommands: [] }; const chatAgentService = new class extends mock<IChatAgentService>() { override getAgents(): IChatAgentData[] { return [{ id: 'testEditorAgent', ...agentData }]; } override onDidChangeAgents: Event<IChatAgent | undefined> = Event.None; }; instantiationService.stub(IChatAgentService, chatAgentService); </ins> markerService = new class extends mock<ITestMarkerService>() { override markers: ResourceMap<IMarkerData[]> = new ResourceMap();


import { toDisposable, DisposableStore, dispose } from 'vs/base/common/lifecycle'; import { StableEditorScrollState } from 'vs/editor/browser/core/editorState'; import { ICodeEditor, MouseTargetType, IViewZoneChangeAccessor, IActiveCodeEditor } from 'vs/editor/browser/editorBrowser'; <del> import { registerEditorContribution } from 'vs/editor/browser/editorExtensions'; </del> <ins> import { registerEditorContribution, EditorCommand, ServicesAccessor } from 'vs/editor/browser/editorExtensions'; </ins> import { IEditorContribution } from 'vs/editor/common/editorCommon'; import { IModelDecorationsChangeAccessor } from 'vs/editor/common/model'; import { CodeLensProviderRegistry, CodeLens } from 'vs/editor/common/modes';


return undefined; } for (const _key in obj) { <del> if (obj.hasOwnProperty(_key) && _key.toLowerCase() === key.toLowerCase()) { </del> <ins> if (Object.hasOwnProperty.call(obj, _key) && _key.toLowerCase() === key.toLowerCase()) { </ins> return obj[_key]; } }


/** A regex that matches paths in the form ?c:foo c:foo, ~foo, .foo, ..foo, foobar */ export const winLocalLinkClause = '((' + winPathPrefix + '|(' + winExcludedPathCharactersClause + ')+)?(' + winPathSeparatorClause + '(' + winExcludedPathCharactersClause + ')+)+)'; <ins> // TODO: This should eventually move to the more structured terminalLinkParsing </ins> /** As xterm reads from DOM, space in that case is nonbreaking char ASCII code - 160, replacing space with nonBreakningSpace or space ASCII code - 32. */ export const lineAndColumnClause = [


} private replaceNotebookCellMetadata(uri: URI, index: number, cellMetadata: Record<string, any>, metadata?: vscode.WorkspaceEditEntryMetadata): void { <del> this._edits.push({ _type: FileEditType.Cell, metadata, uri, edit: { editType: CellEditType.PartialMetadata, index, metadata: cellMetadata } }); </del> <ins> this._edits.push({ _type: FileEditType.Cell, metadata, uri, edit: { editType: CellEditType.Metadata, index, metadata: cellMetadata } }); </ins> } // --- text


} const COMMIT_FORMAT = '%H%n%aN%n%aE%n%at%n%ct%n%P%n%D%n%B'; <ins> const STASH_FORMAT = '%H%n%P%n%gd%n%gs'; </ins> export interface ICloneOptions { readonly parentPath: string;


- `npm.autoDetect` - Enable detecting scripts as tasks, the default is `on`. - `npm.runSilent` - Run npm script with the `--silent` option, the default is `false`. <del> - `npm.packageManager` - The package manager used to run the scripts: `npm` or `yarn`, the default is `npm`. </del> <ins> - `npm.packageManager` - The package manager used to run the scripts: `npm`, `yarn` or `pnpm`, the default is `npm`. </ins> - `npm.exclude` - Glob patterns for folders that should be excluded from automatic script detection. The pattern is matched against the **absolute path** of the package.json. For example, to exclude all test folders use '**/test/**'. - `npm.enableScriptExplorer` - Enable an explorer view for npm scripts. - `npm.scriptExplorerAction` - The default click action: `open` or `run`, the default is `open`.


dependencies: object-keys "~0.4.0" <del> xterm-addon-canvas@0.2.0-beta.15: version "0.2.0-beta.15" resolved "https://registry.yarnpkg.com/xterm-addon-canvas/-/xterm-addon-canvas-0.2.0-beta.15.tgz#de863e46410b1de357b153abf1984227777760e4" integrity sha512-E1pNCDSVTINchwWLysZ9ZD/BPv1WLGV52xRHB00US1PHHELbhtvms+6dZ44WZEDXhtfpptRZ1VBx+QpvfJIuvw== xterm-addon-search@0.10.0-beta.3: version "0.10.0-beta.3" resolved "https://registry.yarnpkg.com/xterm-addon-search/-/xterm-addon-search-0.10.0-beta.3.tgz#5194434d86105637c71f6f20139a9d0b5c1a956a" integrity sha512-UeGm/ymnp7HUYJJtsP0D+bljOWbdk3MctcLJ+0jv8AmU6YlAzJFtouvYSQrD5SAMyht5CRsvjzFgqic9X02JYg== xterm-addon-serialize@0.8.0-beta.3: version "0.8.0-beta.3" resolved "https://registry.yarnpkg.com/xterm-addon-serialize/-/xterm-addon-serialize-0.8.0-beta.3.tgz#47ade3fedacbb75bd26e63cfe0120586623e0e4f" integrity sha512-gvfempZCYuAhLqN4O6fA2TuoavPjOxFKlh8hLcOzPackiLUhwKr1jQpDXcnq8VgqUiGgb+XNZpPEbI0Q7EhTgA== xterm-addon-unicode11@0.4.0-beta.3: version "0.4.0-beta.3" resolved "https://registry.yarnpkg.com/xterm-addon-unicode11/-/xterm-addon-unicode11-0.4.0-beta.3.tgz#f350184155fafd5ad0d6fbf31d13e6ca7dea1efa" integrity sha512-FryZAVwbUjKTmwXnm1trch/2XO60F5JsDvOkZhzobV1hm10sFLVuZpFyHXiUx7TFeeFsvNP+S77LAtWoeT5z+Q== xterm-addon-webgl@0.13.0-beta.32: version "0.13.0-beta.32" resolved "https://registry.yarnpkg.com/xterm-addon-webgl/-/xterm-addon-webgl-0.13.0-beta.32.tgz#ae7335f788ae611733e03f6ca38280ab7b86d212" integrity sha512-xOudNzYXaRh9QZ+IigXM5EB3bM8l3/F8F35EpJRYvvsylVxiB6Km8X8l7+nxlWt+uYdnHZs0ka2rvtL8kOP/uw== </del> <ins> xterm-addon-canvas@0.2.0-beta.17: version "0.2.0-beta.17" resolved "https://registry.yarnpkg.com/xterm-addon-canvas/-/xterm-addon-canvas-0.2.0-beta.17.tgz#e84a86530b20bd3edcce16b4566f346cd186ab4d" integrity sha512-2ukPdCA92VTFYQRE56ylzvI3cfaQYDWd/Mc4jlEItI6sV/EA5RnUbbP+2sFIx0JlmHK6nVYXXNY2p6QRB7MRew== xterm-addon-search@0.10.0-beta.5: version "0.10.0-beta.5" resolved "https://registry.yarnpkg.com/xterm-addon-search/-/xterm-addon-search-0.10.0-beta.5.tgz#a2cb16bda4ddf8783b80433155ad94f5822271f8" integrity sha512-kjog7cm1iEZ2XyQFVs3KAvoI2pKoX0cq2WWjL0FuXYXpKQ9vXmfrWSR7PiJ6zpTIRvr6UtaSGKhmZVHLNA79WA== xterm-addon-serialize@0.8.0-beta.5: version "0.8.0-beta.5" resolved "https://registry.yarnpkg.com/xterm-addon-serialize/-/xterm-addon-serialize-0.8.0-beta.5.tgz#3d2f3be173f4f1c31ae7bf25179e8ecddf2b33b2" integrity sha512-rkSUaO1XBcy3ipScZMA5PrOKu/DfXo8XC/V7hZlhMiBNbZKlbk2rFb3X0FB1f07hw7oEkHLjuIJEY5Qtxfe9/w== xterm-addon-unicode11@0.4.0-beta.5: version "0.4.0-beta.5" resolved "https://registry.yarnpkg.com/xterm-addon-unicode11/-/xterm-addon-unicode11-0.4.0-beta.5.tgz#3900e66f10d2e506133b61d7421aab6878d32665" integrity sha512-+g+fuxAd/tkCEJ/jhdnebXKtdPrhsu4VKWNnB/3qM35GbuGQOasmYFYnKL+HYZMpbQ6YqeZcXTVg/wnCTttz0g== xterm-addon-webgl@0.13.0-beta.35: version "0.13.0-beta.35" resolved "https://registry.yarnpkg.com/xterm-addon-webgl/-/xterm-addon-webgl-0.13.0-beta.35.tgz#98b5dc102583120de25c7c6e0f35cd34ab6bef98" integrity sha512-powgeb3ifEZK7zWwLJuE8YRz/Z0UzDrrVA9NTx9mH7+vWxrGt9ZgroychoeCqZBvKMofiUM5vlf1oWdSmsMfzw== </ins> xterm-headless@5.0.0-beta.5: version "5.0.0-beta.5" resolved "https://registry.yarnpkg.com/xterm-headless/-/xterm-headless-5.0.0-beta.5.tgz#e29b6c5081f31f887122b7263ba996b0c46b3c22" integrity sha512-CMQ1+prBNF92oBMeZzc2rfTcmOaCGfwwSaoPYNTjyziZT6mZsEg7amajYkb0YAnqJ29MFm4kPGZbU78/dX4k2A== <del> xterm@5.0.0-beta.32: version "5.0.0-beta.32" resolved "https://registry.yarnpkg.com/xterm/-/xterm-5.0.0-beta.32.tgz#62bb9902429c0055fd2fd85c9eecfbf1756ed31c" integrity sha512-OAM1GaBs/chK63Cr86XbVhfVCLLXLpNxxFrv3RK9xoyb9dwiY3gaMxK9jeGzTnrbGLWJb+k5nxaC0rx2YsHvUA== </del> <ins> xterm@5.0.0-beta.35: version "5.0.0-beta.35" resolved "https://registry.yarnpkg.com/xterm/-/xterm-5.0.0-beta.35.tgz#3bbf5780c98aaaa6476e7590dff1d8f5014fce9d" integrity sha512-tzJTel1E/FmB0VQDb44xApVB+ln+BifIbHD4V9x9Z3D9m1cMmPHy8J8efdILkn1TxXGlCl7VC35nG122Qq5exw== </ins> y18n@^3.2.1: version "3.2.2"


public async run(accessor: ServicesAccessor | undefined, editor: ICodeEditor): Promise<void> { const controller = InlineCompletionsController.get(editor); <del> controller?.model.get()?.acceptNextWord(controller.editor); </del> <ins> await controller?.model.get()?.acceptNextWord(controller.editor); </ins> } }


keybinding: [ // On mac, require that the cursor is at the top of the input, to avoid stealing cmd+up to move the cursor to the top { <del> when: CONTEXT_CHAT_INPUT_CURSOR_AT_TOP, </del> <ins> when: ContextKeyExpr.and(CONTEXT_CHAT_INPUT_CURSOR_AT_TOP, CONTEXT_IN_QUICK_CHAT.negate()), </ins> primary: KeyMod.CtrlCmd | KeyCode.UpArrow, weight: KeybindingWeight.EditorContrib, }, // On win/linux, ctrl+up can always focus the chat list { <del> when: ContextKeyExpr.or(IsWindowsContext, IsLinuxContext), </del> <ins> when: ContextKeyExpr.and(ContextKeyExpr.or(IsWindowsContext, IsLinuxContext), CONTEXT_IN_QUICK_CHAT.negate()), </ins> primary: KeyMod.CtrlCmd | KeyCode.UpArrow, weight: KeybindingWeight.EditorContrib, <ins> }, { when: ContextKeyExpr.and(CONTEXT_IN_CHAT_SESSION, CONTEXT_IN_QUICK_CHAT), primary: KeyMod.CtrlCmd | KeyCode.DownArrow, weight: KeybindingWeight.WorkbenchContrib, </ins> } ] });


} private updateInputBox(): void { <del> if (typeof this.repository.provider.commitTemplate === 'undefined') { </del> <ins> if (typeof this.repository.provider.commitTemplate === 'undefined' || this.inputBox.value) { </ins> return; }


event.stopPropagation(); event.preventDefault(); <del> const actions: IAction[] = []; actions.push(<IAction>{ id: `${viewDescriptor.id}.removeView`, label: localize('hideView', "Hide"), enabled: viewDescriptor.canToggleVisibility, run: () => this.toggleViewVisibility(viewDescriptor.id) }); const otherActions = this.getContextMenuActions(); if (otherActions.length) { actions.push(...[new Separator(), ...otherActions]); } </del> <ins> const actions: IAction[] = this.getContextMenuActions(viewDescriptor); </ins> let anchor: { x: number, y: number } = { x: event.posx, y: event.posy }; this.contextMenuService.showContextMenu({


"tab.inactiveBackground": "#414339", "tab.border": "#1e1f1c", "tab.inactiveForeground": "#ccccc7", // needs to be bright so it's readable when another editor group is focused <del> "widget.shadow": "#1e1f1c", </del> <ins> "widget.shadow": "#000000", </ins> "progressBar.background": "#75715E", "badge.background": "#75715E", "badge.foreground": "#f8f8f2",


} }); <ins> registerAction2(class extends Action2 { constructor() { super( { id: 'notebook.diff.action.previous', title: localize('notebook.diff.action.previous.title', "Show Previous Change"), icon: previousChangeIcon, f1: false, keybinding: { primary: KeyMod.Shift | KeyMod.Alt | KeyCode.F3, weight: KeybindingWeight.WorkbenchContrib }, menu: { id: MenuId.EditorTitle, group: 'navigation', when: ActiveEditorContext.isEqualTo(NotebookTextDiffEditor.ID) } } ); } run(accessor: ServicesAccessor) { const editorService: IEditorService = accessor.get(IEditorService); if (editorService.activeEditorPane?.getId() !== NOTEBOOK_DIFF_EDITOR_ID) { return; } const editor = editorService.activeEditorPane.getControl() as INotebookTextDiffEditor | undefined; editor?.previousChange(); } }); registerAction2(class extends Action2 { constructor() { super( { id: 'notebook.diff.action.next', title: localize('notebook.diff.action.next.title', "Show Next Change"), icon: nextChangeIcon, f1: false, keybinding: { primary: KeyMod.Alt | KeyCode.F3, weight: KeybindingWeight.WorkbenchContrib }, menu: { id: MenuId.EditorTitle, group: 'navigation', when: ActiveEditorContext.isEqualTo(NotebookTextDiffEditor.ID) } } ); } run(accessor: ServicesAccessor) { const editorService: IEditorService = accessor.get(IEditorService); if (editorService.activeEditorPane?.getId() !== NOTEBOOK_DIFF_EDITOR_ID) { return; } const editor = editorService.activeEditorPane.getControl() as INotebookTextDiffEditor | undefined; editor?.nextChange(); } }); </ins> Registry.as<IConfigurationRegistry>(ConfigurationExtensions.Configuration).registerConfiguration({ id: 'notebook', order: 100,


@ITelemetryService private readonly telemetryService: ITelemetryService, @IProductService private readonly productService: IProductService, @ITerminalService private readonly terminalService: ITerminalService, <del> @IStorageService private readonly _storageService: IStorageService </del> <ins> @IStorageService private readonly _storageService: IStorageService, @IContextMenuService private readonly contextMenuService: IContextMenuService </ins> ) { super(); this.toDispose.add(_instance.onDidFocus(() => {


overviewRulerLanes = 63, parameterHints = 64, peekWidgetDefaultFocus = 65, <del> quickSuggestions = 66, quickSuggestionsDelay = 67, readOnly = 68, renderControlCharacters = 69, renderIndentGuides = 70, renderFinalNewline = 71, renderLineHighlight = 72, renderValidationDecorations = 73, renderWhitespace = 74, revealHorizontalRightPadding = 75, roundedSelection = 76, rulers = 77, scrollbar = 78, scrollBeyondLastColumn = 79, scrollBeyondLastLine = 80, selectionClipboard = 81, selectionHighlight = 82, selectOnLineNumbers = 83, semanticHighlighting = 84, showFoldingControls = 85, showUnused = 86, snippetSuggestions = 87, smoothScrolling = 88, stopRenderingLineAfter = 89, suggest = 90, suggestFontSize = 91, suggestLineHeight = 92, suggestOnTriggerCharacters = 93, suggestSelection = 94, tabCompletion = 95, useTabStops = 96, wordSeparators = 97, wordWrap = 98, wordWrapBreakAfterCharacters = 99, wordWrapBreakBeforeCharacters = 100, wordWrapColumn = 101, wordWrapMinified = 102, wrappingIndent = 103, wrappingStrategy = 104, editorClassName = 105, pixelRatio = 106, tabFocusMode = 107, layoutInfo = 108, wrappingInfo = 109 </del> <ins> definitionLinkOpensInPeek = 66, quickSuggestions = 67, quickSuggestionsDelay = 68, readOnly = 69, renderControlCharacters = 70, renderIndentGuides = 71, renderFinalNewline = 72, renderLineHighlight = 73, renderValidationDecorations = 74, renderWhitespace = 75, revealHorizontalRightPadding = 76, roundedSelection = 77, rulers = 78, scrollbar = 79, scrollBeyondLastColumn = 80, scrollBeyondLastLine = 81, selectionClipboard = 82, selectionHighlight = 83, selectOnLineNumbers = 84, semanticHighlighting = 85, showFoldingControls = 86, showUnused = 87, snippetSuggestions = 88, smoothScrolling = 89, stopRenderingLineAfter = 90, suggest = 91, suggestFontSize = 92, suggestLineHeight = 93, suggestOnTriggerCharacters = 94, suggestSelection = 95, tabCompletion = 96, useTabStops = 97, wordSeparators = 98, wordWrap = 99, wordWrapBreakAfterCharacters = 100, wordWrapBreakBeforeCharacters = 101, wordWrapColumn = 102, wordWrapMinified = 103, wrappingIndent = 104, wrappingStrategy = 105, editorClassName = 106, pixelRatio = 107, tabFocusMode = 108, layoutInfo = 109, wrappingInfo = 110 </ins> } /**


.review-widget .body .review-comment .review-comment-contents .comment-body { padding-top: 4px; <ins> } .review-widget .body .review-comment .review-comment-contents .comment-body-max-height { </ins> max-height: 20em; }


import { SyncActionDescriptor, MenuRegistry, MenuId } from 'vs/platform/actions/common/actions'; import { Registry } from 'vs/platform/registry/common/platform'; import { registerSingleton } from 'vs/platform/instantiation/common/extensions'; <del> import { KeybindingWeight, IKeybindings, KeybindingsRegistry } from 'vs/platform/keybinding/common/keybindingsRegistry'; </del> <ins> import { KeybindingWeight, IKeybindings } from 'vs/platform/keybinding/common/keybindingsRegistry'; </ins> import { IConfigurationRegistry, Extensions as ConfigurationExtensions } from 'vs/platform/configuration/common/configurationRegistry'; import { IWorkbenchActionRegistry, Extensions as WorkbenchActionRegistryExtensions } from 'vs/workbench/common/actions'; import { ShowViewletAction, Extensions as ViewletExtensions, ViewletRegistry, ViewletDescriptor } from 'vs/workbench/browser/viewlet';


cursor: pointer; } <del> .monaco-workbench .monaco-font-aliasing-antialiased { </del> <ins> .monaco-workbench.monaco-font-aliasing-antialiased { </ins> -webkit-font-smoothing: antialiased; } <del> .monaco-workbench .monaco-font-aliasing-none { </del> <ins> .monaco-workbench.monaco-font-aliasing-none { </ins> -webkit-font-smoothing: none; } @media (-webkit-min-device-pixel-ratio: 2), (min-resolution: 192dpi) { <del> .monaco-workbench .monaco-font-aliasing-auto { </del> <ins> .monaco-workbench.monaco-font-aliasing-auto { </ins> -webkit-font-smoothing: antialiased; } }


} return cwd; } <ins> /** * Determines whether the given shell launch config should use the environment variable collection. * @param slc The shell launch config to check. */ export function shouldUseEnvironmentVariableCollection(slc: IShellLaunchConfig): boolean { return !slc.strictEnv && !slc.hideFromUser; } </ins>


} } <del> if (historyItem.labels) { </del> <ins> const labels = this.getLabels(element.repository); const historyItemLabels = (historyItem.labels ?? []) .filter(l => labels.includes(l.title)); if (historyItemLabels) { </ins> const historyItemGroupLocalColor = colorTheme.getColor(historyItemGroupLocal); const historyItemGroupRemoteColor = colorTheme.getColor(historyItemGroupRemote); const historyItemGroupBaseColor = colorTheme.getColor(historyItemGroupBase);


// Avoid doing progressive rendering for multiple markdown parts simultaneously else if (!hasRenderedOneMarkdownBlock && wordCountResults[index]) { const { value } = wordCountResults[index]; <del> result = this.renderMarkdown(new MarkdownString(value), element, templateData, true); </del> <ins> const part = partsToRender[index]; const originalMarkdown = 'originalMarkdown' in part ? part.originalMarkdown : undefined; const markdownToRender = new MarkdownString(value, originalMarkdown); result = this.renderMarkdown(markdownToRender, element, templateData, true); </ins> hasRenderedOneMarkdownBlock = true; }


return { fileUri: URI.file(path) }; } <del> private afterWindowOpen(): void { </del> <ins> private afterWindowOpen(accessor: ServicesAccessor): void { </ins> // Signal phase: after window open this.lifecycleMainService.phase = LifecycleMainPhase.AfterWindowOpen; // Remote Authorities this.handleRemoteAuthorities(); <ins> // Initialize update service const updateService = accessor.get(IUpdateService); if (updateService instanceof Win32UpdateService || updateService instanceof LinuxUpdateService || updateService instanceof DarwinUpdateService) { updateService.initialize(); } </ins> } private handleRemoteAuthorities(): void {


terminals: instances.map(t => { return { relativeSize: isHorizontal ? t.cols / totalSize : t.rows / totalSize, <del> terminal: t.persistentTerminalId ? t.persistentTerminalId : t.id </del> <ins> terminal: t.persistentTerminalId || 0 </ins> }; }) };


assert.strictEqual(result, '2_test.js'); }); <del> test('Increment folder name with suffix version', function () { </del> <ins> test('Increment file name with prefix version, too big number', function () { const name = '9007199254740992.test.js'; const result = incrementFileName(name, false); assert.strictEqual(result, '9007199254740992.test.1.js'); }); test('Increment folder name with prefix version', function () { </ins> const name = '1.test'; const result = incrementFileName(name, true); assert.strictEqual(result, '2.test'); }); <del> test('Increment folder name with suffix version, trailing zeros', function () { </del> <ins> test('Increment folder name with prefix version, too big number', function () { const name = '9007199254740992.test'; const result = incrementFileName(name, true); assert.strictEqual(result, '9007199254740992.test.1'); }); test('Increment folder name with prefix version, trailing zeros', function () { </ins> const name = '001.test'; const result = incrementFileName(name, true); assert.strictEqual(result, '002.test'); }); <del> test('Increment folder name with suffix version  with `-` as separator', function () { </del> <ins> test('Increment folder name with prefix version  with `-` as separator', function () { </ins> const name = '1-test'; const result = incrementFileName(name, true); assert.strictEqual(result, '2-test');


return Promise.all([a, b, c, d]); }); <ins> test('api-command: vscode.open with untitled supports associated resource (#138925)', async function () { let uri = Uri.parse(workspace.workspaceFolders![0].uri.toString() + '/far-copy.js').with({ scheme: 'untitled' }); await commands.executeCommand('vscode.open', uri).then(() => assert.ok(true), () => assert.ok(false)); // untitled with associated resource are dirty from the beginning assert.ok(window.activeTextEditor?.document.isDirty); }); </ins> });


private _run(): void { let workerRequestIsValid; <del> if (!this.editor.hasTextFocus()) { // no focus (new nb cell, etc) if (WordHighlighter.query === null) { // no previous query, nothing to highlight </del> <ins> const hasTextFocus = this.editor.hasTextFocus(); if (!hasTextFocus) { // new nb cell scrolled in, didChangeModel fires if (!WordHighlighter.query) { // no previous query, nothing to highlight off of </ins> return; } <del> } else { </del> <ins> } else { // has text focus </ins> const editorSelection = this.editor.getSelection(); // ignore multiline selection if (!editorSelection || editorSelection.startLineNumber !== editorSelection.endLineNumber) { <ins> WordHighlighter.query = null; </ins> this._stopAll(); return; }


fi fi <del> if [ ! -L $0 ]; then </del> <ins> if [ ! -L "$0" ]; then </ins> # if path is not a symlink, find relatively <del> VSCODE_PATH="$(dirname $0)/.." </del> <ins> VSCODE_PATH="$(dirname "$0")/.." </ins> else if command -v readlink >/dev/null; then # if readlink exists, follow the symlink and find relatively <del> VSCODE_PATH="$(dirname $(readlink -f $0))/.." </del> <ins> VSCODE_PATH="$(dirname $(readlink -f "$0"))/.." </ins> else # else use the standard install location VSCODE_PATH="/usr/share/@@NAME@@"


setup(() => { provideVariablesCalled = false; dataSource = new NotebookVariableDataSource(kernelService); <ins> results = [ { id: 1, name: 'a', value: '1', hasNamedChildren: false, indexedChildrenCount: 0 }, ]; </ins> }); test('Root element should return children', async () => {


private _sessionCtor: CancelablePromise<void> | undefined; private _activeSession?: Session; private _warmupRequestCts?: CancellationTokenSource; <ins> private _activeRequestCts?: CancellationTokenSource; </ins> private readonly _ctxHasActiveRequest: IContextKey<boolean>; private readonly _ctxCellWidgetFocused: IContextKey<boolean>; private readonly _ctxUserDidEdit: IContextKey<boolean>;


} readonly label = 'Update Notebook Metadata'; undo() { <del> that._updateNotebookMetadata(oldMetadata, false); </del> <ins> that._updateNotebookMetadata({ ...oldMetadata, runState: that.metadata.runState }, false); </ins> } redo() { <del> that._updateNotebookMetadata(metadata, false); </del> <ins> that._updateNotebookMetadata({ ...metadata, runState: that.metadata.runState }, false); </ins> } }(), undefined, undefined); }


export class SkipUpdateAction extends AbstractUpdateAction { <ins> static readonly ID = 'workbench.extensions.action.ignoreUpdates'; static readonly LABEL = localize('ignoreUpdates', "Ignore Updates"); </ins> constructor( @IExtensionsWorkbenchService extensionsWorkbenchService: IExtensionsWorkbenchService ) { <del> super(`extensions.ignoreUpdates`, localize('ignoreUpdates', "Ignore Updates"), extensionsWorkbenchService); </del> <ins> super(SkipUpdateAction.ID, SkipUpdateAction.LABEL, extensionsWorkbenchService); </ins> } override update() {


}); }); <del> test('onDidCloseTerminal event fires when terminal is disposed', (done) => { disposables.push(window.onDidOpenTerminal(term => { try { equal(terminal, term); } catch (e) { done(e); return; } terminal.dispose(); disposables.push(window.onDidCloseTerminal(() => done())); })); </del> <ins> test('onDidCloseTerminal event fires when terminal is disposed', async () => { </ins> const terminal = window.createTerminal(); <ins> const result = await new Promise<Terminal>(r => { disposables.push(window.onDidOpenTerminal(t => { if (t === terminal) { r(t); } })); }); equal(result, terminal); await new Promise<void>(r => { disposables.push(window.onDidCloseTerminal(t => { if (t === terminal) { r(); } })); terminal.dispose(); }); </ins> }); <del> test('processId immediately after createTerminal should fetch the pid', (done) => { disposables.push(window.onDidOpenTerminal(term => { try { equal(terminal, term); } catch (e) { done(e); return; } terminal.processId.then(id => { try { ok(id && id > 0); } catch (e) { done(e); return; } terminal.dispose(); disposables.push(window.onDidCloseTerminal(() => done())); }); })); </del> <ins> test('processId immediately after createTerminal should fetch the pid', async () => { </ins> const terminal = window.createTerminal(); <ins> const result = await new Promise<Terminal>(r => { disposables.push(window.onDidOpenTerminal(t => { if (t === terminal) { r(t); } })); }); equal(result, terminal); let pid = await result.processId; equal(true, pid && pid > 0); await new Promise<void>(r => { disposables.push(window.onDidCloseTerminal(t => { if (t === terminal) { r(); } })); terminal.dispose(); }); </ins> }); <del> test('name in constructor should set terminal.name', (done) => { disposables.push(window.onDidOpenTerminal(term => { try { equal(terminal, term); } catch (e) { done(e); return; } terminal.dispose(); disposables.push(window.onDidCloseTerminal(() => done())); })); </del> <ins> test('name in constructor should set terminal.name', async () => { </ins> const terminal = window.createTerminal('a'); <del> try { equal(terminal.name, 'a'); } catch (e) { done(e); return; } </del> <ins> const result = await new Promise<Terminal>(r => { disposables.push(window.onDidOpenTerminal(t => { if (t === terminal) { r(t); } })); }); equal(result, terminal); await new Promise<void>(r => { disposables.push(window.onDidCloseTerminal(t => { if (t === terminal) { r(); } })); terminal.dispose(); }); </ins> }); <del> test('creationOptions should be set and readonly for TerminalOptions terminals', (done) => { disposables.push(window.onDidOpenTerminal(term => { try { equal(terminal, term); } catch (e) { done(e); return; } terminal.dispose(); disposables.push(window.onDidCloseTerminal(() => done())); })); </del> <ins> test('creationOptions should be set and readonly for TerminalOptions terminals', async () => { </ins> const options = { name: 'foo', hideFromUser: true }; const terminal = window.createTerminal(options); <del> try { equal(terminal.name, 'foo'); const terminalOptions = terminal.creationOptions as TerminalOptions; equal(terminalOptions.name, 'foo'); equal(terminalOptions.hideFromUser, true); throws(() => terminalOptions.name = 'bad', 'creationOptions should be readonly at runtime'); } catch (e) { done(e); return; } </del> <ins> const terminalOptions = terminal.creationOptions as TerminalOptions; const result = await new Promise<Terminal>(r => { disposables.push(window.onDidOpenTerminal(t => { if (t === terminal) { r(t); } })); }); equal(result, terminal); await new Promise<void>(r => { disposables.push(window.onDidCloseTerminal(t => { if (t === terminal) { r(); } })); terminal.dispose(); }); throws(() => terminalOptions.name = 'bad', 'creationOptions should be readonly at runtime'); </ins> }); <del> test('onDidOpenTerminal should fire when a terminal is created', (done) => { disposables.push(window.onDidOpenTerminal(term => { try { equal(term.name, 'b'); } catch (e) { done(e); return; } disposables.push(window.onDidCloseTerminal(() => done())); terminal.dispose(); })); </del> <ins> test('onDidOpenTerminal should fire when a terminal is created', async () => { </ins> const terminal = window.createTerminal('b'); <ins> const result = await new Promise<Terminal>(r => { disposables.push(window.onDidOpenTerminal(t => { if (t === terminal) { r(t); } })); }); equal(result, terminal); await new Promise<void>(r => { disposables.push(window.onDidCloseTerminal(t => { if (t === terminal) { r(); } })); terminal.dispose(); }); </ins> }); <del> test('exitStatus.code should be set to undefined after a terminal is disposed', (done) => { disposables.push(window.onDidOpenTerminal(term => { try { equal(term, terminal); } catch (e) { done(e); return; } </del> <ins> test('exitStatus.code should be set to undefined after a terminal is disposed', async () => { const terminal = window.createTerminal(); const result = await new Promise<Terminal>(r => { disposables.push(window.onDidOpenTerminal(t => { if (t === terminal) { r(t); } })); }); equal(result, terminal); await new Promise<void>(r => { </ins> disposables.push(window.onDidCloseTerminal(t => { <del> try { </del> <ins> if (t === terminal) { </ins> deepEqual(t.exitStatus, { code: undefined }); <del> } catch (e) { done(e); return; </del> <ins> r(); </ins> } <del> done(); </del> })); terminal.dispose(); <del> })); const terminal = window.createTerminal(); </del> <ins> }); </ins> }); // test('onDidChangeActiveTerminal should fire when new terminals are created', (done) => {


"@vscode/vscode-languagedetection": "1.0.21", "@vscode/windows-process-tree": "^0.5.0", "@vscode/windows-registry": "^1.1.0", <del> "@xterm/addon-canvas": "0.6.0-beta.19", "@xterm/addon-image": "0.7.0-beta.17", "@xterm/addon-search": "0.14.0-beta.19", "@xterm/addon-serialize": "0.12.0-beta.19", "@xterm/addon-unicode11": "0.7.0-beta.19", "@xterm/addon-webgl": "0.17.0-beta.19", "@xterm/headless": "5.4.0-beta.19", "@xterm/xterm": "5.4.0-beta.19", </del> <ins> "@xterm/addon-canvas": "0.6.0-beta.20", "@xterm/addon-image": "0.7.0-beta.18", "@xterm/addon-search": "0.14.0-beta.20", "@xterm/addon-serialize": "0.12.0-beta.20", "@xterm/addon-unicode11": "0.7.0-beta.20", "@xterm/addon-webgl": "0.17.0-beta.20", "@xterm/headless": "5.4.0-beta.20", "@xterm/xterm": "5.4.0-beta.20", </ins> "cookie": "^0.4.0", "graceful-fs": "4.2.11", "http-proxy-agent": "^7.0.0",


import product from 'vs/platform/node/product'; import { INotificationService } from 'vs/platform/notification/common/notification'; import { EditorServiceImpl } from 'vs/workbench/browser/parts/editor/editor'; <ins> import { IExtensionService } from 'vs/workbench/services/extensions/common/extensions'; import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding'; </ins> const TextInputActions: IAction[] = [ new Action('undo', nls.localize('undo', "Undo"), null, true, () => document.execCommand('undo') && TPromise.as(true)),


} } <del> return { primary: Array.from(allowedPrimary.values()), secondary: Array.from(allowedSecondary.values()) }; </del> <ins> return { primary: this.buildMenu(primaryGroups), secondary: this.buildMenu(secondaryGroups) }; </ins> } dispose() {


} } <del> for (let i = (renderActions.length - 1); i !== 0; i--) { </del> <ins> for (let i = (renderActions.length - 1); i > 0; i--) { </ins> const temp = renderActions[i]; if (temp.size === 0) { continue;


defaultProvider = provider; } else { try { <del> validDocumentColorProviderFound ||= await collector.compute(provider, model, token, colorData); </del> <ins> if (await collector.compute(provider, model, token, colorData)) { validDocumentColorProviderFound = true; } </ins> } catch (e) { onUnexpectedExternalError(e); }


/* internal */ configFileDiagnosticsReceived(event: Proto.ConfigFileDiagnosticEvent): void { // See https://github.com/Microsoft/TypeScript/issues/10384 <del> /* https://github.com/Microsoft/TypeScript/issues/10473 </del> const body = event.body; <del> if (body.diagnostics) { const language = body.triggerFile ? this.findLanguage(body.triggerFile) : this.findLanguage(body.configFile); if (language) { if (body.diagnostics.length === 0) { language.configFileDiagnosticsReceived(body.configFile, []); } else if (body.diagnostics.length >= 1) { workspace.openTextDocument(Uri.file(body.configFile)).then((document) => { let curly: [number, number, number] = undefined; let nonCurly: [number, number, number] = undefined; let diagnostic: Diagnostic; for (let index = 0; index < document.lineCount; index++) { let line = document.lineAt(index); let text = line.text; let firstNonWhitespaceCharacterIndex = line.firstNonWhitespaceCharacterIndex; if (firstNonWhitespaceCharacterIndex < text.length) { if (text.charAt(firstNonWhitespaceCharacterIndex) === '{') { curly = [index, firstNonWhitespaceCharacterIndex, firstNonWhitespaceCharacterIndex + 1]; break; } else { let matches = /s*([^s]*)(?:s*|$)/.exec(text.substr(firstNonWhitespaceCharacterIndex)); if (matches.length >= 1) { nonCurly = [index, firstNonWhitespaceCharacterIndex, firstNonWhitespaceCharacterIndex + matches[1].length]; } } } } let match = curly || nonCurly; if (match) { diagnostic = new Diagnostic(new Range(match[0], match[1], match[0], match[2]), body.diagnostics[0].text); </del> <ins> if (!body || !body.diagnostics) { return; } const language = body.triggerFile ? this.findLanguage(body.triggerFile) : this.findLanguage(body.configFile); if (!language) { return; } if (body.diagnostics.length === 0) { language.configFileDiagnosticsReceived(body.configFile, []); } else if (body.diagnostics.length >= 1) { workspace.openTextDocument(Uri.file(body.configFile)).then((document) => { let curly: [number, number, number] | undefined = undefined; let nonCurly: [number, number, number] | undefined = undefined; let diagnostic: Diagnostic; for (let index = 0; index < document.lineCount; index++) { const line = document.lineAt(index); const text = line.text; const firstNonWhitespaceCharacterIndex = line.firstNonWhitespaceCharacterIndex; if (firstNonWhitespaceCharacterIndex < text.length) { if (text.charAt(firstNonWhitespaceCharacterIndex) === '{') { curly = [index, firstNonWhitespaceCharacterIndex, firstNonWhitespaceCharacterIndex + 1]; break; </ins> } else { <del> diagnostic = new Diagnostic(new Range(0,0,0,0), body.diagnostics[0].text); } if (diagnostic) { diagnostic.source = language.diagnosticSource; language.configFileDiagnosticsReceived(body.configFile, [diagnostic]); </del> <ins> const matches = /s*([^s]*)(?:s*|$)/.exec(text.substr(firstNonWhitespaceCharacterIndex)); if (matches && matches.length >= 1) { nonCurly = [index, firstNonWhitespaceCharacterIndex, firstNonWhitespaceCharacterIndex + matches[1].length]; } </ins> } <del> }, (error) => { language.configFileDiagnosticsReceived(body.configFile, [new Diagnostic(new Range(0,0,0,0), body.diagnostics[0].text)]); }); </del> <ins> } </ins> } <del> } </del> <ins> const match = curly || nonCurly; if (match) { diagnostic = new Diagnostic(new Range(match[0], match[1], match[0], match[2]), body.diagnostics[0].text); } else { diagnostic = new Diagnostic(new Range(0, 0, 0, 0), body.diagnostics[0].text); } if (diagnostic) { diagnostic.source = language.diagnosticSource; language.configFileDiagnosticsReceived(body.configFile, [diagnostic]); } }, (error) => { language.configFileDiagnosticsReceived(body.configFile, [new Diagnostic(new Range(0, 0, 0, 0), body.diagnostics[0].text)]); }); </ins> } <del> */ </del> } private createMarkerDatas(diagnostics: Proto.Diagnostic[], source: string): Diagnostic[] {


const scrollState = StableEditorScrollState.capture(this.editor); this.editor.executeEdits( 'suggestController.additionalTextEdits.sync', <del> item.completion.additionalTextEdits.map(edit => EditOperation.replaceMove(Range.lift(edit.range), edit.text)) </del> <ins> item.completion.additionalTextEdits.map(edit => { let range = Range.lift(edit.range); if (range.startLineNumber === item.position.lineNumber && range.startColumn > item.position.column) { // shift additional edit when it is "after" the completion insertion position const columnDelta = this.editor.getPosition()!.column - item.position.column; const startColumnDelta = columnDelta; const endColumnDelta = Range.spansMultipleLines(range) ? 0 : columnDelta; range = new Range(range.startLineNumber, range.startColumn + startColumnDelta, range.endLineNumber, range.endColumn + endColumnDelta); } return EditOperation.replaceMove(range, edit.text); }) </ins> ); scrollState.restoreRelativeVerticalPositionOfCursor(this.editor);


} } <del> // Store the existing selection if there was one. const visibleSelection = visibleQuickAccess?.picker?.valueSelection; </del> // Create a picker for the provider to use with the initial value // and adjust the filtering to exclude the prefix from filtering const disposables = new DisposableStore();


DeleteWordLeftTerminalAction.ID, DeleteWordRightTerminalAction.ID ].sort() <ins> }, 'terminal.integrated.env.osx': { 'description': nls.localize('terminal.integrated.env.osx', "Object with environment variables that will be added to the VS Code process to be used by the terminal on OS X"), 'type': 'object', 'default': {} }, 'terminal.integrated.env.linux': { 'description': nls.localize('terminal.integrated.env.linux', "Object with environment variables that will be added to the VS Code process to be used by the terminal on Linux"), 'type': 'object', 'default': {} }, 'terminal.integrated.env.windows': { 'description': nls.localize('terminal.integrated.env.windows', "Object with environment variables that will be added to the VS Code process to be used by the terminal on Windows"), 'type': 'object', 'default': {} </ins> } } });


ui.ignoreFocusOut = false; this.setComboboxAccessibility(false); ui.inputBox.ariaLabel = ''; <ins> ui.inputBox.toggles = undefined; </ins> const backKeybindingLabel = this.options.backKeybindingLabel(); backButton.tooltip = backKeybindingLabel ? localize('quickInput.backWithKeybinding', "Back ({0})", backKeybindingLabel) : localize('quickInput.back', "Back");


} } else { const previousScrollTop = this.view.getScrollTop(); <del> this.view.setScrollTop(previousScrollTop + this.view.renderHeight - this.view.elementHeight(lastPageIndex)); </del> <ins> let nextpageScrollTop = previousScrollTop + this.view.renderHeight; if (lastPageIndex > currentlyFocusedElementIndex) { // scroll last page element to the top only if the last page element is below the focused element nextpageScrollTop -= this.view.elementHeight(lastPageIndex); } this.view.setScrollTop(nextpageScrollTop); </ins> if (this.view.getScrollTop() !== previousScrollTop) { this.setFocus([]);


<ins> /*--------------------------------------------------------------------------------------------- *  Copyright (c) Microsoft Corporation. All rights reserved. *  Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ declare module 'vscode' { export interface TerminalOptions { /** * Opt-out of the default terminal persistence on restart and reload */ disablePersistence?: boolean; } export interface ExtensionTerminalOptions { /** * Opt-out of the default terminal persistence on restart and reload */ disablePersistence?: boolean; } } </ins>


stack.style.margin = '8px 0'; const element = document.createElement('span'); <del> insertOutput(outputInfo.id, [err.stack ?? ''], ctx.settings.lineLimit, false, element, true); </del> <ins> insertOutput(outputInfo.id, [err.stack ?? ''], ctx.settings.lineLimit, ctx.settings.outputScrolling, element, true); </ins> stack.appendChild(element); container.appendChild(stack); } else {


"scripts": { "update-grammar": "node ../node_modules/vscode-grammar-updater/bin daaain/Handlebars grammars/Handlebars.json ./syntaxes/Handlebars.tmLanguage.json" }, <ins> "extensionKind": [ "ui", "workspace" ], </ins> "contributes": { "languages": [ {


}); } <del> private _acceptNext(editor: ICodeEditor, getAcceptUntilIndex: (position: Position, text: string) => number): void { </del> <ins> private async _acceptNext(editor: ICodeEditor, getAcceptUntilIndex: (position: Position, text: string) => number): Promise<void> { </ins> if (editor.getModel() !== this.textModel) { throw new BugIndicatingError(); }


import { toErrorMessage } from 'vs/base/common/errorMessage'; import { Emitter } from 'vs/base/common/event'; import { isEqualOrParent, randomPath } from 'vs/base/common/extpath'; <del> import { ParsedPattern, patternsEquals } from 'vs/base/common/glob'; </del> <ins> import { GLOBSTAR, ParsedPattern, patternsEquals } from 'vs/base/common/glob'; </ins> import { Disposable } from 'vs/base/common/lifecycle'; import { TernarySearchTree } from 'vs/base/common/map'; import { normalizeNFC } from 'vs/base/common/normalization';


DOM.append(this._notebookEditor.getDomNode(), this.getDomNode()); this._findWidgetFocused = KEYBINDING_CONTEXT_NOTEBOOK_FIND_WIDGET_FOCUSED.bindTo(contextKeyService); this._register(this._findInput.onKeyDown((e) => this._onFindInputKeyDown(e))); <ins> this._register(this._replaceInput.onKeyDown((e) => this._onReplaceInputKeyDown(e))); </ins> this._register(this._state.onFindReplaceStateChange((e) => { this.onInputChanged();


// service worker already loaded & ready to receive messages postVersionMessage(currentController); } else { <del> console.log(`Found unexpected service worker controller. Found: ${currentController?.scriptURL}. Expected: ${swPath}`); </del> <ins> if (currentController) { console.log(`Found unexpected service worker controller. Found: ${currentController.scriptURL}. Expected: ${swPath}. Waiting for controllerchange.`); } else { console.log(`No service worker controller found. Waiting for controllerchange.`); } </ins> <del> // either there's no controlling service worker, or it's an old one: // wait for it to change before posting the message </del> <ins> // Either there's no controlling service worker, or it's an old one. // Wait for it to change before posting the message </ins> const onControllerChange = () => { navigator.serviceWorker.removeEventListener('controllerchange', onControllerChange); <ins> if (navigator.serviceWorker.controller) { </ins> postVersionMessage(navigator.serviceWorker.controller); <ins> } else { return reject(new Error('No controller found.')); } </ins> }; navigator.serviceWorker.addEventListener('controllerchange', onControllerChange); }


<del> /*--------------------------------------------------------------------------------------------- *  Copyright (c) Microsoft Corporation. All rights reserved. *  Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ declare module 'vscode' { // https://github.com/microsoft/vscode/issues/171173 // export interface ExtensionContext { // 	/** // 	 * Gets the extension's global environment variable collection for this workspace, enabling changes to be // 	 * applied to terminal environment variables. // 	 */ // 	readonly environmentVariableCollection: GlobalEnvironmentVariableCollection; // } export interface GlobalEnvironmentVariableCollection extends EnvironmentVariableCollection { /** * Gets scope-specific environment variable collection for the extension. This enables alterations to * terminal environment variables solely within the designated scope, and is applied in addition to (and * after) the global collection. * * Each object obtained through this method is isolated and does not impact objects for other scopes, * including the global collection. * * @param scope The scope to which the environment variable collection applies to. * * If a scope parameter is omitted, collection applicable to all relevant scopes for that parameter is * returned. For instance, if the 'workspaceFolder' parameter is not specified, the collection that applies * across all workspace folders will be returned. */ getScoped(scope: EnvironmentVariableScope): EnvironmentVariableCollection; } export type EnvironmentVariableScope = { /** * Any specific workspace folder to get collection for. If unspecified, collection applicable to all workspace folders is returned. */ workspaceFolder?: WorkspaceFolder; }; } </del>


this._heartbeatFirstTimeout = setTimeout(() => this._handleHeartbeatFirstTimeout(), HeartbeatConstants.BeatInterval * HeartbeatConstants.FirstWaitMultiplier); if (!this._isResponsive) { this._isResponsive = true; <ins> this._onPtyHostResponsive.fire(); </ins> } <del> this._onPtyHostResponsive.fire(); </del> } private _handleHeartbeatFirstTimeout() {


return; } <del> await result.repository.popStash(result.stash.index); </del> await commands.executeCommand('workbench.action.closeActiveEditor'); <ins> await result.repository.popStash(result.stash.index); </ins> } @command('git.stashApply', { repository: true })


const editorGroupService = accessor.get(IEditorGroupsService); const newOrientation = (editorGroupService.orientation === GroupOrientation.VERTICAL) ? GroupOrientation.HORIZONTAL : GroupOrientation.VERTICAL; editorGroupService.setGroupOrientation(newOrientation); <ins> editorGroupService.activeGroup.focus(); </ins> } });


group: '', title: nls.localize('actions.clipboard.pasteLabel', "Paste"), order: 1 <ins> }, { menuId: MenuId.SimpleEditorContext, group: CLIPBOARD_CONTEXT_MENU_GROUP, title: nls.localize('actions.clipboard.pasteLabel', "Paste"), when: EditorContextKeys.writable, order: 4, </ins> }] })) : undefined;


this._zone.widget.updateStatus(message); } <del> override needsMargin(): boolean { return true; } </del> private async _updateDiffZones() { const diff = await this._editorWorkerService.computeDiff(this._session.textModel0.uri, this._session.textModelN.uri, { ignoreTrimWhitespace: false, maxComputationTimeMs: 5000, computeMoves: false }, 'advanced'); if (!diff || diff.changes.length === 0) {


} /** <del> * The main match information for a {@link TextSearchResultNew}. </del> <ins> * A query match instance in a file. * * For example, consider this excerpt: * * ```ts * const bar = 1; * console.log(bar); * const foo = bar; * ``` * * If the query is `log`, then the line `console.log(bar);` should be represented using a {@link TextSearchMatchNew}. </ins> */ export class TextSearchMatchNew { /**


const holdMode = keybindingService.enableKeybindingHoldMode(id); <ins> let session: IVoiceChatSession | undefined = undefined; </ins> let acceptVoice = false; const handle = disposableTimeout(() => { acceptVoice = true; <del> session.setTimeoutDisabled(true); // disable accept on timeout when hold mode runs for VOICE_KEY_HOLD_THRESHOLD </del> <ins> session?.setTimeoutDisabled(true); // disable accept on timeout when hold mode runs for VOICE_KEY_HOLD_THRESHOLD </ins> }, VOICE_KEY_HOLD_THRESHOLD); const controller = await VoiceChatSessionControllerFactory.create(accessor, target);


assertReplace(['abc', 'Abc'], 'Def', 'def'); assertReplace(['Abc', 'abc'], 'Def', 'Def'); assertReplace(['ABC', 'abc'], 'Def', 'DEF'); <ins> assertReplace(['aBc', 'abc'], 'Def', 'def'); </ins> assertReplace(['AbC'], 'Def', 'Def'); <del> assertReplace(['aBC'], 'Def', 'Def'); </del> <ins> assertReplace(['aBC'], 'Def', 'def'); assertReplace(['aBc'], 'DeF', 'deF'); </ins> assertReplace(['Foo-Bar'], 'newfoo-newbar', 'Newfoo-Newbar'); assertReplace(['Foo-Bar-Abc'], 'newfoo-newbar-newabc', 'Newfoo-Newbar-Newabc'); assertReplace(['Foo-Bar-abc'], 'newfoo-newbar', 'Newfoo-newbar'); assertReplace(['foo-Bar'], 'newfoo-newbar', 'newfoo-Newbar'); assertReplace(['foo-BAR'], 'newfoo-newbar', 'newfoo-NEWBAR'); <ins> assertReplace(['foO-BAR'], 'NewFoo-NewBar', 'newFoo-NEWBAR'); </ins> assertReplace(['Foo_Bar'], 'newfoo_newbar', 'Newfoo_Newbar'); assertReplace(['Foo_Bar_Abc'], 'newfoo_newbar_newabc', 'Newfoo_Newbar_Newabc'); assertReplace(['Foo_Bar_abc'], 'newfoo_newbar', 'Newfoo_newbar');


const choices = [open, openNewWindow]; if (!askToOpen) { <ins> await this.model.openRepository(repositoryPath); </ins> return; }


} # Set IsWindows property <del> [Console]::Write("$([char]0x1b)]633;P;IsWindows=$($IsWindows)`a") </del> <ins> if ($PSVersionTable.PSVersion -lt "6.0") { # Windows PowerShell is only available on Windows [Console]::Write("$([char]0x1b)]633;P;IsWindows=$true`a") } else { [Console]::Write("$([char]0x1b)]633;P;IsWindows=$IsWindows`a") } </ins> # Set always on key handlers which map to default VS Code keybindings function Set-MappedKeyHandler {


openView: 'never' | 'file' | 'firstFile'; useRelativeTime: boolean; visible: boolean; <ins> maxHeight: boolean; </ins> } export const COMMENTS_SECTION = 'comments';


'Selection': IMenu; 'View': IMenu; 'Go': IMenu; <del> 'Terminal': IMenu; </del> 'Debug': IMenu; 'Tasks': IMenu; 'Window'?: IMenu;


export function compareNotebookPos(match1: NotebookMatch, match2: NotebookMatch): number { if (match1.cellIndex === match2.cellIndex) { <del> if (match1.matchStartIndex === match2.matchStartIndex) { if (match1.matchEndIndex === match2.matchEndIndex) { return 0; } else if (match1.matchEndIndex < match2.matchEndIndex) { </del> <ins> if (match1.webviewIndex !== undefined && match2.webviewIndex !== undefined) { return match1.webviewIndex - match2.webviewIndex; } else if (match1.webviewIndex === undefined && match2.webviewIndex === undefined) { if (match1.matchStartIndex === match2.matchStartIndex) { return match1.matchEndIndex - match2.matchEndIndex; } else if (match1.matchStartIndex < match2.matchStartIndex) { </ins> return -1; } else { return 1; } <del> } else if (match1.matchStartIndex < match2.matchStartIndex) { return -1; </del> } else { <del> return 1; </del> <ins> // webview matches should always be after content matches if (match1.webviewIndex !== undefined) { return 1; } else { return -1; } </ins> } } else if (match1.cellIndex < match2.cellIndex) { return -1;


parameters: - name: VSCODE_BUILD_WIN32 type: boolean <ins> default: false </ins> - name: VSCODE_BUILD_WIN32_32BIT type: boolean <ins> default: false </ins> - name: VSCODE_BUILD_WIN32_ARM64 type: boolean <ins> default: false </ins> - name: VSCODE_QUALITY type: string - name: channel