@codingame/monaco-vscode-api 1.85.6 → 2.0.0-v2.1

package/vscode/src/vs/editor/browser/viewParts/overviewRuler/decorationsOverviewRuler.js

@@ -0,0 +1,377 @@
+import { createFastDomNode } from '../../../../base/browser/fastDomNode.js';
+import { Color } from '../../../../base/common/color.js';
+import { ViewPart } from '../../view/viewPart.js';
+import { Position } from '../../../common/core/position.js';
+import { TokenizationRegistry } from '../../../common/languages.js';
+import { editorOverviewRulerBorder, editorCursorForeground, editorOverviewRulerBackground } from '../../../common/core/editorColorRegistry.js';
+import { OverviewRulerDecorationsGroup } from '../../../common/viewModel.js';
+import { equals } from '../../../../base/common/arrays.js';
+class Settings {
+    constructor(config, theme) {
+        const options = config.options;
+        this.lineHeight = options.get(66 );
+        this.pixelRatio = options.get(141 );
+        this.overviewRulerLanes = options.get(82 );
+        this.renderBorder = options.get(81 );
+        const borderColor = theme.getColor(editorOverviewRulerBorder);
+        this.borderColor = borderColor ? ( borderColor.toString()) : null;
+        this.hideCursor = options.get(59 );
+        const cursorColor = theme.getColor(editorCursorForeground);
+        this.cursorColor = cursorColor ? ( ( cursorColor.transparent(0.7)).toString()) : null;
+        this.themeType = theme.type;
+        const minimapOpts = options.get(72 );
+        const minimapEnabled = minimapOpts.enabled;
+        const minimapSide = minimapOpts.side;
+        const themeColor = theme.getColor(editorOverviewRulerBackground);
+        const defaultBackground = TokenizationRegistry.getDefaultBackground();
+        if (themeColor) {
+            this.backgroundColor = themeColor;
+        }
+        else if (minimapEnabled && minimapSide === 'right') {
+            this.backgroundColor = defaultBackground;
+        }
+        else {
+            this.backgroundColor = null;
+        }
+        const layoutInfo = options.get(143 );
+        const position = layoutInfo.overviewRuler;
+        this.top = position.top;
+        this.right = position.right;
+        this.domWidth = position.width;
+        this.domHeight = position.height;
+        if (this.overviewRulerLanes === 0) {
+            this.canvasWidth = 0;
+            this.canvasHeight = 0;
+        }
+        else {
+            this.canvasWidth = (this.domWidth * this.pixelRatio) | 0;
+            this.canvasHeight = (this.domHeight * this.pixelRatio) | 0;
+        }
+        const [x, w] = this._initLanes(1, this.canvasWidth, this.overviewRulerLanes);
+        this.x = x;
+        this.w = w;
+    }
+    _initLanes(canvasLeftOffset, canvasWidth, laneCount) {
+        const remainingWidth = canvasWidth - canvasLeftOffset;
+        if (laneCount >= 3) {
+            const leftWidth = Math.floor(remainingWidth / 3);
+            const rightWidth = Math.floor(remainingWidth / 3);
+            const centerWidth = remainingWidth - leftWidth - rightWidth;
+            const leftOffset = canvasLeftOffset;
+            const centerOffset = leftOffset + leftWidth;
+            const rightOffset = leftOffset + leftWidth + centerWidth;
+            return [
+                [
+                    0,
+                    leftOffset,
+                    centerOffset,
+                    leftOffset,
+                    rightOffset,
+                    leftOffset,
+                    centerOffset,
+                    leftOffset,
+                ], [
+                    0,
+                    leftWidth,
+                    centerWidth,
+                    leftWidth + centerWidth,
+                    rightWidth,
+                    leftWidth + centerWidth + rightWidth,
+                    centerWidth + rightWidth,
+                    leftWidth + centerWidth + rightWidth,
+                ]
+            ];
+        }
+        else if (laneCount === 2) {
+            const leftWidth = Math.floor(remainingWidth / 2);
+            const rightWidth = remainingWidth - leftWidth;
+            const leftOffset = canvasLeftOffset;
+            const rightOffset = leftOffset + leftWidth;
+            return [
+                [
+                    0,
+                    leftOffset,
+                    leftOffset,
+                    leftOffset,
+                    rightOffset,
+                    leftOffset,
+                    leftOffset,
+                    leftOffset,
+                ], [
+                    0,
+                    leftWidth,
+                    leftWidth,
+                    leftWidth,
+                    rightWidth,
+                    leftWidth + rightWidth,
+                    leftWidth + rightWidth,
+                    leftWidth + rightWidth,
+                ]
+            ];
+        }
+        else {
+            const offset = canvasLeftOffset;
+            const width = remainingWidth;
+            return [
+                [
+                    0,
+                    offset,
+                    offset,
+                    offset,
+                    offset,
+                    offset,
+                    offset,
+                    offset,
+                ], [
+                    0,
+                    width,
+                    width,
+                    width,
+                    width,
+                    width,
+                    width,
+                    width,
+                ]
+            ];
+        }
+    }
+    equals(other) {
+        return (this.lineHeight === other.lineHeight
+            && this.pixelRatio === other.pixelRatio
+            && this.overviewRulerLanes === other.overviewRulerLanes
+            && this.renderBorder === other.renderBorder
+            && this.borderColor === other.borderColor
+            && this.hideCursor === other.hideCursor
+            && this.cursorColor === other.cursorColor
+            && this.themeType === other.themeType
+            && Color.equals(this.backgroundColor, other.backgroundColor)
+            && this.top === other.top
+            && this.right === other.right
+            && this.domWidth === other.domWidth
+            && this.domHeight === other.domHeight
+            && this.canvasWidth === other.canvasWidth
+            && this.canvasHeight === other.canvasHeight);
+    }
+}
+class DecorationsOverviewRuler extends ViewPart {
+    constructor(context) {
+        super(context);
+        this._actualShouldRender = 0 ;
+        this._renderedDecorations = [];
+        this._renderedCursorPositions = [];
+        this._domNode = createFastDomNode(document.createElement('canvas'));
+        this._domNode.setClassName('decorationsOverviewRuler');
+        this._domNode.setPosition('absolute');
+        this._domNode.setLayerHinting(true);
+        this._domNode.setContain('strict');
+        this._domNode.setAttribute('aria-hidden', 'true');
+        this._updateSettings(false);
+        this._tokensColorTrackerListener = TokenizationRegistry.onDidChange((e) => {
+            if (e.changedColorMap) {
+                this._updateSettings(true);
+            }
+        });
+        this._cursorPositions = [];
+    }
+    dispose() {
+        super.dispose();
+        this._tokensColorTrackerListener.dispose();
+    }
+    _updateSettings(renderNow) {
+        const newSettings = ( new Settings(this._context.configuration, this._context.theme));
+        if (this._settings && this._settings.equals(newSettings)) {
+            return false;
+        }
+        this._settings = newSettings;
+        this._domNode.setTop(this._settings.top);
+        this._domNode.setRight(this._settings.right);
+        this._domNode.setWidth(this._settings.domWidth);
+        this._domNode.setHeight(this._settings.domHeight);
+        this._domNode.domNode.width = this._settings.canvasWidth;
+        this._domNode.domNode.height = this._settings.canvasHeight;
+        if (renderNow) {
+            this._render();
+        }
+        return true;
+    }
+    _markRenderingIsNeeded() {
+        this._actualShouldRender = 2 ;
+        return true;
+    }
+    _markRenderingIsMaybeNeeded() {
+        this._actualShouldRender = 1 ;
+        return true;
+    }
+    onConfigurationChanged(e) {
+        return this._updateSettings(false) ? this._markRenderingIsNeeded() : false;
+    }
+    onCursorStateChanged(e) {
+        this._cursorPositions = [];
+        for (let i = 0, len = e.selections.length; i < len; i++) {
+            this._cursorPositions[i] = e.selections[i].getPosition();
+        }
+        this._cursorPositions.sort(Position.compare);
+        return this._markRenderingIsMaybeNeeded();
+    }
+    onDecorationsChanged(e) {
+        if (e.affectsOverviewRuler) {
+            return this._markRenderingIsMaybeNeeded();
+        }
+        return false;
+    }
+    onFlushed(e) {
+        return this._markRenderingIsNeeded();
+    }
+    onScrollChanged(e) {
+        return e.scrollHeightChanged ? this._markRenderingIsNeeded() : false;
+    }
+    onZonesChanged(e) {
+        return this._markRenderingIsNeeded();
+    }
+    onThemeChanged(e) {
+        return this._updateSettings(false) ? this._markRenderingIsNeeded() : false;
+    }
+    getDomNode() {
+        return this._domNode.domNode;
+    }
+    prepareRender(ctx) {
+    }
+    render(editorCtx) {
+        this._render();
+        this._actualShouldRender = 0 ;
+    }
+    _render() {
+        const backgroundColor = this._settings.backgroundColor;
+        if (this._settings.overviewRulerLanes === 0) {
+            this._domNode.setBackgroundColor(backgroundColor ? Color.Format.CSS.formatHexA(backgroundColor) : '');
+            this._domNode.setDisplay('none');
+            return;
+        }
+        const decorations = this._context.viewModel.getAllOverviewRulerDecorations(this._context.theme);
+        decorations.sort(OverviewRulerDecorationsGroup.compareByRenderingProps);
+        if (this._actualShouldRender === 1  && !OverviewRulerDecorationsGroup.equalsArr(this._renderedDecorations, decorations)) {
+            this._actualShouldRender = 2 ;
+        }
+        if (this._actualShouldRender === 1  && !equals(this._renderedCursorPositions, this._cursorPositions, (a, b) => a.lineNumber === b.lineNumber)) {
+            this._actualShouldRender = 2 ;
+        }
+        if (this._actualShouldRender === 1 ) {
+            return;
+        }
+        this._renderedDecorations = decorations;
+        this._renderedCursorPositions = this._cursorPositions;
+        this._domNode.setDisplay('block');
+        const canvasWidth = this._settings.canvasWidth;
+        const canvasHeight = this._settings.canvasHeight;
+        const lineHeight = this._settings.lineHeight;
+        const viewLayout = this._context.viewLayout;
+        const outerHeight = this._context.viewLayout.getScrollHeight();
+        const heightRatio = canvasHeight / outerHeight;
+        const minDecorationHeight = (6  * this._settings.pixelRatio) | 0;
+        const halfMinDecorationHeight = (minDecorationHeight / 2) | 0;
+        const canvasCtx = this._domNode.domNode.getContext('2d');
+        if (backgroundColor) {
+            if (backgroundColor.isOpaque()) {
+                canvasCtx.fillStyle = Color.Format.CSS.formatHexA(backgroundColor);
+                canvasCtx.fillRect(0, 0, canvasWidth, canvasHeight);
+            }
+            else {
+                canvasCtx.clearRect(0, 0, canvasWidth, canvasHeight);
+                canvasCtx.fillStyle = Color.Format.CSS.formatHexA(backgroundColor);
+                canvasCtx.fillRect(0, 0, canvasWidth, canvasHeight);
+            }
+        }
+        else {
+            canvasCtx.clearRect(0, 0, canvasWidth, canvasHeight);
+        }
+        const x = this._settings.x;
+        const w = this._settings.w;
+        for (const decorationGroup of decorations) {
+            const color = decorationGroup.color;
+            const decorationGroupData = decorationGroup.data;
+            canvasCtx.fillStyle = color;
+            let prevLane = 0;
+            let prevY1 = 0;
+            let prevY2 = 0;
+            for (let i = 0, len = decorationGroupData.length / 3; i < len; i++) {
+                const lane = decorationGroupData[3 * i];
+                const startLineNumber = decorationGroupData[3 * i + 1];
+                const endLineNumber = decorationGroupData[3 * i + 2];
+                let y1 = (viewLayout.getVerticalOffsetForLineNumber(startLineNumber) * heightRatio) | 0;
+                let y2 = ((viewLayout.getVerticalOffsetForLineNumber(endLineNumber) + lineHeight) * heightRatio) | 0;
+                const height = y2 - y1;
+                if (height < minDecorationHeight) {
+                    let yCenter = ((y1 + y2) / 2) | 0;
+                    if (yCenter < halfMinDecorationHeight) {
+                        yCenter = halfMinDecorationHeight;
+                    }
+                    else if (yCenter + halfMinDecorationHeight > canvasHeight) {
+                        yCenter = canvasHeight - halfMinDecorationHeight;
+                    }
+                    y1 = yCenter - halfMinDecorationHeight;
+                    y2 = yCenter + halfMinDecorationHeight;
+                }
+                if (y1 > prevY2 + 1 || lane !== prevLane) {
+                    if (i !== 0) {
+                        canvasCtx.fillRect(x[prevLane], prevY1, w[prevLane], prevY2 - prevY1);
+                    }
+                    prevLane = lane;
+                    prevY1 = y1;
+                    prevY2 = y2;
+                }
+                else {
+                    if (y2 > prevY2) {
+                        prevY2 = y2;
+                    }
+                }
+            }
+            canvasCtx.fillRect(x[prevLane], prevY1, w[prevLane], prevY2 - prevY1);
+        }
+        if (!this._settings.hideCursor && this._settings.cursorColor) {
+            const cursorHeight = (2 * this._settings.pixelRatio) | 0;
+            const halfCursorHeight = (cursorHeight / 2) | 0;
+            const cursorX = this._settings.x[7 ];
+            const cursorW = this._settings.w[7 ];
+            canvasCtx.fillStyle = this._settings.cursorColor;
+            let prevY1 = -100;
+            let prevY2 = -100;
+            for (let i = 0, len = this._cursorPositions.length; i < len; i++) {
+                const cursor = this._cursorPositions[i];
+                let yCenter = (viewLayout.getVerticalOffsetForLineNumber(cursor.lineNumber) * heightRatio) | 0;
+                if (yCenter < halfCursorHeight) {
+                    yCenter = halfCursorHeight;
+                }
+                else if (yCenter + halfCursorHeight > canvasHeight) {
+                    yCenter = canvasHeight - halfCursorHeight;
+                }
+                const y1 = yCenter - halfCursorHeight;
+                const y2 = y1 + cursorHeight;
+                if (y1 > prevY2 + 1) {
+                    if (i !== 0) {
+                        canvasCtx.fillRect(cursorX, prevY1, cursorW, prevY2 - prevY1);
+                    }
+                    prevY1 = y1;
+                    prevY2 = y2;
+                }
+                else {
+                    if (y2 > prevY2) {
+                        prevY2 = y2;
+                    }
+                }
+            }
+            canvasCtx.fillRect(cursorX, prevY1, cursorW, prevY2 - prevY1);
+        }
+        if (this._settings.renderBorder && this._settings.borderColor && this._settings.overviewRulerLanes > 0) {
+            canvasCtx.beginPath();
+            canvasCtx.lineWidth = 1;
+            canvasCtx.strokeStyle = this._settings.borderColor;
+            canvasCtx.moveTo(0, 0);
+            canvasCtx.lineTo(0, canvasHeight);
+            canvasCtx.stroke();
+            canvasCtx.moveTo(0, 0);
+            canvasCtx.lineTo(canvasWidth, 0);
+            canvasCtx.stroke();
+        }
+    }
+}
+export { DecorationsOverviewRuler };

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

