@codingame/monaco-vscode-api 5.2.0 → 6.0.0

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

@@ -1,28 +1,18 @@
 import { IndentAction } from './languageConfiguration.js';
-import { getScopedLineTokens, getIndentationAtPosition } from './languageConfigurationRegistry.js';
+import { getIndentationAtPosition } from './languageConfigurationRegistry.js';
+import { IndentationContextProcessor } from './supports/indentationLineProcessor.js';
 function getEnterAction(autoIndent, model, range, languageConfigurationService) {
-    const scopedLineTokens = getScopedLineTokens(model, range.startLineNumber, range.startColumn);
-    const richEditSupport = languageConfigurationService.getLanguageConfiguration(scopedLineTokens.languageId);
+    model.tokenization.forceTokenization(range.startLineNumber);
+    const languageId = model.getLanguageIdAtPosition(range.startLineNumber, range.startColumn);
+    const richEditSupport = languageConfigurationService.getLanguageConfiguration(languageId);
     if (!richEditSupport) {
         return null;
     }
-    const scopedLineText = scopedLineTokens.getLineContent();
-    const beforeEnterText = scopedLineText.substr(0, range.startColumn - 1 - scopedLineTokens.firstCharOffset);
-    let afterEnterText;
-    if (range.isEmpty()) {
-        afterEnterText = scopedLineText.substr(range.startColumn - 1 - scopedLineTokens.firstCharOffset);
-    }
-    else {
-        const endScopedLineTokens = getScopedLineTokens(model, range.endLineNumber, range.endColumn);
-        afterEnterText = endScopedLineTokens.getLineContent().substr(range.endColumn - 1 - scopedLineTokens.firstCharOffset);
-    }
-    let previousLineText = '';
-    if (range.startLineNumber > 1 && scopedLineTokens.firstCharOffset === 0) {
-        const oneLineAboveScopedLineTokens = getScopedLineTokens(model, range.startLineNumber - 1);
-        if (oneLineAboveScopedLineTokens.languageId === scopedLineTokens.languageId) {
-            previousLineText = oneLineAboveScopedLineTokens.getLineContent();
-        }
-    }
+    const indentationContextProcessor = ( new IndentationContextProcessor(model, languageConfigurationService));
+    const processedContextTokens = indentationContextProcessor.getProcessedTokenContextAroundRange(range);
+    const previousLineText = processedContextTokens.previousLineProcessedTokens.getLineContent();
+    const beforeEnterText = processedContextTokens.beforeRangeProcessedTokens.getLineContent();
+    const afterEnterText = processedContextTokens.afterRangeProcessedTokens.getLineContent();
     const enterResult = richEditSupport.onEnter(autoIndent, previousLineText, beforeEnterText, afterEnterText);
     if (!enterResult) {
         return null;

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

@@ -1,3 +1,5 @@
+import { CharCode } from '../../../base/common/charCode.js';
+import { StandardTokenType } from '../encodedTokenAttributes.js';
 var IndentAction;
 ( (function(IndentAction) {
     IndentAction[IndentAction["None"] = 0] = "None";
@@ -33,13 +35,13 @@ class StandardAutoClosingPairConditional {
     }
     isOK(standardToken) {
         switch (standardToken) {
-            case 0 :
+            case StandardTokenType.Other:
                 return true;
-            case 1 :
+            case StandardTokenType.Comment:
                 return this._inComment;
-            case 2 :
+            case StandardTokenType.String:
                 return this._inString;
-            case 3 :
+            case StandardTokenType.RegEx:
                 return this._inRegEx;
         }
     }
@@ -64,13 +66,13 @@ class StandardAutoClosingPairConditional {
         if (!this._neutralCharacterSearched) {
             this._neutralCharacterSearched = true;
             if (!this._neutralCharacter) {
-                this._neutralCharacter = this._findNeutralCharacterInRange(48 , 57 );
+                this._neutralCharacter = this._findNeutralCharacterInRange(CharCode.Digit0, CharCode.Digit9);
             }
             if (!this._neutralCharacter) {
-                this._neutralCharacter = this._findNeutralCharacterInRange(97 , 122 );
+                this._neutralCharacter = this._findNeutralCharacterInRange(CharCode.a, CharCode.z);
             }
             if (!this._neutralCharacter) {
-                this._neutralCharacter = this._findNeutralCharacterInRange(65 , 90 );
+                this._neutralCharacter = this._findNeutralCharacterInRange(CharCode.A, CharCode.Z);
             }
         }
         return this._neutralCharacter;

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

@@ -4,7 +4,6 @@ import { Disposable, 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';
-import { createScopedLineTokens } from './supports.js';
 import { CharacterPairSupport } from './supports/characterPair.js';
 import { BracketElectricCharacterSupport } from './supports/electricCharacter.js';
 import { IndentRulesSupport } from './supports/indentRules.js';
@@ -13,7 +12,7 @@ import { RichEditBrackets } from './supports/richEditBrackets.js';
 import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
 import { IConfigurationService } from '../../../platform/configuration/common/configuration.service.js';
 import { ILanguageService } from './language.js';
-import { registerSingleton } from '../../../platform/instantiation/common/extensions.js';
+import { registerSingleton, InstantiationType } from '../../../platform/instantiation/common/extensions.js';
 import { PLAINTEXT_LANGUAGE_ID } from './modesRegistry.js';
 import { LanguageBracketsConfiguration } from './supports/languageBracketsConfiguration.js';
 class LanguageConfigurationServiceChangeEvent {
@@ -122,12 +121,6 @@ function getIndentationAtPosition(model, lineNumber, column) {
     }
     return indentation;
 }
-function getScopedLineTokens(model, lineNumber, columnNumber) {
-    model.tokenization.forceTokenization(lineNumber);
-    const lineTokens = model.tokenization.getLineTokens(lineNumber);
-    const column = (typeof columnNumber === 'undefined' ? model.getLineMaxColumn(lineNumber) - 1 : columnNumber - 1);
-    return createScopedLineTokens(lineTokens, column);
-}
 class ComposedLanguageConfiguration {
     constructor(languageId) {
         this.languageId = languageId;
@@ -333,5 +326,5 @@ class ResolvedLanguageConfiguration {
         return comments;
     }
 }
-registerSingleton(ILanguageConfigurationService, LanguageConfigurationService, 1 );
-export { ILanguageConfigurationService, LanguageConfigurationChangeEvent, LanguageConfigurationRegistry, LanguageConfigurationService, LanguageConfigurationServiceChangeEvent, ResolvedLanguageConfiguration, getIndentationAtPosition, getScopedLineTokens };
+registerSingleton(ILanguageConfigurationService, LanguageConfigurationService, InstantiationType.Delayed);
+export { ILanguageConfigurationService, LanguageConfigurationChangeEvent, LanguageConfigurationRegistry, LanguageConfigurationService, LanguageConfigurationServiceChangeEvent, ResolvedLanguageConfiguration, getIndentationAtPosition };

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

@@ -1,4 +1,23 @@
+import { CharCode } from '../../../base/common/charCode.js';
 import { CharacterClassifier } from '../core/characterClassifier.js';
+var State;
+( (function(State) {
+    State[State["Invalid"] = 0] = "Invalid";
+    State[State["Start"] = 1] = "Start";
+    State[State["H"] = 2] = "H";
+    State[State["HT"] = 3] = "HT";
+    State[State["HTT"] = 4] = "HTT";
+    State[State["HTTP"] = 5] = "HTTP";
+    State[State["F"] = 6] = "F";
+    State[State["FI"] = 7] = "FI";
+    State[State["FIL"] = 8] = "FIL";
+    State[State["BeforeColon"] = 9] = "BeforeColon";
+    State[State["AfterColon"] = 10] = "AfterColon";
+    State[State["AlmostThere"] = 11] = "AlmostThere";
+    State[State["End"] = 12] = "End";
+    State[State["Accept"] = 13] = "Accept";
+    State[State["LastKnownState"] = 14] = "LastKnownState";
+})(State || (State = {})));
 class Uint8Matrix {
     constructor(rows, cols, defaultValue) {
         const data = ( new Uint8Array(rows * cols));
@@ -19,7 +38,7 @@ class Uint8Matrix {
 class StateMachine {
     constructor(edges) {
         let maxCharCode = 0;
-        let maxState = 0 ;
+        let maxState = State.Invalid;
         for (let i = 0, len = edges.length; i < len; i++) {
             const [from, chCode, to] = edges[i];
             if (chCode > maxCharCode) {
@@ -34,7 +53,7 @@ class StateMachine {
         }
         maxCharCode++;
         maxState++;
-        const states = ( new Uint8Matrix(maxState, maxCharCode, 0 ));
+        const states = ( new Uint8Matrix(maxState, maxCharCode, State.Invalid));
         for (let i = 0, len = edges.length; i < len; i++) {
             const [from, chCode, to] = edges[i];
             states.set(from, chCode, to);
@@ -44,7 +63,7 @@ class StateMachine {
     }
     nextState(currentState, chCode) {
         if (chCode < 0 || chCode >= this._maxCharCode) {
-            return 0 ;
+            return State.Invalid;
         }
         return this._states.get(currentState, chCode);
     }
@@ -53,43 +72,49 @@ let _stateMachine = null;
 function getStateMachine() {
     if (_stateMachine === null) {
         _stateMachine = ( new StateMachine([
-            [1 , 104 , 2 ],
-            [1 , 72 , 2 ],
-            [1 , 102 , 6 ],
-            [1 , 70 , 6 ],
-            [2 , 116 , 3 ],
-            [2 , 84 , 3 ],
-            [3 , 116 , 4 ],
-            [3 , 84 , 4 ],
-            [4 , 112 , 5 ],
-            [4 , 80 , 5 ],
-            [5 , 115 , 9 ],
-            [5 , 83 , 9 ],
-            [5 , 58 , 10 ],
-            [6 , 105 , 7 ],
-            [6 , 73 , 7 ],
-            [7 , 108 , 8 ],
-            [7 , 76 , 8 ],
-            [8 , 101 , 9 ],
-            [8 , 69 , 9 ],
-            [9 , 58 , 10 ],
-            [10 , 47 , 11 ],
-            [11 , 47 , 12 ],
+            [State.Start, CharCode.h, State.H],
+            [State.Start, CharCode.H, State.H],
+            [State.Start, CharCode.f, State.F],
+            [State.Start, CharCode.F, State.F],
+            [State.H, CharCode.t, State.HT],
+            [State.H, CharCode.T, State.HT],
+            [State.HT, CharCode.t, State.HTT],
+            [State.HT, CharCode.T, State.HTT],
+            [State.HTT, CharCode.p, State.HTTP],
+            [State.HTT, CharCode.P, State.HTTP],
+            [State.HTTP, CharCode.s, State.BeforeColon],
+            [State.HTTP, CharCode.S, State.BeforeColon],
+            [State.HTTP, CharCode.Colon, State.AfterColon],
+            [State.F, CharCode.i, State.FI],
+            [State.F, CharCode.I, State.FI],
+            [State.FI, CharCode.l, State.FIL],
+            [State.FI, CharCode.L, State.FIL],
+            [State.FIL, CharCode.e, State.BeforeColon],
+            [State.FIL, CharCode.E, State.BeforeColon],
+            [State.BeforeColon, CharCode.Colon, State.AfterColon],
+            [State.AfterColon, CharCode.Slash, State.AlmostThere],
+            [State.AlmostThere, CharCode.Slash, State.End],
         ]));
     }
     return _stateMachine;
 }
+var CharacterClass;
+( (function(CharacterClass) {
+    CharacterClass[CharacterClass["None"] = 0] = "None";
+    CharacterClass[CharacterClass["ForceTermination"] = 1] = "ForceTermination";
+    CharacterClass[CharacterClass["CannotEndIn"] = 2] = "CannotEndIn";
+})(CharacterClass || (CharacterClass = {})));
 let _classifier = null;
 function getClassifier() {
     if (_classifier === null) {
-        _classifier = ( new CharacterClassifier(0 ));
+        _classifier = ( new CharacterClassifier(CharacterClass.None));
         const FORCE_TERMINATION_CHARACTERS = ' \t<>\'\"、。｡､，．：；‘〈「『〔（［｛｢｣｝］）〕』」〉’｀～…';
         for (let i = 0; i < FORCE_TERMINATION_CHARACTERS.length; i++) {
-            _classifier.set(FORCE_TERMINATION_CHARACTERS.charCodeAt(i), 1 );
+            _classifier.set(FORCE_TERMINATION_CHARACTERS.charCodeAt(i), CharacterClass.ForceTermination);
         }
         const CANNOT_END_WITH_CHARACTERS = '.,;:';
         for (let i = 0; i < CANNOT_END_WITH_CHARACTERS.length; i++) {
-            _classifier.set(CANNOT_END_WITH_CHARACTERS.charCodeAt(i), 2 );
+            _classifier.set(CANNOT_END_WITH_CHARACTERS.charCodeAt(i), CharacterClass.CannotEndIn);
         }
     }
     return _classifier;
@@ -100,7 +125,7 @@ class LinkComputer {
         do {
             const chCode = line.charCodeAt(lastIncludedCharIndex);
             const chClass = classifier.get(chCode);
-            if (chClass !== 2 ) {
+            if (chClass !== CharacterClass.CannotEndIn) {
                 break;
             }
             lastIncludedCharIndex--;
@@ -108,9 +133,9 @@ class LinkComputer {
         if (linkBeginIndex > 0) {
             const charCodeBeforeLink = line.charCodeAt(linkBeginIndex - 1);
             const lastCharCodeInLink = line.charCodeAt(lastIncludedCharIndex);
-            if (((charCodeBeforeLink === 40  && lastCharCodeInLink === 41) )
-                || ((charCodeBeforeLink === 91  && lastCharCodeInLink === 93) )
-                || ((charCodeBeforeLink === 123  && lastCharCodeInLink === 125) )) {
+            if ((charCodeBeforeLink === CharCode.OpenParen && lastCharCodeInLink === CharCode.CloseParen)
+                || (charCodeBeforeLink === CharCode.OpenSquareBracket && lastCharCodeInLink === CharCode.CloseSquareBracket)
+                || (charCodeBeforeLink === CharCode.OpenCurlyBrace && lastCharCodeInLink === CharCode.CloseCurlyBrace)) {
                 lastIncludedCharIndex--;
             }
         }
@@ -133,7 +158,7 @@ class LinkComputer {
             let j = 0;
             let linkBeginIndex = 0;
             let linkBeginChCode = 0;
-            let state = 1 ;
+            let state = State.Start;
             let hasOpenParens = false;
             let hasOpenSquareBracket = false;
             let inSquareBrackets = false;
@@ -141,86 +166,86 @@ class LinkComputer {
             while (j < len) {
                 let resetStateMachine = false;
                 const chCode = line.charCodeAt(j);
-                if (state === 13 ) {
+                if (state === State.Accept) {
                     let chClass;
                     switch (chCode) {
-                        case 40 :
+                        case CharCode.OpenParen:
                             hasOpenParens = true;
-                            chClass = 0 ;
+                            chClass = CharacterClass.None;
                             break;
-                        case 41 :
-                            chClass = ((hasOpenParens ? 0  : 1) );
+                        case CharCode.CloseParen:
+                            chClass = (hasOpenParens ? CharacterClass.None : CharacterClass.ForceTermination);
                             break;
-                        case 91 :
+                        case CharCode.OpenSquareBracket:
                             inSquareBrackets = true;
                             hasOpenSquareBracket = true;
-                            chClass = 0 ;
+                            chClass = CharacterClass.None;
                             break;
-                        case 93 :
+                        case CharCode.CloseSquareBracket:
                             inSquareBrackets = false;
-                            chClass = ((hasOpenSquareBracket ? 0  : 1) );
+                            chClass = (hasOpenSquareBracket ? CharacterClass.None : CharacterClass.ForceTermination);
                             break;
-                        case 123 :
+                        case CharCode.OpenCurlyBrace:
                             hasOpenCurlyBracket = true;
-                            chClass = 0 ;
+                            chClass = CharacterClass.None;
                             break;
-                        case 125 :
-                            chClass = ((hasOpenCurlyBracket ? 0  : 1) );
+                        case CharCode.CloseCurlyBrace:
+                            chClass = (hasOpenCurlyBracket ? CharacterClass.None : CharacterClass.ForceTermination);
                             break;
-                        case 39 :
-                        case 34 :
-                        case 96 :
+                        case CharCode.SingleQuote:
+                        case CharCode.DoubleQuote:
+                        case CharCode.BackTick:
                             if (linkBeginChCode === chCode) {
-                                chClass = 1 ;
+                                chClass = CharacterClass.ForceTermination;
                             }
-                            else if (linkBeginChCode === 39  || linkBeginChCode === 34  || linkBeginChCode === 96 ) {
-                                chClass = 0 ;
+                            else if (linkBeginChCode === CharCode.SingleQuote || linkBeginChCode === CharCode.DoubleQuote || linkBeginChCode === CharCode.BackTick) {
+                                chClass = CharacterClass.None;
                             }
                             else {
-                                chClass = 1 ;
+                                chClass = CharacterClass.ForceTermination;
                             }
                             break;
-                        case 42 :
-                            chClass = ((linkBeginChCode === 42) ) ? 1  : 0 ;
+                        case CharCode.Asterisk:
+                            chClass = (linkBeginChCode === CharCode.Asterisk) ? CharacterClass.ForceTermination : CharacterClass.None;
                             break;
-                        case 124 :
-                            chClass = ((linkBeginChCode === 124) ) ? 1  : 0 ;
+                        case CharCode.Pipe:
+                            chClass = (linkBeginChCode === CharCode.Pipe) ? CharacterClass.ForceTermination : CharacterClass.None;
                             break;
-                        case 32 :
-                            chClass = ((inSquareBrackets ? 0  : 1) );
+                        case CharCode.Space:
+                            chClass = (inSquareBrackets ? CharacterClass.None : CharacterClass.ForceTermination);
                             break;
                         default:
                             chClass = classifier.get(chCode);
                     }
-                    if (chClass === 1 ) {
+                    if (chClass === CharacterClass.ForceTermination) {
                         result.push(LinkComputer._createLink(classifier, line, i, linkBeginIndex, j));
                         resetStateMachine = true;
                     }
                 }
-                else if (state === 12 ) {
+                else if (state === State.End) {
                     let chClass;
-                    if (chCode === 91 ) {
+                    if (chCode === CharCode.OpenSquareBracket) {
                         hasOpenSquareBracket = true;
-                        chClass = 0 ;
+                        chClass = CharacterClass.None;
                     }
                     else {
                         chClass = classifier.get(chCode);
                     }
-                    if (chClass === 1 ) {
+                    if (chClass === CharacterClass.ForceTermination) {
                         resetStateMachine = true;
                     }
                     else {
-                        state = 13 ;
+                        state = State.Accept;
                     }
                 }
                 else {
                     state = stateMachine.nextState(state, chCode);
-                    if (state === 0 ) {
+                    if (state === State.Invalid) {
                         resetStateMachine = true;
                     }
                 }
                 if (resetStateMachine) {
-                    state = 1 ;
+                    state = State.Start;
                     hasOpenParens = false;
                     hasOpenSquareBracket = false;
                     hasOpenCurlyBracket = false;
@@ -229,7 +254,7 @@ class LinkComputer {
                 }
                 j++;
             }
-            if (state === 13 ) {
+            if (state === State.Accept) {
                 result.push(LinkComputer._createLink(classifier, line, i, linkBeginIndex, len));
             }
         }
@@ -242,4 +267,4 @@ function computeLinks(model) {
     }
     return LinkComputer.computeLinks(model);
 }
-export { LinkComputer, StateMachine, computeLinks };
+export { LinkComputer, State, StateMachine, computeLinks };

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

@@ -1,4 +1,5 @@
 import { TokenizationResult, Token, EncodedTokenizationResult } from '../languages.js';
+import { MetadataConsts, StandardTokenType, FontStyle, ColorId } from '../encodedTokenAttributes.js';
 const NullState = new class {
     clone() {
         return this;
@@ -13,11 +14,11 @@ function nullTokenize(languageId, state) {
 function nullTokenizeEncoded(languageId, state) {
     const tokens = ( new Uint32Array(2));
     tokens[0] = 0;
-    tokens[1] = (((languageId << 0) )
-        | ((0  << 8) )
-        | ((0  << 11) )
-        | ((1  << 15) )
-        | ((2  << 24) )) >>> 0;
+    tokens[1] = ((languageId << MetadataConsts.LANGUAGEID_OFFSET)
+        | (StandardTokenType.Other << MetadataConsts.TOKEN_TYPE_OFFSET)
+        | (FontStyle.None << MetadataConsts.FONT_STYLE_OFFSET)
+        | (ColorId.DefaultForeground << MetadataConsts.FOREGROUND_OFFSET)
+        | (ColorId.DefaultBackground << MetadataConsts.BACKGROUND_OFFSET)) >>> 0;
     return ( new EncodedTokenizationResult(tokens, state === null ? NullState : state));
 }
 export { NullState, nullTokenize, nullTokenizeEncoded };

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

@@ -1,3 +1,10 @@
+var IndentConsts;
+( (function(IndentConsts) {
+    IndentConsts[IndentConsts["INCREASE_MASK"] = 1] = "INCREASE_MASK";
+    IndentConsts[IndentConsts["DECREASE_MASK"] = 2] = "DECREASE_MASK";
+    IndentConsts[IndentConsts["INDENT_NEXTLINE_MASK"] = 4] = "INDENT_NEXTLINE_MASK";
+    IndentConsts[IndentConsts["UNINDENT_MASK"] = 8] = "UNINDENT_MASK";
+})(IndentConsts || (IndentConsts = {})));
 function resetGlobalRegex(reg) {
     if (reg.global) {
         reg.lastIndex = 0;
@@ -37,18 +44,18 @@ class IndentRulesSupport {
     getIndentMetadata(text) {
         let ret = 0;
         if (this.shouldIncrease(text)) {
-            ret += 1 ;
+            ret += IndentConsts.INCREASE_MASK;
         }
         if (this.shouldDecrease(text)) {
-            ret += 2 ;
+            ret += IndentConsts.DECREASE_MASK;
         }
         if (this.shouldIndentNextLine(text)) {
-            ret += 4 ;
+            ret += IndentConsts.INDENT_NEXTLINE_MASK;
         }
         if (this.shouldIgnore(text)) {
-            ret += 8 ;
+            ret += IndentConsts.UNINDENT_MASK;
         }
         return ret;
     }
 }
-export { IndentRulesSupport };
+export { IndentConsts, IndentRulesSupport };

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

@@ -0,0 +1,150 @@
+import { getLeadingWhitespace } from '../../../../base/common/strings.js';
+import { createScopedLineTokens } from '../supports.js';
+import { LineTokens } from '../../tokens/lineTokens.js';
+import { StandardTokenType } from '../../encodedTokenAttributes.js';
+class ProcessedIndentRulesSupport {
+    constructor(model, indentRulesSupport, languageConfigurationService) {
+        this._indentRulesSupport = indentRulesSupport;
+        this._indentationLineProcessor = ( new IndentationLineProcessor(model, languageConfigurationService));
+    }
+    shouldIncrease(lineNumber, newIndentation) {
+        const processedLine = this._indentationLineProcessor.getProcessedLine(lineNumber, newIndentation);
+        return this._indentRulesSupport.shouldIncrease(processedLine);
+    }
+    shouldDecrease(lineNumber, newIndentation) {
+        const processedLine = this._indentationLineProcessor.getProcessedLine(lineNumber, newIndentation);
+        return this._indentRulesSupport.shouldDecrease(processedLine);
+    }
+    shouldIgnore(lineNumber, newIndentation) {
+        const processedLine = this._indentationLineProcessor.getProcessedLine(lineNumber, newIndentation);
+        return this._indentRulesSupport.shouldIgnore(processedLine);
+    }
+    shouldIndentNextLine(lineNumber, newIndentation) {
+        const processedLine = this._indentationLineProcessor.getProcessedLine(lineNumber, newIndentation);
+        return this._indentRulesSupport.shouldIndentNextLine(processedLine);
+    }
+}
+class IndentationContextProcessor {
+    constructor(model, languageConfigurationService) {
+        this.model = model;
+        this.indentationLineProcessor = ( new IndentationLineProcessor(model, languageConfigurationService));
+    }
+    getProcessedTokenContextAroundRange(range) {
+        const beforeRangeProcessedTokens = this._getProcessedTokensBeforeRange(range);
+        const afterRangeProcessedTokens = this._getProcessedTokensAfterRange(range);
+        const previousLineProcessedTokens = this._getProcessedPreviousLineTokens(range);
+        return { beforeRangeProcessedTokens, afterRangeProcessedTokens, previousLineProcessedTokens };
+    }
+    _getProcessedTokensBeforeRange(range) {
+        this.model.tokenization.forceTokenization(range.startLineNumber);
+        const lineTokens = this.model.tokenization.getLineTokens(range.startLineNumber);
+        const scopedLineTokens = createScopedLineTokens(lineTokens, range.startColumn - 1);
+        let slicedTokens;
+        if (isLanguageDifferentFromLineStart(this.model, range.getStartPosition())) {
+            const columnIndexWithinScope = (range.startColumn - 1) - scopedLineTokens.firstCharOffset;
+            const firstCharacterOffset = scopedLineTokens.firstCharOffset;
+            const lastCharacterOffset = firstCharacterOffset + columnIndexWithinScope;
+            slicedTokens = lineTokens.sliceAndInflate(firstCharacterOffset, lastCharacterOffset, 0);
+        }
+        else {
+            const columnWithinLine = range.startColumn - 1;
+            slicedTokens = lineTokens.sliceAndInflate(0, columnWithinLine, 0);
+        }
+        const processedTokens = this.indentationLineProcessor.getProcessedTokens(slicedTokens);
+        return processedTokens;
+    }
+    _getProcessedTokensAfterRange(range) {
+        const position = range.isEmpty() ? range.getStartPosition() : range.getEndPosition();
+        this.model.tokenization.forceTokenization(position.lineNumber);
+        const lineTokens = this.model.tokenization.getLineTokens(position.lineNumber);
+        const scopedLineTokens = createScopedLineTokens(lineTokens, position.column - 1);
+        const columnIndexWithinScope = position.column - 1 - scopedLineTokens.firstCharOffset;
+        const firstCharacterOffset = scopedLineTokens.firstCharOffset + columnIndexWithinScope;
+        const lastCharacterOffset = scopedLineTokens.firstCharOffset + scopedLineTokens.getLineLength();
+        const slicedTokens = lineTokens.sliceAndInflate(firstCharacterOffset, lastCharacterOffset, 0);
+        const processedTokens = this.indentationLineProcessor.getProcessedTokens(slicedTokens);
+        return processedTokens;
+    }
+    _getProcessedPreviousLineTokens(range) {
+        const getScopedLineTokensAtEndColumnOfLine = (lineNumber) => {
+            this.model.tokenization.forceTokenization(lineNumber);
+            const lineTokens = this.model.tokenization.getLineTokens(lineNumber);
+            const endColumnOfLine = this.model.getLineMaxColumn(lineNumber) - 1;
+            const scopedLineTokensAtEndColumn = createScopedLineTokens(lineTokens, endColumnOfLine);
+            return scopedLineTokensAtEndColumn;
+        };
+        this.model.tokenization.forceTokenization(range.startLineNumber);
+        const lineTokens = this.model.tokenization.getLineTokens(range.startLineNumber);
+        const scopedLineTokens = createScopedLineTokens(lineTokens, range.startColumn - 1);
+        const emptyTokens = LineTokens.createEmpty('', scopedLineTokens.languageIdCodec);
+        const previousLineNumber = range.startLineNumber - 1;
+        const isFirstLine = previousLineNumber === 0;
+        if (isFirstLine) {
+            return emptyTokens;
+        }
+        const canScopeExtendOnPreviousLine = scopedLineTokens.firstCharOffset === 0;
+        if (!canScopeExtendOnPreviousLine) {
+            return emptyTokens;
+        }
+        const scopedLineTokensAtEndColumnOfPreviousLine = getScopedLineTokensAtEndColumnOfLine(previousLineNumber);
+        const doesLanguageContinueOnPreviousLine = scopedLineTokens.languageId === scopedLineTokensAtEndColumnOfPreviousLine.languageId;
+        if (!doesLanguageContinueOnPreviousLine) {
+            return emptyTokens;
+        }
+        const previousSlicedLineTokens = scopedLineTokensAtEndColumnOfPreviousLine.toIViewLineTokens();
+        const processedTokens = this.indentationLineProcessor.getProcessedTokens(previousSlicedLineTokens);
+        return processedTokens;
+    }
+}
+class IndentationLineProcessor {
+    constructor(model, languageConfigurationService) {
+        this.model = model;
+        this.languageConfigurationService = languageConfigurationService;
+    }
+    getProcessedLine(lineNumber, newIndentation) {
+        const replaceIndentation = (line, newIndentation) => {
+            const currentIndentation = getLeadingWhitespace(line);
+            const adjustedLine = newIndentation + line.substring(currentIndentation.length);
+            return adjustedLine;
+        };
+        this.model.tokenization.forceTokenization?.(lineNumber);
+        const tokens = this.model.tokenization.getLineTokens(lineNumber);
+        let processedLine = this.getProcessedTokens(tokens).getLineContent();
+        if (newIndentation !== undefined) {
+            processedLine = replaceIndentation(processedLine, newIndentation);
+        }
+        return processedLine;
+    }
+    getProcessedTokens(tokens) {
+        const shouldRemoveBracketsFromTokenType = (tokenType) => {
+            return tokenType === StandardTokenType.String
+                || tokenType === StandardTokenType.RegEx
+                || tokenType === StandardTokenType.Comment;
+        };
+        const languageId = tokens.getLanguageId(0);
+        const bracketsConfiguration = this.languageConfigurationService.getLanguageConfiguration(languageId).bracketsNew;
+        const bracketsRegExp = bracketsConfiguration.getBracketRegExp({ global: true });
+        const textAndMetadata = [];
+        tokens.forEach((tokenIndex) => {
+            const tokenType = tokens.getStandardTokenType(tokenIndex);
+            let text = tokens.getTokenText(tokenIndex);
+            if (shouldRemoveBracketsFromTokenType(tokenType)) {
+                text = text.replace(bracketsRegExp, '');
+            }
+            const metadata = tokens.getMetadata(tokenIndex);
+            textAndMetadata.push({ text, metadata });
+        });
+        const processedLineTokens = LineTokens.createFromTextAndMetadata(textAndMetadata, tokens.languageIdCodec);
+        return processedLineTokens;
+    }
+}
+function isLanguageDifferentFromLineStart(model, position) {
+    model.tokenization.forceTokenization(position.lineNumber);
+    const lineTokens = model.tokenization.getLineTokens(position.lineNumber);
+    const scopedLineTokens = createScopedLineTokens(lineTokens, position.column - 1);
+    const doesScopeStartAtOffsetZero = scopedLineTokens.firstCharOffset === 0;
+    const isScopedLanguageEqualToFirstLanguageOnLine = lineTokens.getLanguageId(0) === scopedLineTokens.languageId;
+    const languageIsDifferentFromLineStart = !doesScopeStartAtOffsetZero && !isScopedLanguageEqualToFirstLanguageOnLine;
+    return languageIsDifferentFromLineStart;
+}
+export { IndentationContextProcessor, ProcessedIndentRulesSupport, isLanguageDifferentFromLineStart };

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

@@ -1,3 +1,4 @@
+import { RegExpOptions } from '../../../../base/common/strings.js';
 import { LanguageConfiguration } from '../languageConfiguration.js';
 
 /**
@@ -20,6 +21,7 @@ declare class LanguageBracketsConfiguration {
     getOpeningBracketInfo(bracketText: string): OpeningBracketKind | undefined;
     getClosingBracketInfo(bracketText: string): ClosingBracketKind | undefined;
     getBracketInfo(bracketText: string): BracketKind | undefined;
+    getBracketRegExp(options?: RegExpOptions): RegExp;
 }
 type BracketKind = OpeningBracketKind | ClosingBracketKind;
 declare class BracketKindBase {

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

@@ -1,4 +1,5 @@
 import { CachedFunction } from '../../../../base/common/cache.js';
+import { createBracketOrRegExp } from './richEditBrackets.js';
 class LanguageBracketsConfiguration {
     constructor(languageId, config) {
         this.languageId = languageId;
@@ -53,6 +54,10 @@ class LanguageBracketsConfiguration {
     getBracketInfo(bracketText) {
         return this.getOpeningBracketInfo(bracketText) || this.getClosingBracketInfo(bracketText);
     }
+    getBracketRegExp(options) {
+        const brackets = Array.from([...( this._openingBrackets.keys()), ...( this._closingBrackets.keys())]);
+        return createBracketOrRegExp(brackets, options);
+    }
 }
 function filterValidBrackets(bracketPairs) {
     return bracketPairs.filter(([open, close]) => open !== '' && close !== '');