jiebi/CodeConvo huggingface dataset:
import { ExplorerViewPaneContainer } from 'vs/workbench/contrib/files/browser/explorerViewlet'; import { onUnexpectedError } from 'vs/base/common/errors'; import { category, getElementsToOperateOn, getSearchView, openSearchView } from 'vs/workbench/contrib/search/browser/searchActionsBase'; <ins> import { withNullAsUndefined } from 'vs/base/common/types'; import { IConfigurationResolverService } from 'vs/workbench/services/configurationResolver/common/configurationResolver'; import { IHistoryService } from 'vs/workbench/services/history/common/history'; import { Schemas } from 'vs/base/common/network'; </ins> //#region Interfaces
.filter((renderableMatch): renderableMatch is URI => (renderableMatch !== null)); } <del> export function findInFilesCommand(accessor: ServicesAccessor, args: IFindInFilesArgs = {}) { </del> <ins> export async function findInFilesCommand(accessor: ServicesAccessor, _args: IFindInFilesArgs = {}) { </ins> const searchConfig = accessor.get(IConfigurationService).getValue<ISearchConfiguration>().search; <ins> const viewsService = accessor.get(IViewsService); const args: IFindInFilesArgs = {}; if (Object.keys(_args).length !== 0) { // resolve variables in the same way as in // https://github.com/microsoft/vscode/blob/8b76efe9d317d50cb5b57a7658e09ce6ebffaf36/src/vs/workbench/contrib/searchEditor/browser/searchEditorActions.ts#L152-L158 const configurationResolverService = accessor.get(IConfigurationResolverService); const historyService = accessor.get(IHistoryService); const workspaceContextService = accessor.get(IWorkspaceContextService); const activeWorkspaceRootUri = historyService.getLastActiveWorkspaceRoot(Schemas.file); const lastActiveWorkspaceRoot = activeWorkspaceRootUri ? withNullAsUndefined(workspaceContextService.getWorkspaceFolder(activeWorkspaceRootUri)) : undefined; for (const entry of Object.entries(_args)) { const name = entry[0]; const value = entry[1]; if (value !== undefined) { (args as any)[name as any] = (typeof value === 'string') ? await configurationResolverService.resolveAsync(lastActiveWorkspaceRoot, value) : value; } } } </ins> const mode = searchConfig.mode; if (mode === 'view') { <del> const viewsService = accessor.get(IViewsService); </del> openSearchView(viewsService, false).then(openedView => { if (openedView) { const searchAndReplaceWidget = openedView.searchAndReplaceWidget;
// if it's clearing all outputs, or outputs are all rendered synchronously // shrink immediately as the final output height will be zero. // if it's rerun, then the output clearing might be temporary, so we don't shrink immediately <del> this._validateFinalOutputHeight(false || (context === CellOutputUpdateContext.Other && this.viewCell.outputsViewModels.length === 0)); </del> <ins> this._validateFinalOutputHeight(context === CellOutputUpdateContext.Other && this.viewCell.outputsViewModels.length === 0); </ins> } private _generateShowMoreElement(disposables: DisposableStore): HTMLElement {
import { CancellationToken, CancellationTokenSource } from 'vs/base/common/cancellation'; import { KeyCode } from 'vs/base/common/keyCodes'; import * as lifecycle from 'vs/base/common/lifecycle'; <ins> import { clamp } from 'vs/base/common/numbers'; </ins> import { isMacintosh } from 'vs/base/common/platform'; import { ScrollbarVisibility } from 'vs/base/common/scrollable'; import { ContentWidgetPositionPreference, ICodeEditor, IContentWidget, IContentWidgetPosition } from 'vs/editor/browser/editorBrowser'; import { ConfigurationChangedEvent, EditorOption } from 'vs/editor/common/config/editorOptions'; <ins> import { IDimension } from 'vs/editor/common/core/dimension'; </ins> import { Position } from 'vs/editor/common/core/position'; import { Range } from 'vs/editor/common/core/range'; import { ModelDecorationOptions } from 'vs/editor/common/model/textModel';
private create(): void { this.domNode = $('.debug-hover-widget'); this.complexValueContainer = dom.append(this.domNode, $('.complex-value')); <ins> this.complexValueContainer.style.visibility = 'hidden'; </ins> this.complexValueTitle = dom.append(this.complexValueContainer, $('.title')); this.treeContainer = dom.append(this.complexValueContainer, $('.debug-hover-tree')); this.treeContainer.setAttribute('role', 'tree');
this.domNode.style.border = `1px solid ${asCssVariable(editorHoverBorder)}`; this.domNode.style.color = asCssVariable(editorHoverForeground); <del> this.toDispose.push(this.tree.onDidChangeContentHeight(() => this.layoutTreeAndContainer(false))); </del> <ins> this.toDispose.push(this.tree.onDidChangeContentHeight(() => { if (!this.isUpdatingTree) { // Don't do a layout in the middle of the async setInput this.layoutTreeAndContainer(); } })); </ins> this.registerListeners(); this.editor.addContentWidget(this);
this.valueContainer.hidden = true; <del> await this.tree.setInput(expression); </del> <ins> this.expressionToRender = expression; </ins> this.complexValueTitle.textContent = expression.value; this.complexValueTitle.title = expression.value; <del> this.layoutTreeAndContainer(true); </del> <ins> this.editor.layoutContentWidget(this); </ins> this.tree.scrollTop = 0; this.tree.scrollLeft = 0; this.complexValueContainer.hidden = false;
} } <del> private layoutTreeAndContainer(initialLayout: boolean): void { </del> <ins> private layoutTreeAndContainer(): void { this.layoutTree(); this.editor.layoutContentWidget(this); } private layoutTree(): void { </ins> const scrollBarHeight = 10; const treeHeight = Math.min(Math.max(266, this.editor.getLayoutInfo().height * 0.55), this.tree.contentHeight + scrollBarHeight); <ins> // Reset to a smaller width, if it was previously rendered wide this.tree.layout(treeHeight, 400); // const titleWidth = this.complexValueTitle.clientWidth; const realTreeWidth = this.tree.getHTMLElement().offsetWidth; // const contentWidth = Math.max(titleWidth, realTreeWidth); const treeWidth = clamp(realTreeWidth, 400, 550); this.tree.layout(treeHeight, treeWidth); </ins> this.treeContainer.style.height = `${treeHeight}px`; <del> this.tree.layout(treeHeight, initialLayout ? 400 : undefined); this.editor.layoutContentWidget(this); </del> this.scrollbar.scanDomNode(); } <ins> beforeRender(): IDimension | null { // beforeRender will be called each time the hover size changes, and the content widget is layed out again. if (this.expressionToRender) { const expression = this.expressionToRender; this.expressionToRender = undefined; // Do this in beforeRender once the content widget is no longer display=none so that its elements' sizes will be measured correctly. this.isUpdatingTree = true; this.tree.setInput(expression).then(() => { this.isUpdatingTree = false; dom.scheduleAtNextAnimationFrame(() => { // Wait for scrollWidth to update after a frame this.layoutTree(); this.editor.layoutContentWidget(this); this.complexValueContainer.style.visibility = ''; }); }); } return null; } </ins> afterRender(positionPreference: ContentWidgetPositionPreference | null) { if (positionPreference) { // Remember where the editor placed you to keep position stable #109226
export async function pickRemoteSource(model: Model, options: PickRemoteSourceOptions & { branch: true }): Promise<PickRemoteSourceResult | undefined>; export async function pickRemoteSource(model: Model, options: PickRemoteSourceOptions = {}): Promise<string | PickRemoteSourceResult | undefined> { const quickpick = window.createQuickPick<(QuickPickItem & { provider?: RemoteSourceProvider; url?: string })>(); <del> quickpick.ignoreFocusOut = true; </del> quickpick.title = options.title; if (options.providerName) {
if (options.inlineClassName) { const offset = (outputLineIndex > 0 ? lineBreakData.wrappedTextIndentLength : 0); const start = offset + Math.max(injectedTextStartOffsetInInputWithInjections - lineStartOffsetInInputWithInjections, 0); <del> const end = offset + Math.min(injectedTextEndOffsetInInputWithInjections - lineStartOffsetInInputWithInjections, lineEndOffsetInInputWithInjections); </del> <ins> const end = offset + Math.min(injectedTextEndOffsetInInputWithInjections - lineStartOffsetInInputWithInjections, lineEndOffsetInInputWithInjections - lineStartOffsetInInputWithInjections); </ins> if (start !== end) { inlineDecorations.push(new SingleLineInlineDecoration(start, end, options.inlineClassName, options.inlineClassNameAffectsLetterSpacing!)); }
})), [ { inlineDecorations: [{ startOffset: 8, endOffset: 23 }] }, <del> { inlineDecorations: [{ startOffset: 4, endOffset: 42 }] }, </del> <ins> { inlineDecorations: [{ startOffset: 4, endOffset: 30 }] }, </ins> { inlineDecorations: [{ startOffset: 4, endOffset: 16 }] }, { inlineDecorations: undefined }, { inlineDecorations: undefined },
"@vscode/l10n": "^0.0.11", "jsonc-parser": "^3.2.0", "request-light": "^0.7.0", <del> "vscode-json-languageservice": "^5.3.1", </del> <ins> "vscode-json-languageservice": "^5.3.2", </ins> "vscode-languageserver": "^8.1.0", "vscode-uri": "^3.0.7" },
resolved "https://registry.yarnpkg.com/request-light/-/request-light-0.7.0.tgz#885628bb2f8040c26401ebf258ec51c4ae98ac2a" integrity sha512-lMbBMrDoxgsyO+yB3sDcrDuX85yYt7sS8BfQd11jtbW/z5ZWgLZRcEGLsLoYw7I0WSUGQBs8CC8ScIxkTX1+6Q== <del> vscode-json-languageservice@^5.3.1: version "5.3.1" resolved "https://registry.yarnpkg.com/vscode-json-languageservice/-/vscode-json-languageservice-5.3.1.tgz#c36175d05f425fbd8f47dcee6f2a72096bdda36f" integrity sha512-tPRf/2LOBS6uFflFLABdj8T3ol2/QgZ0kpzZHFCs+cbxpnjBNiCo+rfh3th0dtdytq5dSnWo5iFJj99zF6jZWQ== </del> <ins> vscode-json-languageservice@^5.3.2: version "5.3.2" resolved "https://registry.yarnpkg.com/vscode-json-languageservice/-/vscode-json-languageservice-5.3.2.tgz#11e530ba9ec541eaeb421dc274a22efdb5d580ef" integrity sha512-5td6olfoNdtyxnNA4uocq7V9jdTJt63o9mGEntQb6cbD2HiObZW2XgbSj6nRaebWwBCiYdWpFklNjm6Wz6Xy1Q== </ins> dependencies: "@vscode/l10n" "^0.0.11" jsonc-parser "^3.2.0"
} } <del> private async selectStep(id: string | undefined, delayFocus = true, forceRebuild = false) { if (id && this.editorInput.selectedStep === id && !forceRebuild) { return; } </del> <ins> private async selectStep(id: string | undefined, delayFocus = true) { if (id && this.editorInput.selectedStep === id) { return; } </ins> if (id) { let stepElement = this.container.querySelector<HTMLDivElement>(`[data-step-id="${id}"]`);
if (event.keyCode === KeyCode.UpArrow) { const toExpand = category.steps.filter((step, index) => index < currentStepIndex() && this.contextService.contextMatchesRules(step.when)); if (toExpand.length) { <del> this.selectStep(toExpand[toExpand.length - 1].id, false, false); </del> <ins> this.selectStep(toExpand[toExpand.length - 1].id, false); </ins> } } if (event.keyCode === KeyCode.DownArrow) { const toExpand = category.steps.find((step, index) => index > currentStepIndex() && this.contextService.contextMatchesRules(step.when)); if (toExpand) { <del> this.selectStep(toExpand.id, false, false); </del> <ins> this.selectStep(toExpand.id, false); </ins> } } }));
reset(this.stepsContent, categoryDescriptorComponent, stepListComponent, this.stepMediaComponent, categoryFooter); const toExpand = category.steps.find(step => this.contextService.contextMatchesRules(step.when) && !step.done) ?? category.steps[0]; <del> this.selectStep(selectedStep ?? toExpand.id, !selectedStep, true); </del> <ins> this.selectStep(selectedStep ?? toExpand.id, !selectedStep); </ins> this.detailsScrollbar.scanDomNode(); this.detailsPageScrollbar?.scanDomNode();
if (!this._updateCustomBuiltinExtensionsCachePromise) { this._updateCustomBuiltinExtensionsCachePromise = (async () => { this.logService.info('Updating additional builtin extensions cache'); <del> const cached = await this.getCustomBuiltinExtensionsFromCache(); </del> const webExtensions: IWebExtension[] = []; const { extensions } = await this.readCustomBuiltinExtensionsInfoFromEnv(); if (extensions.length) {
} await Promise.all([...galleryExtensionsMap.values()].map(async gallery => { try { <del> const webExtension = cached.find(e => areSameExtensions(e.identifier, gallery.identifier) && e.version === gallery.version) ?? await this.toWebExtensionFromGallery(gallery, { isPreReleaseVersion: gallery.properties.isPreReleaseVersion, preRelease: gallery.properties.isPreReleaseVersion, isBuiltin: true }); </del> <ins> const webExtension = await this.toWebExtensionFromGallery(gallery, { isPreReleaseVersion: gallery.properties.isPreReleaseVersion, preRelease: gallery.properties.isPreReleaseVersion, isBuiltin: true }); </ins> webExtensions.push(webExtension); } catch (error) { this.logService.info(`Ignoring additional builtin extension ${gallery.identifier.id} because there is an error while converting it into web extension`, getErrorMessage(error));
MonacoEditorSchemas['http://opentools.azurewebsites.net/jsconfig'] = { 'title': nls.localize('jsconfig.json.title', "JSON schema for the JavaScript configuration file"), 'type': 'object', <del> 'default': { 'compilerOptions': { 'target': 'ES5' } }, </del> <ins> 'default': { 'compilerOptions': { 'target': 'ES6' } }, </ins> 'properties': { 'compilerOptions': { 'type': 'object',
this._compilerOptions = options || ts.getDefaultCompilerOptions(); this._compilerOptions.allowNonTsExtensions = true; // because of JS* and mirror model we need this this._compilerOptions.module = ts.ModuleKind.CommonJS; // because of JS* <ins> this._compilerOptions.target = options && options.target !== undefined ? options.target : ts.ScriptTarget.Latest; // because of JS* </ins> } getCompilationSettings(): ts.CompilerOptions {
WindowsEnableConpty = 'terminal.integrated.windowsEnableConpty', WordSeparators = 'terminal.integrated.wordSeparators', EnableFileLinks = 'terminal.integrated.enableFileLinks', <ins> AllowedLinkSchemes = 'terminal.integrated.allowedLinkSchemes', </ins> UnicodeVersion = 'terminal.integrated.unicodeVersion', LocalEchoLatencyThreshold = 'terminal.integrated.localEchoLatencyThreshold', LocalEchoEnabled = 'terminal.integrated.localEchoEnabled',
], default: 'on' }, <ins> [TerminalSettingId.AllowedLinkSchemes]: { description: localize('terminal.integrated.allowedLinkSchemes', "An array of strings containing the URI schemes that the terminal is allowed to open links for. By default, only a small subset of possible schemes are allowed for security reasons."), type: 'array', items: { type: 'string' }, default: [ 'file', 'http', 'https', 'mailto', 'vscode', 'vscode-insiders', ] }, </ins> [TerminalSettingId.UnicodeVersion]: { type: 'string', enum: ['6', '11'],
import { TerminalLocalLinkDetector } from 'vs/workbench/contrib/terminalContrib/links/browser/terminalLocalLinkDetector'; import { TerminalUriLinkDetector } from 'vs/workbench/contrib/terminalContrib/links/browser/terminalUriLinkDetector'; import { TerminalWordLinkDetector } from 'vs/workbench/contrib/terminalContrib/links/browser/terminalWordLinkDetector'; <del> import { ITerminalExternalLinkProvider, TerminalLinkQuickPickEvent } from 'vs/workbench/contrib/terminal/browser/terminal'; </del> <ins> import { ITerminalConfigurationService, ITerminalExternalLinkProvider, TerminalLinkQuickPickEvent } from 'vs/workbench/contrib/terminal/browser/terminal'; </ins> import { ILinkHoverTargetOptions, TerminalHover } from 'vs/workbench/contrib/terminal/browser/widgets/terminalHoverWidget'; import { TerminalWidgetManager } from 'vs/workbench/contrib/terminal/browser/widgets/widgetManager'; import { IXtermCore } from 'vs/workbench/contrib/terminal/browser/xterm-private';
import { RunOnceScheduler } from 'vs/base/common/async'; import { ITerminalLogService } from 'vs/platform/terminal/common/terminal'; import { TerminalMultiLineLinkDetector } from 'vs/workbench/contrib/terminalContrib/links/browser/terminalMultiLineLinkDetector'; <ins> import { INotificationService, Severity } from 'vs/platform/notification/common/notification'; </ins> export type XtermLinkMatcherHandler = (event: MouseEvent | undefined, link: string) => Promise<void>;
capabilities: ITerminalCapabilityStore, private readonly _linkResolver: ITerminalLinkResolver, @IConfigurationService private readonly _configurationService: IConfigurationService, <ins> @ITerminalConfigurationService private readonly _terminalConfigurationService: ITerminalConfigurationService, </ins> @IInstantiationService private readonly _instantiationService: IInstantiationService, <ins> @INotificationService private readonly _notificationService: INotificationService, </ins> @ITerminalLogService private readonly _logService: ITerminalLogService, @ITunnelService private readonly _tunnelService: ITunnelService ) {
activeTooltipScheduler?.dispose(); })); this._xterm.options.linkHandler = { <del> activate: (_, text) => { </del> <ins> allowNonHttpProtocols: true, activate: (event, text) => { if (!this._isLinkActivationModifierDown(event)) { return; } const colonIndex = text.indexOf(':'); if (colonIndex === -1) { throw new Error(`Could not find scheme in link "${text}"`); } const scheme = text.substring(0, colonIndex); if (this._terminalConfigurationService.config.allowedLinkSchemes.indexOf(scheme) === -1) { this._notificationService.prompt(Severity.Warning, nls.localize('scheme', 'Opening URIs can be insecure, do you want to allow opening links with the scheme {0}?', scheme), [ { label: nls.localize('allow', 'Allow {0}', scheme), run: () => { const allowedLinkSchemes = [ ...this._terminalConfigurationService.config.allowedLinkSchemes, scheme ]; this._configurationService.updateValue(`terminal.integrated.allowedLinkSchemes`, allowedLinkSchemes); } } ]); } </ins> this._openers.get(TerminalBuiltinLinkType.Url)?.open({ type: TerminalBuiltinLinkType.Url, text,
const fileService = accessor.get(IFileService); const openerService = accessor.get(IOpenerService); <del> let { range, uri } = test.item; </del> <ins> const { range, uri } = test.item; </ins> if (!uri) { return; } // If an editor has the file open, there are decorations. Try to adjust the // revealed range to those decorations (#133441). <del> range = accessor.get(ITestingDecorationsService).getDecoratedRangeForTest(uri, extId) || range; </del> <ins> const position = accessor.get(ITestingDecorationsService).getDecoratedTestPosition(uri, extId) || range?.getStartPosition(); </ins> accessor.get(ITestExplorerFilterState).reveal.value = extId; accessor.get(ITestingPeekOpener).closeAllPeeks();
} } <del> const firstLineRange = (originalRange: IRange) => ({ </del> <ins> const collapseRange = (originalRange: IRange) => ({ </ins> startLineNumber: originalRange.startLineNumber, endLineNumber: originalRange.startLineNumber, <del> startColumn: 0, endColumn: Number.MAX_SAFE_INTEGER, </del> <ins> startColumn: originalRange.startColumn, endColumn: originalRange.startColumn, </ins> }); const createRunTestDecoration = (tests: readonly IncrementalTestCollectionItem[], states: readonly (TestResultItem | undefined)[], visible: boolean): IModelDeltaDecoration => {
} return { <del> range: firstLineRange(range), </del> <ins> range: collapseRange(range), </ins> options: { description: 'run-test-decoration', <del> isWholeLine: true, </del> <ins> showIfCollapsed: true, </ins> get hoverMessage() { if (!hoverMessage) { const building = hoverMessage = new MarkdownString('', true).appendText(hoverMessageParts.join(', ') + '.');
import { binarySearch } from 'vs/base/common/arrays'; import { Event } from 'vs/base/common/event'; import { URI } from 'vs/base/common/uri'; <del> import { Range } from 'vs/editor/common/core/range'; </del> <ins> import { Position } from 'vs/editor/common/core/position'; </ins> import { IModelDeltaDecoration } from 'vs/editor/common/model'; import { createDecorator } from 'vs/platform/instantiation/common/instantiation'; import { ITestMessage } from 'vs/workbench/contrib/testing/common/testTypes';
append_dir GTK_PATH "$SNAP/usr/lib/$ARCH/gtk-3.0" append_dir GTK_PATH "$SNAP/usr/lib/gtk-3.0" <ins> # We don't have gtk libraries in this path but # enforcing this environment variable will disallow # gtk binaries like `gtk-query-immodules` to not search # in system default library paths. # Based on https://gitlab.gnome.org/GNOME/gtk/-/blob/main/gtk/gtkmodules.c#L104-136 export GTK_EXE_PREFIX="$SNAP/usr" </ins> # ibus and fcitx integration GTK_IM_MODULE_DIR="$SNAP_USER_COMMON/.cache/immodules"
const gtkIMModuleFile = process.env['GTK_IM_MODULE_FILE']; const gdkBackend = process.env['GDK_BACKEND']; const gioModuleDir = process.env['GIO_MODULE_DIR']; <ins> const gtkExePrefix = process.env['GTK_EXE_PREFIX']; </ins> delete process.env['GDK_PIXBUF_MODULE_FILE']; delete process.env['GDK_PIXBUF_MODULEDIR']; delete process.env['GTK_IM_MODULE_FILE']; delete process.env['GDK_BACKEND']; delete process.env['GIO_MODULE_DIR']; <ins> delete process.env['GTK_EXE_PREFIX']; </ins> shell.openExternal(url);
process.env['GTK_IM_MODULE_FILE'] = gtkIMModuleFile; process.env['GDK_BACKEND'] = gdkBackend; process.env['GIO_MODULE_DIR'] = gioModuleDir; <ins> process.env['GTK_EXE_PREFIX'] = gtkExePrefix; </ins> } moveItemToTrash(windowId: number | undefined, fullPath: string): Promise<void> {
metadata.scrollable : options.outputScrolling; } <ins> //  div.cell_container //    div.output_container //      div.output.output-stream		<-- outputElement parameter //        div.scrollable? tabindex="0" 	<-- contentParent //          div output-item-id="{guid}"	<-- content from outputItem parameter </ins> function renderStream(outputInfo: OutputItem, outputElement: HTMLElement, error: boolean, ctx: IRichRenderContext): IDisposable { const disposableStore = createDisposableStore(); const outputScrolling = scrollingEnabled(outputInfo, ctx.settings);
const scrollTop = outputScrolling ? findScrolledHeight(outputElement) : undefined; // If the previous output item for the same cell was also a stream, append this output to the previous <del> const existingContentParent = getPreviousMatchingContentGroup(outputElement); </del> <ins> const existingContentParent = getPreviousMatchingContentGroup(outputElement) || outputElement.querySelector('div'); </ins> if (existingContentParent) { const existing = existingContentParent.querySelector(`[output-item-id="${outputInfo.id}"]`) as HTMLElement | null; if (existing) {
import { IRange, Range } from 'vs/editor/common/core/range'; import { getDefinitionsAtPosition } from 'vs/editor/contrib/gotoSymbol/browser/goToSymbol'; import { goToDefinitionWithLocation } from 'vs/editor/contrib/inlayHints/browser/inlayHintsLocations'; <del> import { Position } from 'vs/editor/common/core/position'; </del> <ins> import { IPosition, Position } from 'vs/editor/common/core/position'; </ins> import { CancellationTokenSource } from 'vs/base/common/cancellation'; import { ILanguageConfigurationService } from 'vs/editor/common/languages/languageConfigurationRegistry'; import { ILanguageFeatureDebounceService } from 'vs/editor/common/services/languageFeatureDebounce';
const focusTracker = this._register(dom.trackFocus(this._stickyScrollWidget.getDomNode())); this._register(focusTracker.onDidBlur(_ => { const height = this._stickyScrollWidget.getDomNode().clientHeight; <del> if (height !== 0) { this._disposeFocusStickyScrollStore(); } else { // If the height is 0, then the blur has been caused by scrolling. In that case keep the focus on the sticky scroll. </del> <ins> // Suppose that the blurring is caused by scrolling, then keep the focus on the sticky scroll // This is determined by the fact that the height of the widget has become zero and there has been no position revealing if (this._positionRevealed === false && height === 0) { </ins> this._focusedStickyElementIndex = -1; this.focus(); <ins> } // In all other casees, dispose the focus on the sticky scroll else { this._disposeFocusStickyScrollStore(); </ins> } })); this._register(focusTracker.onDidFocus(_ => { this.focus(); })); this._register(this._createClickLinkGesture()); <ins> // Suppose that mouse down on the sticky scroll, then do not focus on the sticky scroll because this will be followed by the revealing of a position this._register(dom.addDisposableListener(this._stickyScrollWidget.getDomNode(), dom.EventType.MOUSE_DOWN, (e) => { this._onMouseDown = true; })); </ins> } get stickyScrollCandidateProvider(): IStickyLineCandidateProvider {