@@ -0,0 +1,124 @@
+import { createFastDomNode } from '../../../../base/browser/fastDomNode.js';
+import { OverviewZoneManager } from '../../../common/viewModel/overviewZoneManager.js';
+import { ViewEventHandler } from '../../../common/viewEventHandler.js';
+class OverviewRuler extends ViewEventHandler {
+    constructor(context, cssClassName) {
+        super();
+        this._context = context;
+        const options = this._context.configuration.options;
+        this._domNode = createFastDomNode(document.createElement('canvas'));
+        this._domNode.setClassName(cssClassName);
+        this._domNode.setPosition('absolute');
+        this._domNode.setLayerHinting(true);
+        this._domNode.setContain('strict');
+        this._zoneManager = ( new OverviewZoneManager(
+            (lineNumber) => this._context.viewLayout.getVerticalOffsetForLineNumber(lineNumber)
+        ));
+        this._zoneManager.setDOMWidth(0);
+        this._zoneManager.setDOMHeight(0);
+        this._zoneManager.setOuterHeight(this._context.viewLayout.getScrollHeight());
+        this._zoneManager.setLineHeight(options.get(66 ));
+        this._zoneManager.setPixelRatio(options.get(141 ));
+        this._context.addEventHandler(this);
+    }
+    dispose() {
+        this._context.removeEventHandler(this);
+        super.dispose();
+    }
+    onConfigurationChanged(e) {
+        const options = this._context.configuration.options;
+        if (e.hasChanged(66 )) {
+            this._zoneManager.setLineHeight(options.get(66 ));
+            this._render();
+        }
+        if (e.hasChanged(141 )) {
+            this._zoneManager.setPixelRatio(options.get(141 ));
+            this._domNode.setWidth(this._zoneManager.getDOMWidth());
+            this._domNode.setHeight(this._zoneManager.getDOMHeight());
+            this._domNode.domNode.width = this._zoneManager.getCanvasWidth();
+            this._domNode.domNode.height = this._zoneManager.getCanvasHeight();
+            this._render();
+        }
+        return true;
+    }
+    onFlushed(e) {
+        this._render();
+        return true;
+    }
+    onScrollChanged(e) {
+        if (e.scrollHeightChanged) {
+            this._zoneManager.setOuterHeight(e.scrollHeight);
+            this._render();
+        }
+        return true;
+    }
+    onZonesChanged(e) {
+        this._render();
+        return true;
+    }
+    getDomNode() {
+        return this._domNode.domNode;
+    }
+    setLayout(position) {
+        this._domNode.setTop(position.top);
+        this._domNode.setRight(position.right);
+        let hasChanged = false;
+        hasChanged = this._zoneManager.setDOMWidth(position.width) || hasChanged;
+        hasChanged = this._zoneManager.setDOMHeight(position.height) || hasChanged;
+        if (hasChanged) {
+            this._domNode.setWidth(this._zoneManager.getDOMWidth());
+            this._domNode.setHeight(this._zoneManager.getDOMHeight());
+            this._domNode.domNode.width = this._zoneManager.getCanvasWidth();
+            this._domNode.domNode.height = this._zoneManager.getCanvasHeight();
+            this._render();
+        }
+    }
+    setZones(zones) {
+        this._zoneManager.setZones(zones);
+        this._render();
+    }
+    _render() {
+        if (this._zoneManager.getOuterHeight() === 0) {
+            return false;
+        }
+        const width = this._zoneManager.getCanvasWidth();
+        const height = this._zoneManager.getCanvasHeight();
+        const colorZones = this._zoneManager.resolveColorZones();
+        const id2Color = this._zoneManager.getId2Color();
+        const ctx = this._domNode.domNode.getContext('2d');
+        ctx.clearRect(0, 0, width, height);
+        if (colorZones.length > 0) {
+            this._renderOneLane(ctx, colorZones, id2Color, width);
+        }
+        return true;
+    }
+    _renderOneLane(ctx, colorZones, id2Color, width) {
+        let currentColorId = 0;
+        let currentFrom = 0;
+        let currentTo = 0;
+        for (const zone of colorZones) {
+            const zoneColorId = zone.colorId;
+            const zoneFrom = zone.from;
+            const zoneTo = zone.to;
+            if (zoneColorId !== currentColorId) {
+                ctx.fillRect(0, currentFrom, width, currentTo - currentFrom);
+                currentColorId = zoneColorId;
+                ctx.fillStyle = id2Color[currentColorId];
+                currentFrom = zoneFrom;
+                currentTo = zoneTo;
+            }
+            else {
+                if (currentTo >= zoneFrom) {
+                    currentTo = Math.max(currentTo, zoneTo);
+                }
+                else {
+                    ctx.fillRect(0, currentFrom, width, currentTo - currentFrom);
+                    currentFrom = zoneFrom;
+                    currentTo = zoneTo;
+                }
+            }
+        }
+        ctx.fillRect(0, currentFrom, width, currentTo - currentFrom);
+    }
+}
+export { OverviewRuler };

