@codingame/monaco-vscode-api 9.0.3 → 10.0.1

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

@@ -2,20 +2,15 @@ import './minimap.css.js';
 import { addStandardDisposableListener, getDomNodePagePosition, EventType, addDisposableListener } from '../../../../base/browser/dom.js';
 import { createFastDomNode } from '../../../../base/browser/fastDomNode.js';
 import { GlobalPointerMoveMonitor } from '../../../../base/browser/globalPointerMoveMonitor.js';
-import { CharCode } from '../../../../base/common/charCode.js';
 import { Disposable } from '../../../../base/common/lifecycle.js';
 import { isWindows } from '../../../../base/common/platform.js';
 import { isFullWidthCharacter } from '../../../../base/common/strings.js';
 import { RenderedLinesCollection } from '../../view/viewLayer.js';
-import { ViewPart, PartFingerprints, PartFingerprint } from '../../view/viewPart.js';
-import { RenderMinimap, MINIMAP_GUTTER_WIDTH, EditorOption, EditorLayoutInfoComputer } from '../../../common/config/editorOptions.js';
+import { ViewPart, PartFingerprints } from '../../view/viewPart.js';
+import { MINIMAP_GUTTER_WIDTH, EditorLayoutInfoComputer } from '../../../common/config/editorOptions.js';
 import { Range } from '../../../common/core/range.js';
 import { RGBA8 } from '../../../common/core/rgba.js';
-import { ScrollType } from '../../../common/editorCommon.js';
-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';
@@ -31,7 +26,6 @@ import '../../../../platform/theme/common/colors/searchColors.js';
 import { Selection } from '../../../common/core/selection.js';
 import { Gesture, EventType as EventType$1 } from '../../../../base/browser/touch.js';
 import { MinimapCharRendererFactory } from './minimapCharRendererFactory.js';
-import { MinimapPosition, MinimapSectionHeaderStyle } from '../../../common/model.js';
 import { createSingleCallFunction } from '../../../../base/common/functional.js';
 import { LRUCache } from '../../../../base/common/map.js';
 import { DEFAULT_FONT_FAMILY } from '../../../../base/browser/fonts.js';
