@codingame/monaco-vscode-api 13.1.7 → 14.0.0

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

@@ -5,73 +5,73 @@ import { RawContextKey } from '../../platform/contextkey/common/contextkey.js';
 var EditorContextKeys;
 (function (EditorContextKeys) {
     EditorContextKeys.editorSimpleInput = ( new RawContextKey('editorSimpleInput', false, true));
-    EditorContextKeys.editorTextFocus = ( new RawContextKey('editorTextFocus', false, ( localize(706, "Whether the editor text has focus (cursor is blinking)"))));
+    EditorContextKeys.editorTextFocus = ( new RawContextKey('editorTextFocus', false, ( localize(712, "Whether the editor text has focus (cursor is blinking)"))));
     EditorContextKeys.focus = ( new RawContextKey('editorFocus', false, ( localize(
-     707,
+     713,
      "Whether the editor or an editor widget has focus (e.g. focus is in the find widget)"
     ))));
     EditorContextKeys.textInputFocus = ( new RawContextKey('textInputFocus', false, ( localize(
-     708,
+     714,
      "Whether an editor or a rich text input has focus (cursor is blinking)"
     ))));
-    EditorContextKeys.readOnly = ( new RawContextKey('editorReadonly', false, ( localize(709, "Whether the editor is read-only"))));
-    EditorContextKeys.inDiffEditor = ( new RawContextKey('inDiffEditor', false, ( localize(710, "Whether the context is a diff editor"))));
-    EditorContextKeys.isEmbeddedDiffEditor = ( new RawContextKey('isEmbeddedDiffEditor', false, ( localize(711, "Whether the context is an embedded diff editor"))));
-    EditorContextKeys.multiDiffEditorAllCollapsed = ( new RawContextKey('multiDiffEditorAllCollapsed', undefined, ( localize(712, "Whether all files in multi diff editor are collapsed"))));
-    EditorContextKeys.hasChanges = ( new RawContextKey('diffEditorHasChanges', false, ( localize(713, "Whether the diff editor has changes"))));
-    EditorContextKeys.comparingMovedCode = ( new RawContextKey('comparingMovedCode', false, ( localize(714, "Whether a moved code block is selected for comparison"))));
-    EditorContextKeys.accessibleDiffViewerVisible = ( new RawContextKey('accessibleDiffViewerVisible', false, ( localize(715, "Whether the accessible diff viewer is visible"))));
+    EditorContextKeys.readOnly = ( new RawContextKey('editorReadonly', false, ( localize(715, "Whether the editor is read-only"))));
+    EditorContextKeys.inDiffEditor = ( new RawContextKey('inDiffEditor', false, ( localize(716, "Whether the context is a diff editor"))));
+    EditorContextKeys.isEmbeddedDiffEditor = ( new RawContextKey('isEmbeddedDiffEditor', false, ( localize(717, "Whether the context is an embedded diff editor"))));
+    EditorContextKeys.multiDiffEditorAllCollapsed = ( new RawContextKey('multiDiffEditorAllCollapsed', undefined, ( localize(718, "Whether all files in multi diff editor are collapsed"))));
+    EditorContextKeys.hasChanges = ( new RawContextKey('diffEditorHasChanges', false, ( localize(719, "Whether the diff editor has changes"))));
+    EditorContextKeys.comparingMovedCode = ( new RawContextKey('comparingMovedCode', false, ( localize(720, "Whether a moved code block is selected for comparison"))));
+    EditorContextKeys.accessibleDiffViewerVisible = ( new RawContextKey('accessibleDiffViewerVisible', false, ( localize(721, "Whether the accessible diff viewer is visible"))));
     EditorContextKeys.diffEditorRenderSideBySideInlineBreakpointReached = ( new RawContextKey('diffEditorRenderSideBySideInlineBreakpointReached', false, ( localize(
-     716,
+     722,
      "Whether the diff editor render side by side inline breakpoint is reached"
     ))));
-    EditorContextKeys.diffEditorInlineMode = ( new RawContextKey('diffEditorInlineMode', false, ( localize(717, "Whether inline mode is active"))));
-    EditorContextKeys.diffEditorOriginalWritable = ( new RawContextKey('diffEditorOriginalWritable', false, ( localize(718, "Whether modified is writable in the diff editor"))));
-    EditorContextKeys.diffEditorModifiedWritable = ( new RawContextKey('diffEditorModifiedWritable', false, ( localize(719, "Whether modified is writable in the diff editor"))));
-    EditorContextKeys.diffEditorOriginalUri = ( new RawContextKey('diffEditorOriginalUri', '', ( localize(720, "The uri of the original document"))));
-    EditorContextKeys.diffEditorModifiedUri = ( new RawContextKey('diffEditorModifiedUri', '', ( localize(721, "The uri of the modified document"))));
-    EditorContextKeys.columnSelection = ( new RawContextKey('editorColumnSelection', false, ( localize(722, "Whether `editor.columnSelection` is enabled"))));
+    EditorContextKeys.diffEditorInlineMode = ( new RawContextKey('diffEditorInlineMode', false, ( localize(723, "Whether inline mode is active"))));
+    EditorContextKeys.diffEditorOriginalWritable = ( new RawContextKey('diffEditorOriginalWritable', false, ( localize(724, "Whether modified is writable in the diff editor"))));
+    EditorContextKeys.diffEditorModifiedWritable = ( new RawContextKey('diffEditorModifiedWritable', false, ( localize(725, "Whether modified is writable in the diff editor"))));
+    EditorContextKeys.diffEditorOriginalUri = ( new RawContextKey('diffEditorOriginalUri', '', ( localize(726, "The uri of the original document"))));
+    EditorContextKeys.diffEditorModifiedUri = ( new RawContextKey('diffEditorModifiedUri', '', ( localize(727, "The uri of the modified document"))));
+    EditorContextKeys.columnSelection = ( new RawContextKey('editorColumnSelection', false, ( localize(728, "Whether `editor.columnSelection` is enabled"))));
     EditorContextKeys.writable = ( EditorContextKeys.readOnly.toNegated());
-    EditorContextKeys.hasNonEmptySelection = ( new RawContextKey('editorHasSelection', false, ( localize(723, "Whether the editor has text selected"))));
+    EditorContextKeys.hasNonEmptySelection = ( new RawContextKey('editorHasSelection', false, ( localize(729, "Whether the editor has text selected"))));
     EditorContextKeys.hasOnlyEmptySelection = ( EditorContextKeys.hasNonEmptySelection.toNegated());
-    EditorContextKeys.hasMultipleSelections = ( new RawContextKey('editorHasMultipleSelections', false, ( localize(724, "Whether the editor has multiple selections"))));
+    EditorContextKeys.hasMultipleSelections = ( new RawContextKey('editorHasMultipleSelections', false, ( localize(730, "Whether the editor has multiple selections"))));
     EditorContextKeys.hasSingleSelection = ( EditorContextKeys.hasMultipleSelections.toNegated());
-    EditorContextKeys.tabMovesFocus = ( new RawContextKey('editorTabMovesFocus', false, ( localize(725, "Whether `Tab` will move focus out of the editor"))));
+    EditorContextKeys.tabMovesFocus = ( new RawContextKey('editorTabMovesFocus', false, ( localize(731, "Whether `Tab` will move focus out of the editor"))));
     EditorContextKeys.tabDoesNotMoveFocus = ( EditorContextKeys.tabMovesFocus.toNegated());
     EditorContextKeys.isInEmbeddedEditor = ( new RawContextKey('isInEmbeddedEditor', false, true));
     EditorContextKeys.canUndo = ( new RawContextKey('canUndo', false, true));
     EditorContextKeys.canRedo = ( new RawContextKey('canRedo', false, true));
-    EditorContextKeys.hoverVisible = ( new RawContextKey('editorHoverVisible', false, ( localize(726, "Whether the editor hover is visible"))));
-    EditorContextKeys.hoverFocused = ( new RawContextKey('editorHoverFocused', false, ( localize(727, "Whether the editor hover is focused"))));
-    EditorContextKeys.stickyScrollFocused = ( new RawContextKey('stickyScrollFocused', false, ( localize(728, "Whether the sticky scroll is focused"))));
-    EditorContextKeys.stickyScrollVisible = ( new RawContextKey('stickyScrollVisible', false, ( localize(729, "Whether the sticky scroll is visible"))));
-    EditorContextKeys.standaloneColorPickerVisible = ( new RawContextKey('standaloneColorPickerVisible', false, ( localize(730, "Whether the standalone color picker is visible"))));
-    EditorContextKeys.standaloneColorPickerFocused = ( new RawContextKey('standaloneColorPickerFocused', false, ( localize(731, "Whether the standalone color picker is focused"))));
-    EditorContextKeys.inCompositeEditor = ( new RawContextKey('inCompositeEditor', undefined, ( localize(732, "Whether the editor is part of a larger editor (e.g. notebooks)"))));
+    EditorContextKeys.hoverVisible = ( new RawContextKey('editorHoverVisible', false, ( localize(732, "Whether the editor hover is visible"))));
+    EditorContextKeys.hoverFocused = ( new RawContextKey('editorHoverFocused', false, ( localize(733, "Whether the editor hover is focused"))));
+    EditorContextKeys.stickyScrollFocused = ( new RawContextKey('stickyScrollFocused', false, ( localize(734, "Whether the sticky scroll is focused"))));
+    EditorContextKeys.stickyScrollVisible = ( new RawContextKey('stickyScrollVisible', false, ( localize(735, "Whether the sticky scroll is visible"))));
+    EditorContextKeys.standaloneColorPickerVisible = ( new RawContextKey('standaloneColorPickerVisible', false, ( localize(736, "Whether the standalone color picker is visible"))));
+    EditorContextKeys.standaloneColorPickerFocused = ( new RawContextKey('standaloneColorPickerFocused', false, ( localize(737, "Whether the standalone color picker is focused"))));
+    EditorContextKeys.inCompositeEditor = ( new RawContextKey('inCompositeEditor', undefined, ( localize(738, "Whether the editor is part of a larger editor (e.g. notebooks)"))));
     EditorContextKeys.notInCompositeEditor = ( EditorContextKeys.inCompositeEditor.toNegated());
-    EditorContextKeys.languageId = ( new RawContextKey('editorLangId', '', ( localize(733, "The language identifier of the editor"))));
-    EditorContextKeys.hasCompletionItemProvider = ( new RawContextKey('editorHasCompletionItemProvider', false, ( localize(734, "Whether the editor has a completion item provider"))));
-    EditorContextKeys.hasCodeActionsProvider = ( new RawContextKey('editorHasCodeActionsProvider', false, ( localize(735, "Whether the editor has a code actions provider"))));
-    EditorContextKeys.hasCodeLensProvider = ( new RawContextKey('editorHasCodeLensProvider', false, ( localize(736, "Whether the editor has a code lens provider"))));
-    EditorContextKeys.hasDefinitionProvider = ( new RawContextKey('editorHasDefinitionProvider', false, ( localize(737, "Whether the editor has a definition provider"))));
-    EditorContextKeys.hasDeclarationProvider = ( new RawContextKey('editorHasDeclarationProvider', false, ( localize(738, "Whether the editor has a declaration provider"))));
-    EditorContextKeys.hasImplementationProvider = ( new RawContextKey('editorHasImplementationProvider', false, ( localize(739, "Whether the editor has an implementation provider"))));
-    EditorContextKeys.hasTypeDefinitionProvider = ( new RawContextKey('editorHasTypeDefinitionProvider', false, ( localize(740, "Whether the editor has a type definition provider"))));
-    EditorContextKeys.hasHoverProvider = ( new RawContextKey('editorHasHoverProvider', false, ( localize(741, "Whether the editor has a hover provider"))));
-    EditorContextKeys.hasDocumentHighlightProvider = ( new RawContextKey('editorHasDocumentHighlightProvider', false, ( localize(742, "Whether the editor has a document highlight provider"))));
-    EditorContextKeys.hasDocumentSymbolProvider = ( new RawContextKey('editorHasDocumentSymbolProvider', false, ( localize(743, "Whether the editor has a document symbol provider"))));
-    EditorContextKeys.hasReferenceProvider = ( new RawContextKey('editorHasReferenceProvider', false, ( localize(744, "Whether the editor has a reference provider"))));
-    EditorContextKeys.hasRenameProvider = ( new RawContextKey('editorHasRenameProvider', false, ( localize(745, "Whether the editor has a rename provider"))));
-    EditorContextKeys.hasSignatureHelpProvider = ( new RawContextKey('editorHasSignatureHelpProvider', false, ( localize(746, "Whether the editor has a signature help provider"))));
-    EditorContextKeys.hasInlayHintsProvider = ( new RawContextKey('editorHasInlayHintsProvider', false, ( localize(747, "Whether the editor has an inline hints provider"))));
-    EditorContextKeys.hasDocumentFormattingProvider = ( new RawContextKey('editorHasDocumentFormattingProvider', false, ( localize(748, "Whether the editor has a document formatting provider"))));
-    EditorContextKeys.hasDocumentSelectionFormattingProvider = ( new RawContextKey('editorHasDocumentSelectionFormattingProvider', false, ( localize(749, "Whether the editor has a document selection formatting provider"))));
-    EditorContextKeys.hasMultipleDocumentFormattingProvider = ( new RawContextKey('editorHasMultipleDocumentFormattingProvider', false, ( localize(750, "Whether the editor has multiple document formatting providers"))));
+    EditorContextKeys.languageId = ( new RawContextKey('editorLangId', '', ( localize(739, "The language identifier of the editor"))));
+    EditorContextKeys.hasCompletionItemProvider = ( new RawContextKey('editorHasCompletionItemProvider', false, ( localize(740, "Whether the editor has a completion item provider"))));
+    EditorContextKeys.hasCodeActionsProvider = ( new RawContextKey('editorHasCodeActionsProvider', false, ( localize(741, "Whether the editor has a code actions provider"))));
+    EditorContextKeys.hasCodeLensProvider = ( new RawContextKey('editorHasCodeLensProvider', false, ( localize(742, "Whether the editor has a code lens provider"))));
+    EditorContextKeys.hasDefinitionProvider = ( new RawContextKey('editorHasDefinitionProvider', false, ( localize(743, "Whether the editor has a definition provider"))));
+    EditorContextKeys.hasDeclarationProvider = ( new RawContextKey('editorHasDeclarationProvider', false, ( localize(744, "Whether the editor has a declaration provider"))));
+    EditorContextKeys.hasImplementationProvider = ( new RawContextKey('editorHasImplementationProvider', false, ( localize(745, "Whether the editor has an implementation provider"))));
+    EditorContextKeys.hasTypeDefinitionProvider = ( new RawContextKey('editorHasTypeDefinitionProvider', false, ( localize(746, "Whether the editor has a type definition provider"))));
+    EditorContextKeys.hasHoverProvider = ( new RawContextKey('editorHasHoverProvider', false, ( localize(747, "Whether the editor has a hover provider"))));
+    EditorContextKeys.hasDocumentHighlightProvider = ( new RawContextKey('editorHasDocumentHighlightProvider', false, ( localize(748, "Whether the editor has a document highlight provider"))));
+    EditorContextKeys.hasDocumentSymbolProvider = ( new RawContextKey('editorHasDocumentSymbolProvider', false, ( localize(749, "Whether the editor has a document symbol provider"))));
+    EditorContextKeys.hasReferenceProvider = ( new RawContextKey('editorHasReferenceProvider', false, ( localize(750, "Whether the editor has a reference provider"))));
+    EditorContextKeys.hasRenameProvider = ( new RawContextKey('editorHasRenameProvider', false, ( localize(751, "Whether the editor has a rename provider"))));
+    EditorContextKeys.hasSignatureHelpProvider = ( new RawContextKey('editorHasSignatureHelpProvider', false, ( localize(752, "Whether the editor has a signature help provider"))));
+    EditorContextKeys.hasInlayHintsProvider = ( new RawContextKey('editorHasInlayHintsProvider', false, ( localize(753, "Whether the editor has an inline hints provider"))));
+    EditorContextKeys.hasDocumentFormattingProvider = ( new RawContextKey('editorHasDocumentFormattingProvider', false, ( localize(754, "Whether the editor has a document formatting provider"))));
+    EditorContextKeys.hasDocumentSelectionFormattingProvider = ( new RawContextKey('editorHasDocumentSelectionFormattingProvider', false, ( localize(755, "Whether the editor has a document selection formatting provider"))));
+    EditorContextKeys.hasMultipleDocumentFormattingProvider = ( new RawContextKey('editorHasMultipleDocumentFormattingProvider', false, ( localize(756, "Whether the editor has multiple document formatting providers"))));
     EditorContextKeys.hasMultipleDocumentSelectionFormattingProvider = ( new RawContextKey(
      'editorHasMultipleDocumentSelectionFormattingProvider',
      false,
      ( localize(
-     751,
+     757,
      "Whether the editor has multiple document selection formatting providers"
     ))
     ));

package/vscode/src/vs/editor/common/languages/defaultDocumentColorsComputer.js

@@ -22,7 +22,7 @@ function _toIColor(r, g, b, a) {
 function _findRange(model, match) {
     const index = match.index;
     const length = match[0].length;
-    if (!index) {
+    if (index === undefined) {
         return;
     }
     const startPosition = model.positionAt(index);

package/vscode/src/vs/editor/common/languages/languageConfigurationRegistry.js

@@ -1,7 +1,7 @@
 
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { Emitter } from '../../../base/common/event.js';
-import { Disposable, toDisposable } from '../../../base/common/lifecycle.js';
+import { Disposable, markAsSingleton, toDisposable } from '../../../base/common/lifecycle.js';
 import { getLeadingWhitespace } from '../../../base/common/strings.js';
 import { DEFAULT_WORD_REGEXP, ensureValidWordDefinition } from '../core/wordHelper.js';
 import { AutoClosingPairs } from './languageConfiguration.js';
@@ -135,7 +135,7 @@ class ComposedLanguageConfiguration {
         const entry = ( new LanguageConfigurationContribution(configuration, priority, ++this._order));
         this._entries.push(entry);
         this._resolved = null;
-        return toDisposable(() => {
+        return markAsSingleton(toDisposable(() => {
             for (let i = 0; i < this._entries.length; i++) {
                 if (this._entries[i] === entry) {
                     this._entries.splice(i, 1);
@@ -143,7 +143,7 @@ class ComposedLanguageConfiguration {
                     break;
                 }
             }
-        });
+        }));
     }
     getResolvedConfiguration() {
         if (!this._resolved) {
@@ -246,10 +246,10 @@ class LanguageConfigurationRegistry extends Disposable {
         }
         const disposable = entries.register(configuration, priority);
         this._onDidChange.fire(( new LanguageConfigurationChangeEvent(languageId)));
-        return toDisposable(() => {
+        return markAsSingleton(toDisposable(() => {
             disposable.dispose();
             this._onDidChange.fire(( new LanguageConfigurationChangeEvent(languageId)));
-        });
+        }));
     }
     getLanguageConfiguration(languageId) {
         const entries = this._entries.get(languageId);

package/vscode/src/vs/editor/common/languages/modesRegistry.js

@@ -39,7 +39,7 @@ const PLAINTEXT_EXTENSION = '.txt';
 ModesRegistry.registerLanguage({
     id: PLAINTEXT_LANGUAGE_ID,
     extensions: [PLAINTEXT_EXTENSION],
-    aliases: [( localize(779, "Plain Text")), 'text'],
+    aliases: [( localize(785, "Plain Text")), 'text'],
     mimetypes: [Mimes.text]
 });
 ( Registry.as(Extensions$1.Configuration))

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

@@ -20,6 +20,8 @@ import { ExtensionIdentifier } from "../../platform/extensions/common/extensions
 import { IMarkerData } from "../../platform/markers/common/markers.js";
 import { IModelTokensChangedEvent } from "./textModelEvents.js";
 import type { Parser } from "@vscode/tree-sitter-wasm";
+import { ITextModel } from "./model.js";
+import { TokenUpdate } from "./model/tokenStore.js";
 export interface ILanguageIdCodec {
     encodeLanguageId(languageId: string): LanguageId;
     decodeLanguageId(languageId: LanguageId): string;
@@ -44,10 +46,20 @@ export declare class EncodedTokenizationResult {
     _encodedTokenizationResultBrand: void;
     constructor(tokens: Uint32Array, endState: IState);
 }
+export interface SyntaxNode {
+    startIndex: number;
+    endIndex: number;
+}
+export interface QueryCapture {
+    name: string;
+    text?: string;
+    node: SyntaxNode;
+}
 export interface ITreeSitterTokenizationSupport {
+    getTokensInRange(textModel: ITextModel, range: Range, rangeStartOffset: number, rangeEndOffset: number): TokenUpdate[] | undefined;
     tokenizeEncoded(lineNumber: number, textModel: model.ITextModel): Uint32Array | undefined;
-    captureAtPosition(lineNumber: number, column: number, textModel: model.ITextModel): Parser.QueryCapture[];
-    captureAtPositionTree(lineNumber: number, column: number, tree: Parser.Tree): Parser.QueryCapture[];
+    captureAtPosition(lineNumber: number, column: number, textModel: model.ITextModel): QueryCapture[];
+    captureAtPositionTree(lineNumber: number, column: number, tree: Parser.Tree): QueryCapture[];
     onDidChangeTokens: Event<{
         textModel: model.ITextModel;
         changes: IModelTokensChangedEvent;
@@ -241,6 +253,7 @@ export interface InlineCompletionContext {
     readonly triggerKind: InlineCompletionTriggerKind;
     readonly selectedSuggestionInfo: SelectedSuggestionInfo | undefined;
     readonly userPrompt?: string | undefined;
+    readonly requestUuid?: string | undefined;
     readonly includeInlineEdits: boolean;
     readonly includeInlineCompletions: boolean;
 }
@@ -263,6 +276,7 @@ export interface InlineCompletion {
     readonly shownCommand?: Command;
     readonly completeBracketPairs?: boolean;
     readonly isInlineEdit?: boolean;
+    readonly showRange?: IRange;
 }
 export interface InlineCompletions<TItem extends InlineCompletion = InlineCompletion> {
     readonly items: readonly TItem[];
@@ -280,6 +294,7 @@ export interface InlineCompletionsProvider<T extends InlineCompletions = InlineC
     freeInlineCompletions(completions: T): void;
     groupId?: InlineCompletionProviderGroupId;
     yieldsToGroupIds?: InlineCompletionProviderGroupId[];
+    displayName?: string;
     toString?(): string;
 }
 export interface CodeAction {
@@ -799,7 +814,7 @@ export interface CodeLens {
 }
 export interface CodeLensList {
     lenses: CodeLens[];
-    dispose(): void;
+    dispose?(): void;
 }
 export interface CodeLensProvider {
     onDidChange?: Event<this>;
@@ -922,31 +937,10 @@ export interface DocumentDropEditProvider {
     provideDocumentDropEdits(model: model.ITextModel, position: IPosition, dataTransfer: IReadonlyVSDataTransfer, token: CancellationToken): ProviderResult<DocumentDropEditsSession>;
     resolveDocumentDropEdit?(edit: DocumentDropEdit, token: CancellationToken): Promise<DocumentDropEdit>;
 }
-export interface DocumentContextItem {
-    readonly uri: URI;
-    readonly version: number;
-    readonly ranges: IRange[];
-}
-export interface MappedEditsContext {
-    readonly documents: DocumentContextItem[][];
-    readonly conversation?: (ConversationRequest | ConversationResponse)[];
-}
-export interface ConversationRequest {
-    readonly type: "request";
-    readonly message: string;
-}
-export interface ConversationResponse {
-    readonly type: "response";
-    readonly message: string;
-    readonly references?: DocumentContextItem[];
-}
-export interface MappedEditsProvider {
-    readonly displayName: string;
-    provideMappedEdits(document: model.ITextModel, codeBlocks: string[], context: MappedEditsContext, token: CancellationToken): Promise<WorkspaceEdit | null>;
-}
 export interface IInlineEdit {
     text: string;
     range: IRange;
+    showRange?: IRange;
     accepted?: Command;
     rejected?: Command;
     shown?: Command;
@@ -954,12 +948,14 @@ export interface IInlineEdit {
 }
 export interface IInlineEditContext {
     triggerKind: InlineEditTriggerKind;
+    requestUuid?: string;
 }
 export declare enum InlineEditTriggerKind {
     Invoke = 0,
     Automatic = 1
 }
 export interface InlineEditProvider<T extends IInlineEdit = IInlineEdit> {
+    displayName?: string;
     provideInlineEdit(model: model.ITextModel, context: IInlineEditContext, token: CancellationToken): ProviderResult<T>;
     freeInlineEdit(edit: T): void;
 }

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

@@ -253,35 +253,35 @@ var SymbolKind;
     SymbolKind[SymbolKind["TypeParameter"] = 25] = "TypeParameter";
 })(SymbolKind || (SymbolKind = {}));
 const symbolKindNames = {
-    [SymbolKind.Array]: ( localize(752, "array")),
-    [SymbolKind.Boolean]: ( localize(753, "boolean")),
-    [SymbolKind.Class]: ( localize(754, "class")),
-    [SymbolKind.Constant]: ( localize(755, "constant")),
-    [SymbolKind.Constructor]: ( localize(756, "constructor")),
-    [SymbolKind.Enum]: ( localize(757, "enumeration")),
-    [SymbolKind.EnumMember]: ( localize(758, "enumeration member")),
-    [SymbolKind.Event]: ( localize(759, "event")),
-    [SymbolKind.Field]: ( localize(760, "field")),
-    [SymbolKind.File]: ( localize(761, "file")),
-    [SymbolKind.Function]: ( localize(762, "function")),
-    [SymbolKind.Interface]: ( localize(763, "interface")),
-    [SymbolKind.Key]: ( localize(764, "key")),
-    [SymbolKind.Method]: ( localize(765, "method")),
-    [SymbolKind.Module]: ( localize(766, "module")),
-    [SymbolKind.Namespace]: ( localize(767, "namespace")),
-    [SymbolKind.Null]: ( localize(768, "null")),
-    [SymbolKind.Number]: ( localize(769, "number")),
-    [SymbolKind.Object]: ( localize(770, "object")),
-    [SymbolKind.Operator]: ( localize(771, "operator")),
-    [SymbolKind.Package]: ( localize(772, "package")),
-    [SymbolKind.Property]: ( localize(773, "property")),
-    [SymbolKind.String]: ( localize(774, "string")),
-    [SymbolKind.Struct]: ( localize(775, "struct")),
-    [SymbolKind.TypeParameter]: ( localize(776, "type parameter")),
-    [SymbolKind.Variable]: ( localize(777, "variable")),
+    [SymbolKind.Array]: ( localize(758, "array")),
+    [SymbolKind.Boolean]: ( localize(759, "boolean")),
+    [SymbolKind.Class]: ( localize(760, "class")),
+    [SymbolKind.Constant]: ( localize(761, "constant")),
+    [SymbolKind.Constructor]: ( localize(762, "constructor")),
+    [SymbolKind.Enum]: ( localize(763, "enumeration")),
+    [SymbolKind.EnumMember]: ( localize(764, "enumeration member")),
+    [SymbolKind.Event]: ( localize(765, "event")),
+    [SymbolKind.Field]: ( localize(766, "field")),
+    [SymbolKind.File]: ( localize(767, "file")),
+    [SymbolKind.Function]: ( localize(768, "function")),
+    [SymbolKind.Interface]: ( localize(769, "interface")),
+    [SymbolKind.Key]: ( localize(770, "key")),
+    [SymbolKind.Method]: ( localize(771, "method")),
+    [SymbolKind.Module]: ( localize(772, "module")),
+    [SymbolKind.Namespace]: ( localize(773, "namespace")),
+    [SymbolKind.Null]: ( localize(774, "null")),
+    [SymbolKind.Number]: ( localize(775, "number")),
+    [SymbolKind.Object]: ( localize(776, "object")),
+    [SymbolKind.Operator]: ( localize(777, "operator")),
+    [SymbolKind.Package]: ( localize(778, "package")),
+    [SymbolKind.Property]: ( localize(779, "property")),
+    [SymbolKind.String]: ( localize(780, "string")),
+    [SymbolKind.Struct]: ( localize(781, "struct")),
+    [SymbolKind.TypeParameter]: ( localize(782, "type parameter")),
+    [SymbolKind.Variable]: ( localize(783, "variable")),
 };
 function getAriaLabelForSymbol(symbolName, kind) {
-    return localize(778, '{0} ({1})', symbolName, symbolKindNames[kind]);
+    return localize(784, '{0} ({1})', symbolName, symbolKindNames[kind]);
 }
 var SymbolTag;
 (function (SymbolTag) {

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

@@ -353,7 +353,7 @@ class EditStack {
         if (isEditStackElement(lastElement) && lastElement.canAppend(this._model)) {
             return lastElement;
         }
-        const newElement = ( new SingleModelEditStackElement(( localize(780, "Typing")), 'undoredo.textBufferEdit', this._model, beforeCursorState));
+        const newElement = ( new SingleModelEditStackElement(( localize(786, "Typing")), 'undoredo.textBufferEdit', this._model, beforeCursorState));
         this._undoRedoService.pushElement(newElement, group);
         return newElement;
     }

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

@@ -158,6 +158,7 @@ export declare class TextModel extends Disposable implements model.ITextModel, I
     private _isValidPosition;
     private _validatePosition;
     validatePosition(position: IPosition): Position;
+    isValidRange(range: Range): boolean;
     private _isValidRange;
     validateRange(_range: IRange): Range;
     modifyPosition(rawPosition: IPosition, offset: number): Position;

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

@@ -299,7 +299,7 @@ let TextModel = class TextModel extends Disposable {
         const { textBuffer, disposable } = createTextBuffer(value, this._options.defaultEOL);
         this._setValueFromTextBuffer(textBuffer, disposable);
     }
-    _createContentChanged2(range, rangeOffset, rangeLength, text, isUndoing, isRedoing, isFlush, isEolChange) {
+    _createContentChanged2(range, rangeOffset, rangeLength, rangeEndPosition, text, isUndoing, isRedoing, isFlush, isEolChange) {
         return {
             changes: [{
                     range: range,
@@ -331,7 +331,7 @@ let TextModel = class TextModel extends Disposable {
         this._trimAutoWhitespaceLines = null;
         this._emitContentChangedEvent(( new ModelRawContentChangedEvent([
             ( new ModelRawFlush())
-        ], this._versionId, false, false)), this._createContentChanged2(( new Range(1, 1, endLineNumber, endColumn)), 0, oldModelValueLength, this.getValue(), false, false, true, false));
+        ], this._versionId, false, false)), this._createContentChanged2(( new Range(1, 1, endLineNumber, endColumn)), 0, oldModelValueLength, ( new Position(endLineNumber, endColumn)), this.getValue(), false, false, true, false));
     }
     setEOL(eol) {
         this._assertNotDisposed();
@@ -349,7 +349,7 @@ let TextModel = class TextModel extends Disposable {
         this._onAfterEOLChange();
         this._emitContentChangedEvent(( new ModelRawContentChangedEvent([
             ( new ModelRawEOLChanged())
-        ], this._versionId, false, false)), this._createContentChanged2(( new Range(1, 1, endLineNumber, endColumn)), 0, oldModelValueLength, this.getValue(), false, false, false, true));
+        ], this._versionId, false, false)), this._createContentChanged2(( new Range(1, 1, endLineNumber, endColumn)), 0, oldModelValueLength, ( new Position(endLineNumber, endColumn)), this.getValue(), false, false, false, true));
     }
     _onBeforeEOLChange() {
         this._decorationsTree.ensureAllNodesHaveRanges(this);
@@ -744,6 +744,9 @@ let TextModel = class TextModel extends Disposable {
         }
         return this._validatePosition(position.lineNumber, position.column, validationType);
     }
+    isValidRange(range) {
+        return this._isValidRange(range, StringOffsetValidationType.SurrogatePairs);
+    }
     _isValidRange(range, validationType) {
         const startLineNumber = range.startLineNumber;
         const startColumn = range.startColumn;

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

@@ -5,8 +5,8 @@ import { StandardTokenType } from "../encodedTokenAttributes.js";
 import { IBackgroundTokenizationStore, IBackgroundTokenizer, ILanguageIdCodec, IState, ITokenizationSupport } from "../languages.js";
 import { ITextModel } from "../model.js";
 import { IModelContentChange } from "../textModelEvents.js";
-import { ITokenizeLineWithEditResult, LineEditWithAdditionalLines } from "../tokenizationTextModelPart.js";
 import { ContiguousMultilineTokensBuilder } from "../tokens/contiguousMultilineTokensBuilder.js";
+import { LineTokens } from "../tokens/lineTokens.js";
 export declare class TokenizerWithStateStore<TState extends IState = IState> {
     readonly tokenizationSupport: ITokenizationSupport;
     private readonly initialState;
@@ -24,7 +24,7 @@ export declare class TokenizerWithStateStoreAndTextModel<TState extends IState =
     constructor(lineCount: number, tokenizationSupport: ITokenizationSupport, _textModel: ITextModel, _languageIdCodec: ILanguageIdCodec);
     updateTokensUntilLine(builder: ContiguousMultilineTokensBuilder, lineNumber: number): void;
     getTokenTypeIfInsertingCharacter(position: Position, character: string): StandardTokenType;
-    tokenizeLineWithEdit(lineNumber: number, edit: LineEditWithAdditionalLines): ITokenizeLineWithEditResult;
+    tokenizeLinesAt(lineNumber: number, lines: string[]): LineTokens[] | null;
     hasAccurateTokensForLine(lineNumber: number): boolean;
     isCheapToTokenize(lineNumber: number): boolean;
     tokenizeHeuristically(builder: ContiguousMultilineTokensBuilder, startLineNumber: number, endLineNumber: number): {

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

@@ -66,27 +66,20 @@ class TokenizerWithStateStoreAndTextModel extends TokenizerWithStateStore {
         const tokenIndex = lineTokens.findTokenIndexAtOffset(position.column - 1);
         return lineTokens.getStandardTokenType(tokenIndex);
     }
-    tokenizeLineWithEdit(lineNumber, edit) {
+    tokenizeLinesAt(lineNumber, lines) {
         const lineStartState = this.getStartState(lineNumber);
         if (!lineStartState) {
-            return { mainLineTokens: null, additionalLines: null };
-        }
-        const curLineContent = this._textModel.getLineContent(lineNumber);
-        const newLineContent = edit.lineEdit.apply(curLineContent);
-        const languageId = this._textModel.getLanguageIdAtPosition(lineNumber, 0);
-        const result = safeTokenize(this._languageIdCodec, languageId, this.tokenizationSupport, newLineContent, true, lineStartState);
-        let additionalLines = null;
-        if (edit.additionalLines) {
-            additionalLines = [];
-            let state = result.endState;
-            for (const line of edit.additionalLines) {
-                const r = safeTokenize(this._languageIdCodec, languageId, this.tokenizationSupport, line, true, state);
-                additionalLines.push(( new LineTokens(r.tokens, line, this._languageIdCodec)));
-                state = r.endState;
-            }
+            return null;
+        }
+        const languageId = this._textModel.getLanguageId();
+        const result = [];
+        let state = lineStartState;
+        for (const line of lines) {
+            const r = safeTokenize(this._languageIdCodec, languageId, this.tokenizationSupport, line, true, state);
+            result.push(( new LineTokens(r.tokens, line, this._languageIdCodec)));
+            state = r.endState;
         }
-        const mainLineTokens = ( new LineTokens(result.tokens, newLineContent, this._languageIdCodec));
-        return { mainLineTokens, additionalLines };
+        return result;
     }
     hasAccurateTokensForLine(lineNumber) {
         const firstInvalidLineNumber = this.store.getFirstInvalidEndStateLineNumberOrMax();

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

@@ -0,0 +1,59 @@
+import { IDisposable } from "../../../base/common/lifecycle.js";
+import { ITextModel } from "../model.js";
+declare class ListNode implements IDisposable {
+    readonly height: number;
+    parent?: ListNode;
+    private readonly _children;
+    get children(): ReadonlyArray<Node>;
+    private _length;
+    get length(): number;
+    constructor(height: number);
+    static create(node1: Node, node2: Node): ListNode;
+    canAppendChild(): boolean;
+    appendChild(node: Node): void;
+    private _updateParentLength;
+    unappendChild(): Node;
+    prependChild(node: Node): void;
+    unprependChild(): Node;
+    lastChild(): Node;
+    dispose(): void;
+}
+type Node = ListNode | LeafNode;
+interface LeafNode {
+    readonly length: number;
+    parent?: ListNode;
+    token: number;
+    needsRefresh?: boolean;
+    height: 0;
+}
+export interface TokenUpdate {
+    readonly startOffsetInclusive: number;
+    readonly length: number;
+    readonly token: number;
+}
+export declare class TokenStore implements IDisposable {
+    private readonly _textModel;
+    private _root;
+    get root(): Node;
+    constructor(_textModel: ITextModel);
+    private createEmptyRoot;
+    buildStore(tokens: TokenUpdate[]): void;
+    private createFromUpdates;
+    update(length: number, tokens: TokenUpdate[], needsRefresh?: boolean): void;
+    delete(length: number, startOffset: number): void;
+    private replace;
+    private traverseInOrderInRange;
+    getTokenAt(offset: number): TokenUpdate | undefined;
+    getTokensInRange(startOffsetInclusive: number, endOffsetExclusive: number): TokenUpdate[];
+    markForRefresh(startOffsetInclusive: number, endOffsetExclusive: number): void;
+    rangeNeedsRefresh(startOffsetInclusive: number, endOffsetExclusive: number): boolean;
+    getNeedsRefresh(): {
+        startOffset: number;
+        endOffset: number;
+    }[];
+    deepCopy(): TokenStore;
+    private _copyNodeIterative;
+    printTree(root?: Node): string;
+    dispose(): void;
+}
+export {};