package/vscode/src/vs/editor/browser/viewParts/rulers/rulers.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-editor .view-ruler{box-shadow:1px 0 0 0 var(--vscode-editorRuler-foreground) inset;position:absolute;top:0}";
+n(css,{});
+export { css, css as default };

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

@@ -0,0 +1,68 @@
+import './rulers.css.js';
+import { createFastDomNode } from '../../../../base/browser/fastDomNode.js';
+import { ViewPart } from '../../view/viewPart.js';
+class Rulers extends ViewPart {
+    constructor(context) {
+        super(context);
+        this.domNode = createFastDomNode(document.createElement('div'));
+        this.domNode.setAttribute('role', 'presentation');
+        this.domNode.setAttribute('aria-hidden', 'true');
+        this.domNode.setClassName('view-rulers');
+        this._renderedRulers = [];
+        const options = this._context.configuration.options;
+        this._rulers = options.get(101 );
+        this._typicalHalfwidthCharacterWidth = options.get(50 ).typicalHalfwidthCharacterWidth;
+    }
+    dispose() {
+        super.dispose();
+    }
+    onConfigurationChanged(e) {
+        const options = this._context.configuration.options;
+        this._rulers = options.get(101 );
+        this._typicalHalfwidthCharacterWidth = options.get(50 ).typicalHalfwidthCharacterWidth;
+        return true;
+    }
+    onScrollChanged(e) {
+        return e.scrollHeightChanged;
+    }
+    prepareRender(ctx) {
+    }
+    _ensureRulersCount() {
+        const currentCount = this._renderedRulers.length;
+        const desiredCount = this._rulers.length;
+        if (currentCount === desiredCount) {
+            return;
+        }
+        if (currentCount < desiredCount) {
+            const { tabSize } = this._context.viewModel.model.getOptions();
+            const rulerWidth = tabSize;
+            let addCount = desiredCount - currentCount;
+            while (addCount > 0) {
+                const node = createFastDomNode(document.createElement('div'));
+                node.setClassName('view-ruler');
+                node.setWidth(rulerWidth);
+                this.domNode.appendChild(node);
+                this._renderedRulers.push(node);
+                addCount--;
+            }
+            return;
+        }
+        let removeCount = currentCount - desiredCount;
+        while (removeCount > 0) {
+            const node = this._renderedRulers.pop();
+            this.domNode.removeChild(node);
+            removeCount--;
+        }
+    }
+    render(ctx) {
+        this._ensureRulersCount();
+        for (let i = 0, len = this._rulers.length; i < len; i++) {
+            const node = this._renderedRulers[i];
+            const ruler = this._rulers[i];
+            node.setBoxShadow(ruler.color ? `1px 0 0 0 ${ruler.color} inset` : ``);
+            node.setHeight(Math.min(ctx.scrollHeight, 1000000));
+            node.setLeft(ruler.column * this._typicalHalfwidthCharacterWidth);
+        }
+    }
+}
+export { Rulers };

