@codingame/monaco-vscode-api 17.2.1 → 18.0.1

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

@@ -18,11 +18,6 @@ import * as model from "./model.js";
 import { ContiguousMultilineTokens } from "./tokens/contiguousMultilineTokens.js";
 import { ExtensionIdentifier } from "../../platform/extensions/common/extensions.js";
 import { IMarkerData } from "../../platform/markers/common/markers.js";
-import { IModelTokensChangedEvent } from "./textModelEvents.js";
-import { ITextModel } from "./model.js";
-import { TokenUpdate } from "@codingame/monaco-vscode-treesitter-service-override/vscode/vs/editor/common/model/tokenStore";
-import { ITextModelTreeSitter } from "@codingame/monaco-vscode-treesitter-service-override/vscode/vs/editor/common/services/treeSitterParserService";
-import type * as Parser from "@vscode/tree-sitter-wasm";
 export interface ILanguageIdCodec {
     encodeLanguageId(languageId: string): LanguageId;
     decodeLanguageId(languageId: LanguageId): string;
@@ -59,25 +54,6 @@ export interface QueryCapture {
     node: SyntaxNode;
     encodedLanguageId: number;
 }
-export interface ITreeSitterTokenizationSupport {
-    getTokensInRange(textModel: ITextModel, range: Range, rangeStartOffset: number, rangeEndOffset: number): TokenUpdate[] | undefined;
-    tokenizeEncoded(lineNumber: number, textModel: model.ITextModel): void;
-    captureAtPosition(lineNumber: number, column: number, textModel: model.ITextModel): QueryCapture[];
-    captureAtRangeTree(range: Range, tree: Parser.Tree, textModelTreeSitter: ITextModelTreeSitter): QueryCapture[];
-    onDidChangeTokens: Event<{
-        textModel: model.ITextModel;
-        changes: IModelTokensChangedEvent;
-    }>;
-    onDidChangeBackgroundTokenization: Event<{
-        textModel: model.ITextModel;
-    }>;
-    tokenizeEncodedInstrumented(lineNumber: number, textModel: model.ITextModel): {
-        result: Uint32Array;
-        captureTime: number;
-        metadataTime: number;
-    } | undefined;
-    guessTokensForLinesContent(lineNumber: number, textModel: model.ITextModel, lines: string[]): Uint32Array[] | undefined;
-}
 export interface ITokenizationSupport {
     readonly backgroundTokenizerShouldOnlyVerifyTokens?: boolean;
     getInitialState(): IState;
@@ -179,7 +155,8 @@ export declare enum CompletionItemKind {
     TypeParameter = 24,
     User = 25,
     Issue = 26,
-    Snippet = 27
+    Tool = 27,
+    Snippet = 28
 }
 export declare namespace CompletionItemKinds {
     function toIcon(kind: CompletionItemKind): ThemeIcon;
@@ -264,7 +241,7 @@ export interface InlineCompletionContext {
     readonly triggerKind: InlineCompletionTriggerKind;
     readonly selectedSuggestionInfo: SelectedSuggestionInfo | undefined;
     readonly userPrompt?: string | undefined;
-    readonly requestUuid?: string | undefined;
+    readonly requestUuid: string;
     readonly includeInlineEdits: boolean;
     readonly includeInlineCompletions: boolean;
 }
@@ -947,7 +924,6 @@ export interface ITokenizationRegistry<TSupport> {
     getDefaultBackground(): Color | null;
 }
 export declare const TokenizationRegistry: ITokenizationRegistry<ITokenizationSupport>;
-export declare const TreeSitterTokenizationRegistry: ITokenizationRegistry<ITreeSitterTokenizationSupport>;
 export declare enum ExternalUriOpenerPriority {
     None = 0,
     Option = 1,
@@ -992,7 +968,7 @@ export interface IInlineEdit {
 }
 export interface IInlineEditContext {
     triggerKind: InlineEditTriggerKind;
-    requestUuid?: string;
+    requestUuid: string;
 }
 export declare enum InlineEditTriggerKind {
     Invoke = 0,

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

@@ -66,7 +66,8 @@ var CompletionItemKind;
     CompletionItemKind[CompletionItemKind["TypeParameter"] = 24] = "TypeParameter";
     CompletionItemKind[CompletionItemKind["User"] = 25] = "User";
     CompletionItemKind[CompletionItemKind["Issue"] = 26] = "Issue";
-    CompletionItemKind[CompletionItemKind["Snippet"] = 27] = "Snippet";
+    CompletionItemKind[CompletionItemKind["Tool"] = 27] = "Tool";
+    CompletionItemKind[CompletionItemKind["Snippet"] = 28] = "Snippet";
 })(CompletionItemKind || (CompletionItemKind = {}));
 var CompletionItemKinds;
 (function (CompletionItemKinds) {
@@ -100,6 +101,7 @@ var CompletionItemKinds;
     byKind.set(CompletionItemKind.TypeParameter, Codicon.symbolTypeParameter);
     byKind.set(CompletionItemKind.User, Codicon.account);
     byKind.set(CompletionItemKind.Issue, Codicon.issues);
+    byKind.set(CompletionItemKind.Tool, Codicon.tools);
     function toIcon(kind) {
         let codicon = byKind.get(kind);
         if (!codicon) {
@@ -111,34 +113,35 @@ var CompletionItemKinds;
     CompletionItemKinds.toIcon = toIcon;
     function toLabel(kind) {
         switch (kind) {
-            case CompletionItemKind.Method: return localize(763, 'Method');
-            case CompletionItemKind.Function: return localize(764, 'Function');
-            case CompletionItemKind.Constructor: return localize(765, 'Constructor');
-            case CompletionItemKind.Field: return localize(766, 'Field');
-            case CompletionItemKind.Variable: return localize(767, 'Variable');
-            case CompletionItemKind.Class: return localize(768, 'Class');
-            case CompletionItemKind.Struct: return localize(769, 'Struct');
-            case CompletionItemKind.Interface: return localize(770, 'Interface');
-            case CompletionItemKind.Module: return localize(771, 'Module');
-            case CompletionItemKind.Property: return localize(772, 'Property');
-            case CompletionItemKind.Event: return localize(773, 'Event');
-            case CompletionItemKind.Operator: return localize(774, 'Operator');
-            case CompletionItemKind.Unit: return localize(775, 'Unit');
-            case CompletionItemKind.Value: return localize(776, 'Value');
-            case CompletionItemKind.Constant: return localize(777, 'Constant');
-            case CompletionItemKind.Enum: return localize(778, 'Enum');
-            case CompletionItemKind.EnumMember: return localize(779, 'Enum Member');
-            case CompletionItemKind.Keyword: return localize(780, 'Keyword');
-            case CompletionItemKind.Text: return localize(781, 'Text');
-            case CompletionItemKind.Color: return localize(782, 'Color');
-            case CompletionItemKind.File: return localize(783, 'File');
-            case CompletionItemKind.Reference: return localize(784, 'Reference');
-            case CompletionItemKind.Customcolor: return localize(785, 'Custom Color');
-            case CompletionItemKind.Folder: return localize(786, 'Folder');
-            case CompletionItemKind.TypeParameter: return localize(787, 'Type Parameter');
-            case CompletionItemKind.User: return localize(788, 'User');
-            case CompletionItemKind.Issue: return localize(789, 'Issue');
-            case CompletionItemKind.Snippet: return localize(790, 'Snippet');
+            case CompletionItemKind.Method: return localize(765, 'Method');
+            case CompletionItemKind.Function: return localize(766, 'Function');
+            case CompletionItemKind.Constructor: return localize(767, 'Constructor');
+            case CompletionItemKind.Field: return localize(768, 'Field');
+            case CompletionItemKind.Variable: return localize(769, 'Variable');
+            case CompletionItemKind.Class: return localize(770, 'Class');
+            case CompletionItemKind.Struct: return localize(771, 'Struct');
+            case CompletionItemKind.Interface: return localize(772, 'Interface');
+            case CompletionItemKind.Module: return localize(773, 'Module');
+            case CompletionItemKind.Property: return localize(774, 'Property');
+            case CompletionItemKind.Event: return localize(775, 'Event');
+            case CompletionItemKind.Operator: return localize(776, 'Operator');
+            case CompletionItemKind.Unit: return localize(777, 'Unit');
+            case CompletionItemKind.Value: return localize(778, 'Value');
+            case CompletionItemKind.Constant: return localize(779, 'Constant');
+            case CompletionItemKind.Enum: return localize(780, 'Enum');
+            case CompletionItemKind.EnumMember: return localize(781, 'Enum Member');
+            case CompletionItemKind.Keyword: return localize(782, 'Keyword');
+            case CompletionItemKind.Text: return localize(783, 'Text');
+            case CompletionItemKind.Color: return localize(784, 'Color');
+            case CompletionItemKind.File: return localize(785, 'File');
+            case CompletionItemKind.Reference: return localize(786, 'Reference');
+            case CompletionItemKind.Customcolor: return localize(787, 'Custom Color');
+            case CompletionItemKind.Folder: return localize(788, 'Folder');
+            case CompletionItemKind.TypeParameter: return localize(789, 'Type Parameter');
+            case CompletionItemKind.User: return localize(790, 'User');
+            case CompletionItemKind.Issue: return localize(791, 'Issue');
+            case CompletionItemKind.Tool: return localize(792, 'Tool');
+            case CompletionItemKind.Snippet: return localize(793, 'Snippet');
             default: return '';
         }
     }
@@ -174,6 +177,7 @@ var CompletionItemKinds;
     data.set('typeParameter', CompletionItemKind.TypeParameter);
     data.set('account', CompletionItemKind.User);
     data.set('issue', CompletionItemKind.Issue);
+    data.set('tool', CompletionItemKind.Tool);
     function fromString(value, strict) {
         let res = data.get(value);
         if (typeof res === 'undefined' && !strict) {
@@ -293,35 +297,35 @@ var SymbolKind;
     SymbolKind[SymbolKind["TypeParameter"] = 25] = "TypeParameter";
 })(SymbolKind || (SymbolKind = {}));
 const symbolKindNames = {
-    [SymbolKind.Array]: ( localize(791, "array")),
-    [SymbolKind.Boolean]: ( localize(792, "boolean")),
-    [SymbolKind.Class]: ( localize(793, "class")),
-    [SymbolKind.Constant]: ( localize(794, "constant")),
-    [SymbolKind.Constructor]: ( localize(795, "constructor")),
-    [SymbolKind.Enum]: ( localize(796, "enumeration")),
-    [SymbolKind.EnumMember]: ( localize(797, "enumeration member")),
-    [SymbolKind.Event]: ( localize(798, "event")),
-    [SymbolKind.Field]: ( localize(799, "field")),
-    [SymbolKind.File]: ( localize(800, "file")),
-    [SymbolKind.Function]: ( localize(801, "function")),
-    [SymbolKind.Interface]: ( localize(802, "interface")),
-    [SymbolKind.Key]: ( localize(803, "key")),
-    [SymbolKind.Method]: ( localize(804, "method")),
-    [SymbolKind.Module]: ( localize(805, "module")),
-    [SymbolKind.Namespace]: ( localize(806, "namespace")),
-    [SymbolKind.Null]: ( localize(807, "null")),
-    [SymbolKind.Number]: ( localize(808, "number")),
-    [SymbolKind.Object]: ( localize(809, "object")),
-    [SymbolKind.Operator]: ( localize(810, "operator")),
-    [SymbolKind.Package]: ( localize(811, "package")),
-    [SymbolKind.Property]: ( localize(812, "property")),
-    [SymbolKind.String]: ( localize(813, "string")),
-    [SymbolKind.Struct]: ( localize(814, "struct")),
-    [SymbolKind.TypeParameter]: ( localize(815, "type parameter")),
-    [SymbolKind.Variable]: ( localize(816, "variable")),
+    [SymbolKind.Array]: ( localize(794, "array")),
+    [SymbolKind.Boolean]: ( localize(795, "boolean")),
+    [SymbolKind.Class]: ( localize(796, "class")),
+    [SymbolKind.Constant]: ( localize(797, "constant")),
+    [SymbolKind.Constructor]: ( localize(798, "constructor")),
+    [SymbolKind.Enum]: ( localize(799, "enumeration")),
+    [SymbolKind.EnumMember]: ( localize(800, "enumeration member")),
+    [SymbolKind.Event]: ( localize(801, "event")),
+    [SymbolKind.Field]: ( localize(802, "field")),
+    [SymbolKind.File]: ( localize(803, "file")),
+    [SymbolKind.Function]: ( localize(804, "function")),
+    [SymbolKind.Interface]: ( localize(805, "interface")),
+    [SymbolKind.Key]: ( localize(806, "key")),
+    [SymbolKind.Method]: ( localize(807, "method")),
+    [SymbolKind.Module]: ( localize(808, "module")),
+    [SymbolKind.Namespace]: ( localize(809, "namespace")),
+    [SymbolKind.Null]: ( localize(810, "null")),
+    [SymbolKind.Number]: ( localize(811, "number")),
+    [SymbolKind.Object]: ( localize(812, "object")),
+    [SymbolKind.Operator]: ( localize(813, "operator")),
+    [SymbolKind.Package]: ( localize(814, "package")),
+    [SymbolKind.Property]: ( localize(815, "property")),
+    [SymbolKind.String]: ( localize(816, "string")),
+    [SymbolKind.Struct]: ( localize(817, "struct")),
+    [SymbolKind.TypeParameter]: ( localize(818, "type parameter")),
+    [SymbolKind.Variable]: ( localize(819, "variable")),
 };
 function getAriaLabelForSymbol(symbolName, kind) {
-    return localize(817, '{0} ({1})', symbolName, symbolKindNames[kind]);
+    return localize(820, '{0} ({1})', symbolName, symbolKindNames[kind]);
 }
 var SymbolTag;
 (function (SymbolTag) {
@@ -404,7 +408,10 @@ var SymbolKinds;
 })(SymbolKinds || (SymbolKinds = {}));
 class TextEdit {
     static asEditOperation(edit) {
-        return EditOperation.replace(Range.lift(edit.range), edit.text);
+        const range = Range.lift(edit.range);
+        return range.isEmpty()
+            ? EditOperation.insert(range.getStartPosition(), edit.text)
+            : EditOperation.replace(range, edit.text);
     }
     static isTextEdit(thing) {
         const possibleTextEdit = thing;
@@ -499,7 +506,6 @@ class LazyTokenizationSupport {
     }
 }
 const TokenizationRegistry = ( new TokenizationRegistry$1());
-const TreeSitterTokenizationRegistry = ( new TokenizationRegistry$1());
 var ExternalUriOpenerPriority;
 (function (ExternalUriOpenerPriority) {
     ExternalUriOpenerPriority[ExternalUriOpenerPriority["None"] = 0] = "None";
@@ -513,4 +519,4 @@ var InlineEditTriggerKind;
     InlineEditTriggerKind[InlineEditTriggerKind["Automatic"] = 1] = "Automatic";
 })(InlineEditTriggerKind || (InlineEditTriggerKind = {}));
 
-export { CodeActionTriggerType, Command, CommentMode, CommentState, CommentThreadApplicability, CommentThreadCollapsibleState, CommentThreadState, CompletionItemInsertTextRule, CompletionItemKind, CompletionItemKinds, CompletionItemTag, CompletionTriggerKind, DocumentHighlightKind, DocumentPasteTriggerKind, EncodedTokenizationResult, ExternalUriOpenerPriority, FoldingRangeKind, HoverVerbosityAction, InlayHintKind, InlineCompletionEndOfLifeReasonKind, InlineCompletionTriggerKind, InlineEditTriggerKind, LazyTokenizationSupport, NewSymbolNameTag, NewSymbolNameTriggerKind, PartialAcceptTriggerKind, SelectedSuggestionInfo, SignatureHelpTriggerKind, SymbolKind, SymbolKinds, SymbolTag, TextEdit, Token, TokenizationRegistry, TokenizationResult, TreeSitterTokenizationRegistry, getAriaLabelForSymbol, isLocation, isLocationLink, symbolKindNames };
+export { CodeActionTriggerType, Command, CommentMode, CommentState, CommentThreadApplicability, CommentThreadCollapsibleState, CommentThreadState, CompletionItemInsertTextRule, CompletionItemKind, CompletionItemKinds, CompletionItemTag, CompletionTriggerKind, DocumentHighlightKind, DocumentPasteTriggerKind, EncodedTokenizationResult, ExternalUriOpenerPriority, FoldingRangeKind, HoverVerbosityAction, InlayHintKind, InlineCompletionEndOfLifeReasonKind, InlineCompletionTriggerKind, InlineEditTriggerKind, LazyTokenizationSupport, NewSymbolNameTag, NewSymbolNameTriggerKind, PartialAcceptTriggerKind, SelectedSuggestionInfo, SignatureHelpTriggerKind, SymbolKind, SymbolKinds, SymbolTag, TextEdit, Token, TokenizationRegistry, TokenizationResult, getAriaLabelForSymbol, isLocation, isLocationLink, symbolKindNames };

package/vscode/src/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/length.d.ts

@@ -1,6 +1,6 @@
 import { Position } from "../../../core/position.js";
 import { Range } from "../../../core/range.js";
-import { TextLength } from "../../../core/textLength.js";
+import { TextLength } from "../../../core/text/textLength.js";
 export declare function lengthDiff(startLineCount: number, startColumnCount: number, endLineCount: number, endColumnCount: number): Length;
 export type Length = {
     _brand: "Length";

package/vscode/src/vs/editor/common/model/bracketPairsTextModelPart/bracketPairsTree/length.js

@@ -1,7 +1,7 @@
 
 import { splitLines } from '../../../../../base/common/strings.js';
 import { Range } from '../../../core/range.js';
-import { TextLength } from '../../../core/textLength.js';
+import { TextLength } from '../../../core/text/textLength.js';
 
 function lengthDiff(startLineCount, startColumnCount, endLineCount, endColumnCount) {
     return (startLineCount !== endLineCount)

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(819, "Typing")), 'undoredo.textBufferEdit', this._model, beforeCursorState));
+        const newElement = ( new SingleModelEditStackElement(( localize(822, "Typing")), 'undoredo.textBufferEdit', this._model, beforeCursorState));
         this._undoRedoService.pushElement(newElement, group);
         return newElement;
     }

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

@@ -4,7 +4,7 @@ import { isHighSurrogate, firstNonWhitespaceIndex, lastNonWhitespaceIndex, isBas
 import { Range } from '../../core/range.js';
 import { EndOfLinePreference, ApplyEditsResult } from '../../model.js';
 import { PieceTreeBase } from './pieceTreeBase.js';
-import { countEOL, StringEOL } from '../../core/eolCounter.js';
+import { countEOL, StringEOL } from '../../core/misc/eolCounter.js';
 import { TextChange } from '../../core/textChange.js';
 import { Disposable } from '../../../../base/common/lifecycle.js';
 

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

@@ -24,6 +24,7 @@ import { IColorTheme } from "../../../platform/theme/common/themeService.js";
 import { ResourceEditStackSnapshot, UndoRedoGroup } from "../../../platform/undoRedo/common/undoRedo.js";
 import { IUndoRedoService } from "../../../platform/undoRedo/common/undoRedo.service.js";
 import { TokenArray } from "../tokens/tokenArray.js";
+import { TextModelEditReason } from "../textModelEditReason.js";
 export declare function createTextBufferFactory(text: string): model.ITextBufferFactory;
 interface ITextStream {
     on(event: "data", callback: (data: string) => void): void;
@@ -221,6 +222,7 @@ export declare class TextModel extends Disposable implements model.ITextModel, I
     normalizePosition(position: Position, affinity: model.PositionAffinity): Position;
     getLineIndentColumn(lineNumber: number): number;
     toString(): string;
+    editWithReason<T>(editReason: TextModelEditReason, cb: () => T): T;
 }
 export declare function indentOfLine(line: string): number;
 export interface IDecorationsTreesHost {

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

@@ -9,12 +9,12 @@ import { listenStream } from '../../../base/common/stream.js';
 import { singleLetterHash, UNUSUAL_LINE_TERMINATORS, isHighSurrogate, htmlAttributeEncodeValue } from '../../../base/common/strings.js';
 import { Constants } from '../../../base/common/uint.js';
 import { URI } from '../../../base/common/uri.js';
-import { countEOL } from '../core/eolCounter.js';
-import { normalizeIndentation } from '../core/indentation.js';
+import { countEOL } from '../core/misc/eolCounter.js';
+import { normalizeIndentation } from '../core/misc/indentation.js';
 import { Position } from '../core/position.js';
 import { Range } from '../core/range.js';
 import { Selection } from '../core/selection.js';
-import { EDITOR_MODEL_DEFAULTS } from '../core/textModelDefaults.js';
+import { EDITOR_MODEL_DEFAULTS } from '../core/misc/textModelDefaults.js';
 import { ILanguageService } from '../languages/language.service.js';
 import { ILanguageConfigurationService } from '../languages/languageConfigurationRegistry.service.js';
 import { isITextSnapshot, DefaultEndOfLine, TextModelResolvedOptions, EndOfLinePreference, EndOfLineSequence, ValidAnnotatedEditOperation, OverviewRulerLane, GlyphMarginLane, TrackedRangeStickiness } from '../model.js';
@@ -27,12 +27,13 @@ import { recomputeMaxEnd, IntervalNode, IntervalTree } from './intervalTree.js';
 import { PieceTreeTextBuffer } from './pieceTreeTextBuffer/pieceTreeTextBuffer.js';
 import { PieceTreeTextBufferBuilder } from './pieceTreeTextBuffer/pieceTreeTextBufferBuilder.js';
 import { SearchParams, TextModelSearch } from './textModelSearch.js';
-import { TokenizationTextModelPart } from './tokenizationTextModelPart.js';
-import { AttachedViews } from './tokens.js';
+import { TokenizationTextModelPart } from './tokens/tokenizationTextModelPart.js';
+import { AttachedViews } from './tokens/abstractSyntaxTokenBackend.js';
 import { InternalModelContentChangeEvent, ModelRawContentChangedEvent, ModelRawFlush, ModelRawEOLChanged, LineInjectedText, ModelRawLineChanged, ModelRawLinesDeleted, ModelRawLinesInserted, ModelInjectedTextChangedEvent, ModelLineHeightChanged, ModelLineHeightChangedEvent } from '../textModelEvents.js';
 import { IInstantiationService } from '../../../platform/instantiation/common/instantiation.js';
 import { IUndoRedoService } from '../../../platform/undoRedo/common/undoRedo.service.js';
 import { SetWithKey } from '../../../base/common/collections.js';
+import { TextModelEditReason } from '../textModelEditReason.js';
 
 var TextModel_1;
 function createTextBufferFactory(text) {
@@ -87,6 +88,7 @@ function createTextBuffer(value, defaultEOL) {
 let MODEL_ID = 0;
 const LIMIT_FIND_COUNT = 999;
 const LONG_LINE_BOUNDARY = 10000;
+const LINE_HEIGHT_CEILING = 300;
 class TextModelSnapshot {
     constructor(source) {
         this._source = source;
@@ -1533,6 +1535,9 @@ let TextModel = class TextModel extends Disposable {
     toString() {
         return `TextModel(${( this.uri.toString())})`;
     }
+    editWithReason(editReason, cb) {
+        return TextModelEditReason.editWithReason(editReason, cb);
+    }
 };
 TextModel = TextModel_1 = ( __decorate([
     ( __param(4, IUndoRedoService)),
@@ -1792,7 +1797,7 @@ class ModelDecorationOptions {
         this.glyphMarginHoverMessage = options.glyphMarginHoverMessage || null;
         this.lineNumberHoverMessage = options.lineNumberHoverMessage || null;
         this.isWholeLine = options.isWholeLine || false;
-        this.lineHeight = options.lineHeight ?? null;
+        this.lineHeight = options.lineHeight ? Math.min(options.lineHeight, LINE_HEIGHT_CEILING) : null;
         this.showIfCollapsed = options.showIfCollapsed || false;
         this.collapseOnReplaceEdit = options.collapseOnReplaceEdit || false;
         this.overviewRuler = options.overviewRuler ? ( new ModelDecorationOverviewRulerOptions(options.overviewRuler)) : null;

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

@@ -0,0 +1,9 @@
+import { StringEdit } from "../core/edits/stringEdit.js";
+import { DetailedLineRangeMapping } from "../diff/rangeMapping.js";
+import { ITextModel, IIdentifiedSingleEditOperation } from "../model.js";
+import { IModelContentChange } from "../textModelEvents.js";
+import { LengthEdit } from "../core/edits/lengthEdit.js";
+export declare function offsetEditToEditOperations(offsetEdit: StringEdit, doc: ITextModel): IIdentifiedSingleEditOperation[];
+export declare function offsetEditFromContentChanges(contentChanges: readonly IModelContentChange[]): StringEdit;
+export declare function offsetEditFromLineRangeMapping(original: ITextModel, modified: ITextModel, changes: readonly DetailedLineRangeMapping[]): StringEdit;
+export declare function linesLengthEditFromModelContentChange(c: IModelContentChange[]): LengthEdit;

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

@@ -0,0 +1,45 @@
+
+import { EditOperation } from '../core/editOperation.js';
+import { Range } from '../core/range.js';
+import { StringReplacement, StringEdit } from '../core/edits/stringEdit.js';
+import { OffsetRange } from '../core/ranges/offsetRange.js';
+import { LengthEdit } from '../core/edits/lengthEdit.js';
+import { countEOL } from '../core/misc/eolCounter.js';
+
+function offsetEditToEditOperations(offsetEdit, doc) {
+    const edits = [];
+    for (const singleEdit of offsetEdit.replacements) {
+        const range = Range.fromPositions(doc.getPositionAt(singleEdit.replaceRange.start), doc.getPositionAt(singleEdit.replaceRange.start + singleEdit.replaceRange.length));
+        edits.push(EditOperation.replace(range, singleEdit.newText));
+    }
+    return edits;
+}
+function offsetEditFromContentChanges(contentChanges) {
+    const editsArr = ( contentChanges.map(c => ( new StringReplacement(OffsetRange.ofStartAndLength(c.rangeOffset, c.rangeLength), c.text))));
+    editsArr.reverse();
+    const edits = ( new StringEdit(editsArr));
+    return edits;
+}
+function offsetEditFromLineRangeMapping(original, modified, changes) {
+    const edits = [];
+    for (const c of changes) {
+        for (const i of c.innerChanges ?? []) {
+            const newText = modified.getValueInRange(i.modifiedRange);
+            const startOrig = original.getOffsetAt(i.originalRange.getStartPosition());
+            const endExOrig = original.getOffsetAt(i.originalRange.getEndPosition());
+            const origRange = ( new OffsetRange(startOrig, endExOrig));
+            edits.push(( new StringReplacement(origRange, newText)));
+        }
+    }
+    return ( new StringEdit(edits));
+}
+function linesLengthEditFromModelContentChange(c) {
+    const contentChanges = c.slice().reverse();
+    const lengthEdits = ( contentChanges.map(c => LengthEdit.replace(
+    (
+    new OffsetRange(c.range.startLineNumber - 1, c.range.endLineNumber)), countEOL(c.text)[0] + 1)));
+    const lengthEdit = LengthEdit.compose(lengthEdits);
+    return lengthEdit;
+}
+
+export { linesLengthEditFromModelContentChange, offsetEditFromContentChanges, offsetEditFromLineRangeMapping, offsetEditToEditOperations };

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

@@ -1,6 +1,6 @@
 import { Range } from "../core/range.js";
-import { AbstractText } from "../core/textEdit.js";
-import { TextLength } from "../core/textLength.js";
+import { AbstractText } from "../core/text/abstractText.js";
+import { TextLength } from "../core/text/textLength.js";
 import { ITextModel } from "../model.js";
 export declare class TextModelText extends AbstractText {
     private readonly _textModel;

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

@@ -1,6 +1,6 @@
 
-import { AbstractText } from '../core/textEdit.js';
-import { TextLength } from '../core/textLength.js';
+import { AbstractText } from '../core/text/abstractText.js';
+import { TextLength } from '../core/text/textLength.js';
 
 class TextModelText extends AbstractText {
     constructor(_textModel) {

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

@@ -1,5 +1,5 @@
-import { LineRange } from "../core/lineRange.js";
-import { OffsetRange } from "../core/offsetRange.js";
+import { LineRange } from "../core/ranges/lineRange.js";
+import { OffsetRange } from "../core/ranges/offsetRange.js";
 import { Position } from "../core/position.js";
 import { StandardTokenType } from "../encodedTokenAttributes.js";
 import { IBackgroundTokenizationStore, IBackgroundTokenizer, ILanguageIdCodec, IState, ITokenizationSupport } from "../languages.js";

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

@@ -3,9 +3,9 @@ import { runWhenGlobalIdle } from '../../../base/common/async.js';
 import { BugIndicatingError, onUnexpectedError } from '../../../base/common/errors.js';
 import { setTimeout0 } from '../../../base/common/platform.js';
 import { StopWatch } from '../../../base/common/stopwatch.js';
-import { countEOL } from '../core/eolCounter.js';
-import { LineRange } from '../core/lineRange.js';
-import { OffsetRange } from '../core/offsetRange.js';
+import { countEOL } from '../core/misc/eolCounter.js';
+import { LineRange } from '../core/ranges/lineRange.js';
+import { OffsetRange } from '../core/ranges/offsetRange.js';
 import { StandardTokenType } from '../encodedTokenAttributes.js';
 import { nullTokenizeEncoded } from '../languages/nullTokenize.js';
 import { FixedArray } from './fixedArray.js';

package/vscode/src/vs/editor/common/model/{tokens.d.ts → tokens/abstractSyntaxTokenBackend.d.ts}

@@ -1,26 +1,32 @@
-import { Emitter, Event } from "../../../base/common/event.js";
-import { Disposable } from "../../../base/common/lifecycle.js";
-import { LineRange } from "../core/lineRange.js";
-import { StandardTokenType } from "../encodedTokenAttributes.js";
-import { ILanguageIdCodec } from "../languages.js";
-import { IAttachedView } from "../model.js";
-import { TextModel } from "./textModel.js";
-import { IModelContentChangedEvent, IModelTokensChangedEvent } from "../textModelEvents.js";
-import { BackgroundTokenizationState } from "../tokenizationTextModelPart.js";
-import { LineTokens } from "../tokens/lineTokens.js";
+import { Emitter, Event } from "../../../../base/common/event.js";
+import { Disposable } from "../../../../base/common/lifecycle.js";
+import { LineRange } from "../../core/ranges/lineRange.js";
+import { StandardTokenType } from "../../encodedTokenAttributes.js";
+import { ILanguageIdCodec } from "../../languages.js";
+import { IAttachedView } from "../../model.js";
+import { TextModel } from "../textModel.js";
+import { IModelContentChangedEvent, IModelTokensChangedEvent } from "../../textModelEvents.js";
+import { BackgroundTokenizationState } from "../../tokenizationTextModelPart.js";
+import { LineTokens } from "../../tokens/lineTokens.js";
+import { IObservable } from "../../../../base/common/observable.js";
 export declare class AttachedViews {
     private readonly _onDidChangeVisibleRanges;
     readonly onDidChangeVisibleRanges: Event<{
         view: IAttachedView;
-        state: IAttachedViewState | undefined;
+        state: AttachedViewState | undefined;
     }>;
     private readonly _views;
+    private readonly _viewsChanged;
+    readonly visibleLineRanges: IObservable<readonly LineRange[]>;
+    constructor();
     attachView(): IAttachedView;
     detachView(view: IAttachedView): void;
 }
-export interface IAttachedViewState {
+export declare class AttachedViewState {
     readonly visibleLineRanges: readonly LineRange[];
     readonly stabilized: boolean;
+    constructor(visibleLineRanges: readonly LineRange[], stabilized: boolean);
+    equals(other: AttachedViewState): boolean;
 }
 export declare class AttachedViewHandler extends Disposable {
     private readonly _refreshTokens;
@@ -30,20 +36,19 @@ export declare class AttachedViewHandler extends Disposable {
     get lineRanges(): readonly LineRange[];
     constructor(_refreshTokens: () => void);
     private update;
-    handleStateChange(state: IAttachedViewState): void;
+    handleStateChange(state: AttachedViewState): void;
 }
-export declare abstract class AbstractTokens extends Disposable {
+export declare abstract class AbstractSyntaxTokenBackend extends Disposable {
     protected readonly _languageIdCodec: ILanguageIdCodec;
     protected readonly _textModel: TextModel;
-    protected getLanguageId: () => string;
     protected abstract _backgroundTokenizationState: BackgroundTokenizationState;
     get backgroundTokenizationState(): BackgroundTokenizationState;
     protected abstract readonly _onDidChangeBackgroundTokenizationState: Emitter<void>;
     abstract readonly onDidChangeBackgroundTokenizationState: Event<void>;
     protected readonly _onDidChangeTokens: Emitter<IModelTokensChangedEvent>;
     readonly onDidChangeTokens: Event<IModelTokensChangedEvent>;
-    constructor(_languageIdCodec: ILanguageIdCodec, _textModel: TextModel, getLanguageId: () => string);
-    abstract resetTokenization(fireTokenChangeEvent?: boolean): void;
+    constructor(_languageIdCodec: ILanguageIdCodec, _textModel: TextModel);
+    abstract todo_resetTokenization(fireTokenChangeEvent?: boolean): void;
     abstract handleDidChangeAttached(): void;
     abstract handleDidChangeContent(e: IModelContentChangedEvent): void;
     abstract forceTokenization(lineNumber: number): void;