@codingame/monaco-vscode-api 19.1.3 → 20.0.0

package/vscode/src/vs/editor/browser/view/domLineBreaksComputer.js

@@ -18,7 +18,7 @@ class DOMLineBreaksComputerFactory {
     constructor(targetWindow) {
         this.targetWindow = targetWindow;
     }
-    createLineBreaksComputer(fontInfo, tabSize, wrappingColumn, wrappingIndent, wordBreak) {
+    createLineBreaksComputer(fontInfo, tabSize, wrappingColumn, wrappingIndent, wordBreak, wrapOnEscapedLineFeeds) {
         const requests = [];
         const injectedTexts = [];
         return {

package/vscode/src/vs/editor/browser/view/renderingContext.d.ts

@@ -1,7 +1,8 @@
 import { Position } from "../../common/core/position.js";
 import { Range } from "../../common/core/range.js";
 import { ViewportData } from "../../common/viewLayout/viewLinesViewportData.js";
-import { IViewLayout, ViewModelDecoration } from "../../common/viewModel.js";
+import { IViewLayout } from "../../common/viewModel.js";
+import { ViewModelDecoration } from "../../common/viewModel/viewModelDecoration.js";
 export interface IViewLines {
     linesVisibleRangesForRange(range: Range, includeNewLines: boolean): LineVisibleRanges[] | null;
     visibleRangeForPosition(position: Position): HorizontalPosition | null;

package/vscode/src/vs/editor/browser/view/viewUserInputEvents.d.ts

@@ -1,7 +1,7 @@
 import { IKeyboardEvent } from "../../../base/browser/keyboardEvent.js";
 import { IEditorMouseEvent, IMouseTarget, IPartialEditorMouseEvent } from "../editorBrowser.js";
-import { ICoordinatesConverter } from "../../common/viewModel.js";
 import { IMouseWheelEvent } from "../../../base/browser/mouseEvent.js";
+import { ICoordinatesConverter } from "../../common/coordinatesConverter.js";
 export interface EventCallback<T> {
     (event: T): void;
 }

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

@@ -124,12 +124,13 @@ class Widget {
         this._context = context;
         this._viewDomNode = viewDomNode;
         this._actual = actual;
+        const options = this._context.configuration.options;
+        const layoutInfo = options.get(EditorOption.layoutInfo);
+        const allowOverflow = options.get(EditorOption.allowOverflow);
         this.domNode = createFastDomNode(this._actual.getDomNode());
         this.id = this._actual.getId();
-        this.allowEditorOverflow = this._actual.allowEditorOverflow || false;
+        this.allowEditorOverflow = (this._actual.allowEditorOverflow || false) && allowOverflow;
         this.suppressMouseDown = this._actual.suppressMouseDown || false;
-        const options = this._context.configuration.options;
-        const layoutInfo = options.get(EditorOption.layoutInfo);
         this._fixedOverflowWidgets = options.get(EditorOption.fixedOverflowWidgets);
         this._contentWidth = layoutInfo.contentWidth;
         this._contentLeft = layoutInfo.contentLeft;

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

@@ -15,6 +15,7 @@ class EditorScrollbar extends ViewPart {
         const mouseWheelScrollSensitivity = options.get(EditorOption.mouseWheelScrollSensitivity);
         const fastScrollSensitivity = options.get(EditorOption.fastScrollSensitivity);
         const scrollPredominantAxis = options.get(EditorOption.scrollPredominantAxis);
+        const inertialScroll = options.get(EditorOption.inertialScroll);
         const scrollbarOptions = {
             listenOnDomNode: viewDomNode.domNode,
             className: 'editor-scrollable' + ' ' + getThemeTypeSelector(context.theme.type),
@@ -35,6 +36,7 @@ class EditorScrollbar extends ViewPart {
             fastScrollSensitivity: fastScrollSensitivity,
             scrollPredominantAxis: scrollPredominantAxis,
             scrollByPage: scrollbar.scrollByPage,
+            inertialScroll: inertialScroll,
         };
         this.scrollbar = this._register(( new SmoothScrollableElement(
             linesContent.domNode,

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

@@ -34,12 +34,18 @@
 	left: -1px;
 	width: 1px;
 }
-.minimap.autohide {
+.minimap.minimap-autohide-mouseover,
+.minimap.minimap-autohide-scroll {
 	opacity: 0;
 	transition: opacity 0.5s;
 }
-.minimap.autohide:hover {
+.minimap.minimap-autohide-scroll{
+	pointer-events: none;
+}
+.minimap.minimap-autohide-mouseover:hover,
+.minimap.minimap-autohide-scroll.active {
 	opacity: 1;
+	pointer-events: auto;
 }
 .monaco-editor .minimap {
 	z-index: 5;

package/vscode/src/vs/editor/browser/viewParts/minimap/minimap.d.ts

@@ -9,9 +9,10 @@ import { RenderingContext, RestrictedRenderingContext } from "../../view/renderi
 import { ViewContext } from "../../../common/viewModel/viewContext.js";
 import { EditorTheme } from "../../../common/editorTheme.js";
 import * as viewEvents from "../../../common/viewEvents.js";
-import { ViewLineData, ViewModelDecoration } from "../../../common/viewModel.js";
+import { ViewLineData } from "../../../common/viewModel.js";
 import { Selection } from "../../../common/core/selection.js";
 import { TextModelResolvedOptions } from "../../../common/model.js";
+import { ViewModelDecoration } from "../../../common/viewModel/viewModelDecoration.js";
 declare class MinimapOptions {
     readonly renderMinimap: RenderMinimap;
     readonly size: "proportional" | "fill" | "fit";
@@ -20,7 +21,7 @@ declare class MinimapOptions {
     readonly paddingTop: number;
     readonly paddingBottom: number;
     readonly showSlider: "always" | "mouseover";
-    readonly autohide: boolean;
+    readonly autohide: "none" | "mouseover" | "scroll";
     readonly pixelRatio: number;
     readonly typicalHalfwidthCharacterWidth: number;
     readonly lineHeight: number;

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

@@ -18,7 +18,6 @@ import { ColorId } from '../../../common/encodedTokenAttributes.js';
 import { Constants } from './minimapCharSheet.js';
 import { MinimapTokensColorTracker } from '../../../common/viewModel/minimapTokensColorTracker.js';
 import { VerticalRevealType } from '../../../common/viewEvents.js';
-import { ViewModelDecoration } from '../../../common/viewModel.js';
 import '../../../../platform/theme/common/colorUtils.js';
 import '../../../../platform/theme/common/colors/baseColors.js';
 import '../../../../platform/theme/common/colors/chartsColors.js';
@@ -37,6 +36,8 @@ import { MinimapPosition, MinimapSectionHeaderStyle } from '../../../common/mode
 import { createSingleCallFunction } from '../../../../base/common/functional.js';
 import { LRUCache } from '../../../../base/common/map.js';
 import { DEFAULT_FONT_FAMILY } from '../../../../base/browser/fonts.js';
+import { ViewModelDecoration } from '../../../common/viewModel/viewModelDecoration.js';
+import { RunOnceScheduler } from '../../../../base/common/async.js';
 
 registerCss(minimap);
 const POINTER_DRAG_RESET_DISTANCE = 140;
@@ -653,7 +654,7 @@ class Minimap extends ViewPart {
         }
     }
     onScrollChanged(e) {
-        return this._actual.onScrollChanged();
+        return this._actual.onScrollChanged(e);
     }
     onThemeChanged(e) {
         this._actual.onThemeChanged();
@@ -875,6 +876,7 @@ class InnerMinimap extends Disposable {
         super();
         this._renderDecorations = false;
         this._gestureInProgress = false;
+        this._isMouseOverMinimap = false;
         this._theme = theme;
         this._model = model;
         this._lastRenderData = null;
@@ -909,8 +911,17 @@ class InnerMinimap extends Disposable {
         this._sliderHorizontal.setClassName('minimap-slider-horizontal');
         this._slider.appendChild(this._sliderHorizontal);
         this._applyLayout();
+        this._hideDelayedScheduler = this._register(( new RunOnceScheduler(() => this._hideImmediatelyIfMouseIsOutside(), 500)));
+        this._register(addStandardDisposableListener(this._domNode.domNode, EventType.MOUSE_OVER, () => {
+            this._isMouseOverMinimap = true;
+        }));
+        this._register(addStandardDisposableListener(this._domNode.domNode, EventType.MOUSE_LEAVE, () => {
+            this._isMouseOverMinimap = false;
+        }));
         this._pointerDownListener = addStandardDisposableListener(this._domNode.domNode, EventType.POINTER_DOWN, (e) => {
             e.preventDefault();
+            const isMouse = (e.pointerType === 'mouse');
+            const isLeftClick = (e.button === 0);
             const renderMinimap = this._model.options.renderMinimap;
             if (renderMinimap === RenderMinimap.None) {
                 return;
@@ -919,19 +930,21 @@ class InnerMinimap extends Disposable {
                 return;
             }
             if (this._model.options.size !== 'proportional') {
-                if (e.button === 0 && this._lastRenderData) {
+                if (isLeftClick && 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);
+            if (isLeftClick || !isMouse) {
+                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) => {
@@ -965,6 +978,17 @@ class InnerMinimap extends Disposable {
             this._slider.toggleClassName('active', false);
         });
     }
+    _hideSoon() {
+        this._hideDelayedScheduler.cancel();
+        this._hideDelayedScheduler.schedule();
+    }
+    _hideImmediatelyIfMouseIsOutside() {
+        if (this._isMouseOverMinimap) {
+            this._hideSoon();
+            return;
+        }
+        this._domNode.toggleClassName('active', false);
+    }
     _startSliderDragging(e, initialPosY, initialSliderState) {
         if (!e.target || !isElement(e.target)) {
             return;
@@ -1011,8 +1035,11 @@ class InnerMinimap extends Disposable {
         else {
             class_.push('slider-mouseover');
         }
-        if (this._model.options.autohide) {
-            class_.push('autohide');
+        if (this._model.options.autohide === 'mouseover') {
+            class_.push('minimap-autohide-mouseover');
+        }
+        else if (this._model.options.autohide === 'scroll') {
+            class_.push('minimap-autohide-scroll');
         }
         return class_.join(' ');
     }
@@ -1079,7 +1106,11 @@ class InnerMinimap extends Disposable {
         this._lastRenderData?.onLinesInserted(insertFromLineNumber, insertToLineNumber);
         return true;
     }
-    onScrollChanged() {
+    onScrollChanged(e) {
+        if (this._model.options.autohide === 'scroll' && (e.scrollTopChanged || e.scrollHeightChanged)) {
+            this._domNode.toggleClassName('active', true);
+            this._hideSoon();
+        }
         this._renderDecorations = true;
         return true;
     }
@@ -1327,7 +1358,7 @@ class InnerMinimap extends Disposable {
         canvasContext.letterSpacing = sectionHeaderLetterSpacing + 'px';
         canvasContext.font = '500 ' + sectionHeaderFontSize + 'px ' + this._model.options.sectionHeaderFontFamily;
         canvasContext.strokeStyle = separatorStroke;
-        canvasContext.lineWidth = 0.2;
+        canvasContext.lineWidth = 0.4;
         const decorations = this._model.getSectionHeaderDecorationsInViewport(layout.startLineNumber, layout.endLineNumber);
         decorations.sort((a, b) => a.range.startLineNumber - b.range.startLineNumber);
         const fitWidth = InnerMinimap._fitSectionHeader.bind(null, canvasContext, canvasInnerWidth - MINIMAP_GUTTER_WIDTH);

package/vscode/src/vs/editor/browser/viewParts/overlayWidgets/overlayWidgets.d.ts

@@ -19,6 +19,7 @@ export declare class ViewOverlayWidgets extends ViewPart {
     dispose(): void;
     getDomNode(): FastDomNode<HTMLElement>;
     onConfigurationChanged(e: viewEvents.ViewConfigurationChangedEvent): boolean;
+    private _widgetCanOverflow;
     addWidget(widget: IOverlayWidget): void;
     setWidgetPosition(widget: IOverlayWidget, position: IOverlayWidgetPosition | null): boolean;
     removeWidget(widget: IOverlayWidget): void;

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

@@ -45,6 +45,11 @@ class ViewOverlayWidgets extends ViewPart {
         this._editorWidth = layoutInfo.width;
         return true;
     }
+    _widgetCanOverflow(widget) {
+        const options = this._context.configuration.options;
+        const allowOverflow = options.get(EditorOption.allowOverflow);
+        return (widget.allowEditorOverflow || false) && allowOverflow;
+    }
     addWidget(widget) {
         const domNode = createFastDomNode(widget.getDomNode());
         this._widgets[widget.getId()] = {
@@ -54,7 +59,7 @@ class ViewOverlayWidgets extends ViewPart {
         };
         domNode.setPosition('absolute');
         domNode.setAttribute('widgetId', widget.getId());
-        if (widget.allowEditorOverflow) {
+        if (this._widgetCanOverflow(widget)) {
             this.overflowingOverlayWidgetsDomNode.appendChild(domNode);
         }
         else {
@@ -137,7 +142,7 @@ class ViewOverlayWidgets extends ViewPart {
         else {
             const { top, left } = widgetData.preference;
             const fixedOverflowWidgets = this._context.configuration.options.get(EditorOption.fixedOverflowWidgets);
-            if (fixedOverflowWidgets && widgetData.widget.allowEditorOverflow) {
+            if (fixedOverflowWidgets && this._widgetCanOverflow(widgetData.widget)) {
                 const editorBoundingBox = this._viewDomNodeRect;
                 domNode.setTop(top + editorBoundingBox.top);
                 domNode.setLeft(left + editorBoundingBox.left);

package/vscode/src/vs/editor/browser/viewParts/viewCursors/viewCursor.d.ts

@@ -20,6 +20,7 @@ export declare class ViewCursor {
     private readonly _domNode;
     private _cursorStyle;
     private _lineCursorWidth;
+    private _lineCursorHeight;
     private _typicalHalfwidthCharacterWidth;
     private _isVisible;
     private _position;

package/vscode/src/vs/editor/browser/viewParts/viewCursors/viewCursor.js

@@ -33,6 +33,7 @@ class ViewCursor {
         this._cursorStyle = options.get(EditorOption.effectiveCursorStyle);
         this._typicalHalfwidthCharacterWidth = fontInfo.typicalHalfwidthCharacterWidth;
         this._lineCursorWidth = Math.min(options.get(EditorOption.cursorWidth), this._typicalHalfwidthCharacterWidth);
+        this._lineCursorHeight = options.get(EditorOption.cursorHeight);
         this._isVisible = true;
         this._domNode = createFastDomNode(createElement('div'));
         this._domNode.setClassName(`cursor ${MOUSE_CURSOR_TEXT_CSS_CLASS_NAME}`);
@@ -85,6 +86,7 @@ class ViewCursor {
         this._cursorStyle = options.get(EditorOption.effectiveCursorStyle);
         this._typicalHalfwidthCharacterWidth = fontInfo.typicalHalfwidthCharacterWidth;
         this._lineCursorWidth = Math.min(options.get(EditorOption.cursorWidth), this._typicalHalfwidthCharacterWidth);
+        this._lineCursorHeight = options.get(EditorOption.cursorHeight);
         applyFontInfo(this._domNode, fontInfo);
         return true;
     }
@@ -108,6 +110,11 @@ class ViewCursor {
         let textContent = '';
         let textContentClassName = '';
         const [position, nextGrapheme] = this._getGraphemeAwarePosition();
+        const lineHeight = this._context.viewLayout.getLineHeightForLineNumber(position.lineNumber);
+        const lineCursorHeight = (this._lineCursorHeight === 0
+            ? lineHeight
+            : Math.min(lineHeight, this._lineCursorHeight));
+        const lineHeightAdjustment = (lineHeight - lineCursorHeight) / 2;
         if (this._cursorStyle === TextEditorCursorStyle.Line || this._cursorStyle === TextEditorCursorStyle.LineThin) {
             const visibleRange = ctx.visibleRangeForPosition(position);
             if (!visibleRange || visibleRange.outsideRenderedLine) {
@@ -131,14 +138,13 @@ class ViewCursor {
                 paddingLeft = 1;
                 left -= paddingLeft;
             }
-            const top = ctx.getVerticalOffsetForLineNumber(position.lineNumber) - ctx.bigNumbersDelta;
-            const lineHeight = this._context.viewLayout.getLineHeightForLineNumber(position.lineNumber);
+            const top = ctx.getVerticalOffsetForLineNumber(position.lineNumber) - ctx.bigNumbersDelta + lineHeightAdjustment;
             return ( new ViewCursorRenderData(
                 top,
                 left,
                 paddingLeft,
                 width,
-                lineHeight,
+                lineCursorHeight,
                 textContent,
                 textContentClassName
             ));
@@ -167,7 +173,6 @@ class ViewCursor {
             textContentClassName = this._getTokenClassName(position);
         }
         let top = ctx.getVerticalOffsetForLineNumber(position.lineNumber) - ctx.bigNumbersDelta;
-        const lineHeight = this._context.viewLayout.getLineHeightForLineNumber(position.lineNumber);
         let height = lineHeight;
         if (this._cursorStyle === TextEditorCursorStyle.Underline || this._cursorStyle === TextEditorCursorStyle.UnderlineThin) {
             top += lineHeight - 2;

package/vscode/src/vs/editor/browser/viewParts/viewLines/viewLine.d.ts

@@ -22,6 +22,7 @@ export declare class ViewLine implements IVisibleLine {
     onSelectionChanged(): boolean;
     renderLine(lineNumber: number, deltaTop: number, lineHeight: number, viewportData: ViewportData, sb: StringBuilder): boolean;
     layoutLine(lineNumber: number, deltaTop: number, lineHeight: number): void;
+    isRenderedRTL(): boolean;
     getWidth(context: DomReadingContext | null): number;
     getWidthIsFast(): boolean;
     needsMonospaceFontCheck(): boolean;

package/vscode/src/vs/editor/browser/viewParts/viewLines/viewLine.js

@@ -6,10 +6,11 @@ import { RangeUtil } from './rangeUtil.js';
 import { VisibleRanges, FloatHorizontalRange } from '../../view/renderingContext.js';
 import { LineDecoration } from '../../../common/viewLayout/lineDecorations.js';
 import { RenderWhitespace, RenderLineInput, renderViewLine, ForeignElementType, DomPosition } from '../../../common/viewLayout/viewLineRenderer.js';
-import { InlineDecorationType } from '../../../common/viewModel.js';
 import { isHighContrast } from '../../../../platform/theme/common/theme.js';
 import { EditorFontLigatures } from '../../../common/config/editorOptions.js';
 import { OffsetRange } from '../../../common/core/ranges/offsetRange.js';
+import { InlineDecorationType } from '../../../common/viewModel/inlineDecorations.js';
+import { TextDirection } from '../../../common/model.js';
 
 const canUseFastRenderedViewLine = (function () {
     if (isNative) {
@@ -57,7 +58,7 @@ class ViewLine {
         this._options = newOptions;
     }
     onSelectionChanged() {
-        if (isHighContrast(this._options.themeType) || this._renderedViewLine?.getRenderWhitespace() === RenderWhitespace.Selection) {
+        if (isHighContrast(this._options.themeType) || this._renderedViewLine?.input.renderWhitespace === RenderWhitespace.Selection) {
             this._isMaybeInvalid = true;
             return true;
         }
@@ -124,24 +125,43 @@ class ViewLine {
             renderWhitespace,
             options.renderControlCharacters,
             options.fontLigatures !== EditorFontLigatures.OFF,
-            selectionsOnLine
+            selectionsOnLine,
+            lineData.textDirection,
+            options.verticalScrollbarSize
         ));
         if (this._renderedViewLine && this._renderedViewLine.input.equals(renderLineInput)) {
             return false;
         }
-        sb.appendString('<div style="top:');
+        sb.appendString('<div ');
+        if (lineData.textDirection === TextDirection.RTL) {
+            sb.appendString('dir="rtl" ');
+        }
+        else if (lineData.containsRTL) {
+            sb.appendString('dir="ltr" ');
+        }
+        sb.appendString('style="top:');
         sb.appendString(String(deltaTop));
         sb.appendString('px;height:');
         sb.appendString(String(lineHeight));
         sb.appendString('px;line-height:');
         sb.appendString(String(lineHeight));
+        if (lineData.textDirection === TextDirection.RTL) {
+            sb.appendString('px;padding-right:');
+            sb.appendString(String(options.verticalScrollbarSize));
+        }
         sb.appendString('px;" class="');
         sb.appendString(ViewLine.CLASS_NAME);
         sb.appendString('">');
         const output = renderViewLine(renderLineInput, sb);
         sb.appendString('</div>');
         let renderedViewLine = null;
-        if (allowFastRendering && monospaceAssumptionsAreValid && canUseFastRenderedViewLine && lineData.isBasicASCII && options.useMonospaceOptimizations && output.containsForeignElements === ForeignElementType.None) {
+        if (allowFastRendering
+            && monospaceAssumptionsAreValid
+            && canUseFastRenderedViewLine
+            && lineData.isBasicASCII
+            && renderLineInput.isLTR
+            && options.useMonospaceOptimizations
+            && output.containsForeignElements === ForeignElementType.None) {
             renderedViewLine = ( new FastRenderedViewLine(
                 this._renderedViewLine ? this._renderedViewLine.domNode : null,
                 renderLineInput,
@@ -149,7 +169,7 @@ class ViewLine {
             ));
         }
         if (!renderedViewLine) {
-            renderedViewLine = createRenderedLine(this._renderedViewLine ? this._renderedViewLine.domNode : null, renderLineInput, output.characterMapping, output.containsRTL, output.containsForeignElements);
+            renderedViewLine = createRenderedLine(this._renderedViewLine ? this._renderedViewLine.domNode : null, renderLineInput, output.characterMapping, output.containsForeignElements);
         }
         this._renderedViewLine = renderedViewLine;
         return true;
@@ -161,6 +181,12 @@ class ViewLine {
             this._renderedViewLine.domNode.setLineHeight(lineHeight);
         }
     }
+    isRenderedRTL() {
+        if (!this._renderedViewLine) {
+            return false;
+        }
+        return this._renderedViewLine.input.textDirection === TextDirection.RTL;
+    }
     getWidth(context) {
         if (!this._renderedViewLine) {
             return 0;
@@ -244,9 +270,6 @@ class FastRenderedViewLine {
         this._characterMapping = characterMapping;
         this._charWidth = renderLineInput.spaceWidth;
     }
-    getRenderWhitespace() {
-        return this.input.renderWhitespace;
-    }
     getWidth(context) {
         if (!this.domNode || this.input.lineContent.length < Constants.MaxMonospaceDistance) {
             const horizontalOffset = this._characterMapping.getHorizontalOffset(this._characterMapping.length);
@@ -276,7 +299,7 @@ class FastRenderedViewLine {
         return monospaceAssumptionsAreValid;
     }
     toSlowRenderedLine() {
-        return createRenderedLine(this.domNode, this.input, this._characterMapping, false, ForeignElementType.None);
+        return createRenderedLine(this.domNode, this.input, this._characterMapping, ForeignElementType.None);
     }
     getVisibleRangesForRange(lineNumber, startColumn, endColumn, context) {
         const startPosition = this._getColumnPixelOffset(lineNumber, startColumn, context);
@@ -325,7 +348,7 @@ class FastRenderedViewLine {
     }
 }
 class RenderedViewLine {
-    constructor(domNode, renderLineInput, characterMapping, containsRTL, containsForeignElements) {
+    constructor(domNode, renderLineInput, characterMapping, containsForeignElements) {
         this.domNode = domNode;
         this.input = renderLineInput;
         this._characterMapping = characterMapping;
@@ -333,7 +356,7 @@ class RenderedViewLine {
         this._containsForeignElements = containsForeignElements;
         this._cachedWidth = -1;
         this._pixelOffsetCache = null;
-        if (!containsRTL || this._characterMapping.length === 0 ) {
+        if (renderLineInput.isLTR) {
             this._pixelOffsetCache = ( new Float32Array(Math.max(2, this._characterMapping.length + 1)));
             for (let column = 0, len = this._characterMapping.length; column <= len; column++) {
                 this._pixelOffsetCache[column] = -1;
@@ -343,9 +366,6 @@ class RenderedViewLine {
     _getReadingTarget(myDomNode) {
         return myDomNode.domNode.firstChild;
     }
-    getRenderWhitespace() {
-        return this.input.renderWhitespace;
-    }
     getWidth(context) {
         if (!this.domNode) {
             return 0;
@@ -394,7 +414,7 @@ class RenderedViewLine {
         }
     }
     _readPixelOffset(domNode, lineNumber, column, context) {
-        if (this._characterMapping.length === 0) {
+        if (this.input.isLTR && this._characterMapping.length === 0) {
             if (this._containsForeignElements === ForeignElementType.None) {
                 return 0;
             }
@@ -432,7 +452,7 @@ class RenderedViewLine {
             }
             return r[0].left;
         }
-        if (column === this._characterMapping.length && this._isWhitespaceOnly && this._containsForeignElements === ForeignElementType.None) {
+        if (this.input.isLTR && column === this._characterMapping.length && this._isWhitespaceOnly && this._containsForeignElements === ForeignElementType.None) {
             return this.getWidth(context);
         }
         const domPosition = this._characterMapping.getDomPosition(column);
@@ -451,7 +471,7 @@ class RenderedViewLine {
         return result;
     }
     _readRawVisibleRangesForRange(domNode, startColumn, endColumn, context) {
-        if (startColumn === 1 && endColumn === this._characterMapping.length) {
+        if (this.input.isLTR && startColumn === 1 && endColumn === this._characterMapping.length) {
             return [( new FloatHorizontalRange(0, this.getWidth(context)))];
         }
         const startDomPosition = this._characterMapping.getDomPosition(startColumn);
@@ -468,7 +488,7 @@ class WebKitRenderedViewLine extends RenderedViewLine {
         if (!output || output.length === 0 || startColumn === endColumn || (startColumn === 1 && endColumn === this._characterMapping.length)) {
             return output;
         }
-        if (!this.input.containsRTL) {
+        if (this.input.isLTR) {
             const endPixelOffset = this._readPixelOffset(domNode, lineNumber, endColumn, context);
             if (endPixelOffset !== -1) {
                 const lastRange = output[output.length - 1];
@@ -486,23 +506,11 @@ const createRenderedLine = (function () {
     }
     return createNormalRenderedLine;
 })();
-function createWebKitRenderedLine(domNode, renderLineInput, characterMapping, containsRTL, containsForeignElements) {
-    return ( new WebKitRenderedViewLine(
-        domNode,
-        renderLineInput,
-        characterMapping,
-        containsRTL,
-        containsForeignElements
-    ));
+function createWebKitRenderedLine(domNode, renderLineInput, characterMapping, containsForeignElements) {
+    return ( new WebKitRenderedViewLine(domNode, renderLineInput, characterMapping, containsForeignElements));
 }
-function createNormalRenderedLine(domNode, renderLineInput, characterMapping, containsRTL, containsForeignElements) {
-    return ( new RenderedViewLine(
-        domNode,
-        renderLineInput,
-        characterMapping,
-        containsRTL,
-        containsForeignElements
-    ));
+function createNormalRenderedLine(domNode, renderLineInput, characterMapping, containsForeignElements) {
+    return ( new RenderedViewLine(domNode, renderLineInput, characterMapping, containsForeignElements));
 }
 function getColumnOfNodeOffset(characterMapping, spanNode, offset) {
     const spanNodeTextContentLength = spanNode.textContent.length;

package/vscode/src/vs/editor/browser/viewParts/viewLines/viewLineOptions.d.ts

@@ -13,6 +13,7 @@ export declare class ViewLineOptions {
     readonly lineHeight: number;
     readonly stopRenderingLineAfter: number;
     readonly fontLigatures: string;
+    readonly verticalScrollbarSize: number;
     readonly useGpu: boolean;
     constructor(config: IEditorConfiguration, themeType: ColorScheme);
     equals(other: ViewLineOptions): boolean;

package/vscode/src/vs/editor/browser/viewParts/viewLines/viewLineOptions.js

@@ -18,6 +18,7 @@ class ViewLineOptions {
         this.lineHeight = options.get(EditorOption.lineHeight);
         this.stopRenderingLineAfter = options.get(EditorOption.stopRenderingLineAfter);
         this.fontLigatures = options.get(EditorOption.fontLigatures);
+        this.verticalScrollbarSize = options.get(EditorOption.scrollbar).verticalScrollbarSize;
         this.useGpu = options.get(EditorOption.experimentalGpuAcceleration) === 'on';
     }
     equals(other) {
@@ -33,6 +34,7 @@ class ViewLineOptions {
             && this.lineHeight === other.lineHeight
             && this.stopRenderingLineAfter === other.stopRenderingLineAfter
             && this.fontLigatures === other.fontLigatures
+            && this.verticalScrollbarSize === other.verticalScrollbarSize
             && this.useGpu === other.useGpu);
     }
 }

package/vscode/src/vs/editor/browser/viewParts/viewLines/viewLines.css

@@ -36,6 +36,7 @@
 	white-space: nowrap;
 }
 .monaco-editor .view-line {
+	box-sizing: border-box;
 	position: absolute;
 	width: 100%;
 }

package/vscode/src/vs/editor/browser/viewParts/viewLines/viewLines.d.ts

@@ -50,6 +50,7 @@ export declare class ViewLines extends ViewPart implements IViewLines {
     getLineWidth(lineNumber: number): number;
     linesVisibleRangesForRange(_range: Range, includeNewLines: boolean): LineVisibleRanges[] | null;
     private _visibleRangesForLineRange;
+    private _lineIsRenderedRTL;
     visibleRangeForPosition(position: Position): HorizontalPosition | null;
     updateLineWidths(): void;
     private _updateLineWidthsFast;