@codingame/monaco-vscode-api 9.0.3 → 10.0.0

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

@@ -0,0 +1,40 @@
+class ViewLineOptions {
+    constructor(config, themeType) {
+        this.themeType = themeType;
+        const options = config.options;
+        const fontInfo = options.get(52 );
+        const experimentalWhitespaceRendering = options.get(40 );
+        if (experimentalWhitespaceRendering === 'off') {
+            this.renderWhitespace = options.get(102 );
+        }
+        else {
+            this.renderWhitespace = 'none';
+        }
+        this.renderControlCharacters = options.get(97 );
+        this.spaceWidth = fontInfo.spaceWidth;
+        this.middotWidth = fontInfo.middotWidth;
+        this.wsmiddotWidth = fontInfo.wsmiddotWidth;
+        this.useMonospaceOptimizations = (fontInfo.isMonospace
+            && !options.get(33 ));
+        this.canUseHalfwidthRightwardsArrow = fontInfo.canUseHalfwidthRightwardsArrow;
+        this.lineHeight = options.get(69 );
+        this.stopRenderingLineAfter = options.get(120 );
+        this.fontLigatures = options.get(53 );
+        this.useGpu = options.get(39 ) === 'on';
+    }
+    equals(other) {
+        return (this.themeType === other.themeType
+            && this.renderWhitespace === other.renderWhitespace
+            && this.renderControlCharacters === other.renderControlCharacters
+            && this.spaceWidth === other.spaceWidth
+            && this.middotWidth === other.middotWidth
+            && this.wsmiddotWidth === other.wsmiddotWidth
+            && this.useMonospaceOptimizations === other.useMonospaceOptimizations
+            && this.canUseHalfwidthRightwardsArrow === other.canUseHalfwidthRightwardsArrow
+            && this.lineHeight === other.lineHeight
+            && this.stopRenderingLineAfter === other.stopRenderingLineAfter
+            && this.fontLigatures === other.fontLigatures
+            && this.useGpu === other.useGpu);
+    }
+}
+export { ViewLineOptions };

package/vscode/src/vs/editor/browser/viewParts/{lines → viewLines}/viewLines.js

@@ -1,19 +1,16 @@
 import { MOUSE_CURSOR_TEXT_CSS_CLASS_NAME } from '../../../../base/browser/ui/mouseCursor/mouseCursor.js';
 import { RunOnceScheduler } from '../../../../base/common/async.js';
 import { isLinux } from '../../../../base/common/platform.js';
-import { Constants } from '../../../../base/common/uint.js';
 import './viewLines.css.js';
 import { applyFontInfo } from '../../config/domFontInfo.js';
 import { LineVisibleRanges, HorizontalRange, HorizontalPosition } from '../../view/renderingContext.js';
 import { VisibleLinesCollection } from '../../view/viewLayer.js';
-import { ViewPart, PartFingerprints, PartFingerprint } from '../../view/viewPart.js';
+import { ViewPart, PartFingerprints } from '../../view/viewPart.js';
 import { DomReadingContext } from './domReadingContext.js';
-import { ViewLineOptions, ViewLine } from './viewLine.js';
-import { EditorOption } from '../../../common/config/editorOptions.js';
+import { ViewLine } from './viewLine.js';
 import { Position } from '../../../common/core/position.js';
 import { Range } from '../../../common/core/range.js';
