@codingame/monaco-vscode-api 18.4.0 → 19.0.1

package/vscode/src/vs/editor/contrib/snippet/browser/snippetVariables.js

@@ -214,10 +214,10 @@ class TimeBasedVariableResolver {
     constructor() {
         this._date = ( new Date());
     }
-    static { this.dayNames = [( localize(1456, "Sunday")), ( localize(1457, "Monday")), ( localize(1458, "Tuesday")), ( localize(1459, "Wednesday")), ( localize(1460, "Thursday")), ( localize(1461, "Friday")), ( localize(1462, "Saturday"))]; }
-    static { this.dayNamesShort = [( localize(1463, "Sun")), ( localize(1464, "Mon")), ( localize(1465, "Tue")), ( localize(1466, "Wed")), ( localize(1467, "Thu")), ( localize(1468, "Fri")), ( localize(1469, "Sat"))]; }
-    static { this.monthNames = [( localize(1470, "January")), ( localize(1471, "February")), ( localize(1472, "March")), ( localize(1473, "April")), ( localize(1474, "May")), ( localize(1475, "June")), ( localize(1476, "July")), ( localize(1477, "August")), ( localize(1478, "September")), ( localize(1479, "October")), ( localize(1480, "November")), ( localize(1481, "December"))]; }
-    static { this.monthNamesShort = [( localize(1482, "Jan")), ( localize(1483, "Feb")), ( localize(1484, "Mar")), ( localize(1485, "Apr")), ( localize(1486, "May")), ( localize(1487, "Jun")), ( localize(1488, "Jul")), ( localize(1489, "Aug")), ( localize(1490, "Sep")), ( localize(1491, "Oct")), ( localize(1492, "Nov")), ( localize(1493, "Dec"))]; }
+    static { this.dayNames = [( localize(1468, "Sunday")), ( localize(1469, "Monday")), ( localize(1470, "Tuesday")), ( localize(1471, "Wednesday")), ( localize(1472, "Thursday")), ( localize(1473, "Friday")), ( localize(1474, "Saturday"))]; }
+    static { this.dayNamesShort = [( localize(1475, "Sun")), ( localize(1476, "Mon")), ( localize(1477, "Tue")), ( localize(1478, "Wed")), ( localize(1479, "Thu")), ( localize(1480, "Fri")), ( localize(1481, "Sat"))]; }
+    static { this.monthNames = [( localize(1482, "January")), ( localize(1483, "February")), ( localize(1484, "March")), ( localize(1485, "April")), ( localize(1486, "May")), ( localize(1487, "June")), ( localize(1488, "July")), ( localize(1489, "August")), ( localize(1490, "September")), ( localize(1491, "October")), ( localize(1492, "November")), ( localize(1493, "December"))]; }
+    static { this.monthNamesShort = [( localize(1494, "Jan")), ( localize(1495, "Feb")), ( localize(1496, "Mar")), ( localize(1497, "Apr")), ( localize(1498, "May")), ( localize(1499, "Jun")), ( localize(1500, "Jul")), ( localize(1501, "Aug")), ( localize(1502, "Sep")), ( localize(1503, "Oct")), ( localize(1504, "Nov")), ( localize(1505, "Dec"))]; }
     resolve(variable) {
         const { name } = variable;
         if (name === 'CURRENT_YEAR') {

package/vscode/src/vs/editor/contrib/stickyScroll/browser/stickyScroll.css

@@ -1,58 +1,58 @@
 .monaco-editor .sticky-widget {
 	overflow: hidden;
+	border-bottom: 1px solid var(--vscode-editorStickyScroll-border);
+	width: 100%;
+	box-shadow: var(--vscode-editorStickyScroll-shadow) 0 4px 2px -2px;
+	z-index: 4;
+	right: initial !important;
+	margin-left: '0px';
 }
-.monaco-editor .sticky-widget-line-numbers {
+.monaco-editor .sticky-widget .sticky-widget-line-numbers {
 	float: left;
-	background-color: inherit;
+	background-color: var(--vscode-editorStickyScrollGutter-background);
 }
-.monaco-editor .sticky-widget-lines-scrollable {
+.monaco-editor .sticky-widget.peek .sticky-widget-line-numbers {
+	background-color: var(--vscode-peekViewEditorStickyScrollGutter-background);
+}
+.monaco-editor .sticky-widget .sticky-widget-lines-scrollable {
 	display: inline-block;
 	position: absolute;
 	overflow: hidden;
 	width: var(--vscode-editorStickyScroll-scrollableWidth);
-	background-color: inherit;
+	background-color: var(--vscode-editorStickyScroll-background);
 }
-.monaco-editor .sticky-widget-lines {
+.monaco-editor .sticky-widget.peek .sticky-widget-lines-scrollable {
+	background-color: var(--vscode-peekViewEditorStickyScroll-background);
+}
+.monaco-editor .sticky-widget .sticky-widget-lines {
 	position: absolute;
 	background-color: inherit;
 }
-.monaco-editor .sticky-line-number, .monaco-editor .sticky-line-content {
+.monaco-editor .sticky-widget .sticky-line-number,
+.monaco-editor .sticky-widget .sticky-line-content {
 	color: var(--vscode-editorLineNumber-foreground);
 	white-space: nowrap;
 	display: inline-block;
 	position: absolute;
 	background-color: inherit;
 }
-.monaco-editor .sticky-line-number .codicon-folding-expanded,
-.monaco-editor .sticky-line-number .codicon-folding-collapsed {
+.monaco-editor .sticky-widget .sticky-line-number .codicon-folding-expanded,
+.monaco-editor .sticky-widget .sticky-line-number .codicon-folding-collapsed {
 	float: right;
 	transition: var(--vscode-editorStickyScroll-foldingOpacityTransition);
 	position: absolute;
 	margin-left: 2px;
 }
-.monaco-editor .sticky-line-content {
+.monaco-editor .sticky-widget .sticky-line-content {
 	width: var(--vscode-editorStickyScroll-scrollableWidth);
 	background-color: inherit;
 	white-space: nowrap;
 }
-.monaco-editor .sticky-line-number-inner {
+.monaco-editor .sticky-widget .sticky-line-number-inner {
 	display: inline-block;
 	text-align: right;
 }
-.monaco-editor .sticky-widget {
-	border-bottom: 1px solid var(--vscode-editorStickyScroll-border);
-}
-.monaco-editor .sticky-line-content:hover {
+.monaco-editor .sticky-widget .sticky-line-content:hover {
 	background-color: var(--vscode-editorStickyScrollHover-background);
 	cursor: pointer;
 }
-.monaco-editor .sticky-widget {
-	width: 100%;
-	box-shadow: var(--vscode-editorStickyScroll-shadow) 0 4px 2px -2px;
-	z-index: 4;
-	background-color: var(--vscode-editorStickyScroll-background);
-	right: initial !important;
-}
-.monaco-editor .sticky-widget.peek {
-	background-color: var(--vscode-peekViewEditorStickyScroll-background);
-}

package/vscode/src/vs/editor/contrib/stickyScroll/browser/stickyScrollActions.js

@@ -15,20 +15,20 @@ class ToggleStickyScroll extends EditorAction2 {
         super({
             id: 'editor.action.toggleStickyScroll',
             title: {
-                ...( localize2(1494, "Toggle Editor Sticky Scroll")),
-                mnemonicTitle: ( localize(1495, "&&Toggle Editor Sticky Scroll")),
+                ...( localize2(1506, "Toggle Editor Sticky Scroll")),
+                mnemonicTitle: ( localize(1507, "&&Toggle Editor Sticky Scroll")),
             },
             metadata: {
                 description: ( localize2(
-                    1496,
+                    1508,
                     "Toggle/enable the editor sticky scroll which shows the nested scopes at the top of the viewport"
                 )),
             },
             category: Categories.View,
             toggled: {
                 condition: ( ContextKeyExpr.equals('config.editor.stickyScroll.enabled', true)),
-                title: ( localize(1497, "Sticky Scroll")),
-                mnemonicTitle: ( localize(1498, "&&Sticky Scroll")),
+                title: ( localize(1509, "Sticky Scroll")),
+                mnemonicTitle: ( localize(1510, "&&Sticky Scroll")),
             },
             menu: [
                 { id: MenuId.CommandPalette },
@@ -53,8 +53,8 @@ class FocusStickyScroll extends EditorAction2 {
         super({
             id: 'editor.action.focusStickyScroll',
             title: {
-                ...( localize2(1499, "Focus Editor Sticky Scroll")),
-                mnemonicTitle: ( localize(1500, "&&Focus Editor Sticky Scroll")),
+                ...( localize2(1511, "Focus Editor Sticky Scroll")),
+                mnemonicTitle: ( localize(1512, "&&Focus Editor Sticky Scroll")),
             },
             precondition: ( ContextKeyExpr.and(( ContextKeyExpr.has('config.editor.stickyScroll.enabled')), EditorContextKeys.stickyScrollVisible)),
             menu: [
@@ -70,7 +70,7 @@ class SelectNextStickyScrollLine extends EditorAction2 {
     constructor() {
         super({
             id: 'editor.action.selectNextStickyScrollLine',
-            title: ( localize2(1501, "Select the next editor sticky scroll line")),
+            title: ( localize2(1513, "Select the next editor sticky scroll line")),
             precondition: ( EditorContextKeys.stickyScrollFocused.isEqualTo(true)),
             keybinding: {
                 weight,
@@ -86,7 +86,7 @@ class SelectPreviousStickyScrollLine extends EditorAction2 {
     constructor() {
         super({
             id: 'editor.action.selectPreviousStickyScrollLine',
-            title: ( localize2(1502, "Select the previous sticky scroll line")),
+            title: ( localize2(1514, "Select the previous sticky scroll line")),
             precondition: ( EditorContextKeys.stickyScrollFocused.isEqualTo(true)),
             keybinding: {
                 weight,
@@ -102,7 +102,7 @@ class GoToStickyScrollLine extends EditorAction2 {
     constructor() {
         super({
             id: 'editor.action.goToFocusedStickyScrollLine',
-            title: ( localize2(1503, "Go to the focused sticky scroll line")),
+            title: ( localize2(1515, "Go to the focused sticky scroll line")),
             precondition: ( EditorContextKeys.stickyScrollFocused.isEqualTo(true)),
             keybinding: {
                 weight,
@@ -118,7 +118,7 @@ class SelectEditor extends EditorAction2 {
     constructor() {
         super({
             id: 'editor.action.selectEditor',
-            title: ( localize2(1504, "Select Editor")),
+            title: ( localize2(1516, "Select Editor")),
             precondition: ( EditorContextKeys.stickyScrollFocused.isEqualTo(true)),
             keybinding: {
                 weight,

package/vscode/src/vs/editor/contrib/stickyScroll/browser/stickyScrollController.js

@@ -65,6 +65,14 @@ let StickyScrollController = class StickyScrollController extends Disposable {
                 }
             });
         }));
+        this._register(this._editor.onDidChangeFont((e) => {
+            e.changes.forEach((change) => {
+                const lineNumber = change.lineNumber;
+                if (this._widgetState.startLineNumbers.includes(lineNumber)) {
+                    this._renderStickyScroll(lineNumber);
+                }
+            });
+        }));
         this._register(this._editor.onDidChangeConfiguration(e => {
             this._readConfigurationChange(e);
         }));
@@ -241,26 +249,18 @@ let StickyScrollController = class StickyScrollController extends Disposable {
             }
             this._revealPosition(position);
         }));
-        const mouseMoveListener = (mouseEvent) => {
+        this._register(addDisposableListener(mainWindow, EventType.MOUSE_MOVE, mouseEvent => {
             this._mouseTarget = mouseEvent.target;
             this._onMouseMoveOrKeyDown(mouseEvent);
-        };
-        const keyDownListener = (mouseEvent) => {
+        }));
+        this._register(addDisposableListener(mainWindow, EventType.KEY_DOWN, mouseEvent => {
             this._onMouseMoveOrKeyDown(mouseEvent);
-        };
-        const keyUpListener = (e) => {
+        }));
+        this._register(addDisposableListener(mainWindow, EventType.KEY_UP, () => {
             if (this._showEndForLine !== undefined) {
                 this._showEndForLine = undefined;
                 this._renderStickyScroll();
             }
-        };
-        mainWindow.addEventListener(EventType.MOUSE_MOVE, mouseMoveListener);
-        mainWindow.addEventListener(EventType.KEY_DOWN, keyDownListener);
-        mainWindow.addEventListener(EventType.KEY_UP, keyUpListener);
-        this._register(toDisposable(() => {
-            mainWindow.removeEventListener(EventType.MOUSE_MOVE, mouseMoveListener);
-            mainWindow.removeEventListener(EventType.KEY_DOWN, keyDownListener);
-            mainWindow.removeEventListener(EventType.KEY_UP, keyUpListener);
         }));
         this._register(gesture.onMouseMoveOrRelevantKeyDown(([mouseEvent, _keyboardEvent]) => {
             const mouseTarget = getMouseEventTarget(mouseEvent);

package/vscode/src/vs/editor/contrib/stickyScroll/browser/stickyScrollModelProvider.js

@@ -1,6 +1,6 @@
 
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { Disposable, DisposableStore, MutableDisposable } from '../../../../base/common/lifecycle.js';
 import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.service.js';
 import { OutlineModel, OutlineGroup, OutlineElement } from '../../documentSymbols/browser/outlineModel.js';
 import { Delayer, createCancelablePromise } from '../../../../base/common/async.js';
@@ -293,22 +293,30 @@ let StickyModelFromCandidateSyntaxFoldingProvider = class StickyModelFromCandida
     constructor(editor, onProviderUpdate, _languageFeaturesService) {
         super(editor);
         this._languageFeaturesService = _languageFeaturesService;
+        this.provider = this._register(( new MutableDisposable()));
+        this._register(this._languageFeaturesService.foldingRangeProvider.onDidChange(() => {
+            this._updateProvider(editor, onProviderUpdate);
+        }));
+        this._updateProvider(editor, onProviderUpdate);
+    }
+    _updateProvider(editor, onProviderUpdate) {
         const selectedProviders = FoldingController.getFoldingRangeProviders(this._languageFeaturesService, editor.getModel());
-        if (selectedProviders.length > 0) {
-            this.provider = this._register(( new SyntaxRangeProvider(
-                editor.getModel(),
-                selectedProviders,
-                onProviderUpdate,
-                this._foldingLimitReporter,
-                undefined
-            )));
+        if (selectedProviders.length === 0) {
+            return;
         }
+        this.provider.value = ( new SyntaxRangeProvider(
+            editor.getModel(),
+            selectedProviders,
+            onProviderUpdate,
+            this._foldingLimitReporter,
+            undefined
+        ));
     }
     isProviderValid() {
         return this.provider !== undefined;
     }
     async createModelFromProvider(token) {
-        return this.provider?.compute(token) ?? null;
+        return this.provider.value?.compute(token) ?? null;
     }
 };
 StickyModelFromCandidateSyntaxFoldingProvider = ( __decorate([

package/vscode/src/vs/editor/contrib/stickyScroll/browser/stickyScrollProvider.d.ts

@@ -3,7 +3,7 @@ import { ICodeEditor } from "../../../browser/editorBrowser.js";
 import { ILanguageFeaturesService } from "../../../common/services/languageFeatures.service.js";
 import { Event } from "../../../../base/common/event.js";
 import { ILanguageConfigurationService } from "../../../common/languages/languageConfigurationRegistry.service.js";
-import { StickyElement, StickyRange } from "./stickyScrollElement.js";
+import { StickyRange } from "./stickyScrollElement.js";
 export declare class StickyLineCandidate {
     readonly startLineNumber: number;
     readonly endLineNumber: number;
@@ -36,7 +36,8 @@ export declare class StickyLineCandidateProvider extends Disposable implements I
     private updateStickyModelProvider;
     update(): Promise<void>;
     private updateStickyModel;
-    private updateIndex;
-    getCandidateStickyLinesIntersectingFromStickyModel(range: StickyRange, outlineModel: StickyElement, result: StickyLineCandidate[], depth: number, top: number, lastStartLineNumber: number): void;
     getCandidateStickyLinesIntersecting(range: StickyRange): StickyLineCandidate[];
+    private getCandidateStickyLinesIntersectingFromStickyModel;
+    private filterHiddenRanges;
+    private updateIndex;
 }

package/vscode/src/vs/editor/contrib/stickyScroll/browser/stickyScrollProvider.js

@@ -68,10 +68,9 @@ let StickyLineCandidateProvider = class StickyLineCandidateProvider extends Disp
     updateStickyModelProvider() {
         this._stickyModelProvider?.dispose();
         this._stickyModelProvider = null;
-        const editor = this._editor;
-        if (editor.hasModel()) {
+        if (this._editor.hasModel()) {
             this._stickyModelProvider = ( new StickyModelProvider(
-                editor,
+                this._editor,
                 () => this._updateSoon.schedule(),
                 this._languageConfigurationService,
                 this._languageFeaturesService
@@ -90,19 +89,17 @@ let StickyLineCandidateProvider = class StickyLineCandidateProvider extends Disp
             return;
         }
         const model = await this._stickyModelProvider.update(token);
-        if (token.isCancellationRequested) {
-            return;
+        if (!token.isCancellationRequested) {
+            this._model = model;
         }
-        this._model = model;
     }
-    updateIndex(index) {
-        if (index === -1) {
-            index = 0;
-        }
-        else if (index < 0) {
-            index = -index - 2;
+    getCandidateStickyLinesIntersecting(range) {
+        if (!this._model?.element) {
+            return [];
         }
-        return index;
+        const stickyLineCandidates = [];
+        this.getCandidateStickyLinesIntersectingFromStickyModel(range, this._model.element, stickyLineCandidates, 0, 0, -1);
+        return this.filterHiddenRanges(stickyLineCandidates);
     }
     getCandidateStickyLinesIntersectingFromStickyModel(range, outlineModel, result, depth, top, lastStartLineNumber) {
         if (outlineModel.children.length === 0) {
@@ -120,38 +117,36 @@ let StickyLineCandidateProvider = class StickyLineCandidateProvider extends Disp
         const upperBound = this.updateIndex(binarySearch(childrenStartLines, range.endLineNumber, (a, b) => { return a - b; }));
         for (let i = lowerBound; i <= upperBound; i++) {
             const child = outlineModel.children[i];
-            if (!child) {
-                return;
-            }
-            const childRange = child.range;
-            if (childRange) {
-                const childStartLine = childRange.startLineNumber;
-                const childEndLine = childRange.endLineNumber;
-                if (range.startLineNumber <= childEndLine + 1 && childStartLine - 1 <= range.endLineNumber && childStartLine !== lastLine) {
-                    lastLine = childStartLine;
-                    const lineHeight = this._editor.getLineHeightForPosition(( new Position(childStartLine, 1)));
-                    result.push(( new StickyLineCandidate(childStartLine, childEndLine - 1, top, lineHeight)));
-                    this.getCandidateStickyLinesIntersectingFromStickyModel(range, child, result, depth + 1, top + lineHeight, childStartLine);
-                }
+            if (!child || !child.range) {
+                continue;
             }
-            else {
-                this.getCandidateStickyLinesIntersectingFromStickyModel(range, child, result, depth, top, lastStartLineNumber);
+            const { startLineNumber, endLineNumber } = child.range;
+            if (range.startLineNumber <= endLineNumber + 1 && startLineNumber - 1 <= range.endLineNumber && startLineNumber !== lastLine) {
+                lastLine = startLineNumber;
+                const lineHeight = this._editor.getLineHeightForPosition(( new Position(startLineNumber, 1)));
+                result.push(( new StickyLineCandidate(startLineNumber, endLineNumber - 1, top, lineHeight)));
+                this.getCandidateStickyLinesIntersectingFromStickyModel(range, child, result, depth + 1, top + lineHeight, startLineNumber);
             }
         }
     }
-    getCandidateStickyLinesIntersecting(range) {
-        if (!this._model?.element) {
-            return [];
-        }
-        let stickyLineCandidates = [];
-        this.getCandidateStickyLinesIntersectingFromStickyModel(range, this._model.element, stickyLineCandidates, 0, 0, -1);
+    filterHiddenRanges(stickyLineCandidates) {
         const hiddenRanges = this._editor._getViewModel()?.getHiddenAreas();
-        if (hiddenRanges) {
-            for (const hiddenRange of hiddenRanges) {
-                stickyLineCandidates = stickyLineCandidates.filter(stickyLine => !(stickyLine.startLineNumber >= hiddenRange.startLineNumber && stickyLine.endLineNumber <= hiddenRange.endLineNumber + 1));
-            }
+        if (!hiddenRanges) {
+            return stickyLineCandidates;
+        }
+        return stickyLineCandidates.filter(candidate => {
+            return !( hiddenRanges.some(hiddenRange => candidate.startLineNumber >= hiddenRange.startLineNumber &&
+                candidate.endLineNumber <= hiddenRange.endLineNumber + 1));
+        });
+    }
+    updateIndex(index) {
+        if (index === -1) {
+            return 0;
         }
-        return stickyLineCandidates;
+        else if (index < 0) {
+            return -index - 2;
+        }
+        return index;
     }
 };
 StickyLineCandidateProvider = ( __decorate([

package/vscode/src/vs/editor/contrib/stickyScroll/browser/stickyScrollWidget.d.ts

@@ -19,7 +19,7 @@ export declare class StickyScrollWidget extends Disposable implements IOverlayWi
     private readonly _linesDomNodeScrollable;
     private readonly _linesDomNode;
     private readonly _editor;
-    private _previousState;
+    private _state;
     private _lineHeight;
     private _renderedStickyLines;
     private _lineNumbers;
@@ -37,15 +37,14 @@ export declare class StickyScrollWidget extends Disposable implements IOverlayWi
     get lineNumberCount(): number;
     getRenderedStickyLine(lineNumber: number): RenderedStickyLine | undefined;
     getCurrentLines(): readonly number[];
-    setState(_state: StickyScrollWidgetState | undefined, foldingModel: FoldingModel | undefined, _rebuildFromLine?: number): void;
-    private _isWidgetHeightZero;
-    private _findLineToRebuildWidgetFrom;
+    setState(state: StickyScrollWidgetState | undefined, foldingModel: FoldingModel | undefined, rebuildFromIndexCandidate?: number): void;
+    private _findRenderingData;
+    private _findIndexToRebuildFrom;
     private _updateWidgetWidth;
-    private _clearStickyLinesFromLine;
     private _useFoldingOpacityTransition;
     private _setFoldingIconsVisibility;
     private _renderRootNode;
-    private _getHeightOfLines;
+    private _clearWidget;
     private _setHeight;
     private _setFoldingHoverListeners;
     private _renderChildNode;

package/vscode/src/vs/editor/contrib/stickyScroll/browser/stickyScrollWidget.js

@@ -113,46 +113,46 @@ class StickyScrollWidget extends Disposable {
     getCurrentLines() {
         return this._lineNumbers;
     }
-    setState(_state, foldingModel, _rebuildFromLine) {
-        if (_rebuildFromLine === undefined &&
-            ((!this._previousState && !_state) || (this._previousState && this._previousState.equals(_state)))) {
+    setState(state, foldingModel, rebuildFromIndexCandidate) {
+        const currentStateAndPreviousStateUndefined = !this._state && !state;
+        const currentStateDefinedAndEqualsPreviousState = this._state && this._state.equals(state);
+        if (rebuildFromIndexCandidate === undefined && (currentStateAndPreviousStateUndefined || currentStateDefinedAndEqualsPreviousState)) {
             return;
         }
-        const isWidgetHeightZero = this._isWidgetHeightZero(_state);
-        const state = isWidgetHeightZero ? undefined : _state;
-        const rebuildFromLine = isWidgetHeightZero ? 0 : this._findLineToRebuildWidgetFrom(_state, _rebuildFromLine);
-        this._renderRootNode(state, foldingModel, rebuildFromLine);
-        this._previousState = _state;
+        const data = this._findRenderingData(state);
+        const previousLineNumbers = this._lineNumbers;
+        this._lineNumbers = data.lineNumbers;
+        this._lastLineRelativePosition = data.lastLineRelativePosition;
+        const rebuildFromIndex = this._findIndexToRebuildFrom(previousLineNumbers, this._lineNumbers, rebuildFromIndexCandidate);
+        this._renderRootNode(this._lineNumbers, this._lastLineRelativePosition, foldingModel, rebuildFromIndex);
+        this._state = state;
     }
-    _isWidgetHeightZero(state) {
+    _findRenderingData(state) {
         if (!state) {
-            return true;
-        }
-        const futureWidgetHeight = this._getHeightOfLines(state.startLineNumbers, state.lastLineRelativePosition);
-        if (futureWidgetHeight > 0) {
-            this._lastLineRelativePosition = state.lastLineRelativePosition;
-            const lineNumbers = [...state.startLineNumbers];
-            if (state.showEndForLine !== null) {
-                lineNumbers[state.showEndForLine] = state.endLineNumbers[state.showEndForLine];
-            }
-            this._lineNumbers = lineNumbers;
+            return { lineNumbers: [], lastLineRelativePosition: 0 };
         }
-        else {
-            this._lastLineRelativePosition = 0;
-            this._lineNumbers = [];
+        const candidateLineNumbers = [...state.startLineNumbers];
+        if (state.showEndForLine !== null) {
+            candidateLineNumbers[state.showEndForLine] = state.endLineNumbers[state.showEndForLine];
+        }
+        let totalHeight = 0;
+        for (let i = 0; i < candidateLineNumbers.length; i++) {
+            totalHeight += this._editor.getLineHeightForPosition(( new Position(candidateLineNumbers[i], 1)));
         }
-        return futureWidgetHeight === 0;
+        if (totalHeight === 0) {
+            return { lineNumbers: [], lastLineRelativePosition: 0 };
+        }
+        return { lineNumbers: candidateLineNumbers, lastLineRelativePosition: state.lastLineRelativePosition };
     }
-    _findLineToRebuildWidgetFrom(state, _rebuildFromLine) {
-        if (!state || !this._previousState) {
+    _findIndexToRebuildFrom(previousLineNumbers, newLineNumbers, rebuildFromIndexCandidate) {
+        if (newLineNumbers.length === 0) {
             return 0;
         }
-        if (_rebuildFromLine !== undefined) {
-            return _rebuildFromLine;
+        if (rebuildFromIndexCandidate !== undefined) {
+            return rebuildFromIndexCandidate;
         }
-        const previousState = this._previousState;
-        const indexOfLinesAlreadyRendered = state.startLineNumbers.findIndex(startLineNumber => !previousState.startLineNumbers.includes(startLineNumber));
-        return (indexOfLinesAlreadyRendered === -1) ? 0 : indexOfLinesAlreadyRendered;
+        const validIndex = newLineNumbers.findIndex(startLineNumber => !previousLineNumbers.includes(startLineNumber));
+        return validIndex === -1 ? 0 : validIndex;
     }
     _updateWidgetWidth() {
         const layoutInfo = this._editor.getLayoutInfo();
@@ -161,15 +161,6 @@ class StickyScrollWidget extends Disposable {
         this._linesDomNodeScrollable.style.setProperty('--vscode-editorStickyScroll-scrollableWidth', `${this._editor.getScrollWidth() - layoutInfo.verticalScrollbarWidth}px`);
         this._rootDomNode.style.width = `${layoutInfo.width - layoutInfo.verticalScrollbarWidth}px`;
     }
-    _clearStickyLinesFromLine(clearFromLine) {
-        this._foldingIconStore.clear();
-        for (let i = clearFromLine; i < this._renderedStickyLines.length; i++) {
-            const stickyLine = this._renderedStickyLines[i];
-            stickyLine.lineNumberDomNode.remove();
-            stickyLine.lineDomNode.remove();
-        }
-        this._renderedStickyLines = this._renderedStickyLines.slice(0, clearFromLine);
-    }
     _useFoldingOpacityTransition(requireTransitions) {
         this._lineNumbersDomNode.style.setProperty('--vscode-editorStickyScroll-foldingOpacityTransition', `opacity ${requireTransitions ? 0.5 : 0}s`);
     }
@@ -182,45 +173,55 @@ class StickyScrollWidget extends Disposable {
             foldingIcon.setVisible(allVisible ? true : foldingIcon.isCollapsed);
         }
     }
-    async _renderRootNode(state, foldingModel, rebuildFromLine) {
-        this._clearStickyLinesFromLine(rebuildFromLine);
-        if (!state) {
-            this._setHeight(0);
+    async _renderRootNode(lineNumbers, lastLineRelativePosition, foldingModel, rebuildFromIndex) {
+        const viewModel = this._editor._getViewModel();
+        if (!viewModel) {
+            this._clearWidget();
+            return;
+        }
+        if (lineNumbers.length === 0) {
+            this._clearWidget();
             return;
         }
+        const renderedStickyLines = [];
+        const lastLineNumber = lineNumbers[lineNumbers.length - 1];
         let top = 0;
-        for (const stickyLine of this._renderedStickyLines) {
-            this._updatePosition(stickyLine, top);
-            top += stickyLine.height;
+        for (let i = 0; i < this._renderedStickyLines.length; i++) {
+            if (i < rebuildFromIndex) {
+                const renderedLine = this._renderedStickyLines[i];
+                renderedStickyLines.push(this._updatePosition(renderedLine, top, renderedLine.lineNumber === lastLineNumber));
+                top += renderedLine.height;
+            }
+            else {
+                const renderedLine = this._renderedStickyLines[i];
+                renderedLine.lineNumberDomNode.remove();
+                renderedLine.lineDomNode.remove();
+            }
         }
         const layoutInfo = this._editor.getLayoutInfo();
-        const linesToRender = this._lineNumbers.slice(rebuildFromLine);
-        for (const [index, line] of linesToRender.entries()) {
-            const stickyLine = this._renderChildNode(index + rebuildFromLine, line, top, foldingModel, layoutInfo);
-            if (!stickyLine) {
-                continue;
-            }
+        for (let i = rebuildFromIndex; i < lineNumbers.length; i++) {
+            const stickyLine = this._renderChildNode(viewModel, i, lineNumbers[i], top, lastLineNumber === lineNumbers[i], foldingModel, layoutInfo);
             top += stickyLine.height;
             this._linesDomNode.appendChild(stickyLine.lineDomNode);
             this._lineNumbersDomNode.appendChild(stickyLine.lineNumberDomNode);
-            this._renderedStickyLines.push(stickyLine);
+            renderedStickyLines.push(stickyLine);
         }
         if (foldingModel) {
             this._setFoldingHoverListeners();
             this._useFoldingOpacityTransition(!this._isOnGlyphMargin);
         }
-        const widgetHeight = top + this._lastLineRelativePosition;
-        this._setHeight(widgetHeight);
-        this._rootDomNode.style.marginLeft = '0px';
         this._minContentWidthInPx = Math.max(...( this._renderedStickyLines.map(l => l.scrollWidth))) + layoutInfo.verticalScrollbarWidth;
+        this._renderedStickyLines = renderedStickyLines;
+        this._setHeight(top + lastLineRelativePosition);
         this._editor.layoutOverlayWidget(this);
     }
-    _getHeightOfLines(lineNumbers, lastLineRelativePosition) {
-        let totalHeight = 0;
-        for (let i = 0; i < lineNumbers.length; i++) {
-            totalHeight += this._editor.getLineHeightForPosition(( new Position(lineNumbers[i], 1)));
+    _clearWidget() {
+        for (let i = 0; i < this._renderedStickyLines.length; i++) {
+            const stickyLine = this._renderedStickyLines[i];
+            stickyLine.lineNumberDomNode.remove();
+            stickyLine.lineDomNode.remove();
         }
-        return totalHeight + lastLineRelativePosition;
+        this._setHeight(0);
     }
     _setHeight(height) {
         if (this._height === height) {
@@ -253,11 +254,7 @@ class StickyScrollWidget extends Disposable {
             this._setFoldingIconsVisibility(false);
         }));
     }
-    _renderChildNode(index, line, top, foldingModel, layoutInfo) {
-        const viewModel = this._editor._getViewModel();
-        if (!viewModel) {
-            return;
-        }
+    _renderChildNode(viewModel, index, line, top, isLastLine, foldingModel, layoutInfo) {
         const viewLineNumber = viewModel.coordinatesConverter.convertModelPositionToViewPosition(( new Position(line, 1))).lineNumber;
         const lineRenderingData = viewModel.getViewLineRenderingData(viewLineNumber);
         const lineNumberOption = this._editor.getOption(EditorOption.lineNumbers);
@@ -348,13 +345,11 @@ class StickyScrollWidget extends Disposable {
             lineHTMLNode.scrollWidth,
             lineHeight
         ));
-        return this._updatePosition(renderedLine, top);
+        return this._updatePosition(renderedLine, top, isLastLine);
     }
-    _updatePosition(stickyLine, top) {
-        const index = stickyLine.index;
+    _updatePosition(stickyLine, top, isLastLine) {
         const lineHTMLNode = stickyLine.lineDomNode;
         const lineNumberHTMLNode = stickyLine.lineNumberDomNode;
-        const isLastLine = index === this._lineNumbers.length - 1;
         if (isLastLine) {
             const zIndex = '0';
             lineHTMLNode.style.zIndex = zIndex;