@codingame/monaco-vscode-api 25.1.2 → 26.0.0

package/vscode/src/vs/editor/browser/viewParts/minimap/minimap.js

@@ -77,7 +77,9 @@ class MinimapOptions {
         this.sectionHeaderFontSize = minimapOpts.sectionHeaderFontSize * pixelRatio;
         this.sectionHeaderLetterSpacing = minimapOpts.sectionHeaderLetterSpacing;
         this.sectionHeaderFontColor = MinimapOptions._getSectionHeaderColor(theme, tokensColorTracker.getColor(ColorId.DefaultForeground));
-        this.charRenderer = createSingleCallFunction(() => MinimapCharRendererFactory.create(this.fontScale, fontInfo.fontFamily));
+        this.charRenderer = createSingleCallFunction(
+            () => MinimapCharRendererFactory.create(this.fontScale, fontInfo.fontFamily)
+        );
         this.defaultBackgroundColor = tokensColorTracker.getColor(ColorId.DefaultBackground);
         this.backgroundColor = MinimapOptions._getMinimapBackground(theme, this.defaultBackgroundColor);
         this.foregroundAlpha = MinimapOptions._getMinimapForegroundOpacity(theme);
@@ -114,45 +116,21 @@ class MinimapOptions {
         return defaultForegroundColor;
     }
     equals(other) {
-        return (this.renderMinimap === other.renderMinimap
-            && this.size === other.size
-            && this.minimapHeightIsEditorHeight === other.minimapHeightIsEditorHeight
-            && this.scrollBeyondLastLine === other.scrollBeyondLastLine
-            && this.paddingTop === other.paddingTop
-            && this.paddingBottom === other.paddingBottom
-            && this.showSlider === other.showSlider
-            && this.autohide === other.autohide
-            && this.pixelRatio === other.pixelRatio
-            && this.typicalHalfwidthCharacterWidth === other.typicalHalfwidthCharacterWidth
-            && this.lineHeight === other.lineHeight
-            && this.minimapLeft === other.minimapLeft
-            && this.minimapWidth === other.minimapWidth
-            && this.minimapHeight === other.minimapHeight
-            && this.canvasInnerWidth === other.canvasInnerWidth
-            && this.canvasInnerHeight === other.canvasInnerHeight
-            && this.canvasOuterWidth === other.canvasOuterWidth
-            && this.canvasOuterHeight === other.canvasOuterHeight
-            && this.isSampling === other.isSampling
-            && this.editorHeight === other.editorHeight
-            && this.fontScale === other.fontScale
-            && this.minimapLineHeight === other.minimapLineHeight
-            && this.minimapCharWidth === other.minimapCharWidth
-            && this.sectionHeaderFontSize === other.sectionHeaderFontSize
-            && this.sectionHeaderLetterSpacing === other.sectionHeaderLetterSpacing
-            && this.defaultBackgroundColor && this.defaultBackgroundColor.equals(other.defaultBackgroundColor)
-            && this.backgroundColor && this.backgroundColor.equals(other.backgroundColor)
-            && this.foregroundAlpha === other.foregroundAlpha);
+        return (this.renderMinimap === other.renderMinimap && this.size === other.size && this.minimapHeightIsEditorHeight === other.minimapHeightIsEditorHeight && this.scrollBeyondLastLine === other.scrollBeyondLastLine && this.paddingTop === other.paddingTop && this.paddingBottom === other.paddingBottom && this.showSlider === other.showSlider && this.autohide === other.autohide && this.pixelRatio === other.pixelRatio && this.typicalHalfwidthCharacterWidth === other.typicalHalfwidthCharacterWidth && this.lineHeight === other.lineHeight && this.minimapLeft === other.minimapLeft && this.minimapWidth === other.minimapWidth && this.minimapHeight === other.minimapHeight && this.canvasInnerWidth === other.canvasInnerWidth && this.canvasInnerHeight === other.canvasInnerHeight && this.canvasOuterWidth === other.canvasOuterWidth && this.canvasOuterHeight === other.canvasOuterHeight && this.isSampling === other.isSampling && this.editorHeight === other.editorHeight && this.fontScale === other.fontScale && this.minimapLineHeight === other.minimapLineHeight && this.minimapCharWidth === other.minimapCharWidth && this.sectionHeaderFontSize === other.sectionHeaderFontSize && this.sectionHeaderLetterSpacing === other.sectionHeaderLetterSpacing && this.defaultBackgroundColor && this.defaultBackgroundColor.equals(other.defaultBackgroundColor) && this.backgroundColor && this.backgroundColor.equals(other.backgroundColor) && this.foregroundAlpha === other.foregroundAlpha);
     }
 }
 class MinimapLayout {
     constructor(
-    scrollTop,
-    scrollHeight, sliderNeeded, _computedSliderRatio,
-    sliderTop,
-    sliderHeight,
-    topPaddingLineCount,
-    startLineNumber,
-    endLineNumber) {
+        scrollTop,
+        scrollHeight,
+        sliderNeeded,
+        _computedSliderRatio,
+        sliderTop,
+        sliderHeight,
+        topPaddingLineCount,
+        startLineNumber,
+        endLineNumber
+    ) {
         this.scrollTop = scrollTop;
         this.scrollHeight = scrollHeight;
         this.sliderNeeded = sliderNeeded;
@@ -180,21 +158,31 @@ class MinimapLayout {
     getYForLineNumber(lineNumber, minimapLineHeight) {
         return +(lineNumber - this.startLineNumber + this.topPaddingLineCount) * minimapLineHeight;
     }
-    static create(options, viewportStartLineNumber, viewportEndLineNumber, viewportStartLineNumberVerticalOffset, viewportHeight, viewportContainsWhitespaceGaps, lineCount, realLineCount, scrollTop, scrollHeight, previousLayout) {
+    static create(
+        options,
+        viewportStartLineNumber,
+        viewportEndLineNumber,
+        viewportStartLineNumberVerticalOffset,
+        viewportHeight,
+        viewportContainsWhitespaceGaps,
+        lineCount,
+        realLineCount,
+        scrollTop,
+        scrollHeight,
+        previousLayout
+    ) {
         const pixelRatio = options.pixelRatio;
         const minimapLineHeight = options.minimapLineHeight;
         const minimapLinesFitting = Math.floor(options.canvasInnerHeight / minimapLineHeight);
         const lineHeight = options.lineHeight;
         if (options.minimapHeightIsEditorHeight) {
-            let logicalScrollHeight = (realLineCount * options.lineHeight
-                + options.paddingTop
-                + options.paddingBottom);
+            let logicalScrollHeight = (realLineCount * options.lineHeight + options.paddingTop + options.paddingBottom);
             if (options.scrollBeyondLastLine) {
                 logicalScrollHeight += Math.max(0, viewportHeight - options.lineHeight - options.paddingBottom);
             }
             const sliderHeight = Math.max(1, Math.floor(viewportHeight * viewportHeight / logicalScrollHeight));
             const maxMinimapSliderTop = Math.max(0, options.minimapHeight - sliderHeight);
-            const computedSliderRatio = (maxMinimapSliderTop) / (scrollHeight - viewportHeight);
+            const computedSliderRatio = maxMinimapSliderTop / (scrollHeight - viewportHeight);
             const sliderTop = (scrollTop * computedSliderRatio);
             const sliderNeeded = (maxMinimapSliderTop > 0);
             const maxLinesFitting = Math.floor(options.canvasInnerHeight / options.minimapLineHeight);
@@ -215,8 +203,7 @@ class MinimapLayout {
         if (viewportContainsWhitespaceGaps && viewportEndLineNumber !== lineCount) {
             const viewportLineCount = viewportEndLineNumber - viewportStartLineNumber + 1;
             sliderHeight = Math.floor(viewportLineCount * minimapLineHeight / pixelRatio);
-        }
-        else {
+        } else {
             const expectedViewportLineCount = viewportHeight / lineHeight;
             sliderHeight = Math.floor(expectedViewportLineCount * minimapLineHeight / pixelRatio);
         }
@@ -230,12 +217,14 @@ class MinimapLayout {
         if (extraLinesAtTheBottom > 0) {
             const expectedViewportLineCount = viewportHeight / lineHeight;
             maxMinimapSliderTop = (extraLinesAtTheTop + lineCount + extraLinesAtTheBottom - expectedViewportLineCount - 1) * minimapLineHeight / pixelRatio;
-        }
-        else {
-            maxMinimapSliderTop = Math.max(0, (extraLinesAtTheTop + lineCount) * minimapLineHeight / pixelRatio - sliderHeight);
+        } else {
+            maxMinimapSliderTop = Math.max(
+                0,
+                (extraLinesAtTheTop + lineCount) * minimapLineHeight / pixelRatio - sliderHeight
+            );
         }
         maxMinimapSliderTop = Math.min(options.minimapHeight - sliderHeight, maxMinimapSliderTop);
-        const computedSliderRatio = (maxMinimapSliderTop) / (scrollHeight - viewportHeight);
+        const computedSliderRatio = maxMinimapSliderTop / (scrollHeight - viewportHeight);
         const sliderTop = (scrollTop * computedSliderRatio);
         if (minimapLinesFitting >= extraLinesAtTheTop + lineCount + extraLinesAtTheBottom) {
             const sliderNeeded = (maxMinimapSliderTop > 0);
@@ -250,22 +239,22 @@ class MinimapLayout {
                 1,
                 lineCount
             ));
-        }
-        else {
+        } else {
             let consideringStartLineNumber;
             if (viewportStartLineNumber > 1) {
                 consideringStartLineNumber = viewportStartLineNumber + extraLinesAtTheTop;
-            }
-            else {
+            } else {
                 consideringStartLineNumber = Math.max(1, scrollTop / lineHeight);
             }
             let topPaddingLineCount;
-            let startLineNumber = Math.max(1, Math.floor(consideringStartLineNumber - sliderTop * pixelRatio / minimapLineHeight));
+            let startLineNumber = Math.max(
+                1,
+                Math.floor(consideringStartLineNumber - sliderTop * pixelRatio / minimapLineHeight)
+            );
             if (startLineNumber < extraLinesAtTheTop) {
                 topPaddingLineCount = extraLinesAtTheTop - startLineNumber + 1;
                 startLineNumber = 1;
-            }
-            else {
+            } else {
                 topPaddingLineCount = 0;
                 startLineNumber = Math.max(1, startLineNumber - extraLinesAtTheTop);
             }
@@ -284,8 +273,7 @@ class MinimapLayout {
             let sliderTopAligned;
             if (scrollTop >= options.paddingTop) {
                 sliderTopAligned = (viewportStartLineNumber - startLineNumber + topPaddingLineCount + partialLine) * minimapLineHeight / pixelRatio;
-            }
-            else {
+            } else {
                 sliderTopAligned = (scrollTop / options.paddingTop) * (topPaddingLineCount + partialLine) * minimapLineHeight / pixelRatio;
             }
             return ( new MinimapLayout(
@@ -303,7 +291,9 @@ class MinimapLayout {
     }
 }
 class MinimapLine {
-    static { this.INVALID = ( new MinimapLine(-1)); }
+    static {
+        this.INVALID = ( new MinimapLine(-1));
+    }
     constructor(dy) {
         this.dy = dy;
     }
@@ -337,8 +327,7 @@ class RenderData {
         return true;
     }
     scrollEquals(layout) {
-        return this.renderedLayout.startLineNumber === layout.startLineNumber
-            && this.renderedLayout.endLineNumber === layout.endLineNumber;
+        return this.renderedLayout.startLineNumber === layout.startLineNumber && this.renderedLayout.endLineNumber === layout.endLineNumber;
     }
     _get() {
         const tmp = this._renderedLines._get();
@@ -364,10 +353,7 @@ class RenderData {
 class MinimapBuffers {
     constructor(ctx, WIDTH, HEIGHT, background) {
         this._backgroundFillData = MinimapBuffers._createBackgroundFillData(WIDTH, HEIGHT, background);
-        this._buffers = [
-            ctx.createImageData(WIDTH, HEIGHT),
-            ctx.createImageData(WIDTH, HEIGHT)
-        ];
+        this._buffers = [ctx.createImageData(WIDTH, HEIGHT), ctx.createImageData(WIDTH, HEIGHT)];
         this._lastUsedBuffer = 0;
     }
     getBuffer() {
@@ -400,7 +386,9 @@ class MinimapSamplingState {
         if (options.renderMinimap === RenderMinimap.None || !options.isSampling) {
             return [null, []];
         }
-        const { minimapLineCount } = EditorLayoutInfoComputer.computeContainedMinimapLineCount({
+        const {
+            minimapLineCount
+        } = EditorLayoutInfoComputer.computeContainedMinimapLineCount({
             viewLineCount: viewLineCount,
             scrollBeyondLastLine: options.scrollBeyondLastLine,
             paddingTop: options.paddingTop,
@@ -437,11 +425,15 @@ class MinimapSamplingState {
             while (oldIndex < oldLength && oldMinimapLines[oldIndex] < fromViewLineNumber) {
                 if (events.length < MAX_EVENT_COUNT) {
                     const oldMinimapLineNumber = oldIndex + 1 + oldDeltaLineCount;
-                    if (lastEvent && lastEvent.type === 'deleted' && lastEvent._oldIndex === oldIndex - 1) {
+                    if (lastEvent && lastEvent.type === "deleted" && lastEvent._oldIndex === oldIndex - 1) {
                         lastEvent.deleteToLineNumber++;
-                    }
-                    else {
-                        lastEvent = { type: 'deleted', _oldIndex: oldIndex, deleteFromLineNumber: oldMinimapLineNumber, deleteToLineNumber: oldMinimapLineNumber };
+                    } else {
+                        lastEvent = {
+                            type: "deleted",
+                            _oldIndex: oldIndex,
+                            deleteFromLineNumber: oldMinimapLineNumber,
+                            deleteToLineNumber: oldMinimapLineNumber
+                        };
                         events.push(lastEvent);
                     }
                     oldDeltaLineCount--;
@@ -452,24 +444,25 @@ class MinimapSamplingState {
             if (oldIndex < oldLength && oldMinimapLines[oldIndex] <= toViewLineNumber) {
                 selectedViewLineNumber = oldMinimapLines[oldIndex];
                 oldIndex++;
-            }
-            else {
+            } else {
                 if (i === 0) {
                     selectedViewLineNumber = 1;
-                }
-                else if (i + 1 === minimapLineCount) {
+                } else if (i + 1 === minimapLineCount) {
                     selectedViewLineNumber = viewLineCount;
-                }
-                else {
+                } else {
                     selectedViewLineNumber = Math.round(i * ratio + halfRatio);
                 }
                 if (events.length < MAX_EVENT_COUNT) {
                     const oldMinimapLineNumber = oldIndex + 1 + oldDeltaLineCount;
-                    if (lastEvent && lastEvent.type === 'inserted' && lastEvent._i === i - 1) {
+                    if (lastEvent && lastEvent.type === "inserted" && lastEvent._i === i - 1) {
                         lastEvent.insertToLineNumber++;
-                    }
-                    else {
-                        lastEvent = { type: 'inserted', _i: i, insertFromLineNumber: oldMinimapLineNumber, insertToLineNumber: oldMinimapLineNumber };
+                    } else {
+                        lastEvent = {
+                            type: "inserted",
+                            _i: i,
+                            insertFromLineNumber: oldMinimapLineNumber,
+                            insertToLineNumber: oldMinimapLineNumber
+                        };
                         events.push(lastEvent);
                     }
                     oldDeltaLineCount++;
@@ -481,29 +474,39 @@ class MinimapSamplingState {
         if (events.length < MAX_EVENT_COUNT) {
             while (oldIndex < oldLength) {
                 const oldMinimapLineNumber = oldIndex + 1 + oldDeltaLineCount;
-                if (lastEvent && lastEvent.type === 'deleted' && lastEvent._oldIndex === oldIndex - 1) {
+                if (lastEvent && lastEvent.type === "deleted" && lastEvent._oldIndex === oldIndex - 1) {
                     lastEvent.deleteToLineNumber++;
-                }
-                else {
-                    lastEvent = { type: 'deleted', _oldIndex: oldIndex, deleteFromLineNumber: oldMinimapLineNumber, deleteToLineNumber: oldMinimapLineNumber };
+                } else {
+                    lastEvent = {
+                        type: "deleted",
+                        _oldIndex: oldIndex,
+                        deleteFromLineNumber: oldMinimapLineNumber,
+                        deleteToLineNumber: oldMinimapLineNumber
+                    };
                     events.push(lastEvent);
                 }
                 oldDeltaLineCount--;
                 oldIndex++;
             }
-        }
-        else {
-            events = [{ type: 'flush' }];
+        } else {
+            events = [{
+                type: "flush"
+            }];
         }
         return [( new MinimapSamplingState(ratio, result)), events];
     }
-    constructor(samplingRatio, minimapLines
+    constructor(
+        samplingRatio,
+        minimapLines
     ) {
         this.samplingRatio = samplingRatio;
         this.minimapLines = minimapLines;
     }
     modelLineToMinimapLine(lineNumber) {
-        return Math.min(this.minimapLines.length, Math.max(1, Math.round(lineNumber / this.samplingRatio)));
+        return Math.min(
+            this.minimapLines.length,
+            Math.max(1, Math.round(lineNumber / this.samplingRatio))
+        );
     }
     modelLineRangeToMinimapLineRange(fromLineNumber, toLineNumber) {
         let fromLineIndex = this.modelLineToMinimapLine(fromLineNumber) - 1;
@@ -530,8 +533,7 @@ class MinimapSamplingState {
                 if (minimapLineStart > 1) {
                     minimapLineStart--;
                 }
-            }
-            else {
+            } else {
                 minimapLineEnd++;
             }
         }
@@ -549,8 +551,7 @@ class MinimapSamplingState {
                 this.minimapLines[i] = Math.max(1, e.fromLineNumber - 1);
                 changeStartIndex = Math.min(changeStartIndex, i);
                 changeEndIndex = Math.max(changeEndIndex, i);
-            }
-            else {
+            } else {
                 this.minimapLines[i] -= deletedLineCount;
             }
         }
@@ -574,7 +575,7 @@ class Minimap extends ViewPart {
         this._selections = [];
         this._minimapSelections = null;
         this.options = ( new MinimapOptions(this._context.configuration, this._context.theme, this.tokensColorTracker));
-        const [samplingState,] = MinimapSamplingState.compute(this.options, this._context.viewModel.getLineCount(), null);
+        const [samplingState] = MinimapSamplingState.compute(this.options, this._context.viewModel.getLineCount(), null);
         this._samplingState = samplingState;
         this._shouldCheckSampling = false;
         this._actual = ( new InnerMinimap(context.theme, this));
@@ -621,12 +622,10 @@ class Minimap extends ViewPart {
             const minimapLineRange = this._samplingState.modelLineRangeToMinimapLineRange(e.fromLineNumber, e.fromLineNumber + e.count - 1);
             if (minimapLineRange) {
                 return this._actual.onLinesChanged(minimapLineRange[0], minimapLineRange[1] - minimapLineRange[0] + 1);
-            }
-            else {
+            } else {
                 return false;
             }
-        }
-        else {
+        } else {
             return this._actual.onLinesChanged(e.fromLineNumber, e.count);
         }
     }
@@ -638,8 +637,7 @@ class Minimap extends ViewPart {
             }
             this._shouldCheckSampling = true;
             return true;
-        }
-        else {
+        } else {
             return this._actual.onLinesDeleted(e.fromLineNumber, e.toLineNumber);
         }
     }
@@ -648,8 +646,7 @@ class Minimap extends ViewPart {
             this._samplingState.onLinesInserted(e);
             this._shouldCheckSampling = true;
             return true;
-        }
-        else {
+        } else {
             return this._actual.onLinesInserted(e.fromLineNumber, e.toLineNumber);
         }
     }
@@ -667,17 +664,18 @@ class Minimap extends ViewPart {
             for (const range of e.ranges) {
                 const minimapLineRange = this._samplingState.modelLineRangeToMinimapLineRange(range.fromLineNumber, range.toLineNumber);
                 if (minimapLineRange) {
-                    ranges.push({ fromLineNumber: minimapLineRange[0], toLineNumber: minimapLineRange[1] });
+                    ranges.push({
+                        fromLineNumber: minimapLineRange[0],
+                        toLineNumber: minimapLineRange[1]
+                    });
                 }
             }
             if (ranges.length) {
                 return this._actual.onTokensChanged(ranges);
-            }
-            else {
+            } else {
                 return false;
             }
-        }
-        else {
+        } else {
             return this._actual.onTokensChanged(e.ranges);
         }
     }
@@ -711,7 +709,7 @@ class Minimap extends ViewPart {
             scrollTop: ctx.scrollTop,
             scrollLeft: ctx.scrollLeft,
             viewportWidth: ctx.viewportWidth,
-            viewportHeight: ctx.viewportHeight,
+            viewportHeight: ctx.viewportHeight
         };
         this._actual.render(minimapCtx);
     }
@@ -723,15 +721,15 @@ class Minimap extends ViewPart {
         if (wasSampling && this._samplingState) {
             for (const event of events) {
                 switch (event.type) {
-                    case 'deleted':
-                        this._actual.onLinesDeleted(event.deleteFromLineNumber, event.deleteToLineNumber);
-                        break;
-                    case 'inserted':
-                        this._actual.onLinesInserted(event.insertFromLineNumber, event.insertToLineNumber);
-                        break;
-                    case 'flush':
-                        this._actual.onFlushed();
-                        break;
+                case "deleted":
+                    this._actual.onLinesDeleted(event.deleteFromLineNumber, event.deleteToLineNumber);
+                    break;
+                case "inserted":
+                    this._actual.onLinesInserted(event.insertFromLineNumber, event.insertToLineNumber);
+                    break;
+                case "flush":
+                    this._actual.onFlushed();
+                    break;
                 }
             }
         }
@@ -763,8 +761,7 @@ class Minimap extends ViewPart {
             for (let lineIndex = 0, lineCount = endLineNumber - startLineNumber + 1; lineIndex < lineCount; lineIndex++) {
                 if (needed[lineIndex]) {
                     result[lineIndex] = this._context.viewModel.getViewLineData(this._samplingState.minimapLines[startLineNumber + lineIndex - 1]);
-                }
-                else {
+                } else {
                     result[lineIndex] = null;
                 }
             }
@@ -785,22 +782,19 @@ class Minimap extends ViewPart {
                         selection.endColumn
                     )));
                 }
-            }
-            else {
+            } else {
                 this._minimapSelections = this._selections;
             }
         }
         return this._minimapSelections;
     }
     getMinimapDecorationsInViewport(startLineNumber, endLineNumber) {
-        return this._getMinimapDecorationsInViewport(startLineNumber, endLineNumber)
-            .filter(decoration => !decoration.options.minimap?.sectionHeaderStyle);
+        return this._getMinimapDecorationsInViewport(startLineNumber, endLineNumber).filter(decoration => !decoration.options.minimap?.sectionHeaderStyle);
     }
     getSectionHeaderDecorationsInViewport(startLineNumber, endLineNumber) {
         const headerHeightInMinimapLines = this.options.sectionHeaderFontSize / this.options.minimapLineHeight;
         startLineNumber = Math.floor(Math.max(1, startLineNumber - headerHeightInMinimapLines));
-        return this._getMinimapDecorationsInViewport(startLineNumber, endLineNumber)
-            .filter(decoration => !!decoration.options.minimap?.sectionHeaderStyle);
+        return this._getMinimapDecorationsInViewport(startLineNumber, endLineNumber).filter(decoration => !!decoration.options.minimap?.sectionHeaderStyle);
     }
     _getMinimapDecorationsInViewport(startLineNumber, endLineNumber) {
         let visibleRange;
@@ -813,8 +807,7 @@ class Minimap extends ViewPart {
                 modelEndLineNumber,
                 this._context.viewModel.getLineMaxColumn(modelEndLineNumber)
             ));
-        }
-        else {
+        } else {
             visibleRange = ( new Range(
                 startLineNumber,
                 1,
@@ -863,7 +856,7 @@ class Minimap extends ViewPart {
         if (this._samplingState) {
             lineNumber = this._samplingState.minimapLines[lineNumber - 1];
         }
-        this._context.viewModel.revealRange('mouse', false, ( new Range(lineNumber, 1, lineNumber, 1)), VerticalRevealType.Center, ScrollType.Smooth);
+        this._context.viewModel.revealRange("mouse", false, ( new Range(lineNumber, 1, lineNumber, 1)), VerticalRevealType.Center, ScrollType.Smooth);
     }
     setScrollTop(scrollTop) {
         this._context.viewModel.viewLayout.setScrollPosition({
@@ -882,45 +875,49 @@ class InnerMinimap extends Disposable {
         this._lastRenderData = null;
         this._buffers = null;
         this._selectionColor = this._theme.getColor(minimapSelection);
-        this._domNode = createFastDomNode(createElement('div'));
+        this._domNode = createFastDomNode(createElement("div"));
         PartFingerprints.write(this._domNode, PartFingerprint.Minimap);
         this._domNode.setClassName(this._getMinimapDomNodeClassName());
-        this._domNode.setPosition('absolute');
-        this._domNode.setAttribute('role', 'presentation');
-        this._domNode.setAttribute('aria-hidden', 'true');
-        this._shadow = createFastDomNode(createElement('div'));
-        this._shadow.setClassName('minimap-shadow-hidden');
+        this._domNode.setPosition("absolute");
+        this._domNode.setAttribute("role", "presentation");
+        this._domNode.setAttribute("aria-hidden", "true");
+        this._shadow = createFastDomNode(createElement("div"));
+        this._shadow.setClassName("minimap-shadow-hidden");
         this._domNode.appendChild(this._shadow);
-        this._canvas = createFastDomNode(createElement('canvas'));
-        this._canvas.setPosition('absolute');
+        this._canvas = createFastDomNode(createElement("canvas"));
+        this._canvas.setPosition("absolute");
         this._canvas.setLeft(0);
         this._domNode.appendChild(this._canvas);
-        this._decorationsCanvas = createFastDomNode(createElement('canvas'));
-        this._decorationsCanvas.setPosition('absolute');
-        this._decorationsCanvas.setClassName('minimap-decorations-layer');
+        this._decorationsCanvas = createFastDomNode(createElement("canvas"));
+        this._decorationsCanvas.setPosition("absolute");
+        this._decorationsCanvas.setClassName("minimap-decorations-layer");
         this._decorationsCanvas.setLeft(0);
         this._domNode.appendChild(this._decorationsCanvas);
-        this._slider = createFastDomNode(createElement('div'));
-        this._slider.setPosition('absolute');
-        this._slider.setClassName('minimap-slider');
+        this._slider = createFastDomNode(createElement("div"));
+        this._slider.setPosition("absolute");
+        this._slider.setClassName("minimap-slider");
         this._slider.setLayerHinting(true);
-        this._slider.setContain('strict');
+        this._slider.setContain("strict");
         this._domNode.appendChild(this._slider);
-        this._sliderHorizontal = createFastDomNode(createElement('div'));
-        this._sliderHorizontal.setPosition('absolute');
-        this._sliderHorizontal.setClassName('minimap-slider-horizontal');
+        this._sliderHorizontal = createFastDomNode(createElement("div"));
+        this._sliderHorizontal.setPosition("absolute");
+        this._sliderHorizontal.setClassName("minimap-slider-horizontal");
         this._slider.appendChild(this._sliderHorizontal);
         this._applyLayout();
         this._hideDelayedScheduler = this._register(( new RunOnceScheduler(() => this._hideImmediatelyIfMouseIsOutside(), 500)));
-        this._register(addStandardDisposableListener(this._domNode.domNode, EventType.MOUSE_OVER, () => {
-            this._isMouseOverMinimap = true;
-        }));
-        this._register(addStandardDisposableListener(this._domNode.domNode, EventType.MOUSE_LEAVE, () => {
-            this._isMouseOverMinimap = false;
-        }));
-        this._pointerDownListener = addStandardDisposableListener(this._domNode.domNode, EventType.POINTER_DOWN, (e) => {
+        this._register(
+            addStandardDisposableListener(this._domNode.domNode, EventType.MOUSE_OVER, () => {
+                this._isMouseOverMinimap = true;
+            })
+        );
+        this._register(
+            addStandardDisposableListener(this._domNode.domNode, EventType.MOUSE_LEAVE, () => {
+                this._isMouseOverMinimap = false;
+            })
+        );
+        this._pointerDownListener = addStandardDisposableListener(this._domNode.domNode, EventType.POINTER_DOWN, e => {
             e.preventDefault();
-            const isMouse = (e.pointerType === 'mouse');
+            const isMouse = (e.pointerType === "mouse");
             const isLeftClick = (e.button === 0);
             const renderMinimap = this._model.options.renderMinimap;
             if (renderMinimap === RenderMinimap.None) {
@@ -929,7 +926,7 @@ class InnerMinimap extends Disposable {
             if (!this._lastRenderData) {
                 return;
             }
-            if (this._model.options.size !== 'proportional') {
+            if (this._model.options.size !== "proportional") {
                 if (isLeftClick && this._lastRenderData) {
                     const position = getDomNodePagePosition(this._slider.domNode);
                     const initialPosY = position.top + position.height / 2;
@@ -947,7 +944,7 @@ class InnerMinimap extends Disposable {
             }
         });
         this._sliderPointerMoveMonitor = ( new GlobalPointerMoveMonitor());
-        this._sliderPointerDownListener = addStandardDisposableListener(this._slider.domNode, EventType.POINTER_DOWN, (e) => {
+        this._sliderPointerDownListener = addStandardDisposableListener(this._slider.domNode, EventType.POINTER_DOWN, e => {
             e.preventDefault();
             e.stopPropagation();
             if (e.button === 0 && this._lastRenderData) {
@@ -955,27 +952,31 @@ class InnerMinimap extends Disposable {
             }
         });
         this._gestureDisposable = Gesture.addTarget(this._domNode.domNode);
-        this._sliderTouchStartListener = addDisposableListener(this._domNode.domNode, EventType$1.Start, (e) => {
+        this._sliderTouchStartListener = addDisposableListener(this._domNode.domNode, EventType$1.Start, e => {
             e.preventDefault();
             e.stopPropagation();
             if (this._lastRenderData) {
-                this._slider.toggleClassName('active', true);
+                this._slider.toggleClassName("active", true);
                 this._gestureInProgress = true;
                 this.scrollDueToTouchEvent(e);
             }
-        }, { passive: false });
-        this._sliderTouchMoveListener = addDisposableListener(this._domNode.domNode, EventType$1.Change, (e) => {
+        }, {
+            passive: false
+        });
+        this._sliderTouchMoveListener = addDisposableListener(this._domNode.domNode, EventType$1.Change, e => {
             e.preventDefault();
             e.stopPropagation();
             if (this._lastRenderData && this._gestureInProgress) {
                 this.scrollDueToTouchEvent(e);
             }
-        }, { passive: false });
-        this._sliderTouchEndListener = addStandardDisposableListener(this._domNode.domNode, EventType$1.End, (e) => {
+        }, {
+            passive: false
+        });
+        this._sliderTouchEndListener = addStandardDisposableListener(this._domNode.domNode, EventType$1.End, e => {
             e.preventDefault();
             e.stopPropagation();
             this._gestureInProgress = false;
-            this._slider.toggleClassName('active', false);
+            this._slider.toggleClassName("active", false);
         });
     }
     _hideSoon() {
@@ -987,17 +988,21 @@ class InnerMinimap extends Disposable {
             this._hideSoon();
             return;
         }
-        this._domNode.toggleClassName('active', false);
+        this._domNode.toggleClassName("active", false);
     }
     _startSliderDragging(e, initialPosY, initialSliderState) {
         if (!e.target || !isElement(e.target)) {
             return;
         }
         const initialPosX = e.pageX;
-        this._slider.toggleClassName('active', true);
+        this._slider.toggleClassName("active", true);
         const handlePointerMove = (posy, posx) => {
             const minimapPosition = getDomNodePagePosition(this._domNode.domNode);
-            const pointerOrthogonalDelta = Math.min(Math.abs(posx - initialPosX), Math.abs(posx - minimapPosition.left), Math.abs(posx - minimapPosition.left - minimapPosition.width));
+            const pointerOrthogonalDelta = Math.min(
+                Math.abs(posx - initialPosX),
+                Math.abs(posx - minimapPosition.left),
+                Math.abs(posx - minimapPosition.left - minimapPosition.width)
+            );
             if (isWindows && pointerOrthogonalDelta > POINTER_DRAG_RESET_DISTANCE) {
                 this._model.setScrollTop(initialSliderState.scrollTop);
                 return;
@@ -1008,9 +1013,15 @@ class InnerMinimap extends Disposable {
         if (e.pageY !== initialPosY) {
             handlePointerMove(e.pageY, initialPosX);
         }
-        this._sliderPointerMoveMonitor.startMonitoring(e.target, e.pointerId, e.buttons, pointerMoveData => handlePointerMove(pointerMoveData.pageY, pointerMoveData.pageX), () => {
-            this._slider.toggleClassName('active', false);
-        });
+        this._sliderPointerMoveMonitor.startMonitoring(
+            e.target,
+            e.pointerId,
+            e.buttons,
+            pointerMoveData => handlePointerMove(pointerMoveData.pageY, pointerMoveData.pageX),
+            () => {
+                this._slider.toggleClassName("active", false);
+            }
+        );
     }
     scrollDueToTouchEvent(touch) {
         const startY = this._domNode.domNode.getBoundingClientRect().top;
@@ -1028,20 +1039,18 @@ class InnerMinimap extends Disposable {
         super.dispose();
     }
     _getMinimapDomNodeClassName() {
-        const class_ = ['minimap'];
-        if (this._model.options.showSlider === 'always') {
-            class_.push('slider-always');
+        const class_ = ["minimap"];
+        if (this._model.options.showSlider === "always") {
+            class_.push("slider-always");
+        } else {
+            class_.push("slider-mouseover");
         }
-        else {
-            class_.push('slider-mouseover');
+        if (this._model.options.autohide === "mouseover") {
+            class_.push("minimap-autohide-mouseover");
+        } else if (this._model.options.autohide === "scroll") {
+            class_.push("minimap-autohide-scroll");
         }
-        if (this._model.options.autohide === 'mouseover') {
-            class_.push('minimap-autohide-mouseover');
-        }
-        else if (this._model.options.autohide === 'scroll') {
-            class_.push('minimap-autohide-scroll');
-        }
-        return class_.join(' ');
+        return class_.join(" ");
     }
     getDomNode() {
         return this._domNode;
@@ -1065,7 +1074,7 @@ class InnerMinimap extends Disposable {
         if (!this._buffers) {
             if (this._model.options.canvasInnerWidth > 0 && this._model.options.canvasInnerHeight > 0) {
                 this._buffers = ( new MinimapBuffers(
-                    this._canvas.domNode.getContext('2d'),
+                    this._canvas.domNode.getContext("2d"),
                     this._model.options.canvasInnerWidth,
                     this._model.options.canvasInnerHeight,
                     this._model.options.backgroundColor
@@ -1107,8 +1116,8 @@ class InnerMinimap extends Disposable {
         return true;
     }
     onScrollChanged(e) {
-        if (this._model.options.autohide === 'scroll' && (e.scrollTopChanged || e.scrollHeightChanged)) {
-            this._domNode.toggleClassName('active', true);
+        if (this._model.options.autohide === "scroll" && (e.scrollTopChanged || e.scrollHeightChanged)) {
+            this._domNode.toggleClassName("active", true);
             this._hideSoon();
         }
         this._renderDecorations = true;
@@ -1137,19 +1146,30 @@ class InnerMinimap extends Disposable {
     render(renderingCtx) {
         const renderMinimap = this._model.options.renderMinimap;
         if (renderMinimap === RenderMinimap.None) {
-            this._shadow.setClassName('minimap-shadow-hidden');
+            this._shadow.setClassName("minimap-shadow-hidden");
             this._sliderHorizontal.setWidth(0);
             this._sliderHorizontal.setHeight(0);
             return;
         }
         if (renderingCtx.scrollLeft + renderingCtx.viewportWidth >= renderingCtx.scrollWidth) {
-            this._shadow.setClassName('minimap-shadow-hidden');
-        }
-        else {
-            this._shadow.setClassName('minimap-shadow-visible');
-        }
-        const layout = MinimapLayout.create(this._model.options, renderingCtx.viewportStartLineNumber, renderingCtx.viewportEndLineNumber, renderingCtx.viewportStartLineNumberVerticalOffset, renderingCtx.viewportHeight, renderingCtx.viewportContainsWhitespaceGaps, this._model.getLineCount(), this._model.getRealLineCount(), renderingCtx.scrollTop, renderingCtx.scrollHeight, this._lastRenderData ? this._lastRenderData.renderedLayout : null);
-        this._slider.setDisplay(layout.sliderNeeded ? 'block' : 'none');
+            this._shadow.setClassName("minimap-shadow-hidden");
+        } else {
+            this._shadow.setClassName("minimap-shadow-visible");
+        }
+        const layout = MinimapLayout.create(
+            this._model.options,
+            renderingCtx.viewportStartLineNumber,
+            renderingCtx.viewportEndLineNumber,
+            renderingCtx.viewportStartLineNumberVerticalOffset,
+            renderingCtx.viewportHeight,
+            renderingCtx.viewportContainsWhitespaceGaps,
+            this._model.getLineCount(),
+            this._model.getRealLineCount(),
+            renderingCtx.scrollTop,
+            renderingCtx.scrollHeight,
+            this._lastRenderData ? this._lastRenderData.renderedLayout : null
+        );
+        this._slider.setDisplay(layout.sliderNeeded ? "block" : "none");
         this._slider.setTop(layout.sliderTop);
         this._slider.setHeight(layout.sliderHeight);
         this._sliderHorizontal.setLeft(0);
@@ -1166,18 +1186,39 @@ class InnerMinimap extends Disposable {
             selections.sort(Range.compareRangesUsingStarts);
             const decorations = this._model.getMinimapDecorationsInViewport(layout.startLineNumber, layout.endLineNumber);
             decorations.sort((a, b) => (a.options.zIndex || 0) - (b.options.zIndex || 0));
-            const { canvasInnerWidth, canvasInnerHeight } = this._model.options;
+            const {
+                canvasInnerWidth,
+                canvasInnerHeight
+            } = this._model.options;
             const minimapLineHeight = this._model.options.minimapLineHeight;
             const minimapCharWidth = this._model.options.minimapCharWidth;
             const tabSize = this._model.getOptions().tabSize;
-            const canvasContext = this._decorationsCanvas.domNode.getContext('2d');
+            const canvasContext = this._decorationsCanvas.domNode.getContext("2d");
             canvasContext.clearRect(0, 0, canvasInnerWidth, canvasInnerHeight);
             const highlightedLines = ( new ContiguousLineMap(layout.startLineNumber, layout.endLineNumber, false));
             this._renderSelectionLineHighlights(canvasContext, selections, highlightedLines, layout, minimapLineHeight);
             this._renderDecorationsLineHighlights(canvasContext, decorations, highlightedLines, layout, minimapLineHeight);
             const lineOffsetMap = ( new ContiguousLineMap(layout.startLineNumber, layout.endLineNumber, null));
-            this._renderSelectionsHighlights(canvasContext, selections, lineOffsetMap, layout, minimapLineHeight, tabSize, minimapCharWidth, canvasInnerWidth);
-            this._renderDecorationsHighlights(canvasContext, decorations, lineOffsetMap, layout, minimapLineHeight, tabSize, minimapCharWidth, canvasInnerWidth);
+            this._renderSelectionsHighlights(
+                canvasContext,
+                selections,
+                lineOffsetMap,
+                layout,
+                minimapLineHeight,
+                tabSize,
+                minimapCharWidth,
+                canvasInnerWidth
+            );
+            this._renderDecorationsHighlights(
+                canvasContext,
+                decorations,
+                lineOffsetMap,
+                layout,
+                minimapLineHeight,
+                tabSize,
+                minimapCharWidth,
+                canvasInnerWidth
+            );
             this._renderSectionHeaders(layout);
         }
     }
@@ -1201,8 +1242,7 @@ class InnerMinimap extends Disposable {
             const yy2 = layout.getYForLineNumber(endLineNumber, minimapLineHeight);
             if (y2 >= yy1) {
                 y2 = yy2;
-            }
-            else {
+            } else {
                 if (y2 > y1) {
                     canvasContext.fillRect(MINIMAP_GUTTER_WIDTH, y1, canvasContext.canvas.width, y2 - y1);
                 }
@@ -1247,7 +1287,16 @@ class InnerMinimap extends Disposable {
             }
         }
     }
-    _renderSelectionsHighlights(canvasContext, selections, lineOffsetMap, layout, lineHeight, tabSize, characterWidth, canvasInnerWidth) {
+    _renderSelectionsHighlights(
+        canvasContext,
+        selections,
+        lineOffsetMap,
+        layout,
+        lineHeight,
+        tabSize,
+        characterWidth,
+        canvasInnerWidth
+    ) {
         if (!this._selectionColor || this._selectionColor.isTransparent()) {
             return;
         }
@@ -1258,11 +1307,32 @@ class InnerMinimap extends Disposable {
             }
             const [startLineNumber, endLineNumber] = intersection;
             for (let line = startLineNumber; line <= endLineNumber; line++) {
-                this.renderDecorationOnLine(canvasContext, lineOffsetMap, selection, this._selectionColor, layout, line, lineHeight, lineHeight, tabSize, characterWidth, canvasInnerWidth);
-            }
-        }
-    }
-    _renderDecorationsHighlights(canvasContext, decorations, lineOffsetMap, layout, minimapLineHeight, tabSize, characterWidth, canvasInnerWidth) {
+                this.renderDecorationOnLine(
+                    canvasContext,
+                    lineOffsetMap,
+                    selection,
+                    this._selectionColor,
+                    layout,
+                    line,
+                    lineHeight,
+                    lineHeight,
+                    tabSize,
+                    characterWidth,
+                    canvasInnerWidth
+                );
+            }
+        }
+    }
+    _renderDecorationsHighlights(
+        canvasContext,
+        decorations,
+        lineOffsetMap,
+        layout,
+        minimapLineHeight,
+        tabSize,
+        characterWidth,
+        canvasInnerWidth
+    ) {
         for (const decoration of decorations) {
             const minimapOptions = decoration.options.minimap;
             if (!minimapOptions) {
@@ -1279,28 +1349,70 @@ class InnerMinimap extends Disposable {
             }
             for (let line = startLineNumber; line <= endLineNumber; line++) {
                 switch (minimapOptions.position) {
-                    case MinimapPosition.Inline:
-                        this.renderDecorationOnLine(canvasContext, lineOffsetMap, decoration.range, decorationColor, layout, line, minimapLineHeight, minimapLineHeight, tabSize, characterWidth, canvasInnerWidth);
-                        continue;
-                    case MinimapPosition.Gutter: {
+                case MinimapPosition.Inline:
+                    this.renderDecorationOnLine(
+                        canvasContext,
+                        lineOffsetMap,
+                        decoration.range,
+                        decorationColor,
+                        layout,
+                        line,
+                        minimapLineHeight,
+                        minimapLineHeight,
+                        tabSize,
+                        characterWidth,
+                        canvasInnerWidth
+                    );
+                    continue;
+                case MinimapPosition.Gutter:
+                    {
                         const y = layout.getYForLineNumber(line, minimapLineHeight);
                         const x = 2;
-                        this.renderDecoration(canvasContext, decorationColor, x, y, GUTTER_DECORATION_WIDTH, minimapLineHeight);
+                        this.renderDecoration(
+                            canvasContext,
+                            decorationColor,
+                            x,
+                            y,
+                            GUTTER_DECORATION_WIDTH,
+                            minimapLineHeight
+                        );
                         continue;
                     }
                 }
             }
         }
     }
-    renderDecorationOnLine(canvasContext, lineOffsetMap, decorationRange, decorationColor, layout, lineNumber, height, minimapLineHeight, tabSize, charWidth, canvasInnerWidth) {
+    renderDecorationOnLine(
+        canvasContext,
+        lineOffsetMap,
+        decorationRange,
+        decorationColor,
+        layout,
+        lineNumber,
+        height,
+        minimapLineHeight,
+        tabSize,
+        charWidth,
+        canvasInnerWidth
+    ) {
         const y = layout.getYForLineNumber(lineNumber, minimapLineHeight);
         if (y + height < 0 || y > this._model.options.canvasInnerHeight) {
             return;
         }
-        const { startLineNumber, endLineNumber } = decorationRange;
+        const {
+            startLineNumber,
+            endLineNumber
+        } = decorationRange;
         const startColumn = (startLineNumber === lineNumber ? decorationRange.startColumn : 1);
         const endColumn = (endLineNumber === lineNumber ? decorationRange.endColumn : this._model.getLineMaxColumn(lineNumber));
-        const x1 = this.getXOffsetForPosition(lineOffsetMap, lineNumber, startColumn, tabSize, charWidth, canvasInnerWidth);
+        const x1 = this.getXOffsetForPosition(
+            lineOffsetMap,
+            lineNumber,
+            startColumn,
+            tabSize,
+            charWidth,
+            canvasInnerWidth
+        );
         const x2 = this.getXOffsetForPosition(lineOffsetMap, lineNumber, endColumn, tabSize, charWidth, canvasInnerWidth);
         this.renderDecoration(canvasContext, decorationColor, x1, y, x2 - x1, height);
     }
@@ -1319,11 +1431,7 @@ class InnerMinimap extends Disposable {
             let prevx = MINIMAP_GUTTER_WIDTH;
             for (let i = 1; i < lineData.length + 1; i++) {
                 const charCode = lineData.charCodeAt(i - 1);
-                const dx = charCode === CharCode.Tab
-                    ? tabSize * charWidth
-                    : isFullWidthCharacter(charCode)
-                        ? 2 * charWidth
-                        : charWidth;
+                const dx = charCode === CharCode.Tab ? tabSize * charWidth : isFullWidthCharacter(charCode) ? 2 * charWidth : charWidth;
                 const x = prevx + dx;
                 if (x >= canvasInnerWidth) {
                     lineIndexToXOffset[i] = canvasInnerWidth;
@@ -1340,7 +1448,7 @@ class InnerMinimap extends Disposable {
         return canvasInnerWidth;
     }
     renderDecoration(canvasContext, decorationColor, x, y, width, height) {
-        canvasContext.fillStyle = decorationColor && ( decorationColor.toString()) || '';
+        canvasContext.fillStyle = decorationColor && ( decorationColor.toString()) || "";
         canvasContext.fillRect(x, y, width, height);
     }
     _renderSectionHeaders(layout) {
@@ -1348,15 +1456,17 @@ class InnerMinimap extends Disposable {
         const sectionHeaderFontSize = this._model.options.sectionHeaderFontSize;
         const sectionHeaderLetterSpacing = this._model.options.sectionHeaderLetterSpacing;
         const backgroundFillHeight = sectionHeaderFontSize * 1.5;
-        const { canvasInnerWidth } = this._model.options;
+        const {
+            canvasInnerWidth
+        } = this._model.options;
         const backgroundColor = this._model.options.backgroundColor;
         const backgroundFill = `rgb(${backgroundColor.r} ${backgroundColor.g} ${backgroundColor.b} / .7)`;
         const foregroundColor = this._model.options.sectionHeaderFontColor;
         const foregroundFill = `rgb(${foregroundColor.r} ${foregroundColor.g} ${foregroundColor.b})`;
         const separatorStroke = foregroundFill;
-        const canvasContext = this._decorationsCanvas.domNode.getContext('2d');
-        canvasContext.letterSpacing = sectionHeaderLetterSpacing + 'px';
-        canvasContext.font = '500 ' + sectionHeaderFontSize + 'px ' + this._model.options.sectionHeaderFontFamily;
+        const canvasContext = this._decorationsCanvas.domNode.getContext("2d");
+        canvasContext.letterSpacing = sectionHeaderLetterSpacing + "px";
+        canvasContext.font = "500 " + sectionHeaderFontSize + "px " + this._model.options.sectionHeaderFontFamily;
         canvasContext.strokeStyle = separatorStroke;
         canvasContext.lineWidth = 0.4;
         const decorations = this._model.getSectionHeaderDecorationsInViewport(layout.startLineNumber, layout.endLineNumber);
@@ -1367,14 +1477,25 @@ class InnerMinimap extends Disposable {
             const backgroundFillY = y - sectionHeaderFontSize;
             const separatorY = backgroundFillY + 2;
             const headerText = this._model.getSectionHeaderText(decoration, fitWidth);
-            InnerMinimap._renderSectionLabel(canvasContext, headerText, decoration.options.minimap?.sectionHeaderStyle === MinimapSectionHeaderStyle.Underlined, backgroundFill, foregroundFill, canvasInnerWidth, backgroundFillY, backgroundFillHeight, y, separatorY);
+            InnerMinimap._renderSectionLabel(
+                canvasContext,
+                headerText,
+                decoration.options.minimap?.sectionHeaderStyle === MinimapSectionHeaderStyle.Underlined,
+                backgroundFill,
+                foregroundFill,
+                canvasInnerWidth,
+                backgroundFillY,
+                backgroundFillHeight,
+                y,
+                separatorY
+            );
         }
     }
     static _fitSectionHeader(target, maxWidth, headerText) {
         if (!headerText) {
             return headerText;
         }
-        const ellipsis = '…';
+        const ellipsis = "…";
         const width = target.measureText(headerText).width;
         const ellipsisWidth = target.measureText(ellipsis).width;
         if (width <= maxWidth || width <= ellipsisWidth) {
@@ -1387,10 +1508,20 @@ class InnerMinimap extends Disposable {
         while (halfCharCount > 0 && /\s/.test(headerText[halfCharCount - 1])) {
             --halfCharCount;
         }
-        return headerText.substring(0, halfCharCount)
-            + ellipsis + headerText.substring(len - (maxCharCount - halfCharCount));
-    }
-    static _renderSectionLabel(target, headerText, hasSeparatorLine, backgroundFill, foregroundFill, minimapWidth, backgroundFillY, backgroundFillHeight, textY, separatorY) {
+        return headerText.substring(0, halfCharCount) + ellipsis + headerText.substring(len - (maxCharCount - halfCharCount));
+    }
+    static _renderSectionLabel(
+        target,
+        headerText,
+        hasSeparatorLine,
+        backgroundFill,
+        foregroundFill,
+        minimapWidth,
+        backgroundFillY,
+        backgroundFillHeight,
+        textY,
+        separatorY
+    ) {
         if (headerText) {
             target.fillStyle = backgroundFill;
             target.fillRect(0, backgroundFillY, minimapWidth, backgroundFillHeight);
@@ -1417,7 +1548,14 @@ class InnerMinimap extends Disposable {
         if (!imageData) {
             return null;
         }
-        const [_dirtyY1, _dirtyY2, needed] = InnerMinimap._renderUntouchedLines(imageData, layout.topPaddingLineCount, startLineNumber, endLineNumber, minimapLineHeight, this._lastRenderData);
+        const [_dirtyY1, _dirtyY2, needed] = InnerMinimap._renderUntouchedLines(
+            imageData,
+            layout.topPaddingLineCount,
+            startLineNumber,
+            endLineNumber,
+            minimapLineHeight,
+            this._lastRenderData
+        );
         const lineInfo = this._model.getMinimapLinesRenderingData(startLineNumber, endLineNumber, needed);
         const tabSize = this._model.getOptions().tabSize;
         const defaultBackground = this._model.options.defaultBackgroundColor;
@@ -1443,7 +1581,23 @@ class InnerMinimap extends Disposable {
         const renderedLines = [];
         for (let lineIndex = 0, lineCount = endLineNumber - startLineNumber + 1; lineIndex < lineCount; lineIndex++) {
             if (needed[lineIndex]) {
-                InnerMinimap._renderLine(imageData, renderBackground, background.a, useLighterFont, renderMinimap, minimapCharWidth, tokensColorTracker, foregroundAlpha, charRenderer, dy, innerLinePadding, tabSize, lineInfo[lineIndex], fontScale, minimapLineHeight);
+                InnerMinimap._renderLine(
+                    imageData,
+                    renderBackground,
+                    background.a,
+                    useLighterFont,
+                    renderMinimap,
+                    minimapCharWidth,
+                    tokensColorTracker,
+                    foregroundAlpha,
+                    charRenderer,
+                    dy,
+                    innerLinePadding,
+                    tabSize,
+                    lineInfo[lineIndex],
+                    fontScale,
+                    minimapLineHeight
+                );
             }
             renderedLines[lineIndex] = ( new MinimapLine(dy));
             dy += minimapLineHeight;
@@ -1451,11 +1605,18 @@ class InnerMinimap extends Disposable {
         const dirtyY1 = (_dirtyY1 === -1 ? 0 : _dirtyY1);
         const dirtyY2 = (_dirtyY2 === -1 ? imageData.height : _dirtyY2);
         const dirtyHeight = dirtyY2 - dirtyY1;
-        const ctx = this._canvas.domNode.getContext('2d');
+        const ctx = this._canvas.domNode.getContext("2d");
         ctx.putImageData(imageData, 0, 0, 0, dirtyY1, imageData.width, dirtyHeight);
         return ( new RenderData(layout, imageData, renderedLines));
     }
-    static _renderUntouchedLines(target, topPaddingLineCount, startLineNumber, endLineNumber, minimapLineHeight, lastRenderData) {
+    static _renderUntouchedLines(
+        target,
+        topPaddingLineCount,
+        startLineNumber,
+        endLineNumber,
+        minimapLineHeight,
+        lastRenderData
+    ) {
         const needed = [];
         if (!lastRenderData) {
             for (let i = 0, len = endLineNumber - startLineNumber + 1; i < len; i++) {
@@ -1494,8 +1655,7 @@ class InnerMinimap extends Disposable {
             if (copySourceEnd === sourceStart && copyDestEnd === destStart) {
                 copySourceEnd = sourceEnd;
                 copyDestEnd = destEnd;
-            }
-            else {
+            } else {
                 if (copySourceStart !== -1) {
                     targetData.set(lastTargetData.subarray(copySourceStart, copySourceEnd), copyDestStart);
                     if (dirtyPixel1 === -1 && copySourceStart === 0 && copySourceStart === copyDestStart) {
@@ -1526,7 +1686,23 @@ class InnerMinimap extends Disposable {
         const dirtyY2 = (dirtyPixel2 === -1 ? -1 : dirtyPixel2 / (WIDTH * 4));
         return [dirtyY1, dirtyY2, needed];
     }
-    static _renderLine(target, backgroundColor, backgroundAlpha, useLighterFont, renderMinimap, charWidth, colorTracker, foregroundAlpha, minimapCharRenderer, dy, innerLinePadding, tabSize, lineData, fontScale, minimapLineHeight) {
+    static _renderLine(
+        target,
+        backgroundColor,
+        backgroundAlpha,
+        useLighterFont,
+        renderMinimap,
+        charWidth,
+        colorTracker,
+        foregroundAlpha,
+        minimapCharRenderer,
+        dy,
+        innerLinePadding,
+        tabSize,
+        lineData,
+        fontScale,
+        minimapLineHeight
+    ) {
         const content = lineData.content;
         const tokens = lineData.tokens;
         const maxDx = target.width - charWidth;
@@ -1547,18 +1723,36 @@ class InnerMinimap extends Disposable {
                     const insertSpacesCount = tabSize - (charIndex + tabsCharDelta) % tabSize;
                     tabsCharDelta += insertSpacesCount - 1;
                     dx += insertSpacesCount * charWidth;
-                }
-                else if (charCode === CharCode.Space) {
+                } else if (charCode === CharCode.Space) {
                     dx += charWidth;
-                }
-                else {
+                } else {
                     const count = isFullWidthCharacter(charCode) ? 2 : 1;
                     for (let i = 0; i < count; i++) {
                         if (renderMinimap === RenderMinimap.Blocks) {
-                            minimapCharRenderer.blockRenderChar(target, dx, dy + innerLinePadding, tokenColor, foregroundAlpha, backgroundColor, backgroundAlpha, force1pxHeight);
-                        }
-                        else {
-                            minimapCharRenderer.renderChar(target, dx, dy + innerLinePadding, charCode, tokenColor, foregroundAlpha, backgroundColor, backgroundAlpha, fontScale, useLighterFont, force1pxHeight);
+                            minimapCharRenderer.blockRenderChar(
+                                target,
+                                dx,
+                                dy + innerLinePadding,
+                                tokenColor,
+                                foregroundAlpha,
+                                backgroundColor,
+                                backgroundAlpha,
+                                force1pxHeight
+                            );
+                        } else {
+                            minimapCharRenderer.renderChar(
+                                target,
+                                dx,
+                                dy + innerLinePadding,
+                                charCode,
+                                tokenColor,
+                                foregroundAlpha,
+                                backgroundColor,
+                                backgroundAlpha,
+                                fontScale,
+                                useLighterFont,
+                                force1pxHeight
+                            );
                         }
                         dx += charWidth;
                         if (dx > maxDx) {