@codingame/monaco-vscode-api 5.2.0 → 6.0.0

package/vscode/src/vs/editor/browser/services/hoverService/hoverWidget.js

@@ -2,12 +2,14 @@ import { __decorate, __param } from '../../../../../../../external/tslib/tslib.e
 import './hover.css.js';
 import { DisposableStore } from '../../../../base/common/lifecycle.js';
 import { Emitter } from '../../../../base/common/event.js';
-import { getWindow, addDisposableListener, prepend, append, $ as $$1, getDomNodeZoomLevel } from '../../../../base/browser/dom.js';
+import { getWindow, addDisposableListener, isHTMLElement, prepend, append, $ as $$1, getDomNodeZoomLevel } from '../../../../base/browser/dom.js';
 import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.service.js';
+import { KeyCode } from '../../../../base/common/keyCodes.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
 import { EDITOR_FONT_DEFAULTS } from '../../../common/config/editorOptions.js';
-import { HoverWidget as HoverWidget$1, getHoverAccessibleViewHint } from '../../../../base/browser/ui/hover/hoverWidget.js';
+import { HoverPosition, HoverWidget as HoverWidget$1, getHoverAccessibleViewHint } from '../../../../base/browser/ui/hover/hoverWidget.js';
 import { Widget } from '../../../../base/browser/ui/widget.js';
+import { AnchorPosition } from '../../../../base/browser/ui/contextview/contextview.js';
 import { IOpenerService } from '../../../../platform/opener/common/opener.service.js';
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
 import { openLinkFromMarkdown, MarkdownRenderer } from '../../widget/markdownRenderer/browser/markdownRenderer.js';
@@ -18,6 +20,12 @@ import { IAccessibilityService } from '../../../../platform/accessibility/common
 import { status } from '../../../../base/browser/ui/aria/aria.js';
 const _moduleId = "vs/editor/browser/services/hoverService/hoverWidget";
 const $ = $$1;