-import { ScrollType } from '../../../common/editorCommon.js';
-import { VerticalRevealType } from '../../../common/viewEvents.js';
+import { ViewLineOptions } from './viewLineOptions.js';
 class LastRenderedData {
     constructor() {
         this._currentVisibleRange = ( new Range(1, 1, 1, 1));
@@ -64,15 +61,15 @@ class ViewLines extends ViewPart {
         super(context);
         const conf = this._context.configuration;
         const options = this._context.configuration.options;
-        const fontInfo = options.get(EditorOption.fontInfo);
-        const wrappingInfo = options.get(EditorOption.wrappingInfo);
-        this._lineHeight = options.get(EditorOption.lineHeight);
+        const fontInfo = options.get(52 );
+        const wrappingInfo = options.get(149 );
+        this._lineHeight = options.get(69 );
         this._typicalHalfwidthCharacterWidth = fontInfo.typicalHalfwidthCharacterWidth;
         this._isViewportWrapping = wrappingInfo.isViewportWrapping;
-        this._revealHorizontalRightPadding = options.get(EditorOption.revealHorizontalRightPadding);
-        this._cursorSurroundingLines = options.get(EditorOption.cursorSurroundingLines);
-        this._cursorSurroundingLinesStyle = options.get(EditorOption.cursorSurroundingLinesStyle);
-        this._canUseLayerHinting = !options.get(EditorOption.disableLayerHinting);
+        this._revealHorizontalRightPadding = options.get(103 );
+        this._cursorSurroundingLines = options.get(29 );
+        this._cursorSurroundingLinesStyle = options.get(30 );
+        this._canUseLayerHinting = !options.get(32 );
         this._viewLineOptions = ( new ViewLineOptions(conf, this._context.theme.type));
         this._linesContent = linesContent;
         this._textRangeRestingSpot = document.createElement('div');
@@ -80,7 +77,7 @@ class ViewLines extends ViewPart {
             createLine: () => ( new ViewLine(this._viewLineOptions)),
         }));
         this.domNode = this._visibleLines.domNode;
-        PartFingerprints.write(this.domNode, PartFingerprint.ViewLines);
+        PartFingerprints.write(this.domNode, 8 );
         this.domNode.setClassName(`view-lines ${MOUSE_CURSOR_TEXT_CSS_CLASS_NAME}`);
         applyFontInfo(this.domNode, fontInfo);
         this._maxLineWidth = 0;
@@ -92,8 +89,8 @@ class ViewLines extends ViewPart {
         }, 2000));
         this._lastRenderedData = ( new LastRenderedData());
         this._horizontalRevealRequest = null;