package/vscode/src/vs/editor/browser/viewParts/scrollDecoration/scrollDecoration.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-editor .scroll-decoration{box-shadow:var(--vscode-scrollbar-shadow) 0 6px 6px -6px inset;height:6px;left:0;position:absolute;top:0}";
+n(css,{});
+export { css, css as default };

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

@@ -0,0 +1,61 @@
+import './scrollDecoration.css.js';
+import { createFastDomNode } from '../../../../base/browser/fastDomNode.js';
+import { ViewPart } from '../../view/viewPart.js';
+class ScrollDecorationViewPart extends ViewPart {
+    constructor(context) {
+        super(context);
+        this._scrollTop = 0;
+        this._width = 0;
+        this._updateWidth();
+        this._shouldShow = false;
+        const options = this._context.configuration.options;
+        const scrollbar = options.get(102 );
+        this._useShadows = scrollbar.useShadows;
+        this._domNode = createFastDomNode(document.createElement('div'));
+        this._domNode.setAttribute('role', 'presentation');
+        this._domNode.setAttribute('aria-hidden', 'true');
+    }
+    dispose() {
+        super.dispose();
+    }
+    _updateShouldShow() {
+        const newShouldShow = (this._useShadows && this._scrollTop > 0);
+        if (this._shouldShow !== newShouldShow) {
+            this._shouldShow = newShouldShow;
+            return true;
+        }
+        return false;
+    }
+    getDomNode() {
+        return this._domNode;
+    }
+    _updateWidth() {
+        const options = this._context.configuration.options;
+        const layoutInfo = options.get(143 );
+        if (layoutInfo.minimap.renderMinimap === 0 || (layoutInfo.minimap.minimapWidth > 0 && layoutInfo.minimap.minimapLeft === 0)) {
+            this._width = layoutInfo.width;
+        }
+        else {
+            this._width = layoutInfo.width - layoutInfo.verticalScrollbarWidth;
+        }
+    }
+    onConfigurationChanged(e) {
+        const options = this._context.configuration.options;
+        const scrollbar = options.get(102 );
+        this._useShadows = scrollbar.useShadows;
+        this._updateWidth();
+        this._updateShouldShow();
+        return true;
+    }
+    onScrollChanged(e) {
+        this._scrollTop = e.scrollTop;
+        return this._updateShouldShow();
+    }
+    prepareRender(ctx) {
+    }
+    render(ctx) {
+        this._domNode.setWidth(this._width);
+        this._domNode.setClassName(this._shouldShow ? 'scroll-decoration' : '');
+    }
+}
+export { ScrollDecorationViewPart };