+var Constants;
+( ((function(Constants) {
+    Constants[Constants["PointerSize"] = 3] = "PointerSize";
+    Constants[Constants["HoverBorderWidth"] = 2] = "HoverBorderWidth";
+    Constants[Constants["HoverWindowEdgeMargin"] = 2] = "HoverWindowEdgeMargin";
+})(Constants || (Constants = {}))));
 let HoverWidget = class HoverWidget extends Widget {
     get _targetWindow() {
         return getWindow(this._target.targetElements[0]);
@@ -30,7 +38,7 @@ let HoverWidget = class HoverWidget extends Widget {
     get domNode() { return this._hover.containerDomNode; }
     get onDispose() { return this._onDispose.event; }
     get onRequestLayout() { return this._onRequestLayout.event; }
-    get anchor() { return this._hoverPosition === 2  ? 0  : 1 ; }
+    get anchor() { return this._hoverPosition === HoverPosition.BELOW ? AnchorPosition.BELOW : AnchorPosition.ABOVE; }
     get x() { return this._x; }
     get y() { return this._y; }
     get isLocked() { return this._isLocked; }
@@ -80,10 +88,10 @@ let HoverWidget = class HoverWidget extends Widget {
         if (options.trapFocus) {
             this._enableFocusTraps = true;
         }
-        this._hoverPosition = options.position?.hoverPosition ?? 3 ;
+        this._hoverPosition = options.position?.hoverPosition ?? HoverPosition.ABOVE;
         this.onmousedown(this._hover.containerDomNode, e => e.stopPropagation());
         this.onkeydown(this._hover.containerDomNode, e => {
-            if (e.equals(9 )) {
+            if (e.equals(KeyCode.Escape)) {
                 this.dispose();
             }
         });
@@ -94,7 +102,7 @@ let HoverWidget = class HoverWidget extends Widget {
             contentsElement.textContent = options.content;
             contentsElement.style.whiteSpace = 'pre-wrap';
         }
-        else if (options.content instanceof HTMLElement) {
+        else if (isHTMLElement(options.content)) {
             contentsElement.appendChild(options.content);
             contentsElement.classList.add('html-hover-contents');
         }
@@ -255,29 +263,29 @@ let HoverWidget = class HoverWidget extends Widget {
         this._hoverContainer.style.margin = '';
         if (this._hoverPointer) {
             switch (this._hoverPosition) {
-                case 1 :
-                    targetRect.left += 3 ;
-                    targetRect.right += 3 ;
-                    this._hoverContainer.style.paddingLeft = `${3 }px`;
-                    this._hoverContainer.style.marginLeft = `${-3 }px`;
+                case HoverPosition.RIGHT:
+                    targetRect.left += Constants.PointerSize;
+                    targetRect.right += Constants.PointerSize;
+                    this._hoverContainer.style.paddingLeft = `${Constants.PointerSize}px`;
+                    this._hoverContainer.style.marginLeft = `${-Constants.PointerSize}px`;
                     break;
-                case 0 :
-                    targetRect.left -= 3 ;
-                    targetRect.right -= 3 ;
-                    this._hoverContainer.style.paddingRight = `${3 }px`;
-                    this._hoverContainer.style.marginRight = `${-3 }px`;
+                case HoverPosition.LEFT:
+                    targetRect.left -= Constants.PointerSize;
+                    targetRect.right -= Constants.PointerSize;
+                    this._hoverContainer.style.paddingRight = `${Constants.PointerSize}px`;
+                    this._hoverContainer.style.marginRight = `${-Constants.PointerSize}px`;
                     break;
-                case 2 :
-                    targetRect.top += 3 ;
-                    targetRect.bottom += 3 ;
-                    this._hoverContainer.style.paddingTop = `${3 }px`;
-                    this._hoverContainer.style.marginTop = `${-3 }px`;
+                case HoverPosition.BELOW:
+                    targetRect.top += Constants.PointerSize;
+                    targetRect.bottom += Constants.PointerSize;
+                    this._hoverContainer.style.paddingTop = `${Constants.PointerSize}px`;
+                    this._hoverContainer.style.marginTop = `${-Constants.PointerSize}px`;
                     break;
-                case 3 :
-                    targetRect.top -= 3 ;
-                    targetRect.bottom -= 3 ;
-                    this._hoverContainer.style.paddingBottom = `${3 }px`;
-                    this._hoverContainer.style.marginBottom = `${-3 }px`;
+                case HoverPosition.ABOVE:
+                    targetRect.top -= Constants.PointerSize;
+                    targetRect.bottom -= Constants.PointerSize;
+                    this._hoverContainer.style.paddingBottom = `${Constants.PointerSize}px`;
+                    this._hoverContainer.style.marginBottom = `${-Constants.PointerSize}px`;
                     break;
             }
             targetRect.center.x = targetRect.left + (width / 2);
@@ -295,14 +303,14 @@ let HoverWidget = class HoverWidget extends Widget {
         this._hover.onContentsChanged();
     }
     computeXCordinate(target) {
-        const hoverWidth = this._hover.containerDomNode.clientWidth + 2 ;
+        const hoverWidth = this._hover.containerDomNode.clientWidth + Constants.HoverBorderWidth;
         if (this._target.x !== undefined) {
             this._x = this._target.x;
         }
-        else if (this._hoverPosition === 1 ) {
+        else if (this._hoverPosition === HoverPosition.RIGHT) {
             this._x = target.right;
         }
-        else if (this._hoverPosition === 0 ) {
+        else if (this._hoverPosition === HoverPosition.LEFT) {
             this._x = target.left - hoverWidth;
         }
         else {
@@ -314,21 +322,21 @@ let HoverWidget = class HoverWidget extends Widget {
             }
             if (this._x + hoverWidth >= this._targetDocumentElement.clientWidth) {
                 this._hover.containerDomNode.classList.add('right-aligned');
-                this._x = Math.max(this._targetDocumentElement.clientWidth - hoverWidth - 2 , this._targetDocumentElement.clientLeft);
+                this._x = Math.max(this._targetDocumentElement.clientWidth - hoverWidth - Constants.HoverWindowEdgeMargin, this._targetDocumentElement.clientLeft);
             }
         }
         if (this._x < this._targetDocumentElement.clientLeft) {
-            this._x = target.left + 2 ;
+            this._x = target.left + Constants.HoverWindowEdgeMargin;
         }
     }
     computeYCordinate(target) {
         if (this._target.y !== undefined) {
             this._y = this._target.y;
         }
-        else if (this._hoverPosition === 3 ) {
+        else if (this._hoverPosition === HoverPosition.ABOVE) {
             this._y = target.top;
         }
-        else if (this._hoverPosition === 2 ) {
+        else if (this._hoverPosition === HoverPosition.BELOW) {
             this._y = target.bottom - 2;
         }
         else {
@@ -347,42 +355,42 @@ let HoverWidget = class HoverWidget extends Widget {
         if (this._target.x !== undefined) {
             return;
         }
-        const hoverPointerOffset = (this._hoverPointer ? 3  : 0);
+        const hoverPointerOffset = (this._hoverPointer ? Constants.PointerSize : 0);
         if (this._forcePosition) {
-            const padding = hoverPointerOffset + 2 ;
-            if (this._hoverPosition === 1 ) {
+            const padding = hoverPointerOffset + Constants.HoverBorderWidth;
+            if (this._hoverPosition === HoverPosition.RIGHT) {
                 this._hover.containerDomNode.style.maxWidth = `${this._targetDocumentElement.clientWidth - target.right - padding}px`;
             }
-            else if (this._hoverPosition === 0 ) {
+            else if (this._hoverPosition === HoverPosition.LEFT) {
                 this._hover.containerDomNode.style.maxWidth = `${target.left - padding}px`;
             }
             return;
         }
-        if (this._hoverPosition === 1 ) {
+        if (this._hoverPosition === HoverPosition.RIGHT) {
             const roomOnRight = this._targetDocumentElement.clientWidth - target.right;
             if (roomOnRight < this._hover.containerDomNode.clientWidth + hoverPointerOffset) {
                 const roomOnLeft = target.left;
                 if (roomOnLeft >= this._hover.containerDomNode.clientWidth + hoverPointerOffset) {
-                    this._hoverPosition = 0 ;
+                    this._hoverPosition = HoverPosition.LEFT;
                 }
                 else {
-                    this._hoverPosition = 2 ;
+                    this._hoverPosition = HoverPosition.BELOW;
                 }
             }
         }
-        else if (this._hoverPosition === 0 ) {
+        else if (this._hoverPosition === HoverPosition.LEFT) {
             const roomOnLeft = target.left;
             if (roomOnLeft < this._hover.containerDomNode.clientWidth + hoverPointerOffset) {
                 const roomOnRight = this._targetDocumentElement.clientWidth - target.right;
                 if (roomOnRight >= this._hover.containerDomNode.clientWidth + hoverPointerOffset) {
-                    this._hoverPosition = 1 ;
+                    this._hoverPosition = HoverPosition.RIGHT;
                 }
                 else {
-                    this._hoverPosition = 2 ;
+                    this._hoverPosition = HoverPosition.BELOW;
                 }
             }
             if (target.left - this._hover.containerDomNode.clientWidth - hoverPointerOffset <= this._targetDocumentElement.clientLeft) {
-                this._hoverPosition = 1 ;
+                this._hoverPosition = HoverPosition.RIGHT;
             }
         }
     }
@@ -390,26 +398,26 @@ let HoverWidget = class HoverWidget extends Widget {
         if (this._target.y !== undefined || this._forcePosition) {
             return;
         }
-        const hoverPointerOffset = (this._hoverPointer ? 3  : 0);
-        if (this._hoverPosition === 3 ) {
+        const hoverPointerOffset = (this._hoverPointer ? Constants.PointerSize : 0);
+        if (this._hoverPosition === HoverPosition.ABOVE) {
             if (target.top - this._hover.containerDomNode.clientHeight - hoverPointerOffset < 0) {
-                this._hoverPosition = 2 ;
+                this._hoverPosition = HoverPosition.BELOW;
             }
         }
-        else if (this._hoverPosition === 2 ) {
+        else if (this._hoverPosition === HoverPosition.BELOW) {
             if (target.bottom + this._hover.containerDomNode.clientHeight + hoverPointerOffset > this._targetWindow.innerHeight) {
-                this._hoverPosition = 3 ;
+                this._hoverPosition = HoverPosition.ABOVE;
             }
         }
     }
     adjustHoverMaxHeight(target) {
         let maxHeight = this._targetWindow.innerHeight / 2;
         if (this._forcePosition) {
-            const padding = (this._hoverPointer ? 3  : 0) + 2 ;
-            if (this._hoverPosition === 3 ) {
+            const padding = (this._hoverPointer ? Constants.PointerSize : 0) + Constants.HoverBorderWidth;
+            if (this._hoverPosition === HoverPosition.ABOVE) {
                 maxHeight = Math.min(maxHeight, target.top - padding);
             }
-            else if (this._hoverPosition === 2 ) {
+            else if (this._hoverPosition === HoverPosition.BELOW) {
                 maxHeight = Math.min(maxHeight, this._targetWindow.innerHeight - target.bottom - padding);
             }
         }
@@ -426,26 +434,26 @@ let HoverWidget = class HoverWidget extends Widget {
             return;
         }
         switch (this._hoverPosition) {
-            case 0 :
-            case 1 : {
-                this._hoverPointer.classList.add(this._hoverPosition === 0  ? 'right' : 'left');
+            case HoverPosition.LEFT:
+            case HoverPosition.RIGHT: {
+                this._hoverPointer.classList.add(this._hoverPosition === HoverPosition.LEFT ? 'right' : 'left');
                 const hoverHeight = this._hover.containerDomNode.clientHeight;
                 if (hoverHeight > target.height) {
-                    this._hoverPointer.style.top = `${target.center.y - (this._y - hoverHeight) - 3 }px`;
+                    this._hoverPointer.style.top = `${target.center.y - (this._y - hoverHeight) - Constants.PointerSize}px`;
                 }
                 else {
-                    this._hoverPointer.style.top = `${Math.round((hoverHeight / 2)) - 3 }px`;
+                    this._hoverPointer.style.top = `${Math.round((hoverHeight / 2)) - Constants.PointerSize}px`;
                 }
                 break;
             }
-            case 3 :
-            case 2 : {
-                this._hoverPointer.classList.add(this._hoverPosition === 3  ? 'bottom' : 'top');
+            case HoverPosition.ABOVE:
+            case HoverPosition.BELOW: {
+                this._hoverPointer.classList.add(this._hoverPosition === HoverPosition.ABOVE ? 'bottom' : 'top');
                 const hoverWidth = this._hover.containerDomNode.clientWidth;
-                let pointerLeftPosition = Math.round((hoverWidth / 2)) - 3 ;
+                let pointerLeftPosition = Math.round((hoverWidth / 2)) - Constants.PointerSize;
                 const pointerX = this._x + pointerLeftPosition;
                 if (pointerX < target.left || pointerX > target.right) {
-                    pointerLeftPosition = target.center.x - this._x - 3 ;
+                    pointerLeftPosition = target.center.x - this._x - Constants.PointerSize;
                 }
                 this._hoverPointer.style.left = `${pointerLeftPosition}px`;
                 break;

package/vscode/src/vs/editor/browser/services/hoverService/updatableHoverWidget.js

@@ -1,3 +1,5 @@
+import { isHTMLElement } from '../../../../base/browser/dom.js';
+import { HoverPosition } from '../../../../base/browser/ui/hover/hoverWidget.js';
 import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
 import { isMarkdownString } from '../../../../base/common/htmlContent.js';
 import { isString, isFunction } from '../../../../base/common/types.js';
@@ -18,7 +20,7 @@ class UpdatableHoverWidget {
             return;
         }
         let resolvedContent;
-        if (content === undefined || isString(content) || content instanceof HTMLElement) {
+        if (content === undefined || isString(content) || isHTMLElement(content)) {
             resolvedContent = content;
         }
         else if (!isFunction(content.markdown)) {
@@ -26,7 +28,7 @@ class UpdatableHoverWidget {
         }
         else {
             if (!this._hoverWidget) {
-                this.show(( localizeWithPath(_moduleId, 0, "Loading...")), focus);
+                this.show(( localizeWithPath(_moduleId, 0, "Loading...")), focus, options);
             }
             this._cancellationTokenSource = ( (new CancellationTokenSource()));
             const token = this._cancellationTokenSource.token;
@@ -51,7 +53,7 @@ class UpdatableHoverWidget {
                     skipFadeInAnimation: !this.fadeInAnimation || !!oldHoverWidget,
                 },
                 position: {
-                    hoverPosition: 2 ,
+                    hoverPosition: HoverPosition.BELOW,
                 },
                 ...options
             };

package/vscode/src/vs/editor/browser/services/markerDecorations.js

@@ -1,6 +1,6 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { IMarkerDecorationsService } from '../../common/services/markerDecorations.js';
-import { registerEditorContribution } from '../editorExtensions.js';
+import { registerEditorContribution, EditorContributionInstantiation } from '../editorExtensions.js';
 let MarkerDecorationsContribution = class MarkerDecorationsContribution {
     static { this.ID = 'editor.contrib.markerDecorations'; }
     constructor(_editor, _markerDecorationsService) {
@@ -11,5 +11,5 @@ let MarkerDecorationsContribution = class MarkerDecorationsContribution {
 MarkerDecorationsContribution = ( __decorate([
     ( __param(1, IMarkerDecorationsService))
 ], MarkerDecorationsContribution));
-registerEditorContribution(MarkerDecorationsContribution.ID, MarkerDecorationsContribution, 0 );
+registerEditorContribution(MarkerDecorationsContribution.ID, MarkerDecorationsContribution, EditorContributionInstantiation.Eager);
 export { MarkerDecorationsContribution };

package/vscode/src/vs/editor/browser/stableEditorScroll.js

@@ -1,3 +1,4 @@
+import { ScrollType } from '../common/editorCommon.js';
 class StableEditorScrollState {
     static capture(editor) {
         if (editor.getScrollTop() === 0 || editor.hasPendingScrollAnimation()) {
@@ -44,7 +45,7 @@ class StableEditorScrollState {
             return;
         }
         const offset = editor.getTopForLineNumber(currentCursorPosition.lineNumber) - editor.getTopForLineNumber(this._cursorPosition.lineNumber);
-        editor.setScrollTop(editor.getScrollTop() + offset);
+        editor.setScrollTop(editor.getScrollTop() + offset, ScrollType.Immediate);
     }
 }
 class StableEditorBottomScrollState {
@@ -58,7 +59,7 @@ class StableEditorBottomScrollState {
         if (visibleRanges.length > 0) {
             visiblePosition = visibleRanges.at(-1).getEndPosition();
             const visiblePositionScrollBottom = editor.getBottomForLineNumber(visiblePosition.lineNumber);
-            visiblePositionScrollDelta = (editor.getScrollTop() + editor.getLayoutInfo().height) - visiblePositionScrollBottom;
+            visiblePositionScrollDelta = visiblePositionScrollBottom - editor.getScrollTop();
         }
         return ( new StableEditorBottomScrollState(
             editor.getScrollTop(),
@@ -79,7 +80,7 @@ class StableEditorBottomScrollState {
         }
         if (this._visiblePosition) {
             const visiblePositionScrollBottom = editor.getBottomForLineNumber(this._visiblePosition.lineNumber);
-            editor.setScrollTop(visiblePositionScrollBottom - (this._visiblePositionScrollDelta + editor.getLayoutInfo().height));
+            editor.setScrollTop(visiblePositionScrollBottom - this._visiblePositionScrollDelta, ScrollType.Immediate);
         }
     }
 }

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

@@ -1,7 +1,9 @@
 import { createTrustedTypesPolicy } from '../../../base/browser/trustedTypes.js';
+import { CharCode } from '../../../base/common/charCode.js';
 import { firstNonWhitespaceIndex, isFullWidthCharacter } from '../../../base/common/strings.js';
 import { assertIsDefined } from '../../../base/common/types.js';
 import { applyFontInfo } from '../config/domFontInfo.js';
+import { WrappingIndent } from '../../common/config/editorOptions.js';
 import { StringBuilder } from '../../common/core/stringBuilder.js';
 import { ModelLineProjectionData } from '../../common/modelLineProjectionData.js';
 import { LineInjectedText } from '../../common/textModelEvents.js';
@@ -48,7 +50,7 @@ function createLineBreaks(targetWindow, requests, fontInfo, tabSize, firstLineBr
         return result;
     }
     const overallWidth = Math.round(firstLineBreakColumn * fontInfo.typicalHalfwidthCharacterWidth);
-    const additionalIndent = (wrappingIndent === 3  ? 2 : wrappingIndent === 2  ? 1 : 0);
+    const additionalIndent = (wrappingIndent === WrappingIndent.DeepIndent ? 2 : wrappingIndent === WrappingIndent.Indent ? 1 : 0);
     const additionalIndentSize = Math.round(tabSize * additionalIndent);
     const additionalIndentLength = Math.ceil(fontInfo.spaceWidth * additionalIndentSize);
     const containerDomNode = document.createElement('div');
@@ -64,14 +66,14 @@ function createLineBreaks(targetWindow, requests, fontInfo, tabSize, firstLineBr
         let firstNonWhitespaceIndex$1 = 0;
         let wrappedTextIndentLength = 0;
         let width = overallWidth;
-        if (wrappingIndent !== 0 ) {
+        if (wrappingIndent !== WrappingIndent.None) {
             firstNonWhitespaceIndex$1 = firstNonWhitespaceIndex(lineContent);
             if (firstNonWhitespaceIndex$1 === -1) {
                 firstNonWhitespaceIndex$1 = 0;
             }
             else {
                 for (let i = 0; i < firstNonWhitespaceIndex$1; i++) {
-                    const charWidth = (lineContent.charCodeAt(i) === 9
+                    const charWidth = (lineContent.charCodeAt(i) === CharCode.Tab
                         ? (tabSize - (wrappedTextIndentLength % tabSize))
                         : 1);
                     wrappedTextIndentLength += charWidth;
@@ -152,6 +154,10 @@ function createLineBreaks(targetWindow, requests, fontInfo, tabSize, firstLineBr
     targetWindow.document.body.removeChild(containerDomNode);
     return result;
 }
+var Constants;
+( (function(Constants) {
+    Constants[Constants["SPAN_MODULO_LIMIT"] = 16384] = "SPAN_MODULO_LIMIT";
+})(Constants || (Constants = {})));
 function renderLine(lineContent, initialVisibleColumn, tabSize, width, sb, wrappingIndentLength) {
     if (wrappingIndentLength !== 0) {
         const hangingOffset = String(wrappingIndentLength);
@@ -171,20 +177,20 @@ function renderLine(lineContent, initialVisibleColumn, tabSize, width, sb, wrapp
     let charOffset = 0;
     const charOffsets = [];
     const visibleColumns = [];
-    let nextCharCode = ((0 < len ? lineContent.charCodeAt(0) : 0) );
+    let nextCharCode = (0 < len ? lineContent.charCodeAt(0) : CharCode.Null);
     sb.appendString('<span>');
     for (let charIndex = 0; charIndex < len; charIndex++) {
-        if (charIndex !== 0 && charIndex % 16384  === 0) {
+        if (charIndex !== 0 && charIndex % Constants.SPAN_MODULO_LIMIT === 0) {
             sb.appendString('</span><span>');
         }
         charOffsets[charIndex] = charOffset;
         visibleColumns[charIndex] = visibleColumn;
         const charCode = nextCharCode;
-        nextCharCode = ((charIndex + 1 < len ? lineContent.charCodeAt(charIndex + 1) : 0) );
+        nextCharCode = (charIndex + 1 < len ? lineContent.charCodeAt(charIndex + 1) : CharCode.Null);
         let producedCharacters = 1;
         let charWidth = 1;
         switch (charCode) {
-            case 9 :
+            case CharCode.Tab:
                 producedCharacters = (tabSize - (visibleColumn % tabSize));
                 charWidth = producedCharacters;
                 for (let space = 1; space <= producedCharacters; space++) {
@@ -192,34 +198,34 @@ function renderLine(lineContent, initialVisibleColumn, tabSize, width, sb, wrapp
                         sb.appendCharCode(0xA0);
                     }
                     else {
-                        sb.appendASCIICharCode(32 );
+                        sb.appendASCIICharCode(CharCode.Space);
                     }
                 }
                 break;
-            case 32 :
-                if (nextCharCode === 32 ) {
+            case CharCode.Space:
+                if (nextCharCode === CharCode.Space) {
                     sb.appendCharCode(0xA0);
                 }
                 else {
-                    sb.appendASCIICharCode(32 );
+                    sb.appendASCIICharCode(CharCode.Space);
                 }
                 break;
-            case 60 :
+            case CharCode.LessThan:
                 sb.appendString('&lt;');
                 break;
-            case 62 :
+            case CharCode.GreaterThan:
                 sb.appendString('&gt;');
                 break;
-            case 38 :
+            case CharCode.Ampersand:
                 sb.appendString('&amp;');
                 break;
-            case 0 :
+            case CharCode.Null:
                 sb.appendString('&#00;');
                 break;
-            case 65279 :
-            case 8232 :
-            case 8233 :
-            case 133 :
+            case CharCode.UTF8_BOM:
+            case CharCode.LINE_SEPARATOR:
+            case CharCode.PARAGRAPH_SEPARATOR:
+            case CharCode.NEXT_LINE:
                 sb.appendCharCode(0xFFFD);
                 break;
             default:
@@ -280,8 +286,8 @@ function discoverBreaks(range, spans, charOffsets, low, lowRects, high, highRect
     discoverBreaks(range, spans, charOffsets, mid, midRects, high, highRects, result);
 }
 function readClientRect(range, spans, startOffset, endOffset) {
-    range.setStart(spans[((startOffset / 16384) ) | 0].firstChild, startOffset % 16384 );
-    range.setEnd(spans[((endOffset / 16384) ) | 0].firstChild, endOffset % 16384 );
+    range.setStart(spans[(startOffset / Constants.SPAN_MODULO_LIMIT) | 0].firstChild, startOffset % Constants.SPAN_MODULO_LIMIT);
+    range.setEnd(spans[(endOffset / Constants.SPAN_MODULO_LIMIT) | 0].firstChild, endOffset % Constants.SPAN_MODULO_LIMIT);
     return range.getClientRects();
 }
 export { DOMLineBreaksComputerFactory };

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

@@ -1,5 +1,6 @@
 import { CoreNavigationCommands } from '../coreCommands.js';
 import { Position } from '../../common/core/position.js';
+import { EditorOption } from '../../common/config/editorOptions.js';
 import { isLinux } from '../../../base/common/platform.js';
 class ViewController {
     constructor(configuration, viewModel, userInputEvents, commandDelegate) {
@@ -40,7 +41,7 @@ class ViewController {
         return viewPosition;
     }
     _hasMulticursorModifier(data) {
-        switch (this.configuration.options.get(78 )) {
+        switch (this.configuration.options.get(EditorOption.multiCursorModifier)) {
             case 'altKey':
                 return data.altKey;
             case 'ctrlKey':
@@ -52,7 +53,7 @@ class ViewController {
         }
     }
     _hasNonMulticursorModifier(data) {
-        switch (this.configuration.options.get(78 )) {
+        switch (this.configuration.options.get(EditorOption.multiCursorModifier)) {
             case 'altKey':
                 return data.ctrlKey || data.metaKey;
             case 'ctrlKey':
@@ -65,8 +66,8 @@ class ViewController {
     }
     dispatchMouse(data) {
         const options = this.configuration.options;
-        const selectionClipboardIsOn = (isLinux && options.get(107 ));
-        const columnSelection = options.get(22 );
+        const selectionClipboardIsOn = (isLinux && options.get(EditorOption.selectionClipboard));
+        const columnSelection = options.get(EditorOption.columnSelection);
         if (data.middleButton && !selectionClipboardIsOn) {
             this._columnSelect(data.position, data.mouseColumn, data.inSelectionMode);
         }

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

@@ -1,6 +1,7 @@
 import { createFastDomNode } from '../../../base/browser/fastDomNode.js';
 import { createTrustedTypesPolicy } from '../../../base/browser/trustedTypes.js';
 import { BugIndicatingError } from '../../../base/common/errors.js';
+import { EditorOption } from '../../common/config/editorOptions.js';
 import { StringBuilder } from '../../common/core/stringBuilder.js';
 class RenderedLinesCollection {
     constructor(createLine) {
@@ -160,7 +161,7 @@ class VisibleLinesCollection {
         return domNode;
     }
     onConfigurationChanged(e) {
-        if (e.hasChanged(145 )) {
+        if (e.hasChanged(EditorOption.layoutInfo)) {
             return true;
         }
         return false;

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

@@ -2,13 +2,14 @@ import { createFastDomNode } from '../../../base/browser/fastDomNode.js';
 import { applyFontInfo } from '../config/domFontInfo.js';
 import { VisibleLinesCollection } from './viewLayer.js';
 import { ViewPart } from './viewPart.js';
+import { EditorOption } from '../../common/config/editorOptions.js';
 class ViewOverlays extends ViewPart {
     constructor(context) {
         super(context);
         this._visibleLines = ( new VisibleLinesCollection(this));
         this.domNode = this._visibleLines.domNode;
         const options = this._context.configuration.options;
-        const fontInfo = options.get(50 );
+        const fontInfo = options.get(EditorOption.fontInfo);
         applyFontInfo(this.domNode, fontInfo);
         this._dynamicOverlays = [];
         this._isFocused = false;
@@ -46,7 +47,7 @@ class ViewOverlays extends ViewPart {
     onConfigurationChanged(e) {
         this._visibleLines.onConfigurationChanged(e);
         const options = this._context.configuration.options;
-        const fontInfo = options.get(50 );
+        const fontInfo = options.get(EditorOption.fontInfo);
         applyFontInfo(this.domNode, fontInfo);
         return true;
     }
@@ -140,13 +141,13 @@ class ContentViewOverlays extends ViewOverlays {
     constructor(context) {
         super(context);
         const options = this._context.configuration.options;
-        const layoutInfo = options.get(145 );
+        const layoutInfo = options.get(EditorOption.layoutInfo);
         this._contentWidth = layoutInfo.contentWidth;
         this.domNode.setHeight(0);
     }
     onConfigurationChanged(e) {
         const options = this._context.configuration.options;
-        const layoutInfo = options.get(145 );
+        const layoutInfo = options.get(EditorOption.layoutInfo);
         this._contentWidth = layoutInfo.contentWidth;
         return super.onConfigurationChanged(e) || true;
     }
@@ -162,16 +163,16 @@ class MarginViewOverlays extends ViewOverlays {
     constructor(context) {
         super(context);
         const options = this._context.configuration.options;
-        const layoutInfo = options.get(145 );
+        const layoutInfo = options.get(EditorOption.layoutInfo);
         this._contentLeft = layoutInfo.contentLeft;
         this.domNode.setClassName('margin-view-overlays');
         this.domNode.setWidth(1);
-        applyFontInfo(this.domNode, options.get(50 ));
+        applyFontInfo(this.domNode, options.get(EditorOption.fontInfo));
     }
     onConfigurationChanged(e) {
         const options = this._context.configuration.options;
-        applyFontInfo(this.domNode, options.get(50 ));
-        const layoutInfo = options.get(145 );
+        applyFontInfo(this.domNode, options.get(EditorOption.fontInfo));
+        const layoutInfo = options.get(EditorOption.layoutInfo);
         this._contentLeft = layoutInfo.contentLeft;
         return super.onConfigurationChanged(e) || true;
     }

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

@@ -10,6 +10,19 @@ class ViewPart extends ViewEventHandler {
         super.dispose();
     }
 }
+var PartFingerprint;
+( (function(PartFingerprint) {
+    PartFingerprint[PartFingerprint["None"] = 0] = "None";
+    PartFingerprint[PartFingerprint["ContentWidgets"] = 1] = "ContentWidgets";
+    PartFingerprint[PartFingerprint["OverflowingContentWidgets"] = 2] = "OverflowingContentWidgets";
+    PartFingerprint[PartFingerprint["OverflowGuard"] = 3] = "OverflowGuard";
+    PartFingerprint[PartFingerprint["OverlayWidgets"] = 4] = "OverlayWidgets";
+    PartFingerprint[PartFingerprint["OverflowingOverlayWidgets"] = 5] = "OverflowingOverlayWidgets";
+    PartFingerprint[PartFingerprint["ScrollableElement"] = 6] = "ScrollableElement";
+    PartFingerprint[PartFingerprint["TextArea"] = 7] = "TextArea";
+    PartFingerprint[PartFingerprint["ViewLines"] = 8] = "ViewLines";
+    PartFingerprint[PartFingerprint["Minimap"] = 9] = "Minimap";
+})(PartFingerprint || (PartFingerprint = {})));
 class PartFingerprints {
     static write(target, partId) {
         target.setAttribute('data-mprt', String(partId));
@@ -17,7 +30,7 @@ class PartFingerprints {
     static read(target) {
         const r = target.getAttribute('data-mprt');
         if (r === null) {
-            return 0 ;
+            return PartFingerprint.None;
         }
         return parseInt(r, 10);
     }
@@ -40,4 +53,4 @@ class PartFingerprints {
         return r;
     }
 }
-export { PartFingerprints, ViewPart };
+export { PartFingerprint, PartFingerprints, ViewPart };