@codingame/monaco-vscode-api 9.0.3 → 10.0.0

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

@@ -1,119 +1,119 @@
 import { localize } from '../../nls.js';
 var AccessibilityHelpNLS;
 ( ((function(AccessibilityHelpNLS) {
-    AccessibilityHelpNLS.accessibilityHelpTitle = ( localize(1234, "Accessibility Help"));
-    AccessibilityHelpNLS.openingDocs = ( localize(1235, "Opening the Accessibility documentation page."));
-    AccessibilityHelpNLS.readonlyDiffEditor = ( localize(1236, "You are in a read-only pane of a diff editor."));
-    AccessibilityHelpNLS.editableDiffEditor = ( localize(1237, "You are in a pane of a diff editor."));
-    AccessibilityHelpNLS.readonlyEditor = ( localize(1238, "You are in a read-only code editor."));
-    AccessibilityHelpNLS.editableEditor = ( localize(1239, "You are in a code editor."));
+    AccessibilityHelpNLS.accessibilityHelpTitle = ( localize(1248, "Accessibility Help"));
+    AccessibilityHelpNLS.openingDocs = ( localize(1249, "Opening the Accessibility documentation page."));
+    AccessibilityHelpNLS.readonlyDiffEditor = ( localize(1250, "You are in a read-only pane of a diff editor."));
+    AccessibilityHelpNLS.editableDiffEditor = ( localize(1251, "You are in a pane of a diff editor."));
+    AccessibilityHelpNLS.readonlyEditor = ( localize(1252, "You are in a read-only code editor."));
+    AccessibilityHelpNLS.editableEditor = ( localize(1253, "You are in a code editor."));
     AccessibilityHelpNLS.changeConfigToOnMac = ( localize(
-        1240,
+        1254,
         "Configure the application to be optimized for usage with a Screen Reader (Command+E)."
     ));
     AccessibilityHelpNLS.changeConfigToOnWinLinux = ( localize(
-        1241,
+        1255,
         "Configure the application to be optimized for usage with a Screen Reader (Control+E)."
     ));
     AccessibilityHelpNLS.auto_on = ( localize(
-        1242,
+        1256,
         "The application is configured to be optimized for usage with a Screen Reader."
     ));
     AccessibilityHelpNLS.auto_off = ( localize(
-        1243,
+        1257,
         "The application is configured to never be optimized for usage with a Screen Reader."
     ));
-    AccessibilityHelpNLS.screenReaderModeEnabled = ( localize(1244, "Screen Reader Optimized Mode enabled."));
-    AccessibilityHelpNLS.screenReaderModeDisabled = ( localize(1245, "Screen Reader Optimized Mode disabled."));
+    AccessibilityHelpNLS.screenReaderModeEnabled = ( localize(1258, "Screen Reader Optimized Mode enabled."));
+    AccessibilityHelpNLS.screenReaderModeDisabled = ( localize(1259, "Screen Reader Optimized Mode disabled."));
     AccessibilityHelpNLS.tabFocusModeOnMsg = ( localize(
-        1246,
+        1260,
         "Pressing Tab in the current editor will move focus to the next focusable element. Toggle this behavior{0}.",
         '<keybinding:editor.action.toggleTabFocusMode>'
     ));
     AccessibilityHelpNLS.tabFocusModeOffMsg = ( localize(
-        1247,
+        1261,
         "Pressing Tab in the current editor will insert the tab character. Toggle this behavior{0}.",
         '<keybinding:editor.action.toggleTabFocusMode>'
     ));
     AccessibilityHelpNLS.stickScroll = ( localize(
-        1248,
+        1262,
         "Focus Sticky Scroll{0} to focus the currently nested scopes.",
         '<keybinding:editor.action.focusStickyDebugConsole>'
     ));
     AccessibilityHelpNLS.codeFolding = ( localize(
-        1249,
+        1263,
         "Use code folding to collapse blocks of code and focus on the code you're interested in via the Toggle Folding Command{0}.",
         '<keybinding:editor.toggleFold>'
     ));
     AccessibilityHelpNLS.intellisense = ( localize(
-        1250,
+        1264,
         "Use Intellisense to improve coding efficiency and reduce errors. Trigger suggestions{0}.",
         '<keybinding:editor.action.triggerSuggest>'
     ));
     AccessibilityHelpNLS.showOrFocusHover = ( localize(
-        1251,
+        1265,
         "Show or focus the hover{0} to read information about the current symbol.",
         '<keybinding:editor.action.showHover>'
     ));
     AccessibilityHelpNLS.goToSymbol = ( localize(
-        1252,
+        1266,
         "Go to Symbol{0} to quickly navigate between symbols in the current file.",
         '<keybinding:workbench.action.gotoSymbol>'
     ));
-    AccessibilityHelpNLS.showAccessibilityHelpAction = ( localize(1253, "Show Accessibility Help"));
+    AccessibilityHelpNLS.showAccessibilityHelpAction = ( localize(1267, "Show Accessibility Help"));
     AccessibilityHelpNLS.listSignalSounds = ( localize(
-        1254,
+        1268,
         "Run the command: List Signal Sounds for an overview of all sounds and their current status."
     ));
     AccessibilityHelpNLS.listAlerts = ( localize(
-        1255,
+        1269,
         "Run the command: List Signal Announcements for an overview of announcements and their current status."
     ));
     AccessibilityHelpNLS.quickChat = ( localize(
-        1256,
+        1270,
         "Toggle quick chat{0} to open or close a chat session.",
         '<keybinding:workbench.action.quickchat.toggle>'
     ));
     AccessibilityHelpNLS.startInlineChat = ( localize(
-        1257,
+        1271,
         "Start inline chat{0} to create an in editor chat session.",
         '<keybinding:inlineChat.start>'
     ));
     AccessibilityHelpNLS.startDebugging = ( localize(
-        1258,
+        1272,
         "The Debug: Start Debugging command{0} will start a debug session.",
         '<keybinding:workbench.action.debug.start>'
     ));
     AccessibilityHelpNLS.setBreakpoint = ( localize(
-        1259,
+        1273,
         "The Debug: Inline Breakpoint command{0} will set or unset a breakpoint at the current cursor position in the active editor.",
         '<keybinding:editor.debug.action.toggleInlineBreakpoint>'
     ));
     AccessibilityHelpNLS.addToWatch = ( localize(
-        1260,
+        1274,
         "The Debug: Add to Watch command{0} will add the selected text to the watch view.",
         '<keybinding:editor.debug.action.selectionToWatch>'
     ));
     AccessibilityHelpNLS.debugExecuteSelection = ( localize(
-        1261,
+        1275,
         "The Debug: Execute Selection command{0} will execute the selected text in the debug console.",
         '<keybinding:editor.debug.action.selectionToRepl>'
     ));
 })(AccessibilityHelpNLS || (AccessibilityHelpNLS = {}))));
 var InspectTokensNLS;
 ( ((function(InspectTokensNLS) {
-    InspectTokensNLS.inspectTokensAction = ( localize(1262, "Developer: Inspect Tokens"));
+    InspectTokensNLS.inspectTokensAction = ( localize(1276, "Developer: Inspect Tokens"));
 })(InspectTokensNLS || (InspectTokensNLS = {}))));
 var StandaloneCodeEditorNLS;
 ( ((function(StandaloneCodeEditorNLS) {
-    StandaloneCodeEditorNLS.editorViewAccessibleLabel = ( localize(1269, "Editor content"));
+    StandaloneCodeEditorNLS.editorViewAccessibleLabel = ( localize(1283, "Editor content"));
 })(StandaloneCodeEditorNLS || (StandaloneCodeEditorNLS = {}))));
 var ToggleHighContrastNLS;
 ( ((function(ToggleHighContrastNLS) {
-    ToggleHighContrastNLS.toggleHighContrast = ( localize(1270, "Toggle High Contrast Theme"));
+    ToggleHighContrastNLS.toggleHighContrast = ( localize(1284, "Toggle High Contrast Theme"));
 })(ToggleHighContrastNLS || (ToggleHighContrastNLS = {}))));
 var StandaloneServicesNLS;
 ( ((function(StandaloneServicesNLS) {
-    StandaloneServicesNLS.bulkEditServiceSummary = ( localize(1271, "Made {0} edits in {1} files"));
+    StandaloneServicesNLS.bulkEditServiceSummary = ( localize(1285, "Made {0} edits in {1} files"));
 })(StandaloneServicesNLS || (StandaloneServicesNLS = {}))));
 export { AccessibilityHelpNLS, InspectTokensNLS, StandaloneCodeEditorNLS, StandaloneServicesNLS, ToggleHighContrastNLS };

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

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

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