package/vscode/src/vs/editor/browser/viewParts/selections/selections.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-editor .lines-content .cslr{position:absolute}.monaco-editor .focused .selected-text{background-color:var(--vscode-editor-selectionBackground)}.monaco-editor .selected-text{background-color:var(--vscode-editor-inactiveSelectionBackground)}.monaco-editor\t\t\t.top-left-radius{border-top-left-radius:3px}.monaco-editor\t\t\t.bottom-left-radius{border-bottom-left-radius:3px}.monaco-editor\t\t\t.top-right-radius{border-top-right-radius:3px}.monaco-editor\t\t\t.bottom-right-radius{border-bottom-right-radius:3px}.monaco-editor.hc-black .top-left-radius{border-top-left-radius:0}.monaco-editor.hc-black .bottom-left-radius{border-bottom-left-radius:0}.monaco-editor.hc-black .top-right-radius{border-top-right-radius:0}.monaco-editor.hc-black .bottom-right-radius{border-bottom-right-radius:0}.monaco-editor.hc-light .top-left-radius{border-top-left-radius:0}.monaco-editor.hc-light .bottom-left-radius{border-bottom-left-radius:0}.monaco-editor.hc-light .top-right-radius{border-top-right-radius:0}.monaco-editor.hc-light .bottom-right-radius{border-bottom-right-radius:0}";
+n(css,{});
+export { css, css as default };