@codingame/monaco-vscode-api 1.85.5 → 2.0.0-rework-ci.1

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

@@ -0,0 +1,1439 @@
+import './minimap.css.js';
+import { addStandardDisposableListener, getDomNodePagePosition, EventType, addDisposableListener } from '../../../../base/browser/dom.js';
+import { createFastDomNode } from '../../../../base/browser/fastDomNode.js';
+import { GlobalPointerMoveMonitor } from '../../../../base/browser/globalPointerMoveMonitor.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { isWindows } from '../../../../base/common/platform.js';
+import { isFullWidthCharacter } from '../../../../base/common/strings.js';
+import { RenderedLinesCollection } from '../../view/viewLayer.js';
+import { ViewPart, PartFingerprints } from '../../view/viewPart.js';
+import { MINIMAP_GUTTER_WIDTH, EditorLayoutInfoComputer } from '../../../common/config/editorOptions.js';
+import { Range } from '../../../common/core/range.js';
+import { RGBA8 } from '../../../common/core/rgba.js';
+import { MinimapTokensColorTracker } from '../../../common/viewModel/minimapTokensColorTracker.js';
+import { ViewModelDecoration } from '../../../common/viewModel.js';
+import { minimapSelection, minimapBackground, minimapForegroundOpacity } from '../../../../platform/theme/common/colorRegistry.js';
+import { Selection } from '../../../common/core/selection.js';
+import { Gesture, EventType as EventType$1 } from '../../../../base/browser/touch.js';
+import { MinimapCharRendererFactory } from './minimapCharRendererFactory.js';
+import { MinimapPosition } from '../../../common/model.js';
+import { createSingleCallFunction } from '../../../../base/common/functional.js';
+const POINTER_DRAG_RESET_DISTANCE = 140;
+const GUTTER_DECORATION_WIDTH = 2;
+class MinimapOptions {
+    constructor(configuration, theme, tokensColorTracker) {
+        const options = configuration.options;
+        const pixelRatio = options.get(141 );
+        const layoutInfo = options.get(143 );
+        const minimapLayout = layoutInfo.minimap;
+        const fontInfo = options.get(50 );
+        const minimapOpts = options.get(72 );
+        this.renderMinimap = minimapLayout.renderMinimap;
+        this.size = minimapOpts.size;
+        this.minimapHeightIsEditorHeight = minimapLayout.minimapHeightIsEditorHeight;
+        this.scrollBeyondLastLine = options.get(104 );
+        this.paddingTop = options.get(83 ).top;
+        this.paddingBottom = options.get(83 ).bottom;
+        this.showSlider = minimapOpts.showSlider;
+        this.autohide = minimapOpts.autohide;
+        this.pixelRatio = pixelRatio;
+        this.typicalHalfwidthCharacterWidth = fontInfo.typicalHalfwidthCharacterWidth;
+        this.lineHeight = options.get(66 );
+        this.minimapLeft = minimapLayout.minimapLeft;
+        this.minimapWidth = minimapLayout.minimapWidth;
+        this.minimapHeight = layoutInfo.height;
+        this.canvasInnerWidth = minimapLayout.minimapCanvasInnerWidth;
+        this.canvasInnerHeight = minimapLayout.minimapCanvasInnerHeight;
+        this.canvasOuterWidth = minimapLayout.minimapCanvasOuterWidth;
+        this.canvasOuterHeight = minimapLayout.minimapCanvasOuterHeight;
+        this.isSampling = minimapLayout.minimapIsSampling;
+        this.editorHeight = layoutInfo.height;
+        this.fontScale = minimapLayout.minimapScale;
+        this.minimapLineHeight = minimapLayout.minimapLineHeight;
+        this.minimapCharWidth = 1  * this.fontScale;
+        this.charRenderer = createSingleCallFunction(() => MinimapCharRendererFactory.create(this.fontScale, fontInfo.fontFamily));
+        this.defaultBackgroundColor = tokensColorTracker.getColor(2 );
+        this.backgroundColor = MinimapOptions._getMinimapBackground(theme, this.defaultBackgroundColor);
+        this.foregroundAlpha = MinimapOptions._getMinimapForegroundOpacity(theme);
+    }
+    static _getMinimapBackground(theme, defaultBackgroundColor) {
+        const themeColor = theme.getColor(minimapBackground);
+        if (themeColor) {
+            return ( new RGBA8(
+                themeColor.rgba.r,
+                themeColor.rgba.g,
+                themeColor.rgba.b,
+                Math.round(255 * themeColor.rgba.a)
+            ));
+        }
+        return defaultBackgroundColor;
+    }
+    static _getMinimapForegroundOpacity(theme) {
+        const themeColor = theme.getColor(minimapForegroundOpacity);
+        if (themeColor) {
+            return RGBA8._clamp(Math.round(255 * themeColor.rgba.a));
+        }
+        return 255;
+    }
+    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.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) {
+        this.scrollTop = scrollTop;
+        this.scrollHeight = scrollHeight;
+        this.sliderNeeded = sliderNeeded;
+        this._computedSliderRatio = _computedSliderRatio;
+        this.sliderTop = sliderTop;
+        this.sliderHeight = sliderHeight;
+        this.topPaddingLineCount = topPaddingLineCount;
+        this.startLineNumber = startLineNumber;
+        this.endLineNumber = endLineNumber;
+    }
+    getDesiredScrollTopFromDelta(delta) {
+        return Math.round(this.scrollTop + delta / this._computedSliderRatio);
+    }
+    getDesiredScrollTopFromTouchLocation(pageY) {
+        return Math.round((pageY - this.sliderHeight / 2) / this._computedSliderRatio);
+    }
+    intersectWithViewport(range) {
+        const startLineNumber = Math.max(this.startLineNumber, range.startLineNumber);
+        const endLineNumber = Math.min(this.endLineNumber, range.endLineNumber);
+        if (startLineNumber > endLineNumber) {
+            return null;
+        }
+        return [startLineNumber, endLineNumber];
+    }
+    getYForLineNumber(lineNumber, minimapLineHeight) {
+        return +(lineNumber - this.startLineNumber + this.topPaddingLineCount) * minimapLineHeight;
+    }
+    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);
+            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 sliderTop = (scrollTop * computedSliderRatio);
+            const sliderNeeded = (maxMinimapSliderTop > 0);
+            const maxLinesFitting = Math.floor(options.canvasInnerHeight / options.minimapLineHeight);
+            const topPaddingLineCount = Math.floor(options.paddingTop / options.lineHeight);
+            return ( new MinimapLayout(
+                scrollTop,
+                scrollHeight,
+                sliderNeeded,
+                computedSliderRatio,
+                sliderTop,
+                sliderHeight,
+                topPaddingLineCount,
+                1,
+                Math.min(lineCount, maxLinesFitting)
+            ));
+        }
+        let sliderHeight;
+        if (viewportContainsWhitespaceGaps && viewportEndLineNumber !== lineCount) {
+            const viewportLineCount = viewportEndLineNumber - viewportStartLineNumber + 1;
+            sliderHeight = Math.floor(viewportLineCount * minimapLineHeight / pixelRatio);
+        }
+        else {
+            const expectedViewportLineCount = viewportHeight / lineHeight;
+            sliderHeight = Math.floor(expectedViewportLineCount * minimapLineHeight / pixelRatio);
+        }
+        const extraLinesAtTheTop = Math.floor(options.paddingTop / lineHeight);
+        let extraLinesAtTheBottom = Math.floor(options.paddingBottom / lineHeight);
+        if (options.scrollBeyondLastLine) {
+            const expectedViewportLineCount = viewportHeight / lineHeight;
+            extraLinesAtTheBottom = Math.max(extraLinesAtTheBottom, expectedViewportLineCount - 1);
+        }
+        let maxMinimapSliderTop;
+        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);
+        }
+        maxMinimapSliderTop = Math.min(options.minimapHeight - sliderHeight, maxMinimapSliderTop);
+        const computedSliderRatio = (maxMinimapSliderTop) / (scrollHeight - viewportHeight);
+        const sliderTop = (scrollTop * computedSliderRatio);
+        if (minimapLinesFitting >= extraLinesAtTheTop + lineCount + extraLinesAtTheBottom) {
+            const sliderNeeded = (maxMinimapSliderTop > 0);
+            return ( new MinimapLayout(
+                scrollTop,
+                scrollHeight,
+                sliderNeeded,
+                computedSliderRatio,
+                sliderTop,
+                sliderHeight,
+                extraLinesAtTheTop,
+                1,
+                lineCount
+            ));
+        }
+        else {
+            let consideringStartLineNumber;
+            if (viewportStartLineNumber > 1) {
+                consideringStartLineNumber = viewportStartLineNumber + extraLinesAtTheTop;
+            }
+            else {
+                consideringStartLineNumber = Math.max(1, scrollTop / lineHeight);
+            }
+            let topPaddingLineCount;
+            let startLineNumber = Math.max(1, Math.floor(consideringStartLineNumber - sliderTop * pixelRatio / minimapLineHeight));
+            if (startLineNumber < extraLinesAtTheTop) {
+                topPaddingLineCount = extraLinesAtTheTop - startLineNumber + 1;
+                startLineNumber = 1;
+            }
+            else {
+                topPaddingLineCount = 0;
+                startLineNumber = Math.max(1, startLineNumber - extraLinesAtTheTop);
+            }
+            if (previousLayout && previousLayout.scrollHeight === scrollHeight) {
+                if (previousLayout.scrollTop > scrollTop) {
+                    startLineNumber = Math.min(startLineNumber, previousLayout.startLineNumber);
+                    topPaddingLineCount = Math.max(topPaddingLineCount, previousLayout.topPaddingLineCount);
+                }
+                if (previousLayout.scrollTop < scrollTop) {
+                    startLineNumber = Math.max(startLineNumber, previousLayout.startLineNumber);
+                    topPaddingLineCount = Math.min(topPaddingLineCount, previousLayout.topPaddingLineCount);
+                }
+            }
+            const endLineNumber = Math.min(lineCount, startLineNumber - topPaddingLineCount + minimapLinesFitting - 1);
+            const partialLine = (scrollTop - viewportStartLineNumberVerticalOffset) / lineHeight;
+            let sliderTopAligned;
+            if (scrollTop >= options.paddingTop) {
+                sliderTopAligned = (viewportStartLineNumber - startLineNumber + topPaddingLineCount + partialLine) * minimapLineHeight / pixelRatio;
+            }
+            else {
+                sliderTopAligned = (scrollTop / options.paddingTop) * (topPaddingLineCount + partialLine) * minimapLineHeight / pixelRatio;
+            }
+            return ( new MinimapLayout(
+                scrollTop,
+                scrollHeight,
+                true,
+                computedSliderRatio,
+                sliderTopAligned,
+                sliderHeight,
+                topPaddingLineCount,
+                startLineNumber,
+                endLineNumber
+            ));
+        }
+    }
+}
+class MinimapLine {
+    static { this.INVALID = ( new MinimapLine(-1)); }
+    constructor(dy) {
+        this.dy = dy;
+    }
+    onContentChanged() {
+        this.dy = -1;
+    }
+    onTokensChanged() {
+        this.dy = -1;
+    }
+}
+class RenderData {
+    constructor(renderedLayout, imageData, lines) {
+        this.renderedLayout = renderedLayout;
+        this._imageData = imageData;
+        this._renderedLines = ( new RenderedLinesCollection(() => MinimapLine.INVALID));
+        this._renderedLines._set(renderedLayout.startLineNumber, lines);
+    }
+    linesEquals(layout) {
+        if (!this.scrollEquals(layout)) {
+            return false;
+        }
+        const tmp = this._renderedLines._get();
+        const lines = tmp.lines;
+        for (let i = 0, len = lines.length; i < len; i++) {
+            if (lines[i].dy === -1) {
+                return false;
+            }
+        }
+        return true;
+    }
+    scrollEquals(layout) {
+        return this.renderedLayout.startLineNumber === layout.startLineNumber
+            && this.renderedLayout.endLineNumber === layout.endLineNumber;
+    }
+    _get() {
+        const tmp = this._renderedLines._get();
+        return {
+            imageData: this._imageData,
+            rendLineNumberStart: tmp.rendLineNumberStart,
+            lines: tmp.lines
+        };
+    }
+    onLinesChanged(changeFromLineNumber, changeCount) {
+        return this._renderedLines.onLinesChanged(changeFromLineNumber, changeCount);
+    }
+    onLinesDeleted(deleteFromLineNumber, deleteToLineNumber) {
+        this._renderedLines.onLinesDeleted(deleteFromLineNumber, deleteToLineNumber);
+    }
+    onLinesInserted(insertFromLineNumber, insertToLineNumber) {
+        this._renderedLines.onLinesInserted(insertFromLineNumber, insertToLineNumber);
+    }
+    onTokensChanged(ranges) {
+        return this._renderedLines.onTokensChanged(ranges);
+    }
+}
+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._lastUsedBuffer = 0;
+    }
+    getBuffer() {
+        this._lastUsedBuffer = 1 - this._lastUsedBuffer;
+        const result = this._buffers[this._lastUsedBuffer];
+        result.data.set(this._backgroundFillData);
+        return result;
+    }
+    static _createBackgroundFillData(WIDTH, HEIGHT, background) {
+        const backgroundR = background.r;
+        const backgroundG = background.g;
+        const backgroundB = background.b;
+        const backgroundA = background.a;
+        const result = ( new Uint8ClampedArray(WIDTH * HEIGHT * 4));
+        let offset = 0;
+        for (let i = 0; i < HEIGHT; i++) {
+            for (let j = 0; j < WIDTH; j++) {
+                result[offset] = backgroundR;
+                result[offset + 1] = backgroundG;
+                result[offset + 2] = backgroundB;
+                result[offset + 3] = backgroundA;
+                offset += 4;
+            }
+        }
+        return result;
+    }
+}
+class MinimapSamplingState {
+    static compute(options, viewLineCount, oldSamplingState) {
+        if (options.renderMinimap === 0  || !options.isSampling) {
+            return [null, []];
+        }
+        const { minimapLineCount } = EditorLayoutInfoComputer.computeContainedMinimapLineCount({
+            viewLineCount: viewLineCount,
+            scrollBeyondLastLine: options.scrollBeyondLastLine,
+            paddingTop: options.paddingTop,
+            paddingBottom: options.paddingBottom,
+            height: options.editorHeight,
+            lineHeight: options.lineHeight,
+            pixelRatio: options.pixelRatio
+        });
+        const ratio = viewLineCount / minimapLineCount;
+        const halfRatio = ratio / 2;
+        if (!oldSamplingState || oldSamplingState.minimapLines.length === 0) {
+            const result = [];
+            result[0] = 1;
+            if (minimapLineCount > 1) {
+                for (let i = 0, lastIndex = minimapLineCount - 1; i < lastIndex; i++) {
+                    result[i] = Math.round(i * ratio + halfRatio);
+                }
+                result[minimapLineCount - 1] = viewLineCount;
+            }
+            return [( new MinimapSamplingState(ratio, result)), []];
+        }
+        const oldMinimapLines = oldSamplingState.minimapLines;
+        const oldLength = oldMinimapLines.length;
+        const result = [];
+        let oldIndex = 0;
+        let oldDeltaLineCount = 0;
+        let minViewLineNumber = 1;
+        const MAX_EVENT_COUNT = 10;
+        let events = [];
+        let lastEvent = null;
+        for (let i = 0; i < minimapLineCount; i++) {
+            const fromViewLineNumber = Math.max(minViewLineNumber, Math.round(i * ratio));
+            const toViewLineNumber = Math.max(fromViewLineNumber, Math.round((i + 1) * ratio));
+            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) {
+                        lastEvent.deleteToLineNumber++;
+                    }
+                    else {
+                        lastEvent = { type: 'deleted', _oldIndex: oldIndex, deleteFromLineNumber: oldMinimapLineNumber, deleteToLineNumber: oldMinimapLineNumber };
+                        events.push(lastEvent);
+                    }
+                    oldDeltaLineCount--;
+                }
+                oldIndex++;
+            }
+            let selectedViewLineNumber;
+            if (oldIndex < oldLength && oldMinimapLines[oldIndex] <= toViewLineNumber) {
+                selectedViewLineNumber = oldMinimapLines[oldIndex];
+                oldIndex++;
+            }
+            else {
+                if (i === 0) {
+                    selectedViewLineNumber = 1;
+                }
+                else if (i + 1 === minimapLineCount) {
+                    selectedViewLineNumber = viewLineCount;
+                }
+                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) {
+                        lastEvent.insertToLineNumber++;
+                    }
+                    else {
+                        lastEvent = { type: 'inserted', _i: i, insertFromLineNumber: oldMinimapLineNumber, insertToLineNumber: oldMinimapLineNumber };
+                        events.push(lastEvent);
+                    }
+                    oldDeltaLineCount++;
+                }
+            }
+            result[i] = selectedViewLineNumber;
+            minViewLineNumber = selectedViewLineNumber;
+        }
+        if (events.length < MAX_EVENT_COUNT) {
+            while (oldIndex < oldLength) {
+                const oldMinimapLineNumber = oldIndex + 1 + oldDeltaLineCount;
+                if (lastEvent && lastEvent.type === 'deleted' && lastEvent._oldIndex === oldIndex - 1) {
+                    lastEvent.deleteToLineNumber++;
+                }
+                else {
+                    lastEvent = { type: 'deleted', _oldIndex: oldIndex, deleteFromLineNumber: oldMinimapLineNumber, deleteToLineNumber: oldMinimapLineNumber };
+                    events.push(lastEvent);
+                }
+                oldDeltaLineCount--;
+                oldIndex++;
+            }
+        }
+        else {
+            events = [{ type: 'flush' }];
+        }
+        return [( new MinimapSamplingState(ratio, result)), events];
+    }
+    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)));
+    }
+    modelLineRangeToMinimapLineRange(fromLineNumber, toLineNumber) {
+        let fromLineIndex = this.modelLineToMinimapLine(fromLineNumber) - 1;
+        while (fromLineIndex > 0 && this.minimapLines[fromLineIndex - 1] >= fromLineNumber) {
+            fromLineIndex--;
+        }
+        let toLineIndex = this.modelLineToMinimapLine(toLineNumber) - 1;
+        while (toLineIndex + 1 < this.minimapLines.length && this.minimapLines[toLineIndex + 1] <= toLineNumber) {
+            toLineIndex++;
+        }
+        if (fromLineIndex === toLineIndex) {
+            const sampledLineNumber = this.minimapLines[fromLineIndex];
+            if (sampledLineNumber < fromLineNumber || sampledLineNumber > toLineNumber) {
+                return null;
+            }
+        }
+        return [fromLineIndex + 1, toLineIndex + 1];
+    }
+    decorationLineRangeToMinimapLineRange(startLineNumber, endLineNumber) {
+        let minimapLineStart = this.modelLineToMinimapLine(startLineNumber);
+        let minimapLineEnd = this.modelLineToMinimapLine(endLineNumber);
+        if (startLineNumber !== endLineNumber && minimapLineEnd === minimapLineStart) {
+            if (minimapLineEnd === this.minimapLines.length) {
+                if (minimapLineStart > 1) {
+                    minimapLineStart--;
+                }
+            }
+            else {
+                minimapLineEnd++;
+            }
+        }
+        return [minimapLineStart, minimapLineEnd];
+    }
+    onLinesDeleted(e) {
+        const deletedLineCount = e.toLineNumber - e.fromLineNumber + 1;
+        let changeStartIndex = this.minimapLines.length;
+        let changeEndIndex = 0;
+        for (let i = this.minimapLines.length - 1; i >= 0; i--) {
+            if (this.minimapLines[i] < e.fromLineNumber) {
+                break;
+            }
+            if (this.minimapLines[i] <= e.toLineNumber) {
+                this.minimapLines[i] = Math.max(1, e.fromLineNumber - 1);
+                changeStartIndex = Math.min(changeStartIndex, i);
+                changeEndIndex = Math.max(changeEndIndex, i);
+            }
+            else {
+                this.minimapLines[i] -= deletedLineCount;
+            }
+        }
+        return [changeStartIndex, changeEndIndex];
+    }
+    onLinesInserted(e) {
+        const insertedLineCount = e.toLineNumber - e.fromLineNumber + 1;
+        for (let i = this.minimapLines.length - 1; i >= 0; i--) {
+            if (this.minimapLines[i] < e.fromLineNumber) {
+                break;
+            }
+            this.minimapLines[i] += insertedLineCount;
+        }
+    }
+}
+class Minimap extends ViewPart {
+    constructor(context) {
+        super(context);
+        this.tokensColorTracker = MinimapTokensColorTracker.getInstance();
+        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);
+        this._samplingState = samplingState;
+        this._shouldCheckSampling = false;
+        this._actual = ( new InnerMinimap(context.theme, this));
+    }
+    dispose() {
+        this._actual.dispose();
+        super.dispose();
+    }
+    getDomNode() {
+        return this._actual.getDomNode();
+    }
+    _onOptionsMaybeChanged() {
+        const opts = ( new MinimapOptions(this._context.configuration, this._context.theme, this.tokensColorTracker));
+        if (this.options.equals(opts)) {
+            return false;
+        }
+        this.options = opts;
+        this._recreateLineSampling();
+        this._actual.onDidChangeOptions();
+        return true;
+    }
+    onConfigurationChanged(e) {
+        return this._onOptionsMaybeChanged();
+    }
+    onCursorStateChanged(e) {
+        this._selections = e.selections;
+        this._minimapSelections = null;
+        return this._actual.onSelectionChanged();
+    }
+    onDecorationsChanged(e) {
+        if (e.affectsMinimap) {
+            return this._actual.onDecorationsChanged();
+        }
+        return false;
+    }
+    onFlushed(e) {
+        if (this._samplingState) {
+            this._shouldCheckSampling = true;
+        }
+        return this._actual.onFlushed();
+    }
+    onLinesChanged(e) {
+        if (this._samplingState) {
+            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 {
+                return false;
+            }
+        }
+        else {
+            return this._actual.onLinesChanged(e.fromLineNumber, e.count);
+        }
+    }
+    onLinesDeleted(e) {
+        if (this._samplingState) {
+            const [changeStartIndex, changeEndIndex] = this._samplingState.onLinesDeleted(e);
+            if (changeStartIndex <= changeEndIndex) {
+                this._actual.onLinesChanged(changeStartIndex + 1, changeEndIndex - changeStartIndex + 1);
+            }
+            this._shouldCheckSampling = true;
+            return true;
+        }
+        else {
+            return this._actual.onLinesDeleted(e.fromLineNumber, e.toLineNumber);
+        }
+    }
+    onLinesInserted(e) {
+        if (this._samplingState) {
+            this._samplingState.onLinesInserted(e);
+            this._shouldCheckSampling = true;
+            return true;
+        }
+        else {
+            return this._actual.onLinesInserted(e.fromLineNumber, e.toLineNumber);
+        }
+    }
+    onScrollChanged(e) {
+        return this._actual.onScrollChanged();
+    }
+    onThemeChanged(e) {
+        this._actual.onThemeChanged();
+        this._onOptionsMaybeChanged();
+        return true;
+    }
+    onTokensChanged(e) {
+        if (this._samplingState) {
+            const ranges = [];
+            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] });
+                }
+            }
+            if (ranges.length) {
+                return this._actual.onTokensChanged(ranges);
+            }
+            else {
+                return false;
+            }
+        }
+        else {
+            return this._actual.onTokensChanged(e.ranges);
+        }
+    }
+    onTokensColorsChanged(e) {
+        this._onOptionsMaybeChanged();
+        return this._actual.onTokensColorsChanged();
+    }
+    onZonesChanged(e) {
+        return this._actual.onZonesChanged();
+    }
+    prepareRender(ctx) {
+        if (this._shouldCheckSampling) {
+            this._shouldCheckSampling = false;
+            this._recreateLineSampling();
+        }
+    }
+    render(ctx) {
+        let viewportStartLineNumber = ctx.visibleRange.startLineNumber;
+        let viewportEndLineNumber = ctx.visibleRange.endLineNumber;
+        if (this._samplingState) {
+            viewportStartLineNumber = this._samplingState.modelLineToMinimapLine(viewportStartLineNumber);
+            viewportEndLineNumber = this._samplingState.modelLineToMinimapLine(viewportEndLineNumber);
+        }
+        const minimapCtx = {
+            viewportContainsWhitespaceGaps: (ctx.viewportData.whitespaceViewportData.length > 0),
+            scrollWidth: ctx.scrollWidth,
+            scrollHeight: ctx.scrollHeight,
+            viewportStartLineNumber: viewportStartLineNumber,
+            viewportEndLineNumber: viewportEndLineNumber,
+            viewportStartLineNumberVerticalOffset: ctx.getVerticalOffsetForLineNumber(viewportStartLineNumber),
+            scrollTop: ctx.scrollTop,
+            scrollLeft: ctx.scrollLeft,
+            viewportWidth: ctx.viewportWidth,
+            viewportHeight: ctx.viewportHeight,
+        };
+        this._actual.render(minimapCtx);
+    }
+    _recreateLineSampling() {
+        this._minimapSelections = null;
+        const wasSampling = Boolean(this._samplingState);
+        const [samplingState, events] = MinimapSamplingState.compute(this.options, this._context.viewModel.getLineCount(), this._samplingState);
+        this._samplingState = samplingState;
+        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;
+                }
+            }
+        }
+    }
+    getLineCount() {
+        if (this._samplingState) {
+            return this._samplingState.minimapLines.length;
+        }
+        return this._context.viewModel.getLineCount();
+    }
+    getRealLineCount() {
+        return this._context.viewModel.getLineCount();
+    }
+    getLineContent(lineNumber) {
+        if (this._samplingState) {
+            return this._context.viewModel.getLineContent(this._samplingState.minimapLines[lineNumber - 1]);
+        }
+        return this._context.viewModel.getLineContent(lineNumber);
+    }
+    getLineMaxColumn(lineNumber) {
+        if (this._samplingState) {
+            return this._context.viewModel.getLineMaxColumn(this._samplingState.minimapLines[lineNumber - 1]);
+        }
+        return this._context.viewModel.getLineMaxColumn(lineNumber);
+    }
+    getMinimapLinesRenderingData(startLineNumber, endLineNumber, needed) {
+        if (this._samplingState) {
+            const result = [];
+            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 {
+                    result[lineIndex] = null;
+                }
+            }
+            return result;
+        }
+        return this._context.viewModel.getMinimapLinesRenderingData(startLineNumber, endLineNumber, needed).data;
+    }
+    getSelections() {
+        if (this._minimapSelections === null) {
+            if (this._samplingState) {
+                this._minimapSelections = [];
+                for (const selection of this._selections) {
+                    const [minimapLineStart, minimapLineEnd] = this._samplingState.decorationLineRangeToMinimapLineRange(selection.startLineNumber, selection.endLineNumber);
+                    this._minimapSelections.push(( new Selection(
+                        minimapLineStart,
+                        selection.startColumn,
+                        minimapLineEnd,
+                        selection.endColumn
+                    )));
+                }
+            }
+            else {
+                this._minimapSelections = this._selections;
+            }
+        }
+        return this._minimapSelections;
+    }
+    getMinimapDecorationsInViewport(startLineNumber, endLineNumber) {
+        let visibleRange;
+        if (this._samplingState) {
+            const modelStartLineNumber = this._samplingState.minimapLines[startLineNumber - 1];
+            const modelEndLineNumber = this._samplingState.minimapLines[endLineNumber - 1];
+            visibleRange = ( new Range(
+                modelStartLineNumber,
+                1,
+                modelEndLineNumber,
+                this._context.viewModel.getLineMaxColumn(modelEndLineNumber)
+            ));
+        }
+        else {
+            visibleRange = ( new Range(
+                startLineNumber,
+                1,
+                endLineNumber,
+                this._context.viewModel.getLineMaxColumn(endLineNumber)
+            ));
+        }
+        const decorations = this._context.viewModel.getMinimapDecorationsInRange(visibleRange);
+        if (this._samplingState) {
+            const result = [];
+            for (const decoration of decorations) {
+                if (!decoration.options.minimap) {
+                    continue;
+                }
+                const range = decoration.range;
+                const minimapStartLineNumber = this._samplingState.modelLineToMinimapLine(range.startLineNumber);
+                const minimapEndLineNumber = this._samplingState.modelLineToMinimapLine(range.endLineNumber);
+                result.push(( new ViewModelDecoration(( new Range(
+                    minimapStartLineNumber,
+                    range.startColumn,
+                    minimapEndLineNumber,
+                    range.endColumn
+                )), decoration.options)));
+            }
+            return result;
+        }
+        return decorations;
+    }
+    getOptions() {
+        return this._context.viewModel.model.getOptions();
+    }
+    revealLineNumber(lineNumber) {
+        if (this._samplingState) {
+            lineNumber = this._samplingState.minimapLines[lineNumber - 1];
+        }
+        this._context.viewModel.revealRange('mouse', false, ( new Range(lineNumber, 1, lineNumber, 1)), 1 , 0 );
+    }
+    setScrollTop(scrollTop) {
+        this._context.viewModel.viewLayout.setScrollPosition({
+            scrollTop: scrollTop
+        }, 1 );
+    }
+}
+class InnerMinimap extends Disposable {
+    constructor(theme, model) {
+        super();
+        this._renderDecorations = false;
+        this._gestureInProgress = false;
+        this._theme = theme;
+        this._model = model;
+        this._lastRenderData = null;
+        this._buffers = null;
+        this._selectionColor = this._theme.getColor(minimapSelection);
+        this._domNode = createFastDomNode(document.createElement('div'));
+        PartFingerprints.write(this._domNode, 8 );
+        this._domNode.setClassName(this._getMinimapDomNodeClassName());
+        this._domNode.setPosition('absolute');
+        this._domNode.setAttribute('role', 'presentation');
+        this._domNode.setAttribute('aria-hidden', 'true');
+        this._shadow = createFastDomNode(document.createElement('div'));
+        this._shadow.setClassName('minimap-shadow-hidden');
+        this._domNode.appendChild(this._shadow);
+        this._canvas = createFastDomNode(document.createElement('canvas'));
+        this._canvas.setPosition('absolute');
+        this._canvas.setLeft(0);
+        this._domNode.appendChild(this._canvas);
+        this._decorationsCanvas = createFastDomNode(document.createElement('canvas'));
+        this._decorationsCanvas.setPosition('absolute');
+        this._decorationsCanvas.setClassName('minimap-decorations-layer');
+        this._decorationsCanvas.setLeft(0);
+        this._domNode.appendChild(this._decorationsCanvas);
+        this._slider = createFastDomNode(document.createElement('div'));
+        this._slider.setPosition('absolute');
+        this._slider.setClassName('minimap-slider');
+        this._slider.setLayerHinting(true);
+        this._slider.setContain('strict');
+        this._domNode.appendChild(this._slider);
+        this._sliderHorizontal = createFastDomNode(document.createElement('div'));
+        this._sliderHorizontal.setPosition('absolute');
+        this._sliderHorizontal.setClassName('minimap-slider-horizontal');
+        this._slider.appendChild(this._sliderHorizontal);
+        this._applyLayout();
+        this._pointerDownListener = addStandardDisposableListener(this._domNode.domNode, EventType.POINTER_DOWN, (e) => {
+            e.preventDefault();
+            const renderMinimap = this._model.options.renderMinimap;
+            if (renderMinimap === 0 ) {
+                return;
+            }
+            if (!this._lastRenderData) {
+                return;
+            }
+            if (this._model.options.size !== 'proportional') {
+                if (e.button === 0 && this._lastRenderData) {
+                    const position = getDomNodePagePosition(this._slider.domNode);
+                    const initialPosY = position.top + position.height / 2;
+                    this._startSliderDragging(e, initialPosY, this._lastRenderData.renderedLayout);
+                }
+                return;
+            }
+            const minimapLineHeight = this._model.options.minimapLineHeight;
+            const internalOffsetY = (this._model.options.canvasInnerHeight / this._model.options.canvasOuterHeight) * e.offsetY;
+            const lineIndex = Math.floor(internalOffsetY / minimapLineHeight);
+            let lineNumber = lineIndex + this._lastRenderData.renderedLayout.startLineNumber - this._lastRenderData.renderedLayout.topPaddingLineCount;
+            lineNumber = Math.min(lineNumber, this._model.getLineCount());
+            this._model.revealLineNumber(lineNumber);
+        });
+        this._sliderPointerMoveMonitor = ( new GlobalPointerMoveMonitor());
+        this._sliderPointerDownListener = addStandardDisposableListener(this._slider.domNode, EventType.POINTER_DOWN, (e) => {
+            e.preventDefault();
+            e.stopPropagation();
+            if (e.button === 0 && this._lastRenderData) {
+                this._startSliderDragging(e, e.pageY, this._lastRenderData.renderedLayout);
+            }
+        });
+        this._gestureDisposable = Gesture.addTarget(this._domNode.domNode);
+        this._sliderTouchStartListener = addDisposableListener(this._domNode.domNode, EventType$1.Start, (e) => {
+            e.preventDefault();
+            e.stopPropagation();
+            if (this._lastRenderData) {
+                this._slider.toggleClassName('active', true);
+                this._gestureInProgress = true;
+                this.scrollDueToTouchEvent(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) => {
+            e.preventDefault();
+            e.stopPropagation();
+            this._gestureInProgress = false;
+            this._slider.toggleClassName('active', false);
+        });
+    }
+    _startSliderDragging(e, initialPosY, initialSliderState) {
+        if (!e.target || !(e.target instanceof Element)) {
+            return;
+        }
+        const initialPosX = e.pageX;
+        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));
+            if (isWindows && pointerOrthogonalDelta > POINTER_DRAG_RESET_DISTANCE) {
+                this._model.setScrollTop(initialSliderState.scrollTop);
+                return;
+            }
+            const pointerDelta = posy - initialPosY;
+            this._model.setScrollTop(initialSliderState.getDesiredScrollTopFromDelta(pointerDelta));
+        };
+        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);
+        });
+    }
+    scrollDueToTouchEvent(touch) {
+        const startY = this._domNode.domNode.getBoundingClientRect().top;
+        const scrollTop = this._lastRenderData.renderedLayout.getDesiredScrollTopFromTouchLocation(touch.pageY - startY);
+        this._model.setScrollTop(scrollTop);
+    }
+    dispose() {
+        this._pointerDownListener.dispose();
+        this._sliderPointerMoveMonitor.dispose();
+        this._sliderPointerDownListener.dispose();
+        this._gestureDisposable.dispose();
+        this._sliderTouchStartListener.dispose();
+        this._sliderTouchMoveListener.dispose();
+        this._sliderTouchEndListener.dispose();
+        super.dispose();
+    }
+    _getMinimapDomNodeClassName() {
+        const class_ = ['minimap'];
+        if (this._model.options.showSlider === 'always') {
+            class_.push('slider-always');
+        }
+        else {
+            class_.push('slider-mouseover');
+        }
+        if (this._model.options.autohide) {
+            class_.push('autohide');
+        }
+        return class_.join(' ');
+    }
+    getDomNode() {
+        return this._domNode;
+    }
+    _applyLayout() {
+        this._domNode.setLeft(this._model.options.minimapLeft);
+        this._domNode.setWidth(this._model.options.minimapWidth);
+        this._domNode.setHeight(this._model.options.minimapHeight);
+        this._shadow.setHeight(this._model.options.minimapHeight);
+        this._canvas.setWidth(this._model.options.canvasOuterWidth);
+        this._canvas.setHeight(this._model.options.canvasOuterHeight);
+        this._canvas.domNode.width = this._model.options.canvasInnerWidth;
+        this._canvas.domNode.height = this._model.options.canvasInnerHeight;
+        this._decorationsCanvas.setWidth(this._model.options.canvasOuterWidth);
+        this._decorationsCanvas.setHeight(this._model.options.canvasOuterHeight);
+        this._decorationsCanvas.domNode.width = this._model.options.canvasInnerWidth;
+        this._decorationsCanvas.domNode.height = this._model.options.canvasInnerHeight;
+        this._slider.setWidth(this._model.options.minimapWidth);
+    }
+    _getBuffer() {
+        if (!this._buffers) {
+            if (this._model.options.canvasInnerWidth > 0 && this._model.options.canvasInnerHeight > 0) {
+                this._buffers = ( new MinimapBuffers(
+                    this._canvas.domNode.getContext('2d'),
+                    this._model.options.canvasInnerWidth,
+                    this._model.options.canvasInnerHeight,
+                    this._model.options.backgroundColor
+                ));
+            }
+        }
+        return this._buffers ? this._buffers.getBuffer() : null;
+    }
+    onDidChangeOptions() {
+        this._lastRenderData = null;
+        this._buffers = null;
+        this._applyLayout();
+        this._domNode.setClassName(this._getMinimapDomNodeClassName());
+    }
+    onSelectionChanged() {
+        this._renderDecorations = true;
+        return true;
+    }
+    onDecorationsChanged() {
+        this._renderDecorations = true;
+        return true;
+    }
+    onFlushed() {
+        this._lastRenderData = null;
+        return true;
+    }
+    onLinesChanged(changeFromLineNumber, changeCount) {
+        if (this._lastRenderData) {
+            return this._lastRenderData.onLinesChanged(changeFromLineNumber, changeCount);
+        }
+        return false;
+    }
+    onLinesDeleted(deleteFromLineNumber, deleteToLineNumber) {
+        this._lastRenderData?.onLinesDeleted(deleteFromLineNumber, deleteToLineNumber);
+        return true;
+    }
+    onLinesInserted(insertFromLineNumber, insertToLineNumber) {
+        this._lastRenderData?.onLinesInserted(insertFromLineNumber, insertToLineNumber);
+        return true;
+    }
+    onScrollChanged() {
+        this._renderDecorations = true;
+        return true;
+    }
+    onThemeChanged() {
+        this._selectionColor = this._theme.getColor(minimapSelection);
+        this._renderDecorations = true;
+        return true;
+    }
+    onTokensChanged(ranges) {
+        if (this._lastRenderData) {
+            return this._lastRenderData.onTokensChanged(ranges);
+        }
+        return false;
+    }
+    onTokensColorsChanged() {
+        this._lastRenderData = null;
+        this._buffers = null;
+        return true;
+    }
+    onZonesChanged() {
+        this._lastRenderData = null;
+        return true;
+    }
+    render(renderingCtx) {
+        const renderMinimap = this._model.options.renderMinimap;
+        if (renderMinimap === 0 ) {
+            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._slider.setTop(layout.sliderTop);
+        this._slider.setHeight(layout.sliderHeight);
+        this._sliderHorizontal.setLeft(0);
+        this._sliderHorizontal.setWidth(this._model.options.minimapWidth);
+        this._sliderHorizontal.setTop(0);
+        this._sliderHorizontal.setHeight(layout.sliderHeight);
+        this.renderDecorations(layout);
+        this._lastRenderData = this.renderLines(layout);
+    }
+    renderDecorations(layout) {
+        if (this._renderDecorations) {
+            this._renderDecorations = false;
+            const selections = this._model.getSelections();
+            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 minimapLineHeight = this._model.options.minimapLineHeight;
+            const minimapCharWidth = this._model.options.minimapCharWidth;
+            const tabSize = this._model.getOptions().tabSize;
+            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);
+        }
+    }
+    _renderSelectionLineHighlights(canvasContext, selections, highlightedLines, layout, minimapLineHeight) {
+        if (!this._selectionColor || this._selectionColor.isTransparent()) {
+            return;
+        }
+        canvasContext.fillStyle = ( ( this._selectionColor.transparent(0.5)).toString());
+        let y1 = 0;
+        let y2 = 0;
+        for (const selection of selections) {
+            const intersection = layout.intersectWithViewport(selection);
+            if (!intersection) {
+                continue;
+            }
+            const [startLineNumber, endLineNumber] = intersection;
+            for (let line = startLineNumber; line <= endLineNumber; line++) {
+                highlightedLines.set(line, true);
+            }
+            const yy1 = layout.getYForLineNumber(startLineNumber, minimapLineHeight);
+            const yy2 = layout.getYForLineNumber(endLineNumber, minimapLineHeight);
+            if (y2 >= yy1) {
+                y2 = yy2;
+            }
+            else {
+                if (y2 > y1) {
+                    canvasContext.fillRect(MINIMAP_GUTTER_WIDTH, y1, canvasContext.canvas.width, y2 - y1);
+                }
+                y1 = yy1;
+                y2 = yy2;
+            }
+        }
+        if (y2 > y1) {
+            canvasContext.fillRect(MINIMAP_GUTTER_WIDTH, y1, canvasContext.canvas.width, y2 - y1);
+        }
+    }
+    _renderDecorationsLineHighlights(canvasContext, decorations, highlightedLines, layout, minimapLineHeight) {
+        const highlightColors = ( new Map());
+        for (let i = decorations.length - 1; i >= 0; i--) {
+            const decoration = decorations[i];
+            const minimapOptions = decoration.options.minimap;
+            if (!minimapOptions || minimapOptions.position !== MinimapPosition.Inline) {
+                continue;
+            }
+            const intersection = layout.intersectWithViewport(decoration.range);
+            if (!intersection) {
+                continue;
+            }
+            const [startLineNumber, endLineNumber] = intersection;
+            const decorationColor = minimapOptions.getColor(this._theme.value);
+            if (!decorationColor || decorationColor.isTransparent()) {
+                continue;
+            }
+            let highlightColor = highlightColors.get(( decorationColor.toString()));
+            if (!highlightColor) {
+                highlightColor = ( ( decorationColor.transparent(0.5)).toString());
+                highlightColors.set(( decorationColor.toString()), highlightColor);
+            }
+            canvasContext.fillStyle = highlightColor;
+            for (let line = startLineNumber; line <= endLineNumber; line++) {
+                if (( highlightedLines.has(line))) {
+                    continue;
+                }
+                highlightedLines.set(line, true);
+                const y = layout.getYForLineNumber(startLineNumber, minimapLineHeight);
+                canvasContext.fillRect(MINIMAP_GUTTER_WIDTH, y, canvasContext.canvas.width, minimapLineHeight);
+            }
+        }
+    }
+    _renderSelectionsHighlights(canvasContext, selections, lineOffsetMap, layout, lineHeight, tabSize, characterWidth, canvasInnerWidth) {
+        if (!this._selectionColor || this._selectionColor.isTransparent()) {
+            return;
+        }
+        for (const selection of selections) {
+            const intersection = layout.intersectWithViewport(selection);
+            if (!intersection) {
+                continue;
+            }
+            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) {
+        for (const decoration of decorations) {
+            const minimapOptions = decoration.options.minimap;
+            if (!minimapOptions) {
+                continue;
+            }
+            const intersection = layout.intersectWithViewport(decoration.range);
+            if (!intersection) {
+                continue;
+            }
+            const [startLineNumber, endLineNumber] = intersection;
+            const decorationColor = minimapOptions.getColor(this._theme.value);
+            if (!decorationColor || decorationColor.isTransparent()) {
+                continue;
+            }
+            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: {
+                        const y = layout.getYForLineNumber(line, minimapLineHeight);
+                        const x = 2;
+                        this.renderDecoration(canvasContext, decorationColor, x, y, GUTTER_DECORATION_WIDTH, minimapLineHeight);
+                        continue;
+                    }
+                }
+            }
+        }
+    }
+    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 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 x2 = this.getXOffsetForPosition(lineOffsetMap, lineNumber, endColumn, tabSize, charWidth, canvasInnerWidth);
+        this.renderDecoration(canvasContext, decorationColor, x1, y, x2 - x1, height);
+    }
+    getXOffsetForPosition(lineOffsetMap, lineNumber, column, tabSize, charWidth, canvasInnerWidth) {
+        if (column === 1) {
+            return MINIMAP_GUTTER_WIDTH;
+        }
+        const minimumXOffset = (column - 1) * charWidth;
+        if (minimumXOffset >= canvasInnerWidth) {
+            return canvasInnerWidth;
+        }
+        let lineIndexToXOffset = lineOffsetMap.get(lineNumber);
+        if (!lineIndexToXOffset) {
+            const lineData = this._model.getLineContent(lineNumber);
+            lineIndexToXOffset = [MINIMAP_GUTTER_WIDTH];
+            let prevx = MINIMAP_GUTTER_WIDTH;
+            for (let i = 1; i < lineData.length + 1; i++) {
+                const charCode = lineData.charCodeAt(i - 1);
+                const dx = charCode === 9
+                    ? tabSize * charWidth
+                    : isFullWidthCharacter(charCode)
+                        ? 2 * charWidth
+                        : charWidth;
+                const x = prevx + dx;
+                if (x >= canvasInnerWidth) {
+                    lineIndexToXOffset[i] = canvasInnerWidth;
+                    break;
+                }
+                lineIndexToXOffset[i] = x;
+                prevx = x;
+            }
+            lineOffsetMap.set(lineNumber, lineIndexToXOffset);
+        }
+        if (column - 1 < lineIndexToXOffset.length) {
+            return lineIndexToXOffset[column - 1];
+        }
+        return canvasInnerWidth;
+    }
+    renderDecoration(canvasContext, decorationColor, x, y, width, height) {
+        canvasContext.fillStyle = decorationColor && ( decorationColor.toString()) || '';
+        canvasContext.fillRect(x, y, width, height);
+    }
+    renderLines(layout) {
+        const startLineNumber = layout.startLineNumber;
+        const endLineNumber = layout.endLineNumber;
+        const minimapLineHeight = this._model.options.minimapLineHeight;
+        if (this._lastRenderData && this._lastRenderData.linesEquals(layout)) {
+            const _lastData = this._lastRenderData._get();
+            return ( new RenderData(layout, _lastData.imageData, _lastData.lines));
+        }
+        const imageData = this._getBuffer();
+        if (!imageData) {
+            return null;
+        }
+        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;
+        const background = this._model.options.backgroundColor;
+        const foregroundAlpha = this._model.options.foregroundAlpha;
+        const tokensColorTracker = this._model.tokensColorTracker;
+        const useLighterFont = tokensColorTracker.backgroundIsLight();
+        const renderMinimap = this._model.options.renderMinimap;
+        const charRenderer = this._model.options.charRenderer();
+        const fontScale = this._model.options.fontScale;
+        const minimapCharWidth = this._model.options.minimapCharWidth;
+        const baseCharHeight = (renderMinimap === 1  ? 2  : 2  + 1);
+        const renderMinimapLineHeight = baseCharHeight * fontScale;
+        const innerLinePadding = (minimapLineHeight > renderMinimapLineHeight ? Math.floor((minimapLineHeight - renderMinimapLineHeight) / 2) : 0);
+        const backgroundA = background.a / 255;
+        const renderBackground = ( new RGBA8(
+            Math.round((background.r - defaultBackground.r) * backgroundA + defaultBackground.r),
+            Math.round((background.g - defaultBackground.g) * backgroundA + defaultBackground.g),
+            Math.round((background.b - defaultBackground.b) * backgroundA + defaultBackground.b),
+            255
+        ));
+        let dy = layout.topPaddingLineCount * minimapLineHeight;
+        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);
+            }
+            renderedLines[lineIndex] = ( new MinimapLine(dy));
+            dy += minimapLineHeight;
+        }
+        const dirtyY1 = (_dirtyY1 === -1 ? 0 : _dirtyY1);
+        const dirtyY2 = (_dirtyY2 === -1 ? imageData.height : _dirtyY2);
+        const dirtyHeight = dirtyY2 - dirtyY1;
+        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) {
+        const needed = [];
+        if (!lastRenderData) {
+            for (let i = 0, len = endLineNumber - startLineNumber + 1; i < len; i++) {
+                needed[i] = true;
+            }
+            return [-1, -1, needed];
+        }
+        const _lastData = lastRenderData._get();
+        const lastTargetData = _lastData.imageData.data;
+        const lastStartLineNumber = _lastData.rendLineNumberStart;
+        const lastLines = _lastData.lines;
+        const lastLinesLength = lastLines.length;
+        const WIDTH = target.width;
+        const targetData = target.data;
+        const maxDestPixel = (endLineNumber - startLineNumber + 1) * minimapLineHeight * WIDTH * 4;
+        let dirtyPixel1 = -1;
+        let dirtyPixel2 = -1;
+        let copySourceStart = -1;
+        let copySourceEnd = -1;
+        let copyDestStart = -1;
+        let copyDestEnd = -1;
+        let dest_dy = topPaddingLineCount * minimapLineHeight;
+        for (let lineNumber = startLineNumber; lineNumber <= endLineNumber; lineNumber++) {
+            const lineIndex = lineNumber - startLineNumber;
+            const lastLineIndex = lineNumber - lastStartLineNumber;
+            const source_dy = (lastLineIndex >= 0 && lastLineIndex < lastLinesLength ? lastLines[lastLineIndex].dy : -1);
+            if (source_dy === -1) {
+                needed[lineIndex] = true;
+                dest_dy += minimapLineHeight;
+                continue;
+            }
+            const sourceStart = source_dy * WIDTH * 4;
+            const sourceEnd = (source_dy + minimapLineHeight) * WIDTH * 4;
+            const destStart = dest_dy * WIDTH * 4;
+            const destEnd = (dest_dy + minimapLineHeight) * WIDTH * 4;
+            if (copySourceEnd === sourceStart && copyDestEnd === destStart) {
+                copySourceEnd = sourceEnd;
+                copyDestEnd = destEnd;
+            }
+            else {
+                if (copySourceStart !== -1) {
+                    targetData.set(lastTargetData.subarray(copySourceStart, copySourceEnd), copyDestStart);
+                    if (dirtyPixel1 === -1 && copySourceStart === 0 && copySourceStart === copyDestStart) {
+                        dirtyPixel1 = copySourceEnd;
+                    }
+                    if (dirtyPixel2 === -1 && copySourceEnd === maxDestPixel && copySourceStart === copyDestStart) {
+                        dirtyPixel2 = copySourceStart;
+                    }
+                }
+                copySourceStart = sourceStart;
+                copySourceEnd = sourceEnd;
+                copyDestStart = destStart;
+                copyDestEnd = destEnd;
+            }
+            needed[lineIndex] = false;
+            dest_dy += minimapLineHeight;
+        }
+        if (copySourceStart !== -1) {
+            targetData.set(lastTargetData.subarray(copySourceStart, copySourceEnd), copyDestStart);
+            if (dirtyPixel1 === -1 && copySourceStart === 0 && copySourceStart === copyDestStart) {
+                dirtyPixel1 = copySourceEnd;
+            }
+            if (dirtyPixel2 === -1 && copySourceEnd === maxDestPixel && copySourceStart === copyDestStart) {
+                dirtyPixel2 = copySourceStart;
+            }
+        }
+        const dirtyY1 = (dirtyPixel1 === -1 ? -1 : dirtyPixel1 / (WIDTH * 4));
+        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) {
+        const content = lineData.content;
+        const tokens = lineData.tokens;
+        const maxDx = target.width - charWidth;
+        const force1pxHeight = (minimapLineHeight === 1);
+        let dx = MINIMAP_GUTTER_WIDTH;
+        let charIndex = 0;
+        let tabsCharDelta = 0;
+        for (let tokenIndex = 0, tokensLen = tokens.getCount(); tokenIndex < tokensLen; tokenIndex++) {
+            const tokenEndIndex = tokens.getEndOffset(tokenIndex);
+            const tokenColorId = tokens.getForeground(tokenIndex);
+            const tokenColor = colorTracker.getColor(tokenColorId);
+            for (; charIndex < tokenEndIndex; charIndex++) {
+                if (dx > maxDx) {
+                    return;
+                }
+                const charCode = content.charCodeAt(charIndex);
+                if (charCode === 9 ) {
+                    const insertSpacesCount = tabSize - (charIndex + tabsCharDelta) % tabSize;
+                    tabsCharDelta += insertSpacesCount - 1;
+                    dx += insertSpacesCount * charWidth;
+                }
+                else if (charCode === 32 ) {
+                    dx += charWidth;
+                }
+                else {
+                    const count = isFullWidthCharacter(charCode) ? 2 : 1;
+                    for (let i = 0; i < count; i++) {
+                        if (renderMinimap === 2 ) {
+                            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) {
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+class ContiguousLineMap {
+    constructor(startLineNumber, endLineNumber, defaultValue) {
+        this._startLineNumber = startLineNumber;
+        this._endLineNumber = endLineNumber;
+        this._defaultValue = defaultValue;
+        this._values = [];
+        for (let i = 0, count = this._endLineNumber - this._startLineNumber + 1; i < count; i++) {
+            this._values[i] = defaultValue;
+        }
+    }
+    has(lineNumber) {
+        return (this.get(lineNumber) !== this._defaultValue);
+    }
+    set(lineNumber, value) {
+        if (lineNumber < this._startLineNumber || lineNumber > this._endLineNumber) {
+            return;
+        }
+        this._values[lineNumber - this._startLineNumber] = value;
+    }
+    get(lineNumber) {
+        if (lineNumber < this._startLineNumber || lineNumber > this._endLineNumber) {
+            return this._defaultValue;
+        }
+        return this._values[lineNumber - this._startLineNumber];
+    }
+}
+export { Minimap };