@codingame/monaco-vscode-api 15.0.2 → 16.0.0

package/vscode/src/vs/editor/common/model/treeSitterTokens.d.ts

@@ -15,7 +15,7 @@ export declare class TreeSitterTokens extends AbstractTokens {
     readonly onDidChangeBackgroundTokenizationState: Event<void>;
     private _lastLanguageId;
     private readonly _tokensChangedListener;
-    private readonly _firstTokenizationCompleteListener;
+    private readonly _onDidChangeBackgroundTokenization;
     constructor(languageIdCodec: ILanguageIdCodec, textModel: TextModel, languageId: () => string, _tokenStore: ITreeSitterTokenizationStoreService);
     private _initialize;
     getLineTokens(lineNumber: number): LineTokens;

package/vscode/src/vs/editor/common/model/treeSitterTokens.js

@@ -19,7 +19,7 @@ let TreeSitterTokens = class TreeSitterTokens extends AbstractTokens {
         this._onDidChangeBackgroundTokenizationState = this._register(( new Emitter()));
         this.onDidChangeBackgroundTokenizationState = this._onDidChangeBackgroundTokenizationState.event;
         this._tokensChangedListener = this._register(( new MutableDisposable()));
-        this._firstTokenizationCompleteListener = this._register(( new MutableDisposable()));
+        this._onDidChangeBackgroundTokenization = this._register(( new MutableDisposable()));
         this._initialize();
     }
     _initialize() {
@@ -32,20 +32,19 @@ let TreeSitterTokens = class TreeSitterTokens extends AbstractTokens {
                     this._onDidChangeTokens.fire(e.changes);
                 }
             });