-        this._stickyScrollEnabled = options.get(EditorOption.stickyScroll).enabled;
-        this._maxNumberStickyLines = options.get(EditorOption.stickyScroll).maxLineCount;
+        this._stickyScrollEnabled = options.get(118 ).enabled;
+        this._maxNumberStickyLines = options.get(118 ).maxLineCount;
     }
     dispose() {
         this._asyncUpdateLineWidths.dispose();
@@ -105,24 +102,24 @@ class ViewLines extends ViewPart {
     }
     onConfigurationChanged(e) {
         this._visibleLines.onConfigurationChanged(e);
-        if (e.hasChanged(EditorOption.wrappingInfo)) {
+        if (e.hasChanged(149 )) {
             this._maxLineWidth = 0;
         }
         const options = this._context.configuration.options;
-        const fontInfo = options.get(EditorOption.fontInfo);
-        const wrappingInfo = options.get(EditorOption.wrappingInfo);
-        this._lineHeight = options.get(EditorOption.lineHeight);
+        const fontInfo = options.get(52 );
+        const wrappingInfo = options.get(149 );
+        this._lineHeight = options.get(69 );
         this._typicalHalfwidthCharacterWidth = fontInfo.typicalHalfwidthCharacterWidth;
         this._isViewportWrapping = wrappingInfo.isViewportWrapping;
-        this._revealHorizontalRightPadding = options.get(EditorOption.revealHorizontalRightPadding);
-        this._cursorSurroundingLines = options.get(EditorOption.cursorSurroundingLines);
-        this._cursorSurroundingLinesStyle = options.get(EditorOption.cursorSurroundingLinesStyle);
-        this._canUseLayerHinting = !options.get(EditorOption.disableLayerHinting);
-        this._stickyScrollEnabled = options.get(EditorOption.stickyScroll).enabled;
-        this._maxNumberStickyLines = options.get(EditorOption.stickyScroll).maxLineCount;
+        this._revealHorizontalRightPadding = options.get(103 );
+        this._cursorSurroundingLines = options.get(29 );
+        this._cursorSurroundingLinesStyle = options.get(30 );
+        this._canUseLayerHinting = !options.get(32 );
+        this._stickyScrollEnabled = options.get(118 ).enabled;
+        this._maxNumberStickyLines = options.get(118 ).maxLineCount;
         applyFontInfo(this.domNode, fontInfo);
         this._onOptionsMaybeChanged();
-        if (e.hasChanged(EditorOption.layoutInfo)) {
+        if (e.hasChanged(148 )) {
             this._maxLineWidth = 0;
         }
         return true;
@@ -213,7 +210,7 @@ class ViewLines extends ViewPart {
             this._horizontalRevealRequest = null;
         }
         const scrollTopDelta = Math.abs(this._context.viewLayout.getCurrentScrollTop() - newScrollPosition.scrollTop);
-        const scrollType = (scrollTopDelta <= this._lineHeight ? ScrollType.Immediate : e.scrollType);
+        const scrollType = (scrollTopDelta <= this._lineHeight ? 1  : e.scrollType);
         this._context.viewModel.viewLayout.setScrollPosition(newScrollPosition, scrollType);
         return true;
     }
@@ -530,7 +527,7 @@ class ViewLines extends ViewPart {
             }
         }
         if (!minimalReveal) {
-            if (verticalType === VerticalRevealType.Simple || verticalType === VerticalRevealType.Bottom) {
+            if (verticalType === 0  || verticalType === 4 ) {
                 paddingBottom += this._lineHeight;
             }
         }
@@ -543,8 +540,8 @@ class ViewLines extends ViewPart {
             }
             newScrollTop = boxStartY;
         }
-        else if (verticalType === VerticalRevealType.NearTop || verticalType === VerticalRevealType.NearTopIfOutsideViewport) {
-            if (verticalType === VerticalRevealType.NearTopIfOutsideViewport && viewportStartY <= boxStartY && boxEndY <= viewportEndY) {
+        else if (verticalType === 5  || verticalType === 6 ) {
+            if (verticalType === 6  && viewportStartY <= boxStartY && boxEndY <= viewportEndY) {
                 newScrollTop = viewportStartY;
             }
             else {
@@ -554,8 +551,8 @@ class ViewLines extends ViewPart {
                 newScrollTop = Math.max(minScrollTop, desiredScrollTop);
             }
         }
-        else if (verticalType === VerticalRevealType.Center || verticalType === VerticalRevealType.CenterIfOutsideViewport) {
-            if (verticalType === VerticalRevealType.CenterIfOutsideViewport && viewportStartY <= boxStartY && boxEndY <= viewportEndY) {
+        else if (verticalType === 1  || verticalType === 2 ) {
+            if (verticalType === 2  && viewportStartY <= boxStartY && boxEndY <= viewportEndY) {
                 newScrollTop = viewportStartY;
             }
             else {
@@ -564,16 +561,16 @@ class ViewLines extends ViewPart {
             }
         }
         else {
-            newScrollTop = this._computeMinimumScrolling(viewportStartY, viewportEndY, boxStartY, boxEndY, verticalType === VerticalRevealType.Top, verticalType === VerticalRevealType.Bottom);
+            newScrollTop = this._computeMinimumScrolling(viewportStartY, viewportEndY, boxStartY, boxEndY, verticalType === 3 , verticalType === 4 );
         }
         return newScrollTop;
     }
     _computeScrollLeftToReveal(horizontalRevealRequest) {
         const viewport = this._context.viewLayout.getCurrentViewport();
-        const layoutInfo = this._context.configuration.options.get(EditorOption.layoutInfo);
+        const layoutInfo = this._context.configuration.options.get(148 );
         const viewportStartX = viewport.left;
         const viewportEndX = viewportStartX + viewport.width - layoutInfo.verticalScrollbarWidth;
-        let boxStartX = Constants.MAX_SAFE_SMALL_INTEGER;
+        let boxStartX = 1073741824 ;
         let boxEndX = 0;
         if (horizontalRevealRequest.type === 'range') {
             const visibleRanges = this._visibleRangesForLineRange(horizontalRevealRequest.lineNumber, horizontalRevealRequest.startColumn, horizontalRevealRequest.endColumn);

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

@@ -0,0 +1,299 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { getActiveWindow } from '../../../../base/browser/dom.js';
+import { BugIndicatingError } from '../../../../base/common/errors.js';
+import '../../../../base/common/arrays.js';
+import '../../../../base/common/event.js';
+import '../../../../base/common/lifecycle.js';
+import { autorun } from '../../../../base/common/observableInternal/autorun.js';
+import '../../../../base/common/observableInternal/derived.js';
+import '../../../../base/common/cancellation.js';
+import '../../../../base/common/observableInternal/utils.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { ILogService } from '../../../../platform/log/common/log.service.js';
+import { TextureAtlasPage } from '../../gpu/atlas/textureAtlasPage.js';
+import { FullFileRenderStrategy } from '../../gpu/fullFileRenderStrategy.js';
+import { GPULifecycle } from '../../gpu/gpuDisposable.js';
+import { observeDevicePixelDimensions, quadVertices } from '../../gpu/gpuUtils.js';
+import { ViewGpuContext } from '../../gpu/viewGpuContext.js';
+import { HorizontalPosition, VisibleRanges, FloatHorizontalRange } from '../../view/renderingContext.js';
+import { ViewPart } from '../../view/viewPart.js';
+import { ViewLineOptions } from '../viewLines/viewLineOptions.js';
+let ViewLinesGpu = class ViewLinesGpu extends ViewPart {
+    constructor(context, _viewGpuContext, _instantiationService, _logService) {
+        super(context);
+        this._viewGpuContext = _viewGpuContext;
+        this._instantiationService = _instantiationService;
+        this._logService = _logService;
+        this._glyphStorageBuffer = [];
+        this._atlasGpuTextureVersions = [];
+        this._initialized = false;
+        this.canvas = this._viewGpuContext.canvas.domNode;
+        this._register(autorun(reader => {
+             this._viewGpuContext.canvasDevicePixelDimensions.read(reader);
+        }));
+        this.initWebgpu();
+    }
+    async initWebgpu() {
+        this._device = await this._viewGpuContext.device;
+        if (this._store.isDisposed) {
+            return;
+        }
+        const atlas = ViewGpuContext.atlas;
+        this._register(atlas.onDidDeleteGlyphs(() => {
+            this._atlasGpuTextureVersions.length = 0;
+            this._atlasGpuTextureVersions[0] = 0;
+            this._atlasGpuTextureVersions[1] = 0;
+            this._renderStrategy.reset();
+        }));
+        const presentationFormat = navigator.gpu.getPreferredCanvasFormat();
+        this._viewGpuContext.ctx.configure({
+            device: this._device,
+            format: presentationFormat,
+            alphaMode: 'premultiplied',
+        });
+        this._renderPassColorAttachment = {
+            view: null,
+            loadOp: 'load',
+            storeOp: 'store',
+        };
+        this._renderPassDescriptor = {
+            label: 'Monaco render pass',
+            colorAttachments: [this._renderPassColorAttachment],
+        };
+        let layoutInfoUniformBuffer;
+        {
+            const bufferValues = ( new Float32Array(6 ));
+            const updateBufferValues = (canvasDevicePixelWidth = this.canvas.width, canvasDevicePixelHeight = this.canvas.height) => {
+                bufferValues[0 ] = canvasDevicePixelWidth;
+                bufferValues[1 ] = canvasDevicePixelHeight;
+                bufferValues[2 ] = Math.ceil(this._context.configuration.options.get(148 ).contentLeft * getActiveWindow().devicePixelRatio);
+                bufferValues[3 ] = 0;
+                bufferValues[4 ] = bufferValues[0 ] - bufferValues[2 ];
+                bufferValues[5 ] = bufferValues[1 ] - bufferValues[3 ];
+                return bufferValues;
+            };
+            layoutInfoUniformBuffer = this._register(GPULifecycle.createBuffer(this._device, {
+                label: 'Monaco uniform buffer',
+                size: 24 ,
+                usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+            }, () => updateBufferValues())).object;
+            this._register(observeDevicePixelDimensions(this.canvas, getActiveWindow(), (w, h) => {
+                this._device.queue.writeBuffer(layoutInfoUniformBuffer, 0, updateBufferValues(w, h));
+            }));
+        }
+        let atlasInfoUniformBuffer;
+        {
+            atlasInfoUniformBuffer = this._register(GPULifecycle.createBuffer(this._device, {
+                label: 'Monaco atlas info uniform buffer',
+                size: 8 ,
+                usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+            }, () => {
+                const values = ( new Float32Array(2 ));
+                values[0 ] = atlas.pageSize;
+                values[1 ] = atlas.pageSize;
+                return values;
+            })).object;
+        }
+        this._renderStrategy = this._register(this._instantiationService.createInstance(FullFileRenderStrategy, this._context, this._device, this.canvas, atlas));
+        this._glyphStorageBuffer[0] = this._register(GPULifecycle.createBuffer(this._device, {
+            label: 'Monaco glyph storage buffer',
+            size: 24  * TextureAtlasPage.maximumGlyphCount,
+            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+        })).object;
+        this._glyphStorageBuffer[1] = this._register(GPULifecycle.createBuffer(this._device, {
+            label: 'Monaco glyph storage buffer',
+            size: 24  * TextureAtlasPage.maximumGlyphCount,
+            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+        })).object;
+        this._atlasGpuTextureVersions[0] = 0;
+        this._atlasGpuTextureVersions[1] = 0;
+        this._atlasGpuTexture = this._register(GPULifecycle.createTexture(this._device, {
+            label: 'Monaco atlas texture',
+            format: 'rgba8unorm',
+            size: { width: atlas.pageSize, height: atlas.pageSize, depthOrArrayLayers: 2 },
+            dimension: '2d',
+            usage: GPUTextureUsage.TEXTURE_BINDING |
+                GPUTextureUsage.COPY_DST |
+                GPUTextureUsage.RENDER_ATTACHMENT,
+        })).object;
+        this._updateAtlasStorageBufferAndTexture();
+        this._vertexBuffer = this._register(GPULifecycle.createBuffer(this._device, {
+            label: 'Monaco vertex buffer',
+            size: quadVertices.byteLength,
+            usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
+        }, quadVertices)).object;
+        const module = this._device.createShaderModule({
+            label: 'Monaco shader module',
+            code: this._renderStrategy.wgsl,
+        });
+        this._pipeline = this._device.createRenderPipeline({
+            label: 'Monaco render pipeline',
+            layout: 'auto',
+            vertex: {
+                module,
+                buffers: [
+                    {
+                        arrayStride: 2 * Float32Array.BYTES_PER_ELEMENT,
+                        attributes: [
+                            { shaderLocation: 0, offset: 0, format: 'float32x2' },
+                        ],
+                    }
+                ]
+            },
+            fragment: {
+                module,
+                targets: [
+                    {
+                        format: presentationFormat,
+                        blend: {
+                            color: {
+                                srcFactor: 'src-alpha',
+                                dstFactor: 'one-minus-src-alpha'
+                            },
+                            alpha: {
+                                srcFactor: 'src-alpha',
+                                dstFactor: 'one-minus-src-alpha'
+                            },
+                        },
+                    }
+                ],
+            },
+        });
+        this._bindGroup = this._device.createBindGroup({
+            label: 'Monaco bind group',
+            layout: this._pipeline.getBindGroupLayout(0),
+            entries: [
+                { binding: 0 , resource: { buffer: this._glyphStorageBuffer[0] } },
+                { binding: 1 , resource: { buffer: this._glyphStorageBuffer[1] } },
+                {
+                    binding: 3 , resource: this._device.createSampler({
+                        label: 'Monaco atlas sampler',
+                        magFilter: 'nearest',
+                        minFilter: 'nearest',
+                    })
+                },
+                { binding: 4 , resource: this._atlasGpuTexture.createView() },
+                { binding: 5 , resource: { buffer: layoutInfoUniformBuffer } },
+                { binding: 6 , resource: { buffer: atlasInfoUniformBuffer } },
+                ...this._renderStrategy.bindGroupEntries
+            ],
+        });
+        this._initialized = true;
+    }
+    _updateAtlasStorageBufferAndTexture() {
+        for (const [layerIndex, page] of ViewGpuContext.atlas.pages.entries()) {
+            if (page.version === this._atlasGpuTextureVersions[layerIndex]) {
+                continue;
+            }
+            this._logService.trace('Updating atlas page[', layerIndex, '] from version ', this._atlasGpuTextureVersions[layerIndex], ' to version ', page.version);
+            const values = ( new Float32Array(
+                6  * TextureAtlasPage.maximumGlyphCount
+            ));
+            let entryOffset = 0;
+            for (const glyph of page.glyphs) {
+                values[entryOffset + 0 ] = glyph.x;
+                values[entryOffset + 0  + 1] = glyph.y;
+                values[entryOffset + 2 ] = glyph.w;
+                values[entryOffset + 2  + 1] = glyph.h;
+                values[entryOffset + 4 ] = glyph.originOffsetX;
+                values[entryOffset + 4  + 1] = glyph.originOffsetY;
+                entryOffset += 6 ;
+            }
+            if (entryOffset / 6  > TextureAtlasPage.maximumGlyphCount) {
+                throw ( new Error(
+                    `Attempting to write more glyphs (${entryOffset / 6 }) than the GPUBuffer can hold (${TextureAtlasPage.maximumGlyphCount})`
+                ));
+            }
+            this._device.queue.writeBuffer(this._glyphStorageBuffer[layerIndex], 0, values);
+            if (page.usedArea.right - page.usedArea.left > 0 && page.usedArea.bottom - page.usedArea.top > 0) {
+                this._device.queue.copyExternalImageToTexture({ source: page.source }, {
+                    texture: this._atlasGpuTexture,
+                    origin: {
+                        x: page.usedArea.left,
+                        y: page.usedArea.top,
+                        z: layerIndex
+                    }
+                }, {
+                    width: page.usedArea.right - page.usedArea.left,
+                    height: page.usedArea.bottom - page.usedArea.top
+                });
+            }
+            this._atlasGpuTextureVersions[layerIndex] = page.version;
+        }
+    }
+    static canRender(options, viewportData, lineNumber) {
+        const d = viewportData.getViewLineRenderingData(lineNumber);
+        return d.content.indexOf('e') !== -1;
+    }
+    prepareRender(ctx) {
+        throw ( new BugIndicatingError('Should not be called'));
+    }
+    render(ctx) {
+        throw ( new BugIndicatingError('Should not be called'));
+    }
+    onLinesChanged(e) {
+        return true;
+    }
+    onScrollChanged(e) {
+        return true;
+    }
+    renderText(viewportData) {
+        if (this._initialized) {
+            return this._renderText(viewportData);
+        }
+    }
+    _renderText(viewportData) {
+        this._viewGpuContext.rectangleRenderer.draw(viewportData);
+        const options = ( new ViewLineOptions(this._context.configuration, this._context.theme.type));
+        const visibleObjectCount = this._renderStrategy.update(viewportData, options);
+        this._updateAtlasStorageBufferAndTexture();
+        const encoder = this._device.createCommandEncoder({ label: 'Monaco command encoder' });
+        this._renderPassColorAttachment.view = this._viewGpuContext.ctx.getCurrentTexture().createView({ label: 'Monaco canvas texture view' });
+        const pass = encoder.beginRenderPass(this._renderPassDescriptor);
+        pass.setPipeline(this._pipeline);
+        pass.setVertexBuffer(0, this._vertexBuffer);
+        pass.setBindGroup(0, this._bindGroup);
+        if (this._renderStrategy?.draw) {
+            this._renderStrategy.draw(pass, viewportData);
+        }
+        else {
+            pass.draw(quadVertices.length / 2, visibleObjectCount);
+        }
+        pass.end();
+        const commandBuffer = encoder.finish();
+        this._device.queue.submit([commandBuffer]);
+        this._lastViewportData = viewportData;
+        this._lastViewLineOptions = options;
+    }
+    linesVisibleRangesForRange(range, includeNewLines) {
+        return null;
+    }
+    _visibleRangesForLineRange(lineNumber, startColumn, endColumn) {
+        if (this.shouldRender()) {
+            return null;
+        }
+        const viewportData = this._lastViewportData;
+        const viewLineOptions = this._lastViewLineOptions;
+        if (!viewportData || !viewLineOptions || lineNumber < viewportData.startLineNumber || lineNumber > viewportData.endLineNumber) {
+            return null;
+        }
+        const result = ( new VisibleRanges(false, [( new FloatHorizontalRange(
+            (startColumn - 1) * viewLineOptions.spaceWidth,
+            (endColumn - startColumn - 1) * viewLineOptions.spaceWidth
+        ))
+        ]));
+        return result;
+    }
+    visibleRangeForPosition(position) {
+        const visibleRanges = this._visibleRangesForLineRange(position.lineNumber, position.column, position.column);
+        if (!visibleRanges) {
+            return null;
+        }
+        return ( new HorizontalPosition(visibleRanges.outsideRenderedLine, visibleRanges.ranges[0].left));
+    }
+};
+ViewLinesGpu = ( __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, ILogService))
+], ViewLinesGpu));
+export { ViewLinesGpu };

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

@@ -2,14 +2,13 @@ import { createFastDomNode } from '../../../../base/browser/fastDomNode.js';
 import { onUnexpectedError } from '../../../../base/common/errors.js';
 import { ViewPart } from '../../view/viewPart.js';
 import { Position } from '../../../common/core/position.js';
-import { EditorOption } from '../../../common/config/editorOptions.js';
 const invalidFunc = () => { throw ( new Error(`Invalid change accessor`)); };
 class ViewZones extends ViewPart {
     constructor(context) {
         super(context);
         const options = this._context.configuration.options;
-        const layoutInfo = options.get(EditorOption.layoutInfo);
-        this._lineHeight = options.get(EditorOption.lineHeight);
+        const layoutInfo = options.get(148 );
+        this._lineHeight = options.get(69 );
         this._contentWidth = layoutInfo.contentWidth;
         this._contentLeft = layoutInfo.contentLeft;
         this.domNode = createFastDomNode(document.createElement('div'));
@@ -54,11 +53,11 @@ class ViewZones extends ViewPart {
     }
     onConfigurationChanged(e) {
         const options = this._context.configuration.options;
-        const layoutInfo = options.get(EditorOption.layoutInfo);
-        this._lineHeight = options.get(EditorOption.lineHeight);
+        const layoutInfo = options.get(148 );
+        this._lineHeight = options.get(69 );
         this._contentWidth = layoutInfo.contentWidth;
         this._contentLeft = layoutInfo.contentLeft;
-        if (e.hasChanged(EditorOption.lineHeight)) {
+        if (e.hasChanged(69 )) {
             this._recomputeWhitespacesProps();
         }
         return true;

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

@@ -1,8 +1,6 @@
 import './whitespace.css.js';
 import { DynamicViewOverlay } from '../../view/dynamicViewOverlay.js';
-import { EditorOption } from '../../../common/config/editorOptions.js';
 import { firstNonWhitespaceIndex, lastNonWhitespaceIndex } from '../../../../base/common/strings.js';
-import { CharCode } from '../../../../base/common/charCode.js';
 import { LineRange } from '../../../common/viewLayout/viewLineRenderer.js';
 import { Position } from '../../../common/core/position.js';
 import { editorWhitespaces } from '../../../common/core/editorColorRegistry.js';
@@ -23,7 +21,7 @@ class WhitespaceOverlay extends DynamicViewOverlay {
     onConfigurationChanged(e) {
         const newOptions = ( new WhitespaceOptions(this._context.configuration));
         if (this._options.equals(newOptions)) {
-            return e.hasChanged(EditorOption.layoutInfo);
+            return e.hasChanged(148 );
         }
         this._options = newOptions;
         return true;
@@ -137,22 +135,22 @@ class WhitespaceOverlay extends DynamicViewOverlay {
                 currentSelectionIndex++;
                 currentSelection = selections && selections[currentSelectionIndex];
             }
-            if (chCode !== CharCode.Tab && chCode !== CharCode.Space) {
+            if (chCode !== 9  && chCode !== 32 ) {
                 continue;
             }
             if (onlyTrailing && !lineIsEmptyOrWhitespace && charIndex <= lastNonWhitespaceIndex$1) {
                 continue;
             }
-            if (onlyBoundary && charIndex >= firstNonWhitespaceIndex$1 && charIndex <= lastNonWhitespaceIndex$1 && chCode === CharCode.Space) {
-                const prevChCode = (charIndex - 1 >= 0 ? lineContent.charCodeAt(charIndex - 1) : CharCode.Null);
-                const nextChCode = (charIndex + 1 < len ? lineContent.charCodeAt(charIndex + 1) : CharCode.Null);
-                if (prevChCode !== CharCode.Space && nextChCode !== CharCode.Space) {
+            if (onlyBoundary && charIndex >= firstNonWhitespaceIndex$1 && charIndex <= lastNonWhitespaceIndex$1 && chCode === 32 ) {
+                const prevChCode = ((charIndex - 1 >= 0 ? lineContent.charCodeAt(charIndex - 1) : 0) );
+                const nextChCode = ((charIndex + 1 < len ? lineContent.charCodeAt(charIndex + 1) : 0) );
+                if (prevChCode !== 32  && nextChCode !== 32 ) {
                     continue;
                 }
             }
             if (onlyBoundary && continuesWithWrappedLine && charIndex === len - 1) {
-                const prevCharCode = (charIndex - 1 >= 0 ? lineContent.charCodeAt(charIndex - 1) : CharCode.Null);
-                const isSingleTrailingSpace = (chCode === CharCode.Space && (prevCharCode !== CharCode.Space && prevCharCode !== CharCode.Tab));
+                const prevCharCode = ((charIndex - 1 >= 0 ? lineContent.charCodeAt(charIndex - 1) : 0) );
+                const isSingleTrailingSpace = (chCode === 32  && ((prevCharCode !== 32  && prevCharCode !== 9) ));
                 if (isSingleTrailingSpace) {
                     continue;
                 }
@@ -166,7 +164,7 @@ class WhitespaceOverlay extends DynamicViewOverlay {
             }
             if (USE_SVG) {
                 maxLeft = Math.max(maxLeft, visibleRange.left);
-                if (chCode === CharCode.Tab) {
+                if (chCode === 9 ) {
                     result += this._renderArrow(lineHeight, spaceWidth, visibleRange.left);
                 }
                 else {
@@ -174,7 +172,7 @@ class WhitespaceOverlay extends DynamicViewOverlay {
                 }
             }
             else {
-                if (chCode === CharCode.Tab) {
+                if (chCode === 9 ) {
                     result += `<div class="mwh" style="left:${visibleRange.left}px;height:${lineHeight}px;">${canUseHalfwidthRightwardsArrow ? String.fromCharCode(0xFFEB) : String.fromCharCode(0x2192)}</div>`;
                 }
                 else {
@@ -223,26 +221,26 @@ class WhitespaceOverlay extends DynamicViewOverlay {
 class WhitespaceOptions {
     constructor(config) {
         const options = config.options;
-        const fontInfo = options.get(EditorOption.fontInfo);
-        const experimentalWhitespaceRendering = options.get(EditorOption.experimentalWhitespaceRendering);
+        const fontInfo = options.get(52 );
+        const experimentalWhitespaceRendering = options.get(40 );
         if (experimentalWhitespaceRendering === 'off') {
             this.renderWhitespace = 'none';
             this.renderWithSVG = false;
         }
         else if (experimentalWhitespaceRendering === 'svg') {
-            this.renderWhitespace = options.get(EditorOption.renderWhitespace);
+            this.renderWhitespace = options.get(102 );
             this.renderWithSVG = true;
         }
         else {
-            this.renderWhitespace = options.get(EditorOption.renderWhitespace);
+            this.renderWhitespace = options.get(102 );
             this.renderWithSVG = false;
         }
         this.spaceWidth = fontInfo.spaceWidth;
         this.middotWidth = fontInfo.middotWidth;
         this.wsmiddotWidth = fontInfo.wsmiddotWidth;
         this.canUseHalfwidthRightwardsArrow = fontInfo.canUseHalfwidthRightwardsArrow;
-        this.lineHeight = options.get(EditorOption.lineHeight);
-        this.stopRenderingLineAfter = options.get(EditorOption.stopRenderingLineAfter);
+        this.lineHeight = options.get(69 );
+        this.stopRenderingLineAfter = options.get(120 );
     }
     equals(other) {
         return (this.renderWhitespace === other.renderWhitespace