@@ -1,6 +1,5 @@
 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());
@@ -76,8 +75,8 @@ class TokenizationRegistry {
         return this._colorMap;
     }
     getDefaultBackground() {
-        if (this._colorMap && this._colorMap.length > ColorId.DefaultBackground) {
-            return this._colorMap[ColorId.DefaultBackground];
+        if (this._colorMap && this._colorMap.length > 2 ) {
+            return this._colorMap[2 ];
         }
         return null;
     }

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

@@ -1,6 +1,13 @@
-var BackgroundTokenizationState;
-( (function(BackgroundTokenizationState) {
-    BackgroundTokenizationState[BackgroundTokenizationState["InProgress"] = 1] = "InProgress";
-    BackgroundTokenizationState[BackgroundTokenizationState["Completed"] = 2] = "Completed";
-})(BackgroundTokenizationState || (BackgroundTokenizationState = {})));
-export { BackgroundTokenizationState };
+import { OffsetEdit } from './core/offsetEdit.js';
+class LineEditWithAdditionalLines {
+    static replace(range, text) {
+        return ( new LineEditWithAdditionalLines(OffsetEdit.replace(range, text), null));
+    }
+    constructor(
+    lineEdit,
+    additionalLines) {
+        this.lineEdit = lineEdit;
+        this.additionalLines = additionalLines;
+    }
+}
+export { LineEditWithAdditionalLines };

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, MetadataConsts, StandardTokenType, FontStyle, ColorId } from '../encodedTokenAttributes.js';
+import { TokenMetadata } from '../encodedTokenAttributes.js';
 class ContiguousTokensStore {
     constructor(languageIdCodec) {
         this._lineTokens = [];
@@ -178,11 +178,11 @@ class ContiguousTokensStore {
     }
 }
 function getDefaultMetadata(topLevelLanguageId) {
-    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;
+    return (((topLevelLanguageId << 0) )
+        | ((0  << 8) )
+        | ((0  << 11) )
+        | ((1  << 15) )
+        | ((2  << 24) )
+        | ((1024) )) >>> 0;
 }
 export { ContiguousTokensStore };

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

@@ -1,6 +1,8 @@
 import { ILanguageIdCodec } from '../languages.js';
 import { StandardTokenType, ColorId, ITokenPresentation } from '../encodedTokenAttributes.js';
 import '../../editor.api.js';
+import { OffsetRange } from '../core/offsetRange.js';
+import { TokenArray } from './tokenArray.js';
 
 interface IViewLineTokens {
     languageIdCodec: ILanguageIdCodec;
@@ -20,17 +22,19 @@ interface IViewLineTokens {
     forEach(callback: (tokenIndex: number) => void): void;
 }
 declare class LineTokens implements IViewLineTokens {
+    static createEmpty(lineContent: string, decoder: ILanguageIdCodec): LineTokens;
+    static createFromTextAndMetadata(data: {
+        text: string;
+        metadata: number;
+    }[], decoder: ILanguageIdCodec): LineTokens;
+    static convertToEndOffset(tokens: Uint32Array, lineTextLength: number): void;
+    static findIndexInTokensArray(tokens: Uint32Array, desiredIndex: number): number;
     _lineTokensBrand: void;
     private readonly _tokens;
     private readonly _tokensCount;
     private readonly _text;
     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;
@@ -53,8 +57,6 @@ declare class LineTokens implements IViewLineTokens {
     findTokenIndexAtOffset(offset: number): number;
     inflate(): IViewLineTokens;
     sliceAndInflate(startOffset: number, endOffset: number, deltaOffset: number): IViewLineTokens;
-    static convertToEndOffset(tokens: Uint32Array, lineTextLength: number): void;
-    static findIndexInTokensArray(tokens: Uint32Array, desiredIndex: number): number;
     /**
      * @pure
      * @param insertTokens Must be sorted by offset.
@@ -64,6 +66,7 @@ declare class LineTokens implements IViewLineTokens {
         text: string;
         tokenMetadata: number;
     }[]): LineTokens;
+    getTokensInRange(range: OffsetRange): TokenArray;
     getTokenText(tokenIndex: number): string;
     forEach(callback: (tokenIndex: number) => void): void;
 }

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

@@ -1,8 +1,7 @@
-import { FontStyle, MetadataConsts, ColorId, TokenMetadata } from '../encodedTokenAttributes.js';
+import { TokenMetadata } from '../encodedTokenAttributes.js';
+import { OffsetRange } from '../core/offsetRange.js';
+import { TokenArrayBuilder } from './tokenArray.js';
 class LineTokens {
-    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));
@@ -21,6 +20,38 @@ class LineTokens {
         }
         return ( new LineTokens(( new Uint32Array(tokens)), fullText, decoder));
     }
+    static convertToEndOffset(tokens, lineTextLength) {
+        const tokenCount = (tokens.length >>> 1);
+        const lastTokenIndex = tokenCount - 1;
+        for (let tokenIndex = 0; tokenIndex < lastTokenIndex; tokenIndex++) {
+            tokens[tokenIndex << 1] = tokens[(tokenIndex + 1) << 1];
+        }
+        tokens[lastTokenIndex << 1] = lineTextLength;
+    }
+    static findIndexInTokensArray(tokens, desiredIndex) {
+        if (tokens.length <= 2) {
+            return 0;
+        }
+        let low = 0;
+        let high = (tokens.length >>> 1) - 1;
+        while (low < high) {
+            const mid = low + Math.floor((high - low) / 2);
+            const endOffset = tokens[(mid << 1)];
+            if (endOffset === desiredIndex) {
+                return mid + 1;
+            }
+            else if (endOffset < desiredIndex) {
+                low = mid + 1;
+            }
+            else if (endOffset > desiredIndex) {
+                high = mid;
+            }
+        }
+        return low;
+    }
+    static { this.defaultTokenMetadata = (((0  << 11) )
+        | ((1  << 15) )
+        | ((2  << 24) )) >>> 0; }
     constructor(tokens, text, decoder) {
         this._lineTokensBrand = undefined;
         this._tokens = tokens;
@@ -103,35 +134,6 @@ class LineTokens {
     sliceAndInflate(startOffset, endOffset, deltaOffset) {
         return ( new SliceLineTokens(this, startOffset, endOffset, deltaOffset));
     }
-    static convertToEndOffset(tokens, lineTextLength) {
-        const tokenCount = (tokens.length >>> 1);
-        const lastTokenIndex = tokenCount - 1;
-        for (let tokenIndex = 0; tokenIndex < lastTokenIndex; tokenIndex++) {
-            tokens[tokenIndex << 1] = tokens[(tokenIndex + 1) << 1];
-        }
-        tokens[lastTokenIndex << 1] = lineTextLength;
-    }
-    static findIndexInTokensArray(tokens, desiredIndex) {
-        if (tokens.length <= 2) {
-            return 0;
-        }
-        let low = 0;
-        let high = (tokens.length >>> 1) - 1;
-        while (low < high) {
-            const mid = low + Math.floor((high - low) / 2);
-            const endOffset = tokens[(mid << 1)];
-            if (endOffset === desiredIndex) {
-                return mid + 1;
-            }
-            else if (endOffset < desiredIndex) {
-                low = mid + 1;
-            }
-            else if (endOffset > desiredIndex) {
-                high = mid;
-            }
-        }
-        return low;
-    }
     withInserted(insertTokens) {
         if (insertTokens.length === 0) {
             return this;
@@ -168,6 +170,19 @@ class LineTokens {
         }
         return ( new LineTokens(( new Uint32Array(newTokens)), text, this.languageIdCodec));
     }
+    getTokensInRange(range) {
+        const builder = ( new TokenArrayBuilder());
+        const startTokenIndex = this.findTokenIndexAtOffset(range.start);
+        const endTokenIndex = this.findTokenIndexAtOffset(range.endExclusive);
+        for (let tokenIndex = startTokenIndex; tokenIndex <= endTokenIndex; tokenIndex++) {
+            const tokenRange = ( new OffsetRange(this.getStartOffset(tokenIndex), this.getEndOffset(tokenIndex)));
+            const length = tokenRange.intersectionLength(range);
+            if (length > 0) {
+                builder.add(length, this.getMetadata(tokenIndex));
+            }
+        }
+        return builder.build();
+    }
     getTokenText(tokenIndex) {
         const startOffset = this.getStartOffset(tokenIndex);
         const endOffset = this.getEndOffset(tokenIndex);

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

@@ -1,4 +1,3 @@
-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';
@@ -58,7 +57,7 @@ class SparseMultilineTokens {
     }
     applyEdit(range, text) {
         const [eolCount, firstLineLength, lastLineLength] = countEOL(text);
-        this.acceptEdit(range, eolCount, firstLineLength, lastLineLength, text.length > 0 ? text.charCodeAt(0) : CharCode.Null);
+        this.acceptEdit(range, eolCount, firstLineLength, lastLineLength, text.length > 0 ? text.charCodeAt(0) : 0 );
     }
     acceptEdit(range, eolCount, firstLineLength, lastLineLength, firstCharCode) {
         this._acceptDeleteRange(range);
@@ -327,9 +326,9 @@ class SparseMultilineTokensStorage {
     acceptInsertText(deltaLine, character, eolCount, firstLineLength, lastLineLength, firstCharCode) {
         const isInsertingPreciselyOneWordCharacter = (eolCount === 0
             && firstLineLength === 1
-            && ((firstCharCode >= CharCode.Digit0 && firstCharCode <= CharCode.Digit9)
-                || (firstCharCode >= CharCode.A && firstCharCode <= CharCode.Z)
-                || (firstCharCode >= CharCode.a && firstCharCode <= CharCode.z)));
+            && (((firstCharCode >= 48  && firstCharCode <= 57) )
+                || ((firstCharCode >= 65  && firstCharCode <= 90) )
+                || ((firstCharCode >= 97  && firstCharCode <= 122) )));
         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,6 +1,5 @@
 import { arrayInsert } from '../../../base/common/arrays.js';
 import { LineTokens } from './lineTokens.js';
-import { MetadataConsts } from '../encodedTokenAttributes.js';
 class SparseTokensStore {
     constructor(languageIdCodec) {
         this._pieces = [];
@@ -105,12 +104,12 @@ class SparseTokensStore {
             const bStartCharacter = bTokens.getStartCharacter(bIndex);
             const bEndCharacter = bTokens.getEndCharacter(bIndex);
             const bMetadata = bTokens.getMetadata(bIndex);
-            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 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 aMask = (~bMask) >>> 0;
             while (aIndex < aLen && aTokens.getEndOffset(aIndex) <= bStartCharacter) {
                 emitToken(aTokens.getEndOffset(aIndex), aTokens.getMetadata(aIndex));

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

@@ -0,0 +1,25 @@
+import { OffsetRange } from '../core/offsetRange.js';
+
+/**
+ * This class represents a sequence of tokens.
+ * Conceptually, each token has a length and a metadata number.
+ * A token array might be used to annotate a string with metadata.
+ * Use {@link TokenArrayBuilder} to efficiently create a token array.
+ *
+ * TODO: Make this class more efficient (e.g. by using a Int32Array).
+*/
+declare class TokenArray {
+    private readonly _tokenInfo;
+    static create(tokenInfo: TokenInfo[]): TokenArray;
+    private constructor();
+    forEach(cb: (range: OffsetRange, tokenInfo: TokenInfo) => void): void;
+    slice(range: OffsetRange): TokenArray;
+}
+type TokenMetadata = number;
+declare class TokenInfo {
+    readonly length: number;
+    readonly metadata: TokenMetadata;
+    constructor(length: number, metadata: TokenMetadata);
+}
+
+export { TokenArray, TokenInfo, type TokenMetadata };

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

@@ -0,0 +1,53 @@
+import { OffsetRange } from '../core/offsetRange.js';
+class TokenArray {
+    static create(tokenInfo) {
+        return ( new TokenArray(tokenInfo));
+    }
+    constructor(_tokenInfo) {
+        this._tokenInfo = _tokenInfo;
+    }
+    forEach(cb) {
+        let lengthSum = 0;
+        for (const tokenInfo of this._tokenInfo) {
+            const range = ( new OffsetRange(lengthSum, lengthSum + tokenInfo.length));
+            cb(range, tokenInfo);
+            lengthSum += tokenInfo.length;
+        }
+    }
+    slice(range) {
+        const result = [];
+        let lengthSum = 0;
+        for (const tokenInfo of this._tokenInfo) {
+            const tokenStart = lengthSum;
+            const tokenEndEx = tokenStart + tokenInfo.length;
+            if (tokenEndEx > range.start) {
+                if (tokenStart >= range.endExclusive) {
+                    break;
+                }
+                const deltaBefore = Math.max(0, range.start - tokenStart);
+                const deltaAfter = Math.max(0, tokenEndEx - range.endExclusive);
+                result.push(( new TokenInfo(tokenInfo.length - deltaBefore - deltaAfter, tokenInfo.metadata)));
+            }
+            lengthSum += tokenInfo.length;
+        }
+        return TokenArray.create(result);
+    }
+}
+class TokenInfo {
+    constructor(length, metadata) {
+        this.length = length;
+        this.metadata = metadata;
+    }
+}
+class TokenArrayBuilder {
+    constructor() {
+        this._tokens = [];
+    }
+    add(length, metadata) {
+        this._tokens.push(( new TokenInfo(length, metadata)));
+    }
+    build() {
+        return TokenArray.create(this._tokens);
+    }
+}
+export { TokenArray, TokenArrayBuilder, TokenInfo };