@@ -40,22 +34,22 @@ const GUTTER_DECORATION_WIDTH = 2;
 class MinimapOptions {
     constructor(configuration, theme, tokensColorTracker) {
         const options = configuration.options;
-        const pixelRatio = options.get(EditorOption.pixelRatio);
-        const layoutInfo = options.get(EditorOption.layoutInfo);
+        const pixelRatio = options.get(146 );
+        const layoutInfo = options.get(148 );
         const minimapLayout = layoutInfo.minimap;
-        const fontInfo = options.get(EditorOption.fontInfo);
-        const minimapOpts = options.get(EditorOption.minimap);
+        const fontInfo = options.get(52 );
+        const minimapOpts = options.get(75 );
         this.renderMinimap = minimapLayout.renderMinimap;
         this.size = minimapOpts.size;
         this.minimapHeightIsEditorHeight = minimapLayout.minimapHeightIsEditorHeight;
-        this.scrollBeyondLastLine = options.get(EditorOption.scrollBeyondLastLine);
-        this.paddingTop = options.get(EditorOption.padding).top;
-        this.paddingBottom = options.get(EditorOption.padding).bottom;
+        this.scrollBeyondLastLine = options.get(108 );
+        this.paddingTop = options.get(86 ).top;
+        this.paddingBottom = options.get(86 ).bottom;
         this.showSlider = minimapOpts.showSlider;
         this.autohide = minimapOpts.autohide;
         this.pixelRatio = pixelRatio;
         this.typicalHalfwidthCharacterWidth = fontInfo.typicalHalfwidthCharacterWidth;
-        this.lineHeight = options.get(EditorOption.lineHeight);
+        this.lineHeight = options.get(69 );
         this.minimapLeft = minimapLayout.minimapLeft;
         this.minimapWidth = minimapLayout.minimapWidth;
         this.minimapHeight = layoutInfo.height;
@@ -67,13 +61,13 @@ class MinimapOptions {
         this.editorHeight = layoutInfo.height;
         this.fontScale = minimapLayout.minimapScale;
         this.minimapLineHeight = minimapLayout.minimapLineHeight;
-        this.minimapCharWidth = Constants.BASE_CHAR_WIDTH * this.fontScale;
+        this.minimapCharWidth = 1  * this.fontScale;
         this.sectionHeaderFontFamily = DEFAULT_FONT_FAMILY;
         this.sectionHeaderFontSize = minimapOpts.sectionHeaderFontSize * pixelRatio;
         this.sectionHeaderLetterSpacing = minimapOpts.sectionHeaderLetterSpacing;
-        this.sectionHeaderFontColor = MinimapOptions._getSectionHeaderColor(theme, tokensColorTracker.getColor(ColorId.DefaultForeground));
+        this.sectionHeaderFontColor = MinimapOptions._getSectionHeaderColor(theme, tokensColorTracker.getColor(1 ));
         this.charRenderer = createSingleCallFunction(() => MinimapCharRendererFactory.create(this.fontScale, fontInfo.fontFamily));
-        this.defaultBackgroundColor = tokensColorTracker.getColor(ColorId.DefaultBackground);
+        this.defaultBackgroundColor = tokensColorTracker.getColor(2 );
         this.backgroundColor = MinimapOptions._getMinimapBackground(theme, this.defaultBackgroundColor);
         this.foregroundAlpha = MinimapOptions._getMinimapForegroundOpacity(theme);
     }
@@ -392,7 +386,7 @@ class MinimapBuffers {
 }
 class MinimapSamplingState {
     static compute(options, viewLineCount, oldSamplingState) {
-        if (options.renderMinimap === RenderMinimap.None || !options.isSampling) {
+        if (options.renderMinimap === 0  || !options.isSampling) {
             return [null, []];
         }
         const { minimapLineCount } = EditorLayoutInfoComputer.computeContainedMinimapLineCount({
@@ -860,12 +854,12 @@ class Minimap extends ViewPart {
         if (this._samplingState) {
             lineNumber = this._samplingState.minimapLines[lineNumber - 1];
         }
-        this._context.viewModel.revealRange('mouse', false, ( new Range(lineNumber, 1, lineNumber, 1)), VerticalRevealType.Center, ScrollType.Smooth);
+        this._context.viewModel.revealRange('mouse', false, ( new Range(lineNumber, 1, lineNumber, 1)), 1 , 0 );
     }
     setScrollTop(scrollTop) {
         this._context.viewModel.viewLayout.setScrollPosition({
             scrollTop: scrollTop
-        }, ScrollType.Immediate);
+        }, 1 );
     }
 }
 class InnerMinimap extends Disposable {
@@ -879,7 +873,7 @@ class InnerMinimap extends Disposable {
         this._buffers = null;
         this._selectionColor = this._theme.getColor(minimapSelection);
         this._domNode = createFastDomNode(document.createElement('div'));
-        PartFingerprints.write(this._domNode, PartFingerprint.Minimap);
+        PartFingerprints.write(this._domNode, 9 );
         this._domNode.setClassName(this._getMinimapDomNodeClassName());
         this._domNode.setPosition('absolute');
         this._domNode.setAttribute('role', 'presentation');
@@ -910,7 +904,7 @@ class InnerMinimap extends Disposable {
         this._pointerDownListener = addStandardDisposableListener(this._domNode.domNode, EventType.POINTER_DOWN, (e) => {
             e.preventDefault();
             const renderMinimap = this._model.options.renderMinimap;
-            if (renderMinimap === RenderMinimap.None) {
+            if (renderMinimap === 0 ) {
                 return;
             }
             if (!this._lastRenderData) {
@@ -1103,7 +1097,7 @@ class InnerMinimap extends Disposable {
     }
     render(renderingCtx) {
         const renderMinimap = this._model.options.renderMinimap;
-        if (renderMinimap === RenderMinimap.None) {
+        if (renderMinimap === 0 ) {
             this._shadow.setClassName('minimap-shadow-hidden');
             this._sliderHorizontal.setWidth(0);
             this._sliderHorizontal.setHeight(0);
@@ -1186,7 +1180,7 @@ class InnerMinimap extends Disposable {
         for (let i = decorations.length - 1; i >= 0; i--) {
             const decoration = decorations[i];
             const minimapOptions = decoration.options.minimap;
-            if (!minimapOptions || minimapOptions.position !== MinimapPosition.Inline) {
+            if (!minimapOptions || minimapOptions.position !== 1 ) {
                 continue;
             }
             const intersection = layout.intersectWithViewport(decoration.range);
@@ -1246,10 +1240,10 @@ class InnerMinimap extends Disposable {
             }
             for (let line = startLineNumber; line <= endLineNumber; line++) {
                 switch (minimapOptions.position) {
-                    case MinimapPosition.Inline:
+                    case 1 :
                         this.renderDecorationOnLine(canvasContext, lineOffsetMap, decoration.range, decorationColor, layout, line, minimapLineHeight, minimapLineHeight, tabSize, characterWidth, canvasInnerWidth);
                         continue;
-                    case MinimapPosition.Gutter: {
+                    case 2 : {
                         const y = layout.getYForLineNumber(line, minimapLineHeight);
                         const x = 2;
                         this.renderDecoration(canvasContext, decorationColor, x, y, GUTTER_DECORATION_WIDTH, minimapLineHeight);
@@ -1286,7 +1280,7 @@ class InnerMinimap extends Disposable {
             let prevx = MINIMAP_GUTTER_WIDTH;
             for (let i = 1; i < lineData.length + 1; i++) {
                 const charCode = lineData.charCodeAt(i - 1);
-                const dx = charCode === CharCode.Tab
+                const dx = charCode === 9
                     ? tabSize * charWidth
                     : isFullWidthCharacter(charCode)
                         ? 2 * charWidth
@@ -1334,7 +1328,7 @@ class InnerMinimap extends Disposable {
             const backgroundFillY = y - sectionHeaderFontSize;
             const separatorY = backgroundFillY + 2;
             const headerText = this._model.getSectionHeaderText(decoration, fitWidth);
-            InnerMinimap._renderSectionLabel(canvasContext, headerText, decoration.options.minimap?.sectionHeaderStyle === MinimapSectionHeaderStyle.Underlined, backgroundFill, foregroundFill, canvasInnerWidth, backgroundFillY, backgroundFillHeight, y, separatorY);
+            InnerMinimap._renderSectionLabel(canvasContext, headerText, decoration.options.minimap?.sectionHeaderStyle === 2 , backgroundFill, foregroundFill, canvasInnerWidth, backgroundFillY, backgroundFillHeight, y, separatorY);
         }
     }
     static _fitSectionHeader(target, maxWidth, headerText) {
@@ -1396,7 +1390,7 @@ class InnerMinimap extends Disposable {
         const charRenderer = this._model.options.charRenderer();
         const fontScale = this._model.options.fontScale;
         const minimapCharWidth = this._model.options.minimapCharWidth;
-        const baseCharHeight = (renderMinimap === RenderMinimap.Text ? Constants.BASE_CHAR_HEIGHT : Constants.BASE_CHAR_HEIGHT + 1);
+        const baseCharHeight = (renderMinimap === 1  ? 2  : 2  + 1);
         const renderMinimapLineHeight = baseCharHeight * fontScale;
         const innerLinePadding = (minimapLineHeight > renderMinimapLineHeight ? Math.floor((minimapLineHeight - renderMinimapLineHeight) / 2) : 0);
         const backgroundA = background.a / 255;
@@ -1510,18 +1504,18 @@ class InnerMinimap extends Disposable {
                     return;
                 }
                 const charCode = content.charCodeAt(charIndex);
-                if (charCode === CharCode.Tab) {
+                if (charCode === 9 ) {
                     const insertSpacesCount = tabSize - (charIndex + tabsCharDelta) % tabSize;
                     tabsCharDelta += insertSpacesCount - 1;
                     dx += insertSpacesCount * charWidth;
                 }
-                else if (charCode === CharCode.Space) {
+                else if (charCode === 32 ) {
                     dx += charWidth;
                 }
                 else {
                     const count = isFullWidthCharacter(charCode) ? 2 : 1;
                     for (let i = 0; i < count; i++) {
-                        if (renderMinimap === RenderMinimap.Blocks) {
+                        if (renderMinimap === 2 ) {
                             minimapCharRenderer.blockRenderChar(target, dx, dy + innerLinePadding, tokenColor, foregroundAlpha, backgroundColor, backgroundAlpha, force1pxHeight);
                         }
                         else {

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

@@ -1,4 +1,4 @@
-import { Constants, getCharIndex } from './minimapCharSheet.js';
+import { getCharIndex } from './minimapCharSheet.js';
 import { toUint8 } from '../../../../base/common/uint.js';
 class MinimapCharRenderer {
     constructor(charData, scale) {
@@ -15,8 +15,8 @@ class MinimapCharRenderer {
         return result;
     }
     renderChar(target, dx, dy, chCode, color, foregroundAlpha, backgroundColor, backgroundAlpha, fontScale, useLighterFont, force1pxHeight) {
-        const charWidth = Constants.BASE_CHAR_WIDTH * this.scale;
-        const charHeight = Constants.BASE_CHAR_HEIGHT * this.scale;
+        const charWidth = 1  * this.scale;
+        const charHeight = 2  * this.scale;
         const renderHeight = (force1pxHeight ? 1 : charHeight);
         if (dx + charWidth > target.width || dy + renderHeight > target.height) {
             console.warn('bad render request outside image data');
@@ -24,7 +24,7 @@ class MinimapCharRenderer {
         }
         const charData = useLighterFont ? this.charDataLight : this.charDataNormal;
         const charIndex = getCharIndex(chCode, fontScale);
-        const destWidth = target.width * Constants.RGBA_CHANNELS_CNT;
+        const destWidth = target.width * 4 ;
         const backgroundR = backgroundColor.r;
         const backgroundG = backgroundColor.g;
         const backgroundB = backgroundColor.b;
@@ -34,7 +34,7 @@ class MinimapCharRenderer {
         const destAlpha = Math.max(foregroundAlpha, backgroundAlpha);
         const dest = target.data;
         let sourceOffset = charIndex * charWidth * charHeight;
-        let row = dy * destWidth + dx * Constants.RGBA_CHANNELS_CNT;
+        let row = dy * destWidth + dx * 4 ;
         for (let y = 0; y < renderHeight; y++) {
             let column = row;
             for (let x = 0; x < charWidth; x++) {
@@ -48,14 +48,14 @@ class MinimapCharRenderer {
         }
     }
     blockRenderChar(target, dx, dy, color, foregroundAlpha, backgroundColor, backgroundAlpha, force1pxHeight) {
-        const charWidth = Constants.BASE_CHAR_WIDTH * this.scale;
-        const charHeight = Constants.BASE_CHAR_HEIGHT * this.scale;
+        const charWidth = 1  * this.scale;
+        const charHeight = 2  * this.scale;
         const renderHeight = (force1pxHeight ? 1 : charHeight);
         if (dx + charWidth > target.width || dy + renderHeight > target.height) {
             console.warn('bad render request outside image data');
             return;
         }
-        const destWidth = target.width * Constants.RGBA_CHANNELS_CNT;
+        const destWidth = target.width * 4 ;
         const c = 0.5 * (foregroundAlpha / 255);
         const backgroundR = backgroundColor.r;
         const backgroundG = backgroundColor.g;
@@ -68,7 +68,7 @@ class MinimapCharRenderer {
         const colorB = backgroundB + deltaB * c;
         const destAlpha = Math.max(foregroundAlpha, backgroundAlpha);
         const dest = target.data;
-        let row = dy * destWidth + dx * Constants.RGBA_CHANNELS_CNT;
+        let row = dy * destWidth + dx * 4 ;
         for (let y = 0; y < renderHeight; y++) {
             let column = row;
             for (let x = 0; x < charWidth; x++) {

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

@@ -1,5 +1,5 @@
 import { MinimapCharRenderer } from './minimapCharRenderer.js';
-import { Constants, allCharCodes } from './minimapCharSheet.js';
+import { allCharCodes } from './minimapCharSheet.js';
 import { prebakedMiniMaps } from './minimapPreBaked.js';
 import { toUint8 } from '../../../../base/common/uint.js';
 class MinimapCharRendererFactory {
@@ -21,22 +21,22 @@ class MinimapCharRendererFactory {
     static createSampleData(fontFamily) {
         const canvas = document.createElement('canvas');
         const ctx = canvas.getContext('2d');
-        canvas.style.height = `${Constants.SAMPLED_CHAR_HEIGHT}px`;
-        canvas.height = Constants.SAMPLED_CHAR_HEIGHT;
-        canvas.width = Constants.CHAR_COUNT * Constants.SAMPLED_CHAR_WIDTH;
-        canvas.style.width = Constants.CHAR_COUNT * Constants.SAMPLED_CHAR_WIDTH + 'px';
+        canvas.style.height = `${16 }px`;
+        canvas.height = 16 ;
+        canvas.width = 96  * 10 ;
+        canvas.style.width = 96  * 10  + 'px';
         ctx.fillStyle = '#ffffff';
-        ctx.font = `bold ${Constants.SAMPLED_CHAR_HEIGHT}px ${fontFamily}`;
+        ctx.font = `bold ${16 }px ${fontFamily}`;
         ctx.textBaseline = 'middle';
         let x = 0;
         for (const code of allCharCodes) {
-            ctx.fillText(String.fromCharCode(code), x, Constants.SAMPLED_CHAR_HEIGHT / 2);
-            x += Constants.SAMPLED_CHAR_WIDTH;
+            ctx.fillText(String.fromCharCode(code), x, 16  / 2);
+            x += 10 ;
         }
-        return ctx.getImageData(0, 0, Constants.CHAR_COUNT * Constants.SAMPLED_CHAR_WIDTH, Constants.SAMPLED_CHAR_HEIGHT);
+        return ctx.getImageData(0, 0, 96  * 10 , 16 );
     }
     static createFromSampleData(source, scale) {
-        const expectedLength = Constants.SAMPLED_CHAR_HEIGHT * Constants.SAMPLED_CHAR_WIDTH * Constants.RGBA_CHANNELS_CNT * Constants.CHAR_COUNT;
+        const expectedLength = 16  * 10  * 4  * 96 ;
         if (source.length !== expectedLength) {
             throw ( new Error('Unexpected source in MinimapCharRenderer'));
         }
@@ -44,24 +44,24 @@ class MinimapCharRendererFactory {
         return ( new MinimapCharRenderer(charData, scale));
     }
     static _downsampleChar(source, sourceOffset, dest, destOffset, scale) {
-        const width = Constants.BASE_CHAR_WIDTH * scale;
-        const height = Constants.BASE_CHAR_HEIGHT * scale;
+        const width = 1  * scale;
+        const height = 2  * scale;
         let targetIndex = destOffset;
         let brightest = 0;
         for (let y = 0; y < height; y++) {
-            const sourceY1 = (y / height) * Constants.SAMPLED_CHAR_HEIGHT;
-            const sourceY2 = ((y + 1) / height) * Constants.SAMPLED_CHAR_HEIGHT;
+            const sourceY1 = (y / height) * 16 ;
+            const sourceY2 = ((y + 1) / height) * 16 ;
             for (let x = 0; x < width; x++) {
-                const sourceX1 = (x / width) * Constants.SAMPLED_CHAR_WIDTH;
-                const sourceX2 = ((x + 1) / width) * Constants.SAMPLED_CHAR_WIDTH;
+                const sourceX1 = (x / width) * 10 ;
+                const sourceX2 = ((x + 1) / width) * 10 ;
                 let value = 0;
                 let samples = 0;
                 for (let sy = sourceY1; sy < sourceY2; sy++) {
-                    const sourceRow = sourceOffset + Math.floor(sy) * Constants.RGBA_SAMPLED_ROW_WIDTH;
+                    const sourceRow = sourceOffset + Math.floor(sy) * 3840 ;
                     const yBalance = 1 - (sy - Math.floor(sy));
                     for (let sx = sourceX1; sx < sourceX2; sx++) {
                         const xBalance = 1 - (sx - Math.floor(sx));
-                        const sourceIndex = sourceRow + Math.floor(sx) * Constants.RGBA_CHANNELS_CNT;
+                        const sourceIndex = sourceRow + Math.floor(sx) * 4 ;
                         const weight = xBalance * yBalance;
                         samples += weight;
                         value += ((source[sourceIndex] * source[sourceIndex + 3]) / 255) * weight;
@@ -75,16 +75,16 @@ class MinimapCharRendererFactory {
         return brightest;
     }
     static _downsample(data, scale) {
-        const pixelsPerCharacter = Constants.BASE_CHAR_HEIGHT * scale * Constants.BASE_CHAR_WIDTH * scale;
-        const resultLen = pixelsPerCharacter * Constants.CHAR_COUNT;
+        const pixelsPerCharacter = 2  * scale * 1  * scale;
+        const resultLen = pixelsPerCharacter * 96 ;
         const result = ( new Uint8ClampedArray(resultLen));
         let resultOffset = 0;
         let sourceOffset = 0;
         let brightest = 0;
-        for (let charIndex = 0; charIndex < Constants.CHAR_COUNT; charIndex++) {
+        for (let charIndex = 0; charIndex < 96 ; charIndex++) {
             brightest = Math.max(brightest, this._downsampleChar(data, sourceOffset, result, resultOffset, scale));
             resultOffset += pixelsPerCharacter;
-            sourceOffset += Constants.SAMPLED_CHAR_WIDTH * Constants.RGBA_CHANNELS_CNT;
+            sourceOffset += 10  * 4 ;
         }
         if (brightest > 0) {
             const adjust = 255 / brightest;

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

@@ -1,32 +1,19 @@
-var Constants;
-( (function(Constants) {
-    Constants[Constants["START_CH_CODE"] = 32] = "START_CH_CODE";
-    Constants[Constants["END_CH_CODE"] = 126] = "END_CH_CODE";
-    Constants[Constants["UNKNOWN_CODE"] = 65533] = "UNKNOWN_CODE";
-    Constants[Constants["CHAR_COUNT"] = 96] = "CHAR_COUNT";
-    Constants[Constants["SAMPLED_CHAR_HEIGHT"] = 16] = "SAMPLED_CHAR_HEIGHT";
-    Constants[Constants["SAMPLED_CHAR_WIDTH"] = 10] = "SAMPLED_CHAR_WIDTH";
-    Constants[Constants["BASE_CHAR_HEIGHT"] = 2] = "BASE_CHAR_HEIGHT";
-    Constants[Constants["BASE_CHAR_WIDTH"] = 1] = "BASE_CHAR_WIDTH";
-    Constants[Constants["RGBA_CHANNELS_CNT"] = 4] = "RGBA_CHANNELS_CNT";
-    Constants[Constants["RGBA_SAMPLED_ROW_WIDTH"] = 3840] = "RGBA_SAMPLED_ROW_WIDTH";
-})(Constants || (Constants = {})));
 const allCharCodes = (() => {
     const v = [];
-    for (let i = Constants.START_CH_CODE; i <= Constants.END_CH_CODE; i++) {
+    for (let i = 32 ; i <= 126 ; i++) {
         v.push(i);
     }
-    v.push(Constants.UNKNOWN_CODE);
+    v.push(65533 );
     return v;
 })();
 const getCharIndex = (chCode, fontScale) => {
-    chCode -= Constants.START_CH_CODE;
-    if (chCode < 0 || chCode > Constants.CHAR_COUNT) {
+    chCode -= 32 ;
+    if (chCode < 0 || chCode > 96 ) {
         if (fontScale <= 2) {
-            return (chCode + Constants.CHAR_COUNT) % Constants.CHAR_COUNT;
+            return ((chCode + 96) ) % 96 ;
         }
-        return Constants.CHAR_COUNT - 1;
+        return 96  - 1;
     }
     return chCode;
 };
-export { Constants, allCharCodes, getCharIndex };
+export { allCharCodes, getCharIndex };

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

@@ -1,15 +1,13 @@
 import './overlayWidgets.css.js';
 import { createFastDomNode } from '../../../../base/browser/fastDomNode.js';
-import { OverlayWidgetPositionPreference } from '../../editorBrowser.js';
-import { ViewPart, PartFingerprints, PartFingerprint } from '../../view/viewPart.js';
-import { EditorOption } from '../../../common/config/editorOptions.js';
+import { ViewPart, PartFingerprints } from '../../view/viewPart.js';
 import { getDomNodePagePosition } from '../../../../base/browser/dom.js';
 class ViewOverlayWidgets extends ViewPart {
     constructor(context, viewDomNode) {
         super(context);
         this._viewDomNode = viewDomNode;
         const options = this._context.configuration.options;
-        const layoutInfo = options.get(EditorOption.layoutInfo);
+        const layoutInfo = options.get(148 );
         this._widgets = {};
         this._verticalScrollbarWidth = layoutInfo.verticalScrollbarWidth;
         this._minimapWidth = layoutInfo.minimap.minimapWidth;
@@ -18,10 +16,10 @@ class ViewOverlayWidgets extends ViewPart {
         this._editorWidth = layoutInfo.width;
         this._viewDomNodeRect = { top: 0, left: 0, width: 0, height: 0 };
         this._domNode = createFastDomNode(document.createElement('div'));
-        PartFingerprints.write(this._domNode, PartFingerprint.OverlayWidgets);
+        PartFingerprints.write(this._domNode, 4 );
         this._domNode.setClassName('overlayWidgets');
         this.overflowingOverlayWidgetsDomNode = createFastDomNode(document.createElement('div'));
-        PartFingerprints.write(this.overflowingOverlayWidgetsDomNode, PartFingerprint.OverflowingOverlayWidgets);
+        PartFingerprints.write(this.overflowingOverlayWidgetsDomNode, 5 );
         this.overflowingOverlayWidgetsDomNode.setClassName('overflowingOverlayWidgets');
     }
     dispose() {
@@ -33,7 +31,7 @@ class ViewOverlayWidgets extends ViewPart {
     }
     onConfigurationChanged(e) {
         const options = this._context.configuration.options;
-        const layoutInfo = options.get(EditorOption.layoutInfo);
+        const layoutInfo = options.get(148 );
         this._verticalScrollbarWidth = layoutInfo.verticalScrollbarWidth;
         this._minimapWidth = layoutInfo.minimap.minimapWidth;
         this._horizontalScrollbarHeight = layoutInfo.horizontalScrollbarHeight;
@@ -104,8 +102,8 @@ class ViewOverlayWidgets extends ViewPart {
             return;
         }
         const maxRight = (2 * this._verticalScrollbarWidth) + this._minimapWidth;
-        if (widgetData.preference === OverlayWidgetPositionPreference.TOP_RIGHT_CORNER || widgetData.preference === OverlayWidgetPositionPreference.BOTTOM_RIGHT_CORNER) {
-            if (widgetData.preference === OverlayWidgetPositionPreference.BOTTOM_RIGHT_CORNER) {
+        if (widgetData.preference === 0  || widgetData.preference === 1 ) {
+            if (widgetData.preference === 1 ) {
                 const widgetHeight = domNode.domNode.clientHeight;
                 domNode.setTop((this._editorHeight - widgetHeight - 2 * this._horizontalScrollbarHeight));
             }
@@ -120,11 +118,11 @@ class ViewOverlayWidgets extends ViewPart {
                 domNode.setRight(maxRight);
             }
         }
-        else if (widgetData.preference === OverlayWidgetPositionPreference.TOP_CENTER) {
+        else if (widgetData.preference === 2 ) {
             domNode.domNode.style.right = '50%';
             if (widgetData.stack !== undefined) {
-                domNode.setTop(stackCoordinates[OverlayWidgetPositionPreference.TOP_CENTER]);
-                stackCoordinates[OverlayWidgetPositionPreference.TOP_CENTER] += domNode.domNode.clientHeight;
+                domNode.setTop(stackCoordinates[2 ]);
+                stackCoordinates[2 ] += domNode.domNode.clientHeight;
             }
             else {
                 domNode.setTop(0);
@@ -132,7 +130,7 @@ class ViewOverlayWidgets extends ViewPart {
         }
         else {
             const { top, left } = widgetData.preference;
-            const fixedOverflowWidgets = this._context.configuration.options.get(EditorOption.fixedOverflowWidgets);
+            const fixedOverflowWidgets = this._context.configuration.options.get(44 );
             if (fixedOverflowWidgets && widgetData.widget.allowEditorOverflow) {
                 const editorBoundingBox = this._viewDomNodeRect;
                 domNode.setTop(top + editorBoundingBox.top);
@@ -152,7 +150,7 @@ class ViewOverlayWidgets extends ViewPart {
     render(ctx) {
         this._domNode.setWidth(this._editorWidth);
         const keys = ( Object.keys(this._widgets));
-        const stackCoordinates = Array.from({ length: OverlayWidgetPositionPreference.TOP_CENTER + 1 }, () => 0);
+        const stackCoordinates = Array.from({ length: 2  + 1 }, () => 0);
         keys.sort((a, b) => (this._widgets[a].stack || 0) - (this._widgets[b].stack || 0));
         for (let i = 0, len = keys.length; i < len; i++) {
             const widgetId = keys[i];

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

@@ -4,19 +4,18 @@ import { ViewPart } from '../../view/viewPart.js';
 import { Position } from '../../../common/core/position.js';
 import { TokenizationRegistry } from '../../../common/languages.js';
 import { editorOverviewRulerBorder, editorCursorForeground, editorMultiCursorPrimaryForeground, editorMultiCursorSecondaryForeground, editorOverviewRulerBackground } from '../../../common/core/editorColorRegistry.js';
-import { EditorOption } from '../../../common/config/editorOptions.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(EditorOption.lineHeight);
-        this.pixelRatio = options.get(EditorOption.pixelRatio);
-        this.overviewRulerLanes = options.get(EditorOption.overviewRulerLanes);
-        this.renderBorder = options.get(EditorOption.overviewRulerBorder);
+        this.lineHeight = options.get(69 );
+        this.pixelRatio = options.get(146 );
+        this.overviewRulerLanes = options.get(85 );
+        this.renderBorder = options.get(84 );
         const borderColor = theme.getColor(editorOverviewRulerBorder);
         this.borderColor = borderColor ? ( borderColor.toString()) : null;
-        this.hideCursor = options.get(EditorOption.hideCursorInOverviewRuler);
+        this.hideCursor = options.get(61 );
         const cursorColorSingle = theme.getColor(editorCursorForeground);
         this.cursorColorSingle = cursorColorSingle ? ( ( cursorColorSingle.transparent(0.7)).toString()) : null;
         const cursorColorPrimary = theme.getColor(editorMultiCursorPrimaryForeground);
@@ -24,7 +23,7 @@ class Settings {
         const cursorColorSecondary = theme.getColor(editorMultiCursorSecondaryForeground);
         this.cursorColorSecondary = cursorColorSecondary ? ( ( cursorColorSecondary.transparent(0.7)).toString()) : null;
         this.themeType = theme.type;
-        const minimapOpts = options.get(EditorOption.minimap);
+        const minimapOpts = options.get(75 );
         const minimapEnabled = minimapOpts.enabled;
         const minimapSide = minimapOpts.side;
         const themeColor = theme.getColor(editorOverviewRulerBackground);
@@ -38,7 +37,7 @@ class Settings {
         else {
             this.backgroundColor = null;
         }
-        const layoutInfo = options.get(EditorOption.layoutInfo);
+        const layoutInfo = options.get(148 );
         const position = layoutInfo.overviewRuler;
         this.top = position.top;
         this.right = position.right;
@@ -160,27 +159,10 @@ class Settings {
             && this.canvasHeight === other.canvasHeight);
     }
 }
-var Constants;
-( (function(Constants) {
-    Constants[Constants["MIN_DECORATION_HEIGHT"] = 6] = "MIN_DECORATION_HEIGHT";
-})(Constants || (Constants = {})));
-var OverviewRulerLane;
-( (function(OverviewRulerLane) {
-    OverviewRulerLane[OverviewRulerLane["Left"] = 1] = "Left";
-    OverviewRulerLane[OverviewRulerLane["Center"] = 2] = "Center";
-    OverviewRulerLane[OverviewRulerLane["Right"] = 4] = "Right";
-    OverviewRulerLane[OverviewRulerLane["Full"] = 7] = "Full";
-})(OverviewRulerLane || (OverviewRulerLane = {})));
-var ShouldRenderValue;
-( (function(ShouldRenderValue) {
-    ShouldRenderValue[ShouldRenderValue["NotNeeded"] = 0] = "NotNeeded";
-    ShouldRenderValue[ShouldRenderValue["Maybe"] = 1] = "Maybe";
-    ShouldRenderValue[ShouldRenderValue["Needed"] = 2] = "Needed";
-})(ShouldRenderValue || (ShouldRenderValue = {})));
 class DecorationsOverviewRuler extends ViewPart {
     constructor(context) {
         super(context);
-        this._actualShouldRender = ShouldRenderValue.NotNeeded;
+        this._actualShouldRender = 0 ;
         this._renderedDecorations = [];
         this._renderedCursorPositions = [];
         this._domNode = createFastDomNode(document.createElement('canvas'));
@@ -219,11 +201,11 @@ class DecorationsOverviewRuler extends ViewPart {
         return true;
     }
     _markRenderingIsNeeded() {
-        this._actualShouldRender = ShouldRenderValue.Needed;
+        this._actualShouldRender = 2 ;
         return true;
     }
     _markRenderingIsMaybeNeeded() {
-        this._actualShouldRender = ShouldRenderValue.Maybe;
+        this._actualShouldRender = 1 ;
         return true;
     }
     onConfigurationChanged(e) {
@@ -266,7 +248,7 @@ class DecorationsOverviewRuler extends ViewPart {
     }
     render(editorCtx) {
         this._render();
-        this._actualShouldRender = ShouldRenderValue.NotNeeded;
+        this._actualShouldRender = 0 ;
     }
     _render() {
         const backgroundColor = this._settings.backgroundColor;
@@ -277,13 +259,13 @@ class DecorationsOverviewRuler extends ViewPart {
         }
         const decorations = this._context.viewModel.getAllOverviewRulerDecorations(this._context.theme);
         decorations.sort(OverviewRulerDecorationsGroup.compareByRenderingProps);
-        if (this._actualShouldRender === ShouldRenderValue.Maybe && !OverviewRulerDecorationsGroup.equalsArr(this._renderedDecorations, decorations)) {
-            this._actualShouldRender = ShouldRenderValue.Needed;
+        if (this._actualShouldRender === 1  && !OverviewRulerDecorationsGroup.equalsArr(this._renderedDecorations, decorations)) {
+            this._actualShouldRender = 2 ;
         }
-        if (this._actualShouldRender === ShouldRenderValue.Maybe && !equals(this._renderedCursorPositions, this._cursorPositions, (a, b) => a.position.lineNumber === b.position.lineNumber && a.color === b.color)) {
-            this._actualShouldRender = ShouldRenderValue.Needed;
+        if (this._actualShouldRender === 1  && !equals(this._renderedCursorPositions, this._cursorPositions, (a, b) => a.position.lineNumber === b.position.lineNumber && a.color === b.color)) {
+            this._actualShouldRender = 2 ;
         }
-        if (this._actualShouldRender === ShouldRenderValue.Maybe) {
+        if (this._actualShouldRender === 1 ) {
             return;
         }
         this._renderedDecorations = decorations;
@@ -295,7 +277,7 @@ class DecorationsOverviewRuler extends ViewPart {
         const viewLayout = this._context.viewLayout;
         const outerHeight = this._context.viewLayout.getScrollHeight();
         const heightRatio = canvasHeight / outerHeight;
-        const minDecorationHeight = (Constants.MIN_DECORATION_HEIGHT * this._settings.pixelRatio) | 0;
+        const minDecorationHeight = (6  * this._settings.pixelRatio) | 0;
         const halfMinDecorationHeight = (minDecorationHeight / 2) | 0;
         const canvasCtx = this._domNode.domNode.getContext('2d');
         if (backgroundColor) {
@@ -358,8 +340,8 @@ class DecorationsOverviewRuler extends ViewPart {
         if (!this._settings.hideCursor) {
             const cursorHeight = (2 * this._settings.pixelRatio) | 0;
             const halfCursorHeight = (cursorHeight / 2) | 0;
-            const cursorX = this._settings.x[OverviewRulerLane.Full];
-            const cursorW = this._settings.w[OverviewRulerLane.Full];
+            const cursorX = this._settings.x[7 ];
+            const cursorW = this._settings.w[7 ];
             let prevY1 = -100;
             let prevY2 = -100;
             let prevColor = null;

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

@@ -1,5 +1,4 @@
 import { createFastDomNode } from '../../../../base/browser/fastDomNode.js';
-import { EditorOption } from '../../../common/config/editorOptions.js';
 import { OverviewZoneManager } from '../../../common/viewModel/overviewZoneManager.js';
 import { ViewEventHandler } from '../../../common/viewEventHandler.js';
 class OverviewRuler extends ViewEventHandler {
@@ -18,8 +17,8 @@ class OverviewRuler extends ViewEventHandler {
         this._zoneManager.setDOMWidth(0);
         this._zoneManager.setDOMHeight(0);
         this._zoneManager.setOuterHeight(this._context.viewLayout.getScrollHeight());
-        this._zoneManager.setLineHeight(options.get(EditorOption.lineHeight));
-        this._zoneManager.setPixelRatio(options.get(EditorOption.pixelRatio));
+        this._zoneManager.setLineHeight(options.get(69 ));
+        this._zoneManager.setPixelRatio(options.get(146 ));
         this._context.addEventHandler(this);
     }
     dispose() {
@@ -28,12 +27,12 @@ class OverviewRuler extends ViewEventHandler {
     }
     onConfigurationChanged(e) {
         const options = this._context.configuration.options;
-        if (e.hasChanged(EditorOption.lineHeight)) {
-            this._zoneManager.setLineHeight(options.get(EditorOption.lineHeight));
+        if (e.hasChanged(69 )) {
+            this._zoneManager.setLineHeight(options.get(69 ));
             this._render();
         }
-        if (e.hasChanged(EditorOption.pixelRatio)) {
-            this._zoneManager.setPixelRatio(options.get(EditorOption.pixelRatio));
+        if (e.hasChanged(146 )) {
+            this._zoneManager.setPixelRatio(options.get(146 ));
             this._domNode.setWidth(this._zoneManager.getDOMWidth());
             this._domNode.setHeight(this._zoneManager.getDOMHeight());
             this._domNode.domNode.width = this._zoneManager.getCanvasWidth();