@codingame/monaco-vscode-api 13.1.6 → 14.0.0

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

@@ -2,16 +2,15 @@ import { ILanguageIdCodec } from "../languages.js";
 import { LineTokens } from "../tokens/lineTokens.js";
 import { StandardTokenType } from "../encodedTokenAttributes.js";
 import { TextModel } from "./textModel.js";
-import { ITreeSitterParserService } from "../services/treeSitterParserService.js";
 import { IModelContentChangedEvent } from "../textModelEvents.js";
 import { AbstractTokens } from "./tokens.js";
-import { ITokenizeLineWithEditResult, LineEditWithAdditionalLines } from "../tokenizationTextModelPart.js";
+import { ITreeSitterTokenizationStoreService } from "./treeSitterTokenStoreService.js";
 export declare class TreeSitterTokens extends AbstractTokens {
-    private readonly _treeSitterService;
+    private readonly _tokenStore;
     private _tokenizationSupport;
     private _lastLanguageId;
     private readonly _tokensChangedListener;
-    constructor(_treeSitterService: ITreeSitterParserService, languageIdCodec: ILanguageIdCodec, textModel: TextModel, languageId: () => string);
+    constructor(languageIdCodec: ILanguageIdCodec, textModel: TextModel, languageId: () => string, _tokenStore: ITreeSitterTokenizationStoreService);
     private _initialize;
     getLineTokens(lineNumber: number): LineTokens;
     resetTokenization(fireTokenChangeEvent?: boolean): void;
@@ -21,6 +20,6 @@ export declare class TreeSitterTokens extends AbstractTokens {
     hasAccurateTokensForLine(lineNumber: number): boolean;
     isCheapToTokenize(lineNumber: number): boolean;
     getTokenTypeIfInsertingCharacter(lineNumber: number, column: number, character: string): StandardTokenType;
-    tokenizeLineWithEdit(lineNumber: number, edit: LineEditWithAdditionalLines): ITokenizeLineWithEditResult;
+    tokenizeLinesAt(lineNumber: number, lines: string[]): LineTokens[] | null;
     get hasTokens(): boolean;
 }

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

@@ -1,14 +1,17 @@
 
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { TreeSitterTokenizationRegistry } from '../languages.js';
 import { LineTokens } from '../tokens/lineTokens.js';
 import { StandardTokenType } from '../encodedTokenAttributes.js';
 import { AbstractTokens } from './tokens.js';
 import { MutableDisposable } from '../../../base/common/lifecycle.js';
+import { ITreeSitterTokenizationStoreService } from './treeSitterTokenStoreService.js';
+import { Range } from '../core/range.js';
 
-class TreeSitterTokens extends AbstractTokens {
-    constructor(_treeSitterService, languageIdCodec, textModel, languageId) {
+let TreeSitterTokens = class TreeSitterTokens extends AbstractTokens {
+    constructor(languageIdCodec, textModel, languageId, _tokenStore) {
         super(languageIdCodec, textModel, languageId);
-        this._treeSitterService = _treeSitterService;
+        this._tokenStore = _tokenStore;
         this._tokenizationSupport = null;
         this._tokensChangedListener = this._register(( new MutableDisposable()));
         this._initialize();
@@ -28,7 +31,7 @@ class TreeSitterTokens extends AbstractTokens {
     getLineTokens(lineNumber) {
         const content = this._textModel.getLineContent(lineNumber);
         if (this._tokenizationSupport) {
-            const rawTokens = this._tokenizationSupport.tokenizeEncoded(lineNumber, this._textModel);
+            const rawTokens = this._tokenStore.getTokens(this._textModel, lineNumber);
             if (rawTokens) {
                 return ( new LineTokens(rawTokens, content, this._languageIdCodec));
             }
@@ -57,9 +60,12 @@ class TreeSitterTokens extends AbstractTokens {
         }
     }
     forceTokenization(lineNumber) {
+        if (this._tokenizationSupport) {
+            this._tokenizationSupport.tokenizeEncoded(lineNumber, this._textModel);
+        }
     }
     hasAccurateTokensForLine(lineNumber) {
-        return true;
+        return this._tokenStore.hasTokens(this._textModel, ( new Range(lineNumber, 1, lineNumber, this._textModel.getLineMaxColumn(lineNumber))));
     }
     isCheapToTokenize(lineNumber) {
         return true;
@@ -67,13 +73,15 @@ class TreeSitterTokens extends AbstractTokens {
     getTokenTypeIfInsertingCharacter(lineNumber, column, character) {
         return StandardTokenType.Other;
     }
-    tokenizeLineWithEdit(lineNumber, edit) {
-        return { mainLineTokens: null, additionalLines: null };
+    tokenizeLinesAt(lineNumber, lines) {
+        return null;
     }
     get hasTokens() {
-        const hasTree = this._treeSitterService.getParseResult(this._textModel) !== undefined;
-        return hasTree;
+        return this._tokenStore.hasTokens(this._textModel);
     }
-}
+};
+TreeSitterTokens = ( __decorate([
+    ( __param(3, ITreeSitterTokenizationStoreService))
+], TreeSitterTokens));
 
 export { TreeSitterTokens };

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

@@ -9,7 +9,7 @@ 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-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/editor/common/diff/documentDiffProvider";
+import { IDocumentDiffProviderOptions } from "@codingame/monaco-vscode-e4d0fd26-1b26-5583-b3f7-582e08d7b389-common/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";

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

@@ -1,6 +1,6 @@
 import { URI } from "../../../base/common/uri.js";
 import { IRange } from "../core/range.js";
-import { IDocumentDiff, IDocumentDiffProviderOptions } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/editor/common/diff/documentDiffProvider";
+import { IDocumentDiff, IDocumentDiffProviderOptions } from "@codingame/monaco-vscode-e4d0fd26-1b26-5583-b3f7-582e08d7b389-common/vscode/vs/editor/common/diff/documentDiffProvider";
 import { IChange } from "../diff/legacyLinesDiffComputer.js";
 import { IColorInformation, IInplaceReplaceSupportResult, TextEdit } from "../languages.js";
 import { UnicodeHighlighterOptions } from "./unicodeTextModelHighlighter.js";

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

@@ -1,5 +1,5 @@
 import { LanguageFeatureRegistry, NotebookInfoResolver } from "../languageFeatureRegistry.js";
-import { CodeActionProvider, CodeLensProvider, CompletionItemProvider, DeclarationProvider, DefinitionProvider, DocumentColorProvider, DocumentFormattingEditProvider, DocumentHighlightProvider, DocumentDropEditProvider, DocumentPasteEditProvider, DocumentRangeFormattingEditProvider, DocumentRangeSemanticTokensProvider, DocumentSemanticTokensProvider, DocumentSymbolProvider, EvaluatableExpressionProvider, FoldingRangeProvider, HoverProvider, ImplementationProvider, InlayHintsProvider, InlineCompletionsProvider, InlineValuesProvider, LinkedEditingRangeProvider, LinkProvider, MappedEditsProvider, MultiDocumentHighlightProvider, NewSymbolNamesProvider, OnTypeFormattingEditProvider, ReferenceProvider, RenameProvider, SelectionRangeProvider, SignatureHelpProvider, TypeDefinitionProvider, InlineEditProvider } from "../languages.js";
+import { CodeActionProvider, CodeLensProvider, CompletionItemProvider, DeclarationProvider, DefinitionProvider, DocumentColorProvider, DocumentFormattingEditProvider, DocumentHighlightProvider, DocumentDropEditProvider, DocumentPasteEditProvider, DocumentRangeFormattingEditProvider, DocumentRangeSemanticTokensProvider, DocumentSemanticTokensProvider, DocumentSymbolProvider, EvaluatableExpressionProvider, FoldingRangeProvider, HoverProvider, ImplementationProvider, InlayHintsProvider, InlineCompletionsProvider, InlineValuesProvider, LinkedEditingRangeProvider, LinkProvider, MultiDocumentHighlightProvider, NewSymbolNamesProvider, OnTypeFormattingEditProvider, ReferenceProvider, RenameProvider, SelectionRangeProvider, SignatureHelpProvider, TypeDefinitionProvider, InlineEditProvider } from "../languages.js";
 export declare const ILanguageFeaturesService: import("../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ILanguageFeaturesService>;
 export interface ILanguageFeaturesService {
     readonly _serviceBrand: undefined;
@@ -35,6 +35,5 @@ export interface ILanguageFeaturesService {
     readonly inlineValuesProvider: LanguageFeatureRegistry<InlineValuesProvider>;
     readonly evaluatableExpressionProvider: LanguageFeatureRegistry<EvaluatableExpressionProvider>;
     readonly documentDropEditProvider: LanguageFeatureRegistry<DocumentDropEditProvider>;
-    readonly mappedEditsProvider: LanguageFeatureRegistry<MappedEditsProvider>;
     setNotebookTypeResolver(resolver: NotebookInfoResolver | undefined): void;
 }

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

@@ -1,5 +1,5 @@
 import { LanguageFeatureRegistry, NotebookInfoResolver } from "../languageFeatureRegistry.js";
-import { CodeActionProvider, CodeLensProvider, CompletionItemProvider, DocumentPasteEditProvider, DeclarationProvider, DefinitionProvider, DocumentColorProvider, DocumentFormattingEditProvider, MultiDocumentHighlightProvider, DocumentHighlightProvider, DocumentDropEditProvider, DocumentRangeFormattingEditProvider, DocumentRangeSemanticTokensProvider, DocumentSemanticTokensProvider, DocumentSymbolProvider, EvaluatableExpressionProvider, FoldingRangeProvider, HoverProvider, ImplementationProvider, InlayHintsProvider, InlineCompletionsProvider, InlineValuesProvider, LinkedEditingRangeProvider, LinkProvider, OnTypeFormattingEditProvider, ReferenceProvider, RenameProvider, SelectionRangeProvider, SignatureHelpProvider, TypeDefinitionProvider, MappedEditsProvider, NewSymbolNamesProvider, InlineEditProvider } from "../languages.js";
+import { CodeActionProvider, CodeLensProvider, CompletionItemProvider, DocumentPasteEditProvider, DeclarationProvider, DefinitionProvider, DocumentColorProvider, DocumentFormattingEditProvider, MultiDocumentHighlightProvider, DocumentHighlightProvider, DocumentDropEditProvider, DocumentRangeFormattingEditProvider, DocumentRangeSemanticTokensProvider, DocumentSemanticTokensProvider, DocumentSymbolProvider, EvaluatableExpressionProvider, FoldingRangeProvider, HoverProvider, ImplementationProvider, InlayHintsProvider, InlineCompletionsProvider, InlineValuesProvider, LinkedEditingRangeProvider, LinkProvider, OnTypeFormattingEditProvider, ReferenceProvider, RenameProvider, SelectionRangeProvider, SignatureHelpProvider, TypeDefinitionProvider, NewSymbolNamesProvider, InlineEditProvider } from "../languages.js";
 import { ILanguageFeaturesService } from "./languageFeatures.js";
 export declare class LanguageFeaturesService implements ILanguageFeaturesService {
     _serviceBrand: undefined;
@@ -35,7 +35,6 @@ export declare class LanguageFeaturesService implements ILanguageFeaturesService
     readonly documentSemanticTokensProvider: LanguageFeatureRegistry<DocumentSemanticTokensProvider>;
     readonly documentDropEditProvider: LanguageFeatureRegistry<DocumentDropEditProvider>;
     readonly documentPasteEditProvider: LanguageFeatureRegistry<DocumentPasteEditProvider>;
-    readonly mappedEditsProvider: LanguageFeatureRegistry<MappedEditsProvider>;
     private _notebookTypeResolver?;
     setNotebookTypeResolver(resolver: NotebookInfoResolver | undefined): void;
     private _score;

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

@@ -37,7 +37,6 @@ class LanguageFeaturesService {
         this.documentSemanticTokensProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
         this.documentDropEditProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
         this.documentPasteEditProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
-        this.mappedEditsProvider = ( new LanguageFeatureRegistry(this._score.bind(this)));
     }
     setNotebookTypeResolver(resolver) {
         this._notebookTypeResolver = resolver;

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

@@ -4,6 +4,21 @@ import { ITextModel } from "../model.js";
 import { Range } from "../core/range.js";
 export declare const EDITOR_EXPERIMENTAL_PREFER_TREESITTER = "editor.experimental.preferTreeSitter";
 export declare const ITreeSitterParserService: import("../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ITreeSitterParserService>;
+export interface RangeChange {
+    newRange: Range;
+    oldRangeLength: number;
+    newRangeStartOffset: number;
+    newRangeEndOffset: number;
+}
+export interface TreeParseUpdateEvent {
+    ranges: RangeChange[] | undefined;
+    versionId: number;
+}
+export interface TreeUpdateEvent {
+    textModel: ITextModel;
+    ranges: RangeChange[];
+    versionId: number;
+}
 export interface ITreeSitterParserService {
     readonly _serviceBrand: undefined;
     onDidAddLanguage: Event<{
@@ -13,15 +28,13 @@ export interface ITreeSitterParserService {
     getOrInitLanguage(languageId: string): Parser.Language | undefined;
     getParseResult(textModel: ITextModel): ITreeSitterParseResult | undefined;
     getTree(content: string, languageId: string): Promise<Parser.Tree | undefined>;
-    onDidUpdateTree: Event<{
-        textModel: ITextModel;
-        ranges: Range[];
-    }>;
-    getTextModelTreeSitter(textModel: ITextModel): ITextModelTreeSitter | undefined;
+    onDidUpdateTree: Event<TreeUpdateEvent>;
+    getTextModelTreeSitter(model: ITextModel, parseImmediately?: boolean): Promise<ITextModelTreeSitter | undefined>;
 }
 export interface ITreeSitterParseResult {
     readonly tree: Parser.Tree | undefined;
     readonly language: Parser.Language;
+    versionId: number;
 }
 export interface ITextModelTreeSitter {
     parse(languageId?: string): Promise<ITreeSitterParseResult | undefined>;

package/vscode/src/vs/editor/common/standaloneStrings.d.ts

@@ -27,6 +27,9 @@ export declare namespace AccessibilityHelpNLS {
     const setBreakpoint: string;
     const addToWatch: string;
     const debugExecuteSelection: string;
+    const chatEditorModification: string;
+    const chatEditorRequestInProgress: string;
+    const chatEditActions: string;
 }
 export declare namespace InspectTokensNLS {
     const inspectTokensAction: string;

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

@@ -3,138 +3,154 @@ import { localize } from '../../nls.js';
 
 var AccessibilityHelpNLS;
 (function (AccessibilityHelpNLS) {
-    AccessibilityHelpNLS.accessibilityHelpTitle = ( localize(781, "Accessibility Help"));
-    AccessibilityHelpNLS.openingDocs = ( localize(782, "Opening the Accessibility documentation page."));
-    AccessibilityHelpNLS.readonlyDiffEditor = ( localize(783, "You are in a read-only pane of a diff editor."));
-    AccessibilityHelpNLS.editableDiffEditor = ( localize(784, "You are in a pane of a diff editor."));
-    AccessibilityHelpNLS.readonlyEditor = ( localize(785, "You are in a read-only code editor."));
-    AccessibilityHelpNLS.editableEditor = ( localize(786, "You are in a code editor."));
+    AccessibilityHelpNLS.accessibilityHelpTitle = ( localize(787, "Accessibility Help"));
+    AccessibilityHelpNLS.openingDocs = ( localize(788, "Opening the Accessibility documentation page."));
+    AccessibilityHelpNLS.readonlyDiffEditor = ( localize(789, "You are in a read-only pane of a diff editor."));
+    AccessibilityHelpNLS.editableDiffEditor = ( localize(790, "You are in a pane of a diff editor."));
+    AccessibilityHelpNLS.readonlyEditor = ( localize(791, "You are in a read-only code editor."));
+    AccessibilityHelpNLS.editableEditor = ( localize(792, "You are in a code editor."));
     AccessibilityHelpNLS.changeConfigToOnMac = ( localize(
-        787,
+        793,
         "Configure the application to be optimized for usage with a Screen Reader (Command+E)."
     ));
     AccessibilityHelpNLS.changeConfigToOnWinLinux = ( localize(
-        788,
+        794,
         "Configure the application to be optimized for usage with a Screen Reader (Control+E)."
     ));
     AccessibilityHelpNLS.auto_on = ( localize(
-        789,
+        795,
         "The application is configured to be optimized for usage with a Screen Reader."
     ));
     AccessibilityHelpNLS.auto_off = ( localize(
-        790,
+        796,
         "The application is configured to never be optimized for usage with a Screen Reader."
     ));
-    AccessibilityHelpNLS.screenReaderModeEnabled = ( localize(791, "Screen Reader Optimized Mode enabled."));
-    AccessibilityHelpNLS.screenReaderModeDisabled = ( localize(792, "Screen Reader Optimized Mode disabled."));
+    AccessibilityHelpNLS.screenReaderModeEnabled = ( localize(797, "Screen Reader Optimized Mode enabled."));
+    AccessibilityHelpNLS.screenReaderModeDisabled = ( localize(798, "Screen Reader Optimized Mode disabled."));
     AccessibilityHelpNLS.tabFocusModeOnMsg = ( localize(
-        793,
+        799,
         "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(
-        794,
+        800,
         "Pressing Tab in the current editor will insert the tab character. Toggle this behavior{0}.",
         '<keybinding:editor.action.toggleTabFocusMode>'
     ));
     AccessibilityHelpNLS.stickScroll = ( localize(
-        795,
+        801,
         "Focus Sticky Scroll{0} to focus the currently nested scopes.",
         '<keybinding:editor.action.focusStickyDebugConsole>'
     ));
     AccessibilityHelpNLS.codeFolding = ( localize(
-        796,
+        802,
         "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(
-        797,
+        803,
         "Use Intellisense to improve coding efficiency and reduce errors. Trigger suggestions{0}.",
         '<keybinding:editor.action.triggerSuggest>'
     ));
     AccessibilityHelpNLS.showOrFocusHover = ( localize(
-        798,
+        804,
         "Show or focus the hover{0} to read information about the current symbol.",
         '<keybinding:editor.action.showHover>'
     ));
     AccessibilityHelpNLS.goToSymbol = ( localize(
-        799,
+        805,
         "Go to Symbol{0} to quickly navigate between symbols in the current file.",
         '<keybinding:workbench.action.gotoSymbol>'
     ));
-    AccessibilityHelpNLS.showAccessibilityHelpAction = ( localize(800, "Show Accessibility Help"));
+    AccessibilityHelpNLS.showAccessibilityHelpAction = ( localize(806, "Show Accessibility Help"));
     AccessibilityHelpNLS.listSignalSounds = ( localize(
-        801,
+        807,
         "Run the command: List Signal Sounds for an overview of all sounds and their current status."
     ));
     AccessibilityHelpNLS.listAlerts = ( localize(
-        802,
+        808,
         "Run the command: List Signal Announcements for an overview of announcements and their current status."
     ));
     AccessibilityHelpNLS.quickChat = ( localize(
-        803,
+        809,
         "Toggle quick chat{0} to open or close a chat session.",
         '<keybinding:workbench.action.quickchat.toggle>'
     ));
     AccessibilityHelpNLS.startInlineChat = ( localize(
-        804,
+        810,
         "Start inline chat{0} to create an in editor chat session.",
         '<keybinding:inlineChat.start>'
     ));
     AccessibilityHelpNLS.startDebugging = ( localize(
-        805,
+        811,
         "The Debug: Start Debugging command{0} will start a debug session.",
         '<keybinding:workbench.action.debug.start>'
     ));
     AccessibilityHelpNLS.setBreakpoint = ( localize(
-        806,
+        812,
         "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(
-        807,
+        813,
         "The Debug: Add to Watch command{0} will add the selected text to the watch view.",
         '<keybinding:editor.debug.action.selectionToWatch>'
     ));
     AccessibilityHelpNLS.debugExecuteSelection = ( localize(
-        808,
+        814,
         "The Debug: Execute Selection command{0} will execute the selected text in the debug console.",
         '<keybinding:editor.debug.action.selectionToRepl>'
     ));
+    AccessibilityHelpNLS.chatEditorModification = ( localize(
+        815,
+        "The editor contains pending modifications that have been made by chat."
+    ));
+    AccessibilityHelpNLS.chatEditorRequestInProgress = ( localize(
+        816,
+        "The editor is currently waiting for modifications to be made by chat."
+    ));
+    AccessibilityHelpNLS.chatEditActions = ( localize(
+        817,
+        'Navigate between edits in the editor with navigate previous{0} and next{1} and accept{3} and reject the current change{4}.',
+        '<keybinding:chatEditor.action.navigatePrevious>',
+        '<keybinding:chatEditor.action.navigateNext>',
+        '<keybinding:chatEditor.action.acceptHunk>',
+        '<keybinding:chatEditor.action.reject>'
+    ));
 })(AccessibilityHelpNLS || (AccessibilityHelpNLS = {}));
 var InspectTokensNLS;
 (function (InspectTokensNLS) {
-    InspectTokensNLS.inspectTokensAction = ( localize(809, "Developer: Inspect Tokens"));
+    InspectTokensNLS.inspectTokensAction = ( localize(818, "Developer: Inspect Tokens"));
 })(InspectTokensNLS || (InspectTokensNLS = {}));
 var GoToLineNLS;
 (function (GoToLineNLS) {
-    GoToLineNLS.gotoLineActionLabel = ( localize(810, "Go to Line/Column..."));
+    GoToLineNLS.gotoLineActionLabel = ( localize(819, "Go to Line/Column..."));
 })(GoToLineNLS || (GoToLineNLS = {}));
 var QuickHelpNLS;
 (function (QuickHelpNLS) {
-    QuickHelpNLS.helpQuickAccessActionLabel = ( localize(811, "Show all Quick Access Providers"));
+    QuickHelpNLS.helpQuickAccessActionLabel = ( localize(820, "Show all Quick Access Providers"));
 })(QuickHelpNLS || (QuickHelpNLS = {}));
 var QuickCommandNLS;
 (function (QuickCommandNLS) {
-    QuickCommandNLS.quickCommandActionLabel = ( localize(812, "Command Palette"));
-    QuickCommandNLS.quickCommandHelp = ( localize(813, "Show And Run Commands"));
+    QuickCommandNLS.quickCommandActionLabel = ( localize(821, "Command Palette"));
+    QuickCommandNLS.quickCommandHelp = ( localize(822, "Show And Run Commands"));
 })(QuickCommandNLS || (QuickCommandNLS = {}));
 var QuickOutlineNLS;
 (function (QuickOutlineNLS) {
-    QuickOutlineNLS.quickOutlineActionLabel = ( localize(814, "Go to Symbol..."));
-    QuickOutlineNLS.quickOutlineByCategoryActionLabel = ( localize(815, "Go to Symbol by Category..."));
+    QuickOutlineNLS.quickOutlineActionLabel = ( localize(823, "Go to Symbol..."));
+    QuickOutlineNLS.quickOutlineByCategoryActionLabel = ( localize(824, "Go to Symbol by Category..."));
 })(QuickOutlineNLS || (QuickOutlineNLS = {}));
 var StandaloneCodeEditorNLS;
 (function (StandaloneCodeEditorNLS) {
-    StandaloneCodeEditorNLS.editorViewAccessibleLabel = ( localize(816, "Editor content"));
+    StandaloneCodeEditorNLS.editorViewAccessibleLabel = ( localize(825, "Editor content"));
 })(StandaloneCodeEditorNLS || (StandaloneCodeEditorNLS = {}));
 var ToggleHighContrastNLS;
 (function (ToggleHighContrastNLS) {
-    ToggleHighContrastNLS.toggleHighContrast = ( localize(817, "Toggle High Contrast Theme"));
+    ToggleHighContrastNLS.toggleHighContrast = ( localize(826, "Toggle High Contrast Theme"));
 })(ToggleHighContrastNLS || (ToggleHighContrastNLS = {}));
 var StandaloneServicesNLS;
 (function (StandaloneServicesNLS) {
-    StandaloneServicesNLS.bulkEditServiceSummary = ( localize(818, "Made {0} edits in {1} files"));
+    StandaloneServicesNLS.bulkEditServiceSummary = ( localize(827, "Made {0} edits in {1} files"));
 })(StandaloneServicesNLS || (StandaloneServicesNLS = {}));
 
 export { AccessibilityHelpNLS, GoToLineNLS, InspectTokensNLS, QuickCommandNLS, QuickHelpNLS, QuickOutlineNLS, StandaloneCodeEditorNLS, StandaloneServicesNLS, ToggleHighContrastNLS };

package/vscode/src/vs/editor/common/tokenizationTextModelPart.d.ts

@@ -1,5 +1,3 @@
-import { OffsetEdit } from "./core/offsetEdit.js";
-import { OffsetRange } from "./core/offsetRange.js";
 import { Range } from "./core/range.js";
 import { StandardTokenType } from "./encodedTokenAttributes.js";
 import { LineTokens } from "./tokens/lineTokens.js";
@@ -17,22 +15,12 @@ export interface ITokenizationTextModelPart {
     isCheapToTokenize(lineNumber: number): boolean;
     getLineTokens(lineNumber: number): LineTokens;
     getTokenTypeIfInsertingCharacter(lineNumber: number, column: number, character: string): StandardTokenType;
-    tokenizeLineWithEdit(lineNumber: number, edit: LineEditWithAdditionalLines): ITokenizeLineWithEditResult;
+    tokenizeLinesAt(lineNumber: number, lines: string[]): LineTokens[] | null;
     getLanguageId(): string;
     getLanguageIdAtPosition(lineNumber: number, column: number): string;
     setLanguageId(languageId: string, source?: string): void;
     readonly backgroundTokenizationState: BackgroundTokenizationState;
 }
-export declare class LineEditWithAdditionalLines {
-    readonly lineEdit: OffsetEdit;
-    readonly additionalLines: string[] | null;
-    static replace(range: OffsetRange, text: string): LineEditWithAdditionalLines;
-    constructor(lineEdit: OffsetEdit, additionalLines: string[] | null);
-}
-export interface ITokenizeLineWithEditResult {
-    readonly mainLineTokens: LineTokens | null;
-    readonly additionalLines: LineTokens[] | null;
-}
 export declare enum BackgroundTokenizationState {
     InProgress = 1,
     Completed = 2

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

@@ -1,21 +1,9 @@
 
-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;
-    }
-}
 var BackgroundTokenizationState;
 (function (BackgroundTokenizationState) {
     BackgroundTokenizationState[BackgroundTokenizationState["InProgress"] = 1] = "InProgress";
     BackgroundTokenizationState[BackgroundTokenizationState["Completed"] = 2] = "Completed";
 })(BackgroundTokenizationState || (BackgroundTokenizationState = {}));
 
-export { BackgroundTokenizationState, LineEditWithAdditionalLines };
+export { BackgroundTokenizationState };

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

@@ -52,6 +52,7 @@ export declare class LineTokens implements IViewLineTokens {
     findTokenIndexAtOffset(offset: number): number;
     inflate(): IViewLineTokens;
     sliceAndInflate(startOffset: number, endOffset: number, deltaOffset: number): IViewLineTokens;
+    sliceZeroCopy(range: OffsetRange): IViewLineTokens;
     withInserted(insertTokens: {
         offset: number;
         text: string;

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

@@ -136,6 +136,9 @@ class LineTokens {
     sliceAndInflate(startOffset, endOffset, deltaOffset) {
         return ( new SliceLineTokens(this, startOffset, endOffset, deltaOffset));
     }
+    sliceZeroCopy(range) {
+        return this.sliceAndInflate(range.start, range.endExclusive, 0);
+    }
     withInserted(insertTokens) {
         if (insertTokens.length === 0) {
             return this;

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

@@ -1,9 +1,14 @@
 import { OffsetRange } from "../core/offsetRange.js";
+import { ILanguageIdCodec } from "../languages.js";
+import { LineTokens } from "./lineTokens.js";
 export declare class TokenArray {
     private readonly _tokenInfo;
+    static fromLineTokens(lineTokens: LineTokens): TokenArray;
     static create(tokenInfo: TokenInfo[]): TokenArray;
     private constructor();
+    toLineTokens(lineContent: string, decoder: ILanguageIdCodec): LineTokens;
     forEach(cb: (range: OffsetRange, tokenInfo: TokenInfo) => void): void;
+    map<T>(cb: (range: OffsetRange, tokenInfo: TokenInfo) => T): T[];
     slice(range: OffsetRange): TokenArray;
 }
 export type TokenMetadata = number;

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

@@ -1,13 +1,27 @@
 
 import { OffsetRange } from '../core/offsetRange.js';
+import { LineTokens } from './lineTokens.js';
 
 class TokenArray {
+    static fromLineTokens(lineTokens) {
+        const tokenInfo = [];
+        for (let i = 0; i < lineTokens.getCount(); i++) {
+            tokenInfo.push(( new TokenInfo(
+                lineTokens.getEndOffset(i) - lineTokens.getStartOffset(i),
+                lineTokens.getMetadata(i)
+            )));
+        }
+        return TokenArray.create(tokenInfo);
+    }
     static create(tokenInfo) {
         return ( new TokenArray(tokenInfo));
     }
     constructor(_tokenInfo) {
         this._tokenInfo = _tokenInfo;
     }
+    toLineTokens(lineContent, decoder) {
+        return LineTokens.createFromTextAndMetadata(( this.map((r, t) => ({ text: r.substring(lineContent), metadata: t.metadata }))), decoder);
+    }
     forEach(cb) {
         let lengthSum = 0;
         for (const tokenInfo of this._tokenInfo) {
@@ -16,6 +30,16 @@ class TokenArray {
             lengthSum += tokenInfo.length;
         }
     }
+    map(cb) {
+        const result = [];
+        let lengthSum = 0;
+        for (const tokenInfo of this._tokenInfo) {
+            const range = ( new OffsetRange(lengthSum, lengthSum + tokenInfo.length));
+            result.push(cb(range, tokenInfo));
+            lengthSum += tokenInfo.length;
+        }
+        return result;
+    }
     slice(range) {
         const result = [];
         let lengthSum = 0;

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(819, "Show more ({0})", renderOverflowingCharCount(overflowingCharCount))));
+        sb.appendString(( localize(828, "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(820, "{0} chars", n);
+        return localize(829, "{0} chars", n);
     }
     if (n < 1024 * 1024) {
         return `${(n / 1024).toFixed(1)} KB`;

package/vscode/src/vs/editor/contrib/anchorSelect/browser/anchorSelect.js

@@ -36,12 +36,12 @@ let SelectionAnchorController = class SelectionAnchorController {
                 this.decorationId = accessor.addDecoration(Selection.fromPositions(position, position), {
                     description: 'selection-anchor',
                     stickiness: TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges,
-                    hoverMessage: ( new MarkdownString()).appendText(( localize(821, "Selection Anchor"))),
+                    hoverMessage: ( new MarkdownString()).appendText(( localize(830, "Selection Anchor"))),
                     className: 'selection-anchor'
                 });
             });
             this.selectionAnchorSetContextKey.set(!!this.decorationId);
-            alert(( localize(822, "Anchor set at {0}:{1}", position.lineNumber, position.column)));
+            alert(( localize(831, "Anchor set at {0}:{1}", position.lineNumber, position.column)));
         }
     }
     goToSelectionAnchor() {
@@ -84,7 +84,7 @@ class SetSelectionAnchor extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.setSelectionAnchor',
-            label: ( localize2(823, "Set Selection Anchor")),
+            label: ( localize2(832, "Set Selection Anchor")),
             precondition: undefined,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,
@@ -101,7 +101,7 @@ class GoToSelectionAnchor extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.goToSelectionAnchor',
-            label: ( localize2(824, "Go to Selection Anchor")),
+            label: ( localize2(833, "Go to Selection Anchor")),
             precondition: SelectionAnchorSet,
         });
     }
@@ -113,7 +113,7 @@ class SelectFromAnchorToCursor extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.selectFromAnchorToCursor',
-            label: ( localize2(825, "Select from Anchor to Cursor")),
+            label: ( localize2(834, "Select from Anchor to Cursor")),
             precondition: SelectionAnchorSet,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,
@@ -130,7 +130,7 @@ class CancelSelectionAnchor extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.cancelSelectionAnchor',
-            label: ( localize2(826, "Cancel Selection Anchor")),
+            label: ( localize2(835, "Cancel Selection Anchor")),
             precondition: SelectionAnchorSet,
             kbOpts: {
                 kbExpr: EditorContextKeys.editorTextFocus,