@codingame/monaco-vscode-api 5.3.0 → 6.0.1

package/vscode/src/vs/editor/common/services/unicodeTextModelHighlighter.js

@@ -50,14 +50,14 @@ class UnicodeTextModelHighlighter {
                         word = null;
                     }
                     const highlightReason = codePointHighlighter.shouldHighlightNonBasicASCII(str, word ? word.word : null);
-                    if (highlightReason !== 0 ) {
-                        if (highlightReason === 3 ) {
+                    if (highlightReason !== SimpleHighlightReason.None) {
+                        if (highlightReason === SimpleHighlightReason.Ambiguous) {
                             ambiguousCharacterCount++;
                         }
-                        else if (highlightReason === 2 ) {
+                        else if (highlightReason === SimpleHighlightReason.Invisible) {
                             invisibleCharacterCount++;
                         }
-                        else if (highlightReason === 1 ) {
+                        else if (highlightReason === SimpleHighlightReason.NonBasicASCII) {
                             nonBasicAsciiCharacterCount++;
                         }
                         else {
@@ -85,18 +85,18 @@ class UnicodeTextModelHighlighter {
         const codePointHighlighter = ( new CodePointHighlighter(options));
         const reason = codePointHighlighter.shouldHighlightNonBasicASCII(char, null);
         switch (reason) {
-            case 0 :
+            case SimpleHighlightReason.None:
                 return null;
-            case 2 :
-                return { kind: 1  };
-            case 3 : {
+            case SimpleHighlightReason.Invisible:
+                return { kind: UnicodeHighlighterReasonKind.Invisible };
+            case SimpleHighlightReason.Ambiguous: {
                 const codePoint = char.codePointAt(0);
                 const primaryConfusable = codePointHighlighter.ambiguousCharacters.getPrimaryConfusable(codePoint);
                 const notAmbiguousInLocales = AmbiguousCharacters.getLocales().filter((l) => !AmbiguousCharacters.getInstance(( new Set([...options.allowedLocales, l]))).isAmbiguous(codePoint));
-                return { kind: 0 , confusableWith: String.fromCodePoint(primaryConfusable), notAmbiguousInLocales };
+                return { kind: UnicodeHighlighterReasonKind.Ambiguous, confusableWith: String.fromCodePoint(primaryConfusable), notAmbiguousInLocales };
             }
-            case 1 :
-                return { kind: 2  };
+            case SimpleHighlightReason.NonBasicASCII:
+                return { kind: UnicodeHighlighterReasonKind.NonBasicAscii };
         }
     }
 }
@@ -104,6 +104,12 @@ function buildRegExpCharClassExpr(codePoints, flags) {
     const src = `[${escapeRegExpCharacters(( codePoints.map((i) => String.fromCodePoint(i))).join(''))}]`;
     return src;
 }
+var UnicodeHighlighterReasonKind;
+( (function(UnicodeHighlighterReasonKind) {
+    UnicodeHighlighterReasonKind[UnicodeHighlighterReasonKind["Ambiguous"] = 0] = "Ambiguous";
+    UnicodeHighlighterReasonKind[UnicodeHighlighterReasonKind["Invisible"] = 1] = "Invisible";
+    UnicodeHighlighterReasonKind[UnicodeHighlighterReasonKind["NonBasicAscii"] = 2] = "NonBasicAscii";
+})(UnicodeHighlighterReasonKind || (UnicodeHighlighterReasonKind = {})));
 class CodePointHighlighter {
     constructor(options) {
         this.options = options;
@@ -135,10 +141,10 @@ class CodePointHighlighter {
     shouldHighlightNonBasicASCII(character, wordContext) {
         const codePoint = character.codePointAt(0);
         if (( this.allowedCodePoints.has(codePoint))) {
-            return 0 ;
+            return SimpleHighlightReason.None;
         }
         if (this.options.nonBasicASCII) {
-            return 1 ;
+            return SimpleHighlightReason.NonBasicASCII;
         }
         let hasBasicASCIICharacters = false;
         let hasNonConfusableNonBasicAsciiCharacter = false;
@@ -157,22 +163,29 @@ class CodePointHighlighter {
         if (
          !hasBasicASCIICharacters &&
              hasNonConfusableNonBasicAsciiCharacter) {
-            return 0 ;
+            return SimpleHighlightReason.None;
         }
         if (this.options.invisibleCharacters) {
             if (!isAllowedInvisibleCharacter(character) && InvisibleCharacters.isInvisibleCharacter(codePoint)) {
-                return 2 ;
+                return SimpleHighlightReason.Invisible;
             }
         }
         if (this.options.ambiguousCharacters) {
             if (this.ambiguousCharacters.isAmbiguous(codePoint)) {
-                return 3 ;
+                return SimpleHighlightReason.Ambiguous;
             }
         }
-        return 0 ;
+        return SimpleHighlightReason.None;
     }
 }
 function isAllowedInvisibleCharacter(character) {
     return character === ' ' || character === '\n' || character === '\t';
 }
-export { UnicodeTextModelHighlighter };
+var SimpleHighlightReason;
+( (function(SimpleHighlightReason) {
+    SimpleHighlightReason[SimpleHighlightReason["None"] = 0] = "None";
+    SimpleHighlightReason[SimpleHighlightReason["NonBasicASCII"] = 1] = "NonBasicASCII";
+    SimpleHighlightReason[SimpleHighlightReason["Invisible"] = 2] = "Invisible";
+    SimpleHighlightReason[SimpleHighlightReason["Ambiguous"] = 3] = "Ambiguous";
+})(SimpleHighlightReason || (SimpleHighlightReason = {})));
+export { UnicodeHighlighterReasonKind, UnicodeTextModelHighlighter };

package/vscode/src/vs/editor/common/standaloneStrings.js

@@ -33,76 +33,55 @@ var AccessibilityHelpNLS;
     AccessibilityHelpNLS.tabFocusModeOnMsg = ( localizeWithPath(
         _moduleId,
         12,
-        "Pressing Tab in the current editor will move focus to the next focusable element. Toggle this behavior {0}."
+        "Pressing Tab in the current editor will move focus to the next focusable element. Toggle this behavior<keybinding:editor.action.toggleTabFocusMode>"
     ));
-    AccessibilityHelpNLS.tabFocusModeOnMsgNoKb = ( localizeWithPath(
+    AccessibilityHelpNLS.tabFocusModeOffMsg = ( localizeWithPath(
         _moduleId,
         13,
-        "Pressing Tab in the current editor will move focus to the next focusable element. The command {0} is currently not triggerable by a keybinding."
+        "Pressing Tab in the current editor will insert the tab character. Toggle this behavior<keybinding:editor.action.toggleTabFocusMode>"
     ));
-    AccessibilityHelpNLS.stickScrollKb = ( localizeWithPath(
+    AccessibilityHelpNLS.stickScroll = ( localizeWithPath(
         _moduleId,
         14,
-        "Focus Sticky Scroll ({0}) to focus the currently nested scopes."
-    ));
-    AccessibilityHelpNLS.stickScrollNoKb = ( localizeWithPath(
-        _moduleId,
-        15,
-        "Focus Sticky Scroll to focus the currently nested scopes. It is currently not triggerable by a keybinding."
-    ));
-    AccessibilityHelpNLS.tabFocusModeOffMsg = ( localizeWithPath(
-        _moduleId,
-        16,
-        "Pressing Tab in the current editor will insert the tab character. Toggle this behavior {0}."
-    ));
-    AccessibilityHelpNLS.tabFocusModeOffMsgNoKb = ( localizeWithPath(
-        _moduleId,
-        17,
-        "Pressing Tab in the current editor will insert the tab character. The command {0} is currently not triggerable by a keybinding."
+        "Focus Sticky Scroll<keybinding:editor.action.focusStickyScroll> to focus the currently nested scopes."
     ));
-    AccessibilityHelpNLS.showAccessibilityHelpAction = ( localizeWithPath(_moduleId, 18, "Show Accessibility Help"));
+    AccessibilityHelpNLS.showAccessibilityHelpAction = ( localizeWithPath(_moduleId, 15, "Show Accessibility Help"));
     AccessibilityHelpNLS.listSignalSounds = ( localizeWithPath(
         _moduleId,
-        19,
+        16,
         "Run the command: List Signal Sounds for an overview of all sounds and their current status."
     ));
     AccessibilityHelpNLS.listAlerts = ( localizeWithPath(
         _moduleId,
-        20,
+        17,
         "Run the command: List Signal Announcements for an overview of announcements and their current status."
     ));
-    AccessibilityHelpNLS.quickChat = ( localizeWithPath(_moduleId, 21, "Toggle quick chat ({0}) to open or close a chat session."));
-    AccessibilityHelpNLS.quickChatNoKb = ( localizeWithPath(
+    AccessibilityHelpNLS.quickChat = ( localizeWithPath(
         _moduleId,
-        22,
-        "Toggle quick chat is not currently triggerable by a keybinding."
+        18,
+        "Toggle quick chat<keybinding:workbench.action.quickchat.toggle> to open or close a chat session."
     ));
     AccessibilityHelpNLS.startInlineChat = ( localizeWithPath(
         _moduleId,
-        23,
-        "Start inline chat ({0}) to create an in editor chat session."
-    ));
-    AccessibilityHelpNLS.startInlineChatNoKb = ( localizeWithPath(
-        _moduleId,
-        24,
-        "The command: Start inline chat is not currentlyt riggerable by a keybinding."
+        19,
+        "Start inline chat<keybinding:inlineChat.start> to create an in editor chat session."
     ));
 })(AccessibilityHelpNLS || (AccessibilityHelpNLS = {}))));
 var InspectTokensNLS;
 ( ((function(InspectTokensNLS) {
-    InspectTokensNLS.inspectTokensAction = ( localizeWithPath(_moduleId, 25, "Developer: Inspect Tokens"));
+    InspectTokensNLS.inspectTokensAction = ( localizeWithPath(_moduleId, 20, "Developer: Inspect Tokens"));
 })(InspectTokensNLS || (InspectTokensNLS = {}))));
 var StandaloneCodeEditorNLS;
 ( ((function(StandaloneCodeEditorNLS) {
-    StandaloneCodeEditorNLS.editorViewAccessibleLabel = ( localizeWithPath(_moduleId, 32, "Editor content"));
-    StandaloneCodeEditorNLS.accessibilityHelpMessage = ( localizeWithPath(_moduleId, 33, "Press Alt+F1 for Accessibility Options."));
+    StandaloneCodeEditorNLS.editorViewAccessibleLabel = ( localizeWithPath(_moduleId, 27, "Editor content"));
+    StandaloneCodeEditorNLS.accessibilityHelpMessage = ( localizeWithPath(_moduleId, 28, "Press Alt+F1 for Accessibility Options."));
 })(StandaloneCodeEditorNLS || (StandaloneCodeEditorNLS = {}))));
 var ToggleHighContrastNLS;
 ( ((function(ToggleHighContrastNLS) {
-    ToggleHighContrastNLS.toggleHighContrast = ( localizeWithPath(_moduleId, 34, "Toggle High Contrast Theme"));
+    ToggleHighContrastNLS.toggleHighContrast = ( localizeWithPath(_moduleId, 29, "Toggle High Contrast Theme"));
 })(ToggleHighContrastNLS || (ToggleHighContrastNLS = {}))));
 var StandaloneServicesNLS;
 ( ((function(StandaloneServicesNLS) {
-    StandaloneServicesNLS.bulkEditServiceSummary = ( localizeWithPath(_moduleId, 35, "Made {0} edits in {1} files"));
+    StandaloneServicesNLS.bulkEditServiceSummary = ( localizeWithPath(_moduleId, 30, "Made {0} edits in {1} files"));
 })(StandaloneServicesNLS || (StandaloneServicesNLS = {}))));
 export { AccessibilityHelpNLS, InspectTokensNLS, StandaloneCodeEditorNLS, StandaloneServicesNLS, ToggleHighContrastNLS };

package/vscode/src/vs/editor/common/textModelEvents.js

@@ -1,6 +1,14 @@
+var RawContentChangedType;
+( (function(RawContentChangedType) {
+    RawContentChangedType[RawContentChangedType["Flush"] = 1] = "Flush";
+    RawContentChangedType[RawContentChangedType["LineChanged"] = 2] = "LineChanged";
+    RawContentChangedType[RawContentChangedType["LinesDeleted"] = 3] = "LinesDeleted";
+    RawContentChangedType[RawContentChangedType["LinesInserted"] = 4] = "LinesInserted";
+    RawContentChangedType[RawContentChangedType["EOLChanged"] = 5] = "EOLChanged";
+})(RawContentChangedType || (RawContentChangedType = {})));
 class ModelRawFlush {
     constructor() {
-        this.changeType = 1 ;
+        this.changeType = RawContentChangedType.Flush;
     }
 }
 class LineInjectedText {
@@ -70,7 +78,7 @@ class LineInjectedText {
 }
 class ModelRawLineChanged {
     constructor(lineNumber, detail, injectedText) {
-        this.changeType = 2 ;
+        this.changeType = RawContentChangedType.LineChanged;
         this.lineNumber = lineNumber;
         this.detail = detail;
         this.injectedText = injectedText;
@@ -78,14 +86,14 @@ class ModelRawLineChanged {
 }
 class ModelRawLinesDeleted {
     constructor(fromLineNumber, toLineNumber) {
-        this.changeType = 3 ;
+        this.changeType = RawContentChangedType.LinesDeleted;
         this.fromLineNumber = fromLineNumber;
         this.toLineNumber = toLineNumber;
     }
 }
 class ModelRawLinesInserted {
     constructor(fromLineNumber, toLineNumber, detail, injectedTexts) {
-        this.changeType = 4 ;
+        this.changeType = RawContentChangedType.LinesInserted;
         this.injectedTexts = injectedTexts;
         this.fromLineNumber = fromLineNumber;
         this.toLineNumber = toLineNumber;
@@ -94,7 +102,7 @@ class ModelRawLinesInserted {
 }
 class ModelRawEOLChanged {
     constructor() {
-        this.changeType = 5 ;
+        this.changeType = RawContentChangedType.EOLChanged;
     }
 }
 class ModelRawContentChangedEvent {
@@ -156,4 +164,4 @@ class InternalModelContentChangeEvent {
         };
     }
 }
-export { InternalModelContentChangeEvent, LineInjectedText, ModelInjectedTextChangedEvent, ModelRawContentChangedEvent, ModelRawEOLChanged, ModelRawFlush, ModelRawLineChanged, ModelRawLinesDeleted, ModelRawLinesInserted };
+export { InternalModelContentChangeEvent, LineInjectedText, ModelInjectedTextChangedEvent, ModelRawContentChangedEvent, ModelRawEOLChanged, ModelRawFlush, ModelRawLineChanged, ModelRawLinesDeleted, ModelRawLinesInserted, RawContentChangedType };

package/vscode/src/vs/editor/common/tokenizationRegistry.js

@@ -1,5 +1,6 @@
 import { Emitter } from '../../base/common/event.js';
 import { toDisposable, Disposable } from '../../base/common/lifecycle.js';
+import { ColorId } from './encodedTokenAttributes.js';
 class TokenizationRegistry {
     constructor() {
         this._tokenizationSupports = ( new Map());
@@ -75,8 +76,8 @@ class TokenizationRegistry {
         return this._colorMap;
     }
     getDefaultBackground() {
-        if (this._colorMap && this._colorMap.length > 2 ) {
-            return this._colorMap[2 ];
+        if (this._colorMap && this._colorMap.length > ColorId.DefaultBackground) {
+            return this._colorMap[ColorId.DefaultBackground];
         }
         return null;
     }

package/vscode/src/vs/editor/common/tokenizationTextModelPart.js

@@ -0,0 +1,6 @@
+var BackgroundTokenizationState;
+( (function(BackgroundTokenizationState) {
+    BackgroundTokenizationState[BackgroundTokenizationState["InProgress"] = 1] = "InProgress";
+    BackgroundTokenizationState[BackgroundTokenizationState["Completed"] = 2] = "Completed";
+})(BackgroundTokenizationState || (BackgroundTokenizationState = {})));
+export { BackgroundTokenizationState };

package/vscode/src/vs/editor/common/tokens/contiguousTokensStore.js

@@ -2,7 +2,7 @@ import { arrayInsert } from '../../../base/common/arrays.js';
 import { Position } from '../core/position.js';
 import { EMPTY_LINE_TOKENS, toUint32Array, ContiguousTokensEditing } from './contiguousTokensEditing.js';
 import { LineTokens } from './lineTokens.js';
-import { TokenMetadata } from '../encodedTokenAttributes.js';
+import { TokenMetadata, MetadataConsts, StandardTokenType, FontStyle, ColorId } from '../encodedTokenAttributes.js';
 class ContiguousTokensStore {
     constructor(languageIdCodec) {
         this._lineTokens = [];
@@ -178,11 +178,11 @@ class ContiguousTokensStore {
     }
 }
 function getDefaultMetadata(topLevelLanguageId) {
-    return (((topLevelLanguageId << 0) )
-        | ((0  << 8) )
-        | ((0  << 11) )
-        | ((1  << 15) )
-        | ((2  << 24) )
-        | ((1024) )) >>> 0;
+    return ((topLevelLanguageId << MetadataConsts.LANGUAGEID_OFFSET)
+        | (StandardTokenType.Other << MetadataConsts.TOKEN_TYPE_OFFSET)
+        | (FontStyle.None << MetadataConsts.FONT_STYLE_OFFSET)
+        | (ColorId.DefaultForeground << MetadataConsts.FOREGROUND_OFFSET)
+        | (ColorId.DefaultBackground << MetadataConsts.BACKGROUND_OFFSET)
+        | (MetadataConsts.BALANCED_BRACKETS_MASK)) >>> 0;
 }
 export { ContiguousTokensStore };

package/vscode/src/vs/editor/common/tokens/lineTokens.d.ts

@@ -1,9 +1,12 @@
 import { ILanguageIdCodec } from '../languages.js';
 import { StandardTokenType, ColorId, ITokenPresentation } from '../encodedTokenAttributes.js';
+import '../../editor.api.js';
 
 interface IViewLineTokens {
+    languageIdCodec: ILanguageIdCodec;
     equals(other: IViewLineTokens): boolean;
     getCount(): number;
+    getStandardTokenType(tokenIndex: number): StandardTokenType;
     getForeground(tokenIndex: number): ColorId;
     getEndOffset(tokenIndex: number): number;
     getClassName(tokenIndex: number): string;
@@ -13,15 +16,21 @@ interface IViewLineTokens {
     getLineContent(): string;
     getMetadata(tokenIndex: number): number;
     getLanguageId(tokenIndex: number): string;
+    getTokenText(tokenIndex: number): string;
+    forEach(callback: (tokenIndex: number) => void): void;
 }
 declare class LineTokens implements IViewLineTokens {
     _lineTokensBrand: void;
     private readonly _tokens;
     private readonly _tokensCount;
     private readonly _text;
-    private readonly _languageIdCodec;
+    readonly languageIdCodec: ILanguageIdCodec;
     static defaultTokenMetadata: number;
     static createEmpty(lineContent: string, decoder: ILanguageIdCodec): LineTokens;
+    static createFromTextAndMetadata(data: {
+        text: string;
+        metadata: number;
+    }[], decoder: ILanguageIdCodec): LineTokens;
     constructor(tokens: Uint32Array, text: string, decoder: ILanguageIdCodec);
     equals(other: IViewLineTokens): boolean;
     slicedEquals(other: LineTokens, sliceFromTokenIndex: number, sliceTokenCount: number): boolean;
@@ -55,6 +64,8 @@ declare class LineTokens implements IViewLineTokens {
         text: string;
         tokenMetadata: number;
     }[]): LineTokens;
+    getTokenText(tokenIndex: number): string;
+    forEach(callback: (tokenIndex: number) => void): void;
 }
 
 export { type IViewLineTokens, LineTokens };

package/vscode/src/vs/editor/common/tokens/lineTokens.js

@@ -1,8 +1,8 @@
-import { TokenMetadata } from '../encodedTokenAttributes.js';
+import { FontStyle, MetadataConsts, ColorId, TokenMetadata } from '../encodedTokenAttributes.js';
 class LineTokens {
-    static { this.defaultTokenMetadata = (((0  << 11) )
-        | ((1  << 15) )
-        | ((2  << 24) )) >>> 0; }
+    static { this.defaultTokenMetadata = ((FontStyle.None << MetadataConsts.FONT_STYLE_OFFSET)
+        | (ColorId.DefaultForeground << MetadataConsts.FOREGROUND_OFFSET)
+        | (ColorId.DefaultBackground << MetadataConsts.BACKGROUND_OFFSET)) >>> 0; }
     static createEmpty(lineContent, decoder) {
         const defaultMetadata = LineTokens.defaultTokenMetadata;
         const tokens = ( new Uint32Array(2));
@@ -10,12 +10,23 @@ class LineTokens {
         tokens[1] = defaultMetadata;
         return ( new LineTokens(tokens, lineContent, decoder));
     }
+    static createFromTextAndMetadata(data, decoder) {
+        let offset = 0;
+        let fullText = '';
+        const tokens = ( new Array());
+        for (const { text, metadata } of data) {
+            tokens.push(offset + text.length, metadata);
+            offset += text.length;
+            fullText += text;
+        }
+        return ( new LineTokens(( new Uint32Array(tokens)), fullText, decoder));
+    }
     constructor(tokens, text, decoder) {
         this._lineTokensBrand = undefined;
         this._tokens = tokens;
         this._tokensCount = (this._tokens.length >>> 1);
         this._text = text;
-        this._languageIdCodec = decoder;
+        this.languageIdCodec = decoder;
     }
     equals(other) {
         if (other instanceof LineTokens) {
@@ -58,7 +69,7 @@ class LineTokens {
     getLanguageId(tokenIndex) {
         const metadata = this._tokens[(tokenIndex << 1) + 1];
         const languageId = TokenMetadata.getLanguageId(metadata);
-        return this._languageIdCodec.decodeLanguageId(languageId);
+        return this.languageIdCodec.decodeLanguageId(languageId);
     }
     getStandardTokenType(tokenIndex) {
         const metadata = this._tokens[(tokenIndex << 1) + 1];
@@ -155,7 +166,19 @@ class LineTokens {
                 break;
             }
         }
-        return ( new LineTokens(( new Uint32Array(newTokens)), text, this._languageIdCodec));
+        return ( new LineTokens(( new Uint32Array(newTokens)), text, this.languageIdCodec));
+    }
+    getTokenText(tokenIndex) {
+        const startOffset = this.getStartOffset(tokenIndex);
+        const endOffset = this.getEndOffset(tokenIndex);
+        const text = this._text.substring(startOffset, endOffset);
+        return text;
+    }
+    forEach(callback) {
+        const tokenCount = this.getCount();
+        for (let tokenIndex = 0; tokenIndex < tokenCount; tokenIndex++) {
+            callback(tokenIndex);
+        }
     }
 }
 class SliceLineTokens {
@@ -165,6 +188,7 @@ class SliceLineTokens {
         this._endOffset = endOffset;
         this._deltaOffset = deltaOffset;
         this._firstTokenIndex = source.findTokenIndexAtOffset(startOffset);
+        this.languageIdCodec = source.languageIdCodec;
         this._tokensCount = 0;
         for (let i = this._firstTokenIndex, len = source.getCount(); i < len; i++) {
             const tokenStartOffset = source.getStartOffset(i);
@@ -195,6 +219,9 @@ class SliceLineTokens {
     getCount() {
         return this._tokensCount;
     }
+    getStandardTokenType(tokenIndex) {
+        return this._source.getStandardTokenType(this._firstTokenIndex + tokenIndex);
+    }
     getForeground(tokenIndex) {
         return this._source.getForeground(this._firstTokenIndex + tokenIndex);
     }
@@ -214,5 +241,34 @@ class SliceLineTokens {
     findTokenIndexAtOffset(offset) {
         return this._source.findTokenIndexAtOffset(offset + this._startOffset - this._deltaOffset) - this._firstTokenIndex;
     }
+    getTokenText(tokenIndex) {
+        const adjustedTokenIndex = this._firstTokenIndex + tokenIndex;
+        const tokenStartOffset = this._source.getStartOffset(adjustedTokenIndex);
+        const tokenEndOffset = this._source.getEndOffset(adjustedTokenIndex);
+        let text = this._source.getTokenText(adjustedTokenIndex);
+        if (tokenStartOffset < this._startOffset) {
+            text = text.substring(this._startOffset - tokenStartOffset);
+        }
+        if (tokenEndOffset > this._endOffset) {
+            text = text.substring(0, text.length - (tokenEndOffset - this._endOffset));
+        }
+        return text;
+    }
+    forEach(callback) {
+        for (let tokenIndex = 0; tokenIndex < this.getCount(); tokenIndex++) {
+            callback(tokenIndex);
+        }
+    }
+}
+function getStandardTokenTypeAtPosition(model, position) {
+    const lineNumber = position.lineNumber;
+    if (!model.tokenization.isCheapToTokenize(lineNumber)) {
+        return undefined;
+    }
+    model.tokenization.forceTokenization(lineNumber);
+    const lineTokens = model.tokenization.getLineTokens(lineNumber);
+    const tokenIndex = lineTokens.findTokenIndexAtOffset(position.column - 1);
+    const tokenType = lineTokens.getStandardTokenType(tokenIndex);
+    return tokenType;
 }
-export { LineTokens };
+export { LineTokens, getStandardTokenTypeAtPosition };

package/vscode/src/vs/editor/common/tokens/sparseMultilineTokens.js

@@ -1,3 +1,4 @@
+import { CharCode } from '../../../base/common/charCode.js';
 import { Position } from '../core/position.js';
 import { Range } from '../core/range.js';
 import { countEOL } from '../core/eolCounter.js';
@@ -57,7 +58,7 @@ class SparseMultilineTokens {
     }
     applyEdit(range, text) {
         const [eolCount, firstLineLength, lastLineLength] = countEOL(text);
-        this.acceptEdit(range, eolCount, firstLineLength, lastLineLength, text.length > 0 ? text.charCodeAt(0) : 0 );
+        this.acceptEdit(range, eolCount, firstLineLength, lastLineLength, text.length > 0 ? text.charCodeAt(0) : CharCode.Null);
     }
     acceptEdit(range, eolCount, firstLineLength, lastLineLength, firstCharCode) {
         this._acceptDeleteRange(range);
@@ -326,9 +327,9 @@ class SparseMultilineTokensStorage {
     acceptInsertText(deltaLine, character, eolCount, firstLineLength, lastLineLength, firstCharCode) {
         const isInsertingPreciselyOneWordCharacter = (eolCount === 0
             && firstLineLength === 1
-            && (((firstCharCode >= 48  && firstCharCode <= 57) )
-                || ((firstCharCode >= 65  && firstCharCode <= 90) )
-                || ((firstCharCode >= 97  && firstCharCode <= 122) )));
+            && ((firstCharCode >= CharCode.Digit0 && firstCharCode <= CharCode.Digit9)
+                || (firstCharCode >= CharCode.A && firstCharCode <= CharCode.Z)
+                || (firstCharCode >= CharCode.a && firstCharCode <= CharCode.z)));
         const tokens = this._tokens;
         const tokenCount = this._tokenCount;
         for (let i = 0; i < tokenCount; i++) {

package/vscode/src/vs/editor/common/tokens/sparseTokensStore.js

@@ -1,5 +1,6 @@
 import { arrayInsert } from '../../../base/common/arrays.js';
 import { LineTokens } from './lineTokens.js';
+import { MetadataConsts } from '../encodedTokenAttributes.js';
 class SparseTokensStore {
     constructor(languageIdCodec) {
         this._pieces = [];
@@ -104,12 +105,12 @@ class SparseTokensStore {
             const bStartCharacter = bTokens.getStartCharacter(bIndex);
             const bEndCharacter = bTokens.getEndCharacter(bIndex);
             const bMetadata = bTokens.getMetadata(bIndex);
-            const bMask = ((((bMetadata & 1) ) ? 2048  : 0)
-                | (((bMetadata & 2) ) ? 4096  : 0)
-                | (((bMetadata & 4) ) ? 8192  : 0)
-                | (((bMetadata & 8) ) ? 16384  : 0)
-                | (((bMetadata & 16) ) ? 16744448  : 0)
-                | (((bMetadata & 32) ) ? 4278190080  : 0)) >>> 0;
+            const bMask = (((bMetadata & MetadataConsts.SEMANTIC_USE_ITALIC) ? MetadataConsts.ITALIC_MASK : 0)
+                | ((bMetadata & MetadataConsts.SEMANTIC_USE_BOLD) ? MetadataConsts.BOLD_MASK : 0)
+                | ((bMetadata & MetadataConsts.SEMANTIC_USE_UNDERLINE) ? MetadataConsts.UNDERLINE_MASK : 0)
+                | ((bMetadata & MetadataConsts.SEMANTIC_USE_STRIKETHROUGH) ? MetadataConsts.STRIKETHROUGH_MASK : 0)
+                | ((bMetadata & MetadataConsts.SEMANTIC_USE_FOREGROUND) ? MetadataConsts.FOREGROUND_MASK : 0)
+                | ((bMetadata & MetadataConsts.SEMANTIC_USE_BACKGROUND) ? MetadataConsts.BACKGROUND_MASK : 0)) >>> 0;
             const aMask = (~bMask) >>> 0;
             while (aIndex < aLen && aTokens.getEndOffset(aIndex) <= bStartCharacter) {
                 emitToken(aTokens.getEndOffset(aIndex), aTokens.getMetadata(aIndex));

package/vscode/src/vs/editor/common/viewEventHandler.js

@@ -1,4 +1,5 @@
 import { Disposable } from '../../base/common/lifecycle.js';
+import { ViewEventType } from './viewEvents.js';
 class ViewEventHandler extends Disposable {
     constructor() {
         super();
@@ -75,92 +76,92 @@ class ViewEventHandler extends Disposable {
         for (let i = 0, len = events.length; i < len; i++) {
             const e = events[i];
             switch (e.type) {
-                case 0 :
+                case ViewEventType.ViewCompositionStart:
                     if (this.onCompositionStart(e)) {
                         shouldRender = true;
                     }
                     break;
-                case 1 :
+                case ViewEventType.ViewCompositionEnd:
                     if (this.onCompositionEnd(e)) {
                         shouldRender = true;
                     }
                     break;
-                case 2 :
+                case ViewEventType.ViewConfigurationChanged:
                     if (this.onConfigurationChanged(e)) {
                         shouldRender = true;
                     }
                     break;
-                case 3 :
+                case ViewEventType.ViewCursorStateChanged:
                     if (this.onCursorStateChanged(e)) {
                         shouldRender = true;
                     }
                     break;
-                case 4 :
+                case ViewEventType.ViewDecorationsChanged:
                     if (this.onDecorationsChanged(e)) {
                         shouldRender = true;
                     }
                     break;
-                case 5 :
+                case ViewEventType.ViewFlushed:
                     if (this.onFlushed(e)) {
                         shouldRender = true;
                     }
                     break;
-                case 6 :
+                case ViewEventType.ViewFocusChanged:
                     if (this.onFocusChanged(e)) {
                         shouldRender = true;
                     }
                     break;
-                case 7 :
+                case ViewEventType.ViewLanguageConfigurationChanged:
                     if (this.onLanguageConfigurationChanged(e)) {
                         shouldRender = true;
                     }
                     break;
-                case 8 :
+                case ViewEventType.ViewLineMappingChanged:
                     if (this.onLineMappingChanged(e)) {
                         shouldRender = true;
                     }
                     break;
-                case 9 :
+                case ViewEventType.ViewLinesChanged:
                     if (this.onLinesChanged(e)) {
                         shouldRender = true;
                     }
                     break;
-                case 10 :
+                case ViewEventType.ViewLinesDeleted:
                     if (this.onLinesDeleted(e)) {
                         shouldRender = true;
                     }
                     break;
-                case 11 :
+                case ViewEventType.ViewLinesInserted:
                     if (this.onLinesInserted(e)) {
                         shouldRender = true;
                     }
                     break;
-                case 12 :
+                case ViewEventType.ViewRevealRangeRequest:
                     if (this.onRevealRangeRequest(e)) {
                         shouldRender = true;
                     }
                     break;
-                case 13 :
+                case ViewEventType.ViewScrollChanged:
                     if (this.onScrollChanged(e)) {
                         shouldRender = true;
                     }
                     break;
-                case 15 :
+                case ViewEventType.ViewTokensChanged:
                     if (this.onTokensChanged(e)) {
                         shouldRender = true;
                     }
                     break;
-                case 14 :
+                case ViewEventType.ViewThemeChanged:
                     if (this.onThemeChanged(e)) {
                         shouldRender = true;
                     }
                     break;
-                case 16 :
+                case ViewEventType.ViewTokensColorsChanged:
                     if (this.onTokensColorsChanged(e)) {
                         shouldRender = true;
                     }
                     break;
-                case 17 :
+                case ViewEventType.ViewZonesChanged:
                     if (this.onZonesChanged(e)) {
                         shouldRender = true;
                     }