-            this._firstTokenizationCompleteListener.value = this._tokenizationSupport?.onDidCompleteFirstTokenization(e => {
+            this._onDidChangeBackgroundTokenization.value = this._tokenizationSupport?.onDidChangeBackgroundTokenization(e => {
                 if (e.textModel === this._textModel) {
                     this._backgroundTokenizationState = BackgroundTokenizationState.Completed;
                     this._onDidChangeBackgroundTokenizationState.fire();
-                    this._firstTokenizationCompleteListener.clear();
                 }
             });
         }
     }
     getLineTokens(lineNumber) {
         const content = this._textModel.getLineContent(lineNumber);
-        if (this._tokenizationSupport) {
+        if (this._tokenizationSupport && content.length > 0) {
             const rawTokens = this._tokenStore.getTokens(this._textModel, lineNumber);
-            if (rawTokens) {
+            if (rawTokens && rawTokens.length > 0) {
                 return ( new LineTokens(rawTokens, content, this._languageIdCodec));
             }
         }
@@ -71,9 +70,12 @@ let TreeSitterTokens = class TreeSitterTokens extends AbstractTokens {
         if (e.isFlush) {
             this.resetTokenization(false);
         }
+        else {
+            this._tokenStore.handleContentChanged(this._textModel, e);
+        }
     }
     forceTokenization(lineNumber) {
-        if (this._tokenizationSupport) {
+        if (this._tokenizationSupport && !this.hasAccurateTokensForLine(lineNumber)) {
             this._tokenizationSupport.tokenizeEncoded(lineNumber, this._textModel);
         }
     }
@@ -87,6 +89,16 @@ let TreeSitterTokens = class TreeSitterTokens extends AbstractTokens {
         return StandardTokenType.Other;
     }
     tokenizeLinesAt(lineNumber, lines) {
+        if (this._tokenizationSupport) {
+            const rawLineTokens = this._tokenizationSupport.guessTokensForLinesContent(lineNumber, this._textModel, lines);
+            const lineTokens = [];
+            if (rawLineTokens) {
+                for (let i = 0; i < rawLineTokens.length; i++) {
+                    lineTokens.push(( new LineTokens(rawLineTokens[i], lines[i], this._languageIdCodec)));
+                }
+                return lineTokens;
+            }
+        }
         return null;
     }
     get hasTokens() {

package/vscode/src/vs/editor/common/services/{editorSimpleWorker.d.ts → editorWebWorker.d.ts}

@@ -1,15 +1,14 @@
 import { IDisposable } from "../../../base/common/lifecycle.js";
 import { URI } from "../../../base/common/uri.js";
-import { IRequestHandler, IWorkerServer } from "../../../base/common/worker/simpleWorker.js";
+import { IWebWorkerServerRequestHandler } from "../../../base/common/worker/webWorker.js";
 import { IRange } from "../core/range.js";
 import { IMirrorTextModel, IModelChangedEvent } from "../model/mirrorTextModel.js";
 import { IColorInformation, IInplaceReplaceSupportResult, ILink, TextEdit } from "../languages.js";
 import { DiffAlgorithmName, IDiffComputationResult, IUnicodeHighlightsResult } from "./editorWorker.js";
-import { EditorWorkerHost } from "./editorWorkerHost.js";
 import { UnicodeHighlighterOptions } from "./unicodeTextModelHighlighter.js";
 import { IChange } from "../diff/legacyLinesDiffComputer.js";
 import { ILinesDiffComputerOptions } from "../diff/linesDiffComputer.js";
-import { IDocumentDiffProviderOptions } from "@codingame/monaco-vscode-e4d0fd26-1b26-5583-b3f7-582e08d7b389-common/vscode/vs/editor/common/diff/documentDiffProvider";
+import { IDocumentDiffProviderOptions } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/editor/common/diff/documentDiffProvider";
 import { FindSectionHeaderOptions, SectionHeader } from "./findSectionHeaders.js";
 import { IRawModelData, IWorkerTextModelSyncChannelServer } from "./textModelSync/textModelSync.protocol.js";
 import { ICommonModel } from "./textModelSync/textModelSync.impl.js";
@@ -26,16 +25,15 @@ export interface IWordRange {
     readonly start: number;
     readonly end: number;
 }
-export interface IForeignModuleFactory {
-    (ctx: IWorkerContext, createData: any): any;
-}
-export declare class BaseEditorSimpleWorker implements IDisposable, IWorkerTextModelSyncChannelServer, IRequestHandler {
+export declare class EditorWorker implements IDisposable, IWorkerTextModelSyncChannelServer, IWebWorkerServerRequestHandler {
+    private readonly _foreignModule;
     _requestHandlerBrand: any;
     private readonly _workerTextModelSyncServer;
-    constructor();
+    constructor(_foreignModule?: any | null);
     dispose(): void;
+    $ping(): Promise<string>;
     protected _getModel(uri: string): ICommonModel | undefined;
-    protected _getModels(): ICommonModel[];
+    getModels(): ICommonModel[];
     $acceptNewModel(data: IRawModelData): void;
     $acceptModelChanged(uri: string, e: IModelChangedEvent): void;
     $acceptRemovedModel(uri: string): void;
@@ -59,14 +57,5 @@ export declare class BaseEditorSimpleWorker implements IDisposable, IWorkerTextM
         [word: string]: IRange[];
     }>;
     $navigateValueSet(modelUrl: string, range: IRange, up: boolean, wordDef: string, wordDefFlags: string): Promise<IInplaceReplaceSupportResult | null>;
-}
-export declare class EditorSimpleWorker extends BaseEditorSimpleWorker {
-    private readonly _host;
-    private readonly _foreignModuleFactory;
-    private _foreignModule;
-    constructor(_host: EditorWorkerHost, _foreignModuleFactory: IForeignModuleFactory | null);
-    $ping(): Promise<string>;
-    $loadForeignModule(moduleId: string, createData: any, foreignHostMethods: string[]): Promise<string[]>;
     $fmr(method: string, args: any[]): Promise<any>;
 }
-export declare function create(workerServer: IWorkerServer): IRequestHandler;

package/vscode/src/vs/editor/common/services/{editorSimpleWorker.js → editorWebWorker.js}

@@ -5,27 +5,29 @@ import { Range } from '../core/range.js';
 import { computeLinks } from '../languages/linkComputer.js';
 import { BasicInplaceReplace } from '../languages/supports/inplaceReplaceSupport.js';
 import { createMonacoBaseAPI } from './editorBaseApi.js';
-import './editorWorkerHost.js';
 import { StopWatch } from '../../../base/common/stopwatch.js';
 import { UnicodeTextModelHighlighter } from './unicodeTextModelHighlighter.js';
 import { DiffComputer } from '../diff/legacyLinesDiffComputer.js';
 import { linesDiffComputers } from '../diff/linesDiffComputers.js';
-import { createProxyObject, getAllMethodNames } from '../../../base/common/objects.js';
 import { BugIndicatingError } from '../../../base/common/errors.js';
 import { computeDefaultDocumentColors } from '../languages/defaultDocumentColorsComputer.js';
 import { findSectionHeaders } from './findSectionHeaders.js';
 import { WorkerTextModelSyncServer } from './textModelSync/textModelSync.impl.js';
 
-class BaseEditorSimpleWorker {
-    constructor() {
+class EditorWorker {
+    constructor(_foreignModule = null) {
+        this._foreignModule = _foreignModule;
         this._workerTextModelSyncServer = ( new WorkerTextModelSyncServer());
     }
     dispose() {
     }
+    async $ping() {
+        return 'pong';
+    }
     _getModel(uri) {
         return this._workerTextModelSyncServer.getModel(uri);
     }
-    _getModels() {
+    getModels() {
         return this._workerTextModelSyncServer.getModels();
     }
     $acceptNewModel(data) {
@@ -57,7 +59,7 @@ class BaseEditorSimpleWorker {
         if (!original || !modified) {
             return null;
         }
-        const result = EditorSimpleWorker.computeDiff(original, modified, options, algorithm);
+        const result = EditorWorker.computeDiff(original, modified, options, algorithm);
         return result;
     }
     static computeDiff(originalTextModel, modifiedTextModel, options, algorithm) {
@@ -165,7 +167,7 @@ class BaseEditorSimpleWorker {
             if (original === text) {
                 continue;
             }
-            if (Math.max(text.length, original.length) > EditorSimpleWorker._diffLimit) {
+            if (Math.max(text.length, original.length) > EditorWorker._diffLimit) {
                 result.push({ range, text });
                 continue;
             }
@@ -215,7 +217,7 @@ class BaseEditorSimpleWorker {
             if (original === text) {
                 continue;
             }
-            if (Math.max(text.length, original.length) > EditorSimpleWorker._diffLimit) {
+            if (Math.max(text.length, original.length) > EditorWorker._diffLimit) {
                 result.push({ range, text });
                 continue;
             }
@@ -296,7 +298,7 @@ class BaseEditorSimpleWorker {
                     continue;
                 }
                 seen.add(word);
-                if (seen.size > EditorSimpleWorker._suggestionsLimit) {
+                if (seen.size > EditorWorker._suggestionsLimit) {
                     break outer;
                 }
             }
@@ -354,34 +356,6 @@ class BaseEditorSimpleWorker {
         const result = BasicInplaceReplace.INSTANCE.navigateValueSet(range, selectionText, wordRange, word, up);
         return result;
     }
-}
-class EditorSimpleWorker extends BaseEditorSimpleWorker {
-    constructor(_host, _foreignModuleFactory) {
-        super();
-        this._host = _host;
-        this._foreignModuleFactory = _foreignModuleFactory;
-        this._foreignModule = null;
-    }
-    async $ping() {
-        return 'pong';
-    }
-    $loadForeignModule(moduleId, createData, foreignHostMethods) {
-        const proxyMethodRequest = (method, args) => {
-            return this._host.$fhr(method, args);
-        };
-        const foreignHost = createProxyObject(foreignHostMethods, proxyMethodRequest);
-        const ctx = {
-            host: foreignHost,
-            getMirrorModels: () => {
-                return this._getModels();
-            }
-        };
-        if (this._foreignModuleFactory) {
-            this._foreignModule = this._foreignModuleFactory(ctx, createData);
-            return Promise.resolve(getAllMethodNames(this._foreignModule));
-        }
-        return Promise.reject(( new Error(`Unexpected usage`)));
-    }
     $fmr(method, args) {
         if (!this._foreignModule || typeof this._foreignModule[method] !== 'function') {
             return Promise.reject(( new Error('Missing requestHandler or method: ' + method)));
@@ -398,4 +372,4 @@ if (typeof importScripts === 'function') {
     globalThis.monaco = createMonacoBaseAPI();
 }
 
-export { BaseEditorSimpleWorker, EditorSimpleWorker };
+export { EditorWorker };

package/vscode/src/vs/editor/common/services/editorWebWorkerMain.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,5 @@
+
+import { bootstrapWebWorker } from '../../../base/common/worker/webWorkerBootstrap.js';
+import { EditorWorker } from './editorWebWorker.js';
+
+bootstrapWebWorker(() => ( new EditorWorker(null)));

package/vscode/src/vs/editor/common/services/editorWorker.service.d.ts

@@ -1,6 +1,6 @@
 import { URI } from "../../../base/common/uri.js";
 import { IRange } from "../core/range.js";
-import { IDocumentDiffProviderOptions, IDocumentDiff } from "@codingame/monaco-vscode-e4d0fd26-1b26-5583-b3f7-582e08d7b389-common/vscode/vs/editor/common/diff/documentDiffProvider";
+import { IDocumentDiffProviderOptions, IDocumentDiff } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/editor/common/diff/documentDiffProvider";
 import { IChange } from "../diff/legacyLinesDiffComputer.js";
 import { TextEdit, IInplaceReplaceSupportResult, IColorInformation } from "../languages.js";
 import { IUnicodeHighlightsResult, DiffAlgorithmName } from "./editorWorker.js";

package/vscode/src/vs/editor/common/services/editorWorkerHost.d.ts

@@ -1,7 +1,7 @@
-import { IWorkerServer, IWorkerClient } from "../../../base/common/worker/simpleWorker.js";
+import { IWebWorkerServer, IWebWorkerClient } from "../../../base/common/worker/webWorker.js";
 export declare abstract class EditorWorkerHost {
     static CHANNEL_NAME: string;
-    static getChannel(workerServer: IWorkerServer): EditorWorkerHost;
-    static setChannel(workerClient: IWorkerClient<any>, obj: EditorWorkerHost): void;
+    static getChannel(workerServer: IWebWorkerServer): EditorWorkerHost;
+    static setChannel(workerClient: IWebWorkerClient<any>, obj: EditorWorkerHost): void;
     abstract $fhr(method: string, args: any[]): Promise<any>;
 }

package/vscode/src/vs/editor/common/services/textModelSync/textModelSync.impl.d.ts

@@ -1,19 +1,19 @@
 import { Disposable } from "../../../../base/common/lifecycle.js";
 import { URI } from "../../../../base/common/uri.js";
-import { IWorkerClient, IWorkerServer } from "../../../../base/common/worker/simpleWorker.js";
+import { IWebWorkerClient, IWebWorkerServer } from "../../../../base/common/worker/webWorker.js";
 import { IPosition } from "../../core/position.js";
 import { IRange, Range } from "../../core/range.js";
 import { IWordAtPosition } from "../../core/wordHelper.js";
 import { IDocumentColorComputerTarget } from "../../languages/defaultDocumentColorsComputer.js";
 import { ILinkComputerTarget } from "../../languages/linkComputer.js";
 import { MirrorTextModel as BaseMirrorModel, IModelChangedEvent } from "../../model/mirrorTextModel.js";
-import { IMirrorModel } from "../editorSimpleWorker.js";
+import { IMirrorModel } from "../editorWebWorker.js";
 import { IModelService } from "../model.service.js";
 import { IRawModelData, IWorkerTextModelSyncChannelServer } from "./textModelSync.protocol.js";
 export declare const STOP_SYNC_MODEL_DELTA_TIME_MS: number;
 export declare const WORKER_TEXT_MODEL_SYNC_CHANNEL = "workerTextModelSync";
 export declare class WorkerTextModelSyncClient extends Disposable {
-    static create(workerClient: IWorkerClient<any>, modelService: IModelService): WorkerTextModelSyncClient;
+    static create(workerClient: IWebWorkerClient<any>, modelService: IModelService): WorkerTextModelSyncClient;
     private readonly _proxy;
     private readonly _modelService;
     private _syncedModels;
@@ -28,7 +28,7 @@ export declare class WorkerTextModelSyncClient extends Disposable {
 export declare class WorkerTextModelSyncServer implements IWorkerTextModelSyncChannelServer {
     private readonly _models;
     constructor();
-    bindToServer(workerServer: IWorkerServer): void;
+    bindToServer(workerServer: IWebWorkerServer): void;
     getModel(uri: string): ICommonModel | undefined;
     getModels(): ICommonModel[];
     $acceptNewModel(data: IRawModelData): void;

package/vscode/src/vs/editor/common/services/textResourceConfiguration.service.d.ts

@@ -10,7 +10,7 @@ export interface ITextResourceConfigurationService {
     getValue<T>(resource: URI | undefined, section?: string): T;
     getValue<T>(resource: URI | undefined, position?: IPosition, section?: string): T;
     inspect<T>(resource: URI | undefined, position: IPosition | null, section: string): IConfigurationValue<Readonly<T>>;
-    updateValue(resource: URI, key: string, value: any, configurationTarget?: ConfigurationTarget): Promise<void>;
+    updateValue(resource: URI | undefined, key: string, value: any, configurationTarget?: ConfigurationTarget): Promise<void>;
 }
 export declare const ITextResourcePropertiesService: import("../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ITextResourcePropertiesService>;
 export interface ITextResourcePropertiesService {

package/vscode/src/vs/editor/common/services/treeSitterParserService.service.d.ts

@@ -1,7 +1,7 @@
 import * as Parser from "@vscode/tree-sitter-wasm";
 import { Event } from "../../../base/common/event.js";
 import { ITextModel } from "../model.js";
-import { ITextModelTreeSitter, ITreeSitterParseResult, TreeUpdateEvent } from "@codingame/monaco-vscode-treesitter-service-override/vscode/vs/editor/common/services/treeSitterParserService";
+import { ITextModelTreeSitter, TreeUpdateEvent } from "@codingame/monaco-vscode-treesitter-service-override/vscode/vs/editor/common/services/treeSitterParserService";
 export declare const ITreeSitterParserService: import("../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ITreeSitterParserService>;
 export interface ITreeSitterParserService {
     readonly _serviceBrand: undefined;
@@ -11,7 +11,7 @@ export interface ITreeSitterParserService {
     }>;
     getOrInitLanguage(languageId: string): Parser.Language | undefined;
     getLanguage(languageId: string): Promise<Parser.Language | undefined>;
-    getParseResult(textModel: ITextModel): ITreeSitterParseResult | undefined;
+    getParseResult(textModel: ITextModel): ITextModelTreeSitter | undefined;
     getTree(content: string, languageId: string): Promise<Parser.Tree | undefined>;
     getTreeSync(content: string, languageId: string): Parser.Tree | undefined;
     onDidUpdateTree: Event<TreeUpdateEvent>;

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

@@ -3,142 +3,142 @@ import { localize } from '../../nls.js';
 
 var AccessibilityHelpNLS;
 (function (AccessibilityHelpNLS) {
-    AccessibilityHelpNLS.accessibilityHelpTitle = ( localize(790, "Accessibility Help"));
-    AccessibilityHelpNLS.openingDocs = ( localize(791, "Opening the Accessibility documentation page."));
-    AccessibilityHelpNLS.readonlyDiffEditor = ( localize(792, "You are in a read-only pane of a diff editor."));
-    AccessibilityHelpNLS.editableDiffEditor = ( localize(793, "You are in a pane of a diff editor."));
-    AccessibilityHelpNLS.readonlyEditor = ( localize(794, "You are in a read-only code editor."));
-    AccessibilityHelpNLS.editableEditor = ( localize(795, "You are in a code editor."));
+    AccessibilityHelpNLS.accessibilityHelpTitle = ( localize(820, "Accessibility Help"));
+    AccessibilityHelpNLS.openingDocs = ( localize(821, "Opening the Accessibility documentation page."));
+    AccessibilityHelpNLS.readonlyDiffEditor = ( localize(822, "You are in a read-only pane of a diff editor."));
+    AccessibilityHelpNLS.editableDiffEditor = ( localize(823, "You are in a pane of a diff editor."));
+    AccessibilityHelpNLS.readonlyEditor = ( localize(824, "You are in a read-only code editor."));
+    AccessibilityHelpNLS.editableEditor = ( localize(825, "You are in a code editor."));
     AccessibilityHelpNLS.defaultWindowTitleIncludesEditorState = ( localize(
-        796,
+        826,
         "activeEditorState - such as modified, problems, and more, is included as a part of the window.title setting by default. Disable it with accessibility.windowTitleOptimized."
     ));
     AccessibilityHelpNLS.defaultWindowTitleExcludingEditorState = ( localize(
-        797,
+        827,
         "activeEditorState - such as modified, problems, and more, is currently not included as a part of the window.title setting by default. Enable it with accessibility.windowTitleOptimized."
     ));
     AccessibilityHelpNLS.toolbar = ( localize(
-        798,
+        828,
         "Around the workbench, when the screen reader announces you've landed in a toolbar, use narrow keys to navigate between the toolbar's actions."
     ));
     AccessibilityHelpNLS.changeConfigToOnMac = ( localize(
-        799,
+        829,
         "Configure the application to be optimized for usage with a Screen Reader (Command+E)."
     ));
     AccessibilityHelpNLS.changeConfigToOnWinLinux = ( localize(
-        800,
+        830,
         "Configure the application to be optimized for usage with a Screen Reader (Control+E)."
     ));
     AccessibilityHelpNLS.auto_on = ( localize(
-        801,
+        831,
         "The application is configured to be optimized for usage with a Screen Reader."
     ));
     AccessibilityHelpNLS.auto_off = ( localize(
-        802,
+        832,
         "The application is configured to never be optimized for usage with a Screen Reader."
     ));
-    AccessibilityHelpNLS.screenReaderModeEnabled = ( localize(803, "Screen Reader Optimized Mode enabled."));
-    AccessibilityHelpNLS.screenReaderModeDisabled = ( localize(804, "Screen Reader Optimized Mode disabled."));
+    AccessibilityHelpNLS.screenReaderModeEnabled = ( localize(833, "Screen Reader Optimized Mode enabled."));
+    AccessibilityHelpNLS.screenReaderModeDisabled = ( localize(834, "Screen Reader Optimized Mode disabled."));
     AccessibilityHelpNLS.tabFocusModeOnMsg = ( localize(
-        805,
+        835,
         "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(
-        806,
+        836,
         "Pressing Tab in the current editor will insert the tab character. Toggle this behavior{0}.",
         '<keybinding:editor.action.toggleTabFocusMode>'
     ));
     AccessibilityHelpNLS.stickScroll = ( localize(
-        807,
+        837,
         "Focus Sticky Scroll{0} to focus the currently nested scopes.",
         '<keybinding:editor.action.focusStickyDebugConsole>'
     ));
     AccessibilityHelpNLS.suggestActions = ( localize(
-        808,
+        838,
         "Trigger the suggest widget{0} to show possible code completions.",
         '<keybinding:editor.action.triggerSuggest>'
     ));
     AccessibilityHelpNLS.acceptSuggestAction = ( localize(
-        809,
+        839,
         "Accept suggestion{0} to accept the currently selected suggestion.",
         '<keybinding:acceptSelectedSuggestion>'
     ));
     AccessibilityHelpNLS.toggleSuggestionFocus = ( localize(
-        810,
+        840,
         "Toggle focus between the suggest widget and the editor{0} and toggle details focus with{1} to learn more about the suggestion.",
         '<keybinding:focusSuggestion>',
         '<keybinding:toggleSuggestionFocus>'
     ));
     AccessibilityHelpNLS.codeFolding = ( localize(
-        811,
+        841,
         "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(
-        812,
+        842,
         "Use Intellisense to improve coding efficiency and reduce errors. Trigger suggestions{0}.",
         '<keybinding:editor.action.triggerSuggest>'
     ));
     AccessibilityHelpNLS.showOrFocusHover = ( localize(
-        813,
+        843,
         "Show or focus the hover{0} to read information about the current symbol.",
         '<keybinding:editor.action.showHover>'
     ));
     AccessibilityHelpNLS.goToSymbol = ( localize(
-        814,
+        844,
         "Go to Symbol{0} to quickly navigate between symbols in the current file.",
         '<keybinding:workbench.action.gotoSymbol>'
     ));
-    AccessibilityHelpNLS.showAccessibilityHelpAction = ( localize(815, "Show Accessibility Help"));
+    AccessibilityHelpNLS.showAccessibilityHelpAction = ( localize(845, "Show Accessibility Help"));
     AccessibilityHelpNLS.listSignalSounds = ( localize(
-        816,
+        846,
         "Run the command: List Signal Sounds for an overview of all sounds and their current status."
     ));
     AccessibilityHelpNLS.listAlerts = ( localize(
-        817,
+        847,
         "Run the command: List Signal Announcements for an overview of announcements and their current status."
     ));
     AccessibilityHelpNLS.quickChat = ( localize(
-        818,
+        848,
         "Toggle quick chat{0} to open or close a chat session.",
         '<keybinding:workbench.action.quickchat.toggle>'
     ));
     AccessibilityHelpNLS.startInlineChat = ( localize(
-        819,
+        849,
         "Start inline chat{0} to create an in editor chat session.",
         '<keybinding:inlineChat.start>'
     ));
     AccessibilityHelpNLS.startDebugging = ( localize(
-        820,
+        850,
         "The Debug: Start Debugging command{0} will start a debug session.",
         '<keybinding:workbench.action.debug.start>'
     ));
     AccessibilityHelpNLS.setBreakpoint = ( localize(
-        821,
+        851,
         "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(
-        822,
+        852,
         "The Debug: Add to Watch command{0} will add the selected text to the watch view.",
         '<keybinding:editor.debug.action.selectionToWatch>'
     ));
     AccessibilityHelpNLS.debugExecuteSelection = ( localize(
-        823,
+        853,
         "The Debug: Execute Selection command{0} will execute the selected text in the debug console.",
         '<keybinding:editor.debug.action.selectionToRepl>'
     ));
     AccessibilityHelpNLS.chatEditorModification = ( localize(
-        824,
+        854,
         "The editor contains pending modifications that have been made by chat."
     ));
     AccessibilityHelpNLS.chatEditorRequestInProgress = ( localize(
-        825,
+        855,
         "The editor is currently waiting for modifications to be made by chat."
     ));
     AccessibilityHelpNLS.chatEditActions = ( localize(
-        826,
+        856,
         'Navigate between edits in the editor with navigate previous{0} and next{1} and accept{2}, reject{3} or view the diff{4} for the current change.',
         '<keybinding:chatEditor.action.navigatePrevious>',
         '<keybinding:chatEditor.action.navigateNext>',
@@ -149,37 +149,37 @@ var AccessibilityHelpNLS;
 })(AccessibilityHelpNLS || (AccessibilityHelpNLS = {}));
 var InspectTokensNLS;
 (function (InspectTokensNLS) {
-    InspectTokensNLS.inspectTokensAction = ( localize(827, "Developer: Inspect Tokens"));
+    InspectTokensNLS.inspectTokensAction = ( localize(857, "Developer: Inspect Tokens"));
 })(InspectTokensNLS || (InspectTokensNLS = {}));
 var GoToLineNLS;
 (function (GoToLineNLS) {
-    GoToLineNLS.gotoLineActionLabel = ( localize(828, "Go to Line/Column..."));
+    GoToLineNLS.gotoLineActionLabel = ( localize(858, "Go to Line/Column..."));
 })(GoToLineNLS || (GoToLineNLS = {}));
 var QuickHelpNLS;
 (function (QuickHelpNLS) {
-    QuickHelpNLS.helpQuickAccessActionLabel = ( localize(829, "Show all Quick Access Providers"));
+    QuickHelpNLS.helpQuickAccessActionLabel = ( localize(859, "Show all Quick Access Providers"));
 })(QuickHelpNLS || (QuickHelpNLS = {}));
 var QuickCommandNLS;
 (function (QuickCommandNLS) {
-    QuickCommandNLS.quickCommandActionLabel = ( localize(830, "Command Palette"));
-    QuickCommandNLS.quickCommandHelp = ( localize(831, "Show And Run Commands"));
+    QuickCommandNLS.quickCommandActionLabel = ( localize(860, "Command Palette"));
+    QuickCommandNLS.quickCommandHelp = ( localize(861, "Show And Run Commands"));
 })(QuickCommandNLS || (QuickCommandNLS = {}));
 var QuickOutlineNLS;
 (function (QuickOutlineNLS) {
-    QuickOutlineNLS.quickOutlineActionLabel = ( localize(832, "Go to Symbol..."));
-    QuickOutlineNLS.quickOutlineByCategoryActionLabel = ( localize(833, "Go to Symbol by Category..."));
+    QuickOutlineNLS.quickOutlineActionLabel = ( localize(862, "Go to Symbol..."));
+    QuickOutlineNLS.quickOutlineByCategoryActionLabel = ( localize(863, "Go to Symbol by Category..."));
 })(QuickOutlineNLS || (QuickOutlineNLS = {}));
 var StandaloneCodeEditorNLS;
 (function (StandaloneCodeEditorNLS) {
-    StandaloneCodeEditorNLS.editorViewAccessibleLabel = ( localize(834, "Editor content"));
+    StandaloneCodeEditorNLS.editorViewAccessibleLabel = ( localize(864, "Editor content"));
 })(StandaloneCodeEditorNLS || (StandaloneCodeEditorNLS = {}));
 var ToggleHighContrastNLS;
 (function (ToggleHighContrastNLS) {
-    ToggleHighContrastNLS.toggleHighContrast = ( localize(835, "Toggle High Contrast Theme"));
+    ToggleHighContrastNLS.toggleHighContrast = ( localize(865, "Toggle High Contrast Theme"));
 })(ToggleHighContrastNLS || (ToggleHighContrastNLS = {}));
 var StandaloneServicesNLS;
 (function (StandaloneServicesNLS) {
-    StandaloneServicesNLS.bulkEditServiceSummary = ( localize(836, "Made {0} edits in {1} files"));
+    StandaloneServicesNLS.bulkEditServiceSummary = ( localize(866, "Made {0} edits in {1} files"));
 })(StandaloneServicesNLS || (StandaloneServicesNLS = {}));
 
 export { AccessibilityHelpNLS, GoToLineNLS, InspectTokensNLS, QuickCommandNLS, QuickHelpNLS, QuickOutlineNLS, StandaloneCodeEditorNLS, StandaloneServicesNLS, ToggleHighContrastNLS };

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

@@ -2,6 +2,7 @@
 import { FontStyle, MetadataConsts, ColorId, TokenMetadata } from '../encodedTokenAttributes.js';
 import { OffsetRange } from '../core/offsetRange.js';
 import { TokenArrayBuilder } from './tokenArray.js';
+import { onUnexpectedError } from '../../../base/common/errors.js';
 
 class LineTokens {
     static createEmpty(lineContent, decoder) {
@@ -56,6 +57,10 @@ class LineTokens {
         | (ColorId.DefaultBackground << MetadataConsts.BACKGROUND_OFFSET)) >>> 0; }
     constructor(tokens, text, decoder) {
         this._lineTokensBrand = undefined;
+        const tokensLength = tokens.length > 1 ? tokens[tokens.length - 2] : 0;
+        if (tokensLength !== text.length) {
+            onUnexpectedError(( new Error('Token length and text length do not match!')));
+        }
         this._tokens = tokens;
         this._tokensCount = (this._tokens.length >>> 1);
         this._text = text;

package/vscode/src/vs/editor/common/viewLayout/viewLineRenderer.js

@@ -885,7 +885,7 @@ function _renderLine(input, sb) {
     }
     if (isOverflowing) {
         sb.appendString('<span class="mtkoverflow">');
-        sb.appendString(( localize(837, "Show more ({0})", renderOverflowingCharCount(overflowingCharCount))));
+        sb.appendString(( localize(867, "Show more ({0})", renderOverflowingCharCount(overflowingCharCount))));
         sb.appendString('</span>');
     }
     sb.appendString('</span>');
@@ -896,7 +896,7 @@ function to4CharHex(n) {
 }
 function renderOverflowingCharCount(n) {
     if (n < 1024) {
-        return localize(838, "{0} chars", n);
+        return localize(868, "{0} chars", n);
     }
     if (n < 1024 * 1024) {
         return `${(n / 1024).toFixed(1)} KB`;

package/vscode/src/vs/editor/common/viewModel/viewModelImpl.d.ts

@@ -48,6 +48,7 @@ export declare class ViewModel extends Disposable implements IViewModel {
     visibleLinesStabilized(): void;
     private _handleVisibleLinesChanged;
     setHasFocus(hasFocus: boolean): void;
+    setHasWidgetFocus(hasWidgetFocus: boolean): void;
     onCompositionStart(): void;
     onCompositionEnd(): void;
     private _captureStableViewport;

package/vscode/src/vs/editor/common/viewModel/viewModelImpl.js

@@ -23,7 +23,7 @@ import { ViewLayout } from '../viewLayout/viewLayout.js';
 import { MinimapTokensColorTracker } from './minimapTokensColorTracker.js';
 import { ViewLineRenderingData, MinimapLinesRenderingData, OverviewRulerDecorationsGroup } from '../viewModel.js';
 import { ViewModelDecorations } from './viewModelDecorations.js';
-import { ViewModelEventDispatcher, ScrollChangedEvent, FocusChangedEvent, ModelContentChangedEvent, ModelTokensChangedEvent, ModelLanguageConfigurationChangedEvent, ModelLanguageChangedEvent, ModelOptionsChangedEvent, ModelDecorationsChangedEvent, HiddenAreasChangedEvent, ReadOnlyEditAttemptEvent, ViewZonesChangedEvent as ViewZonesChangedEvent$1 } from '../viewModelEventDispatcher.js';
+import { ViewModelEventDispatcher, ScrollChangedEvent, FocusChangedEvent, WidgetFocusChangedEvent, ModelContentChangedEvent, ModelTokensChangedEvent, ModelLanguageConfigurationChangedEvent, ModelLanguageChangedEvent, ModelOptionsChangedEvent, ModelDecorationsChangedEvent, HiddenAreasChangedEvent, ReadOnlyEditAttemptEvent, ViewZonesChangedEvent as ViewZonesChangedEvent$1 } from '../viewModelEventDispatcher.js';
 import { ViewModelLinesFromModelAsIs, ViewModelLinesFromProjectedModel } from './viewModelLines.js';
 import { GlyphMarginLanesModel } from './glyphLanesModel.js';
 
@@ -119,9 +119,9 @@ class ViewModel extends Disposable {
         this._register(MinimapTokensColorTracker.getInstance().onDidChange(() => {
             this._eventDispatcher.emitSingleViewEvent(new ViewTokensColorsChangedEvent());
         }));
-        this._register(this._themeService.onDidColorThemeChange((e) => {
+        this._register(this._themeService.onDidColorThemeChange((theme) => {
             this._invalidateDecorationsColorCache();
-            this._eventDispatcher.emitSingleViewEvent(new ViewThemeChangedEvent(e.theme));
+            this._eventDispatcher.emitSingleViewEvent(new ViewThemeChangedEvent(theme));
         }));
         this._updateConfigurationViewLineCountNow();
     }
@@ -169,6 +169,9 @@ class ViewModel extends Disposable {
         this._eventDispatcher.emitSingleViewEvent(new ViewFocusChangedEvent(hasFocus));
         this._eventDispatcher.emitOutgoingEvent(( new FocusChangedEvent(!hasFocus, hasFocus)));
     }
+    setHasWidgetFocus(hasWidgetFocus) {
+        this._eventDispatcher.emitOutgoingEvent(( new WidgetFocusChangedEvent(!hasWidgetFocus, hasWidgetFocus)));
+    }
     onCompositionStart() {
         this._eventDispatcher.emitSingleViewEvent(new ViewCompositionStartEvent());
     }