@codingame/monaco-vscode-api 5.3.0 → 6.0.1

package/vscode/src/vs/editor/common/diff/defaultLinesDiffComputer/linesSliceCharSequence.js

@@ -1,4 +1,5 @@
 import { findLastIdxMonotonous, findLastMonotonous, findFirstMonotonous } from '../../../../base/common/arraysFind.js';
+import { CharCode } from '../../../../base/common/charCode.js';
 import { OffsetRange } from '../../core/offsetRange.js';
 import { Position } from '../../core/position.js';
 import { Range } from '../../core/range.js';
@@ -59,16 +60,16 @@ class LinesSliceCharSequence {
     getBoundaryScore(length) {
         const prevCategory = getCategory(length > 0 ? this.elements[length - 1] : -1);
         const nextCategory = getCategory(length < this.elements.length ? this.elements[length] : -1);
-        if (prevCategory === 7  && nextCategory === 8 ) {
+        if (prevCategory === CharBoundaryCategory.LineBreakCR && nextCategory === CharBoundaryCategory.LineBreakLF) {
             return 0;
         }
-        if (prevCategory === 8 ) {
+        if (prevCategory === CharBoundaryCategory.LineBreakLF) {
             return 150;
         }
         let score = 0;
         if (prevCategory !== nextCategory) {
             score += 10;
-            if (prevCategory === 0  && nextCategory === 1 ) {
+            if (prevCategory === CharBoundaryCategory.WordLower && nextCategory === CharBoundaryCategory.WordUpper) {
                 score += 1;
             }
         }
@@ -119,51 +120,63 @@ class LinesSliceCharSequence {
     }
 }
 function isWordChar(charCode) {
-    return charCode >= 97  && charCode <= 122
-        || charCode >= 65  && charCode <= 90
-        || charCode >= 48  && charCode <= 57 ;
+    return charCode >= CharCode.a && charCode <= CharCode.z
+        || charCode >= CharCode.A && charCode <= CharCode.Z
+        || charCode >= CharCode.Digit0 && charCode <= CharCode.Digit9;
 }
+var CharBoundaryCategory;
+( (function(CharBoundaryCategory) {
+    CharBoundaryCategory[CharBoundaryCategory["WordLower"] = 0] = "WordLower";
+    CharBoundaryCategory[CharBoundaryCategory["WordUpper"] = 1] = "WordUpper";
+    CharBoundaryCategory[CharBoundaryCategory["WordNumber"] = 2] = "WordNumber";
+    CharBoundaryCategory[CharBoundaryCategory["End"] = 3] = "End";
+    CharBoundaryCategory[CharBoundaryCategory["Other"] = 4] = "Other";
+    CharBoundaryCategory[CharBoundaryCategory["Separator"] = 5] = "Separator";
+    CharBoundaryCategory[CharBoundaryCategory["Space"] = 6] = "Space";
+    CharBoundaryCategory[CharBoundaryCategory["LineBreakCR"] = 7] = "LineBreakCR";
+    CharBoundaryCategory[CharBoundaryCategory["LineBreakLF"] = 8] = "LineBreakLF";
+})(CharBoundaryCategory || (CharBoundaryCategory = {})));
 const score = {
-    [0 ]: 0,
-    [1 ]: 0,
-    [2 ]: 0,
-    [3 ]: 10,
-    [4 ]: 2,
-    [5 ]: 30,
-    [6 ]: 3,
-    [7 ]: 10,
-    [8 ]: 10,
+    [CharBoundaryCategory.WordLower]: 0,
+    [CharBoundaryCategory.WordUpper]: 0,
+    [CharBoundaryCategory.WordNumber]: 0,
+    [CharBoundaryCategory.End]: 10,
+    [CharBoundaryCategory.Other]: 2,
+    [CharBoundaryCategory.Separator]: 30,
+    [CharBoundaryCategory.Space]: 3,
+    [CharBoundaryCategory.LineBreakCR]: 10,
+    [CharBoundaryCategory.LineBreakLF]: 10,
 };
 function getCategoryBoundaryScore(category) {
     return score[category];
 }
 function getCategory(charCode) {
-    if (charCode === 10 ) {
-        return 8 ;
+    if (charCode === CharCode.LineFeed) {
+        return CharBoundaryCategory.LineBreakLF;
     }
-    else if (charCode === 13 ) {
-        return 7 ;
+    else if (charCode === CharCode.CarriageReturn) {
+        return CharBoundaryCategory.LineBreakCR;
     }
     else if (isSpace(charCode)) {
-        return 6 ;
+        return CharBoundaryCategory.Space;
     }
-    else if (charCode >= 97  && charCode <= 122 ) {
-        return 0 ;
+    else if (charCode >= CharCode.a && charCode <= CharCode.z) {
+        return CharBoundaryCategory.WordLower;
     }
-    else if (charCode >= 65  && charCode <= 90 ) {
-        return 1 ;
+    else if (charCode >= CharCode.A && charCode <= CharCode.Z) {
+        return CharBoundaryCategory.WordUpper;
     }
-    else if (charCode >= 48  && charCode <= 57 ) {
-        return 2 ;
+    else if (charCode >= CharCode.Digit0 && charCode <= CharCode.Digit9) {
+        return CharBoundaryCategory.WordNumber;
     }
     else if (charCode === -1) {
-        return 3 ;
+        return CharBoundaryCategory.End;
     }
-    else if (charCode === 44  || charCode === 59 ) {
-        return 5 ;
+    else if (charCode === CharCode.Comma || charCode === CharCode.Semicolon) {
+        return CharBoundaryCategory.Separator;
     }
     else {
-        return 4 ;
+        return CharBoundaryCategory.Other;
     }
 }
 export { LinesSliceCharSequence };

package/vscode/src/vs/editor/common/diff/defaultLinesDiffComputer/utils.js

@@ -1,3 +1,4 @@
+import { CharCode } from '../../../../base/common/charCode.js';
 class Array2D {
     constructor(width, height) {
         this.width = width;
@@ -13,7 +14,7 @@ class Array2D {
     }
 }
 function isSpace(charCode) {
-    return charCode === 32  || charCode === 9 ;
+    return charCode === CharCode.Space || charCode === CharCode.Tab;
 }
 class LineRangeFragment {
     static { this.chrKeys = ( new Map()); }

package/vscode/src/vs/editor/common/diff/legacyLinesDiffComputer.js

@@ -1,3 +1,4 @@
+import { CharCode } from '../../../base/common/charCode.js';
 import { LcsDiff } from '../../../base/common/diff/diff.js';
 import { LinesDiff } from './linesDiffComputer.js';
 import { DetailedLineRangeMapping, RangeMapping } from './rangeMapping.js';
@@ -115,7 +116,7 @@ class LineSequence {
                 len++;
             }
             if (!shouldIgnoreTrimWhitespace && index < endIndex) {
-                charCodes[len] = 10 ;
+                charCodes[len] = CharCode.LineFeed;
                 lineNumbers[len] = index + 1;
                 columns[len] = lineContent.length + 1;
                 len++;
@@ -132,7 +133,7 @@ class CharSequence {
     }
     toString() {
         return ('[' + ( this._charCodes.map(
-            (s, idx) => (s === 10  ? '\\n' : String.fromCharCode(s)) + `-(${this._lineNumbers[idx]},${this._columns[idx]})`
+            (s, idx) => (s === CharCode.LineFeed ? '\\n' : String.fromCharCode(s)) + `-(${this._lineNumbers[idx]},${this._columns[idx]})`
         )).join(', ') + ']');
     }
     _assertIndex(index, arr) {
@@ -155,7 +156,7 @@ class CharSequence {
             return this.getStartLineNumber(i + 1);
         }
         this._assertIndex(i, this._lineNumbers);
-        if (this._charCodes[i] === 10 ) {
+        if (this._charCodes[i] === CharCode.LineFeed) {
             return this._lineNumbers[i] + 1;
         }
         return this._lineNumbers[i];
@@ -172,7 +173,7 @@ class CharSequence {
             return this.getStartColumn(i + 1);
         }
         this._assertIndex(i, this._columns);
-        if (this._charCodes[i] === 10 ) {
+        if (this._charCodes[i] === CharCode.LineFeed) {
             return 1;
         }
         return this._columns[i] + 1;

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

@@ -1,3 +1,8 @@
+var ScrollType;
+( (function(ScrollType) {
+    ScrollType[ScrollType["Smooth"] = 0] = "Smooth";
+    ScrollType[ScrollType["Immediate"] = 1] = "Immediate";
+})(ScrollType || (ScrollType = {})));
 function isThemeColor(o) {
     return o && typeof o.id === 'string';
 }
@@ -5,4 +10,14 @@ const EditorType = {
     ICodeEditor: 'vs.editor.ICodeEditor',
     IDiffEditor: 'vs.editor.IDiffEditor'
 };
-export { EditorType, isThemeColor };
+var Handler;
+( (function(Handler) {
+    Handler["CompositionStart"] = "compositionStart";
+    Handler["CompositionEnd"] = "compositionEnd";
+    Handler["Type"] = "type";
+    Handler["ReplacePreviousChar"] = "replacePreviousChar";
+    Handler["CompositionType"] = "compositionType";
+    Handler["Paste"] = "paste";
+    Handler["Cut"] = "cut";
+})(Handler || (Handler = {})));
+export { EditorType, Handler, ScrollType, isThemeColor };

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

@@ -1,36 +1,88 @@
+var LanguageId;
+( (function(LanguageId) {
+    LanguageId[LanguageId["Null"] = 0] = "Null";
+    LanguageId[LanguageId["PlainText"] = 1] = "PlainText";
+})(LanguageId || (LanguageId = {})));
+var FontStyle;
+( (function(FontStyle) {
+    FontStyle[FontStyle["NotSet"] = -1] = "NotSet";
+    FontStyle[FontStyle["None"] = 0] = "None";
+    FontStyle[FontStyle["Italic"] = 1] = "Italic";
+    FontStyle[FontStyle["Bold"] = 2] = "Bold";
+    FontStyle[FontStyle["Underline"] = 4] = "Underline";
+    FontStyle[FontStyle["Strikethrough"] = 8] = "Strikethrough";
+})(FontStyle || (FontStyle = {})));
+var ColorId;
+( (function(ColorId) {
+    ColorId[ColorId["None"] = 0] = "None";
+    ColorId[ColorId["DefaultForeground"] = 1] = "DefaultForeground";
+    ColorId[ColorId["DefaultBackground"] = 2] = "DefaultBackground";
+})(ColorId || (ColorId = {})));
+var StandardTokenType;
+( (function(StandardTokenType) {
+    StandardTokenType[StandardTokenType["Other"] = 0] = "Other";
+    StandardTokenType[StandardTokenType["Comment"] = 1] = "Comment";
+    StandardTokenType[StandardTokenType["String"] = 2] = "String";
+    StandardTokenType[StandardTokenType["RegEx"] = 3] = "RegEx";
+})(StandardTokenType || (StandardTokenType = {})));
+var MetadataConsts;
+( (function(MetadataConsts) {
+    MetadataConsts[MetadataConsts["LANGUAGEID_MASK"] = 255] = "LANGUAGEID_MASK";
+    MetadataConsts[MetadataConsts["TOKEN_TYPE_MASK"] = 768] = "TOKEN_TYPE_MASK";
+    MetadataConsts[MetadataConsts["BALANCED_BRACKETS_MASK"] = 1024] = "BALANCED_BRACKETS_MASK";
+    MetadataConsts[MetadataConsts["FONT_STYLE_MASK"] = 30720] = "FONT_STYLE_MASK";
+    MetadataConsts[MetadataConsts["FOREGROUND_MASK"] = 16744448] = "FOREGROUND_MASK";
+    MetadataConsts[MetadataConsts["BACKGROUND_MASK"] = 4278190080] = "BACKGROUND_MASK";
+    MetadataConsts[MetadataConsts["ITALIC_MASK"] = 2048] = "ITALIC_MASK";
+    MetadataConsts[MetadataConsts["BOLD_MASK"] = 4096] = "BOLD_MASK";
+    MetadataConsts[MetadataConsts["UNDERLINE_MASK"] = 8192] = "UNDERLINE_MASK";
+    MetadataConsts[MetadataConsts["STRIKETHROUGH_MASK"] = 16384] = "STRIKETHROUGH_MASK";
+    MetadataConsts[MetadataConsts["SEMANTIC_USE_ITALIC"] = 1] = "SEMANTIC_USE_ITALIC";
+    MetadataConsts[MetadataConsts["SEMANTIC_USE_BOLD"] = 2] = "SEMANTIC_USE_BOLD";
+    MetadataConsts[MetadataConsts["SEMANTIC_USE_UNDERLINE"] = 4] = "SEMANTIC_USE_UNDERLINE";
+    MetadataConsts[MetadataConsts["SEMANTIC_USE_STRIKETHROUGH"] = 8] = "SEMANTIC_USE_STRIKETHROUGH";
+    MetadataConsts[MetadataConsts["SEMANTIC_USE_FOREGROUND"] = 16] = "SEMANTIC_USE_FOREGROUND";
+    MetadataConsts[MetadataConsts["SEMANTIC_USE_BACKGROUND"] = 32] = "SEMANTIC_USE_BACKGROUND";
+    MetadataConsts[MetadataConsts["LANGUAGEID_OFFSET"] = 0] = "LANGUAGEID_OFFSET";
+    MetadataConsts[MetadataConsts["TOKEN_TYPE_OFFSET"] = 8] = "TOKEN_TYPE_OFFSET";
+    MetadataConsts[MetadataConsts["BALANCED_BRACKETS_OFFSET"] = 10] = "BALANCED_BRACKETS_OFFSET";
+    MetadataConsts[MetadataConsts["FONT_STYLE_OFFSET"] = 11] = "FONT_STYLE_OFFSET";
+    MetadataConsts[MetadataConsts["FOREGROUND_OFFSET"] = 15] = "FOREGROUND_OFFSET";
+    MetadataConsts[MetadataConsts["BACKGROUND_OFFSET"] = 24] = "BACKGROUND_OFFSET";
+})(MetadataConsts || (MetadataConsts = {})));
 class TokenMetadata {
     static getLanguageId(metadata) {
-        return ((metadata & 255) ) >>> 0 ;
+        return (metadata & MetadataConsts.LANGUAGEID_MASK) >>> MetadataConsts.LANGUAGEID_OFFSET;
     }
     static getTokenType(metadata) {
-        return ((metadata & 768) ) >>> 8 ;
+        return (metadata & MetadataConsts.TOKEN_TYPE_MASK) >>> MetadataConsts.TOKEN_TYPE_OFFSET;
     }
     static containsBalancedBrackets(metadata) {
-        return ((metadata & 1024) ) !== 0;
+        return (metadata & MetadataConsts.BALANCED_BRACKETS_MASK) !== 0;
     }
     static getFontStyle(metadata) {
-        return ((metadata & 30720) ) >>> 11 ;
+        return (metadata & MetadataConsts.FONT_STYLE_MASK) >>> MetadataConsts.FONT_STYLE_OFFSET;
     }
     static getForeground(metadata) {
-        return ((metadata & 16744448) ) >>> 15 ;
+        return (metadata & MetadataConsts.FOREGROUND_MASK) >>> MetadataConsts.FOREGROUND_OFFSET;
     }
     static getBackground(metadata) {
-        return ((metadata & 4278190080) ) >>> 24 ;
+        return (metadata & MetadataConsts.BACKGROUND_MASK) >>> MetadataConsts.BACKGROUND_OFFSET;
     }
     static getClassNameFromMetadata(metadata) {
         const foreground = this.getForeground(metadata);
         let className = 'mtk' + foreground;
         const fontStyle = this.getFontStyle(metadata);
-        if (fontStyle & 1 ) {
+        if (fontStyle & FontStyle.Italic) {
             className += ' mtki';
         }
-        if (fontStyle & 2 ) {
+        if (fontStyle & FontStyle.Bold) {
             className += ' mtkb';
         }
-        if (fontStyle & 4 ) {
+        if (fontStyle & FontStyle.Underline) {
             className += ' mtku';
         }
-        if (fontStyle & 8 ) {
+        if (fontStyle & FontStyle.Strikethrough) {
             className += ' mtks';
         }
         return className;
@@ -39,17 +91,17 @@ class TokenMetadata {
         const foreground = this.getForeground(metadata);
         const fontStyle = this.getFontStyle(metadata);
         let result = `color: ${colorMap[foreground]};`;
-        if (fontStyle & 1 ) {
+        if (fontStyle & FontStyle.Italic) {
             result += 'font-style: italic;';
         }
-        if (fontStyle & 2 ) {
+        if (fontStyle & FontStyle.Bold) {
             result += 'font-weight: bold;';
         }
         let textDecoration = '';
-        if (fontStyle & 4 ) {
+        if (fontStyle & FontStyle.Underline) {
             textDecoration += ' underline';
         }
-        if (fontStyle & 8 ) {
+        if (fontStyle & FontStyle.Strikethrough) {
             textDecoration += ' line-through';
         }
         if (textDecoration) {
@@ -62,11 +114,11 @@ class TokenMetadata {
         const fontStyle = this.getFontStyle(metadata);
         return {
             foreground: foreground,
-            italic: Boolean(fontStyle & 1 ),
-            bold: Boolean(fontStyle & 2 ),
-            underline: Boolean(fontStyle & 4 ),
-            strikethrough: Boolean(fontStyle & 8 ),
+            italic: Boolean(fontStyle & FontStyle.Italic),
+            bold: Boolean(fontStyle & FontStyle.Bold),
+            underline: Boolean(fontStyle & FontStyle.Underline),
+            strikethrough: Boolean(fontStyle & FontStyle.Strikethrough),
         };
     }
 }
-export { TokenMetadata };
+export { ColorId, FontStyle, LanguageId, MetadataConsts, StandardTokenType, TokenMetadata };

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

@@ -1,8 +1,9 @@
 import { getLeadingWhitespace } from '../../../base/common/strings.js';
 import { IndentAction } from './languageConfiguration.js';
-import { createScopedLineTokens } from './supports.js';
-import { getScopedLineTokens } from './languageConfigurationRegistry.js';
-function getPrecedingValidLine(model, lineNumber, indentRulesSupport) {
+import { IndentConsts } from './supports/indentRules.js';
+import { EditorAutoIndentStrategy } from '../config/editorOptions.js';
+import { ProcessedIndentRulesSupport, isLanguageDifferentFromLineStart, IndentationContextProcessor } from './supports/indentationLineProcessor.js';
+function getPrecedingValidLine(model, lineNumber, processedIndentRulesSupport) {
     const languageId = model.tokenization.getLanguageIdAtPosition(lineNumber, 0);
     if (lineNumber > 1) {
         let lastLineNumber;
@@ -12,7 +13,7 @@ function getPrecedingValidLine(model, lineNumber, indentRulesSupport) {
                 return resultLineNumber;
             }
             const text = model.getLineContent(lastLineNumber);
-            if (indentRulesSupport.shouldIgnore(text) || /^\s+$/.test(text) || text === '') {
+            if (processedIndentRulesSupport.shouldIgnore(lastLineNumber) || /^\s+$/.test(text) || text === '') {
                 resultLineNumber = lastLineNumber;
                 continue;
             }
@@ -22,13 +23,14 @@ function getPrecedingValidLine(model, lineNumber, indentRulesSupport) {
     return -1;
 }
 function getInheritIndentForLine(autoIndent, model, lineNumber, honorIntentialIndent = true, languageConfigurationService) {
-    if (autoIndent < 4 ) {
+    if (autoIndent < EditorAutoIndentStrategy.Full) {
         return null;
     }
     const indentRulesSupport = languageConfigurationService.getLanguageConfiguration(model.tokenization.getLanguageId()).indentRulesSupport;
     if (!indentRulesSupport) {
         return null;
     }
+    const processedIndentRulesSupport = ( new ProcessedIndentRulesSupport(model, indentRulesSupport, languageConfigurationService));
     if (lineNumber <= 1) {
         return {
             indentation: '',
@@ -46,7 +48,7 @@ function getInheritIndentForLine(autoIndent, model, lineNumber, honorIntentialIn
             };
         }
     }
-    const precedingUnIgnoredLine = getPrecedingValidLine(model, lineNumber, indentRulesSupport);
+    const precedingUnIgnoredLine = getPrecedingValidLine(model, lineNumber, processedIndentRulesSupport);
     if (precedingUnIgnoredLine < 0) {
         return null;
     }
@@ -56,15 +58,16 @@ function getInheritIndentForLine(autoIndent, model, lineNumber, honorIntentialIn
             action: null
         };
     }
-    const precedingUnIgnoredLineContent = model.getLineContent(precedingUnIgnoredLine);
-    if (indentRulesSupport.shouldIncrease(precedingUnIgnoredLineContent) || indentRulesSupport.shouldIndentNextLine(precedingUnIgnoredLineContent)) {
+    if (processedIndentRulesSupport.shouldIncrease(precedingUnIgnoredLine) || processedIndentRulesSupport.shouldIndentNextLine(precedingUnIgnoredLine)) {
+        const precedingUnIgnoredLineContent = model.getLineContent(precedingUnIgnoredLine);
         return {
             indentation: getLeadingWhitespace(precedingUnIgnoredLineContent),
             action: IndentAction.Indent,
             line: precedingUnIgnoredLine
         };
     }
-    else if (indentRulesSupport.shouldDecrease(precedingUnIgnoredLineContent)) {
+    else if (processedIndentRulesSupport.shouldDecrease(precedingUnIgnoredLine)) {
+        const precedingUnIgnoredLineContent = model.getLineContent(precedingUnIgnoredLine);
         return {
             indentation: getLeadingWhitespace(precedingUnIgnoredLineContent),
             action: null,
@@ -81,11 +84,11 @@ function getInheritIndentForLine(autoIndent, model, lineNumber, honorIntentialIn
         }
         const previousLine = precedingUnIgnoredLine - 1;
         const previousLineIndentMetadata = indentRulesSupport.getIndentMetadata(model.getLineContent(previousLine));
-        if (!(previousLineIndentMetadata & (1  | 2 )) &&
-            (previousLineIndentMetadata & 4 )) {
+        if (!(previousLineIndentMetadata & (IndentConsts.INCREASE_MASK | IndentConsts.DECREASE_MASK)) &&
+            (previousLineIndentMetadata & IndentConsts.INDENT_NEXTLINE_MASK)) {
             let stopLine = 0;
             for (let i = previousLine - 1; i > 0; i--) {
-                if (indentRulesSupport.shouldIndentNextLine(model.getLineContent(i))) {
+                if (processedIndentRulesSupport.shouldIndentNextLine(i)) {
                     continue;
                 }
                 stopLine = i;
@@ -106,18 +109,17 @@ function getInheritIndentForLine(autoIndent, model, lineNumber, honorIntentialIn
         }
         else {
             for (let i = precedingUnIgnoredLine; i > 0; i--) {
-                const lineContent = model.getLineContent(i);
-                if (indentRulesSupport.shouldIncrease(lineContent)) {
+                if (processedIndentRulesSupport.shouldIncrease(i)) {
                     return {
-                        indentation: getLeadingWhitespace(lineContent),
+                        indentation: getLeadingWhitespace(model.getLineContent(i)),
                         action: IndentAction.Indent,
                         line: i
                     };
                 }
-                else if (indentRulesSupport.shouldIndentNextLine(lineContent)) {
+                else if (processedIndentRulesSupport.shouldIndentNextLine(i)) {
                     let stopLine = 0;
                     for (let j = i - 1; j > 0; j--) {
-                        if (indentRulesSupport.shouldIndentNextLine(model.getLineContent(i))) {
+                        if (processedIndentRulesSupport.shouldIndentNextLine(i)) {
                             continue;
                         }
                         stopLine = j;
@@ -129,9 +131,9 @@ function getInheritIndentForLine(autoIndent, model, lineNumber, honorIntentialIn
                         line: stopLine + 1
                     };
                 }
-                else if (indentRulesSupport.shouldDecrease(lineContent)) {
+                else if (processedIndentRulesSupport.shouldDecrease(i)) {
                     return {
-                        indentation: getLeadingWhitespace(lineContent),
+                        indentation: getLeadingWhitespace(model.getLineContent(i)),
                         action: null,
                         line: i
                     };
@@ -146,7 +148,7 @@ function getInheritIndentForLine(autoIndent, model, lineNumber, honorIntentialIn
     }
 }
 function getGoodIndentForLine(autoIndent, virtualModel, languageId, lineNumber, indentConverter, languageConfigurationService) {
-    if (autoIndent < 4 ) {
+    if (autoIndent < EditorAutoIndentStrategy.Full) {
         return null;
     }
     const richEditSupport = languageConfigurationService.getLanguageConfiguration(languageId);
@@ -157,8 +159,8 @@ function getGoodIndentForLine(autoIndent, virtualModel, languageId, lineNumber,
     if (!indentRulesSupport) {
         return null;
     }
+    const processedIndentRulesSupport = ( new ProcessedIndentRulesSupport(virtualModel, indentRulesSupport, languageConfigurationService));
     const indent = getInheritIndentForLine(autoIndent, virtualModel, lineNumber, undefined, languageConfigurationService);
-    const lineContent = virtualModel.getLineContent(lineNumber);
     if (indent) {
         const inheritLine = indent.line;
         if (inheritLine !== undefined) {
@@ -183,7 +185,7 @@ function getGoodIndentForLine(autoIndent, virtualModel, languageId, lineNumber,
                     else if (enterResult.indentAction === IndentAction.Outdent) {
                         indentation = indentConverter.unshiftIndent(indentation);
                     }
-                    if (indentRulesSupport.shouldDecrease(lineContent)) {
+                    if (processedIndentRulesSupport.shouldDecrease(lineNumber)) {
                         indentation = indentConverter.unshiftIndent(indentation);
                     }
                     if (enterResult.appendText) {
@@ -193,7 +195,7 @@ function getGoodIndentForLine(autoIndent, virtualModel, languageId, lineNumber,
                 }
             }
         }
-        if (indentRulesSupport.shouldDecrease(lineContent)) {
+        if (processedIndentRulesSupport.shouldDecrease(lineNumber)) {
             if (indent.action === IndentAction.Indent) {
                 return indent.indentation;
             }
@@ -213,101 +215,64 @@ function getGoodIndentForLine(autoIndent, virtualModel, languageId, lineNumber,
     return null;
 }
 function getIndentForEnter(autoIndent, model, range, indentConverter, languageConfigurationService) {
-    if (autoIndent < 4 ) {
+    if (autoIndent < EditorAutoIndentStrategy.Full) {
         return null;
     }
-    model.tokenization.forceTokenization(range.startLineNumber);
-    const lineTokens = model.tokenization.getLineTokens(range.startLineNumber);
-    const scopedLineTokens = createScopedLineTokens(lineTokens, range.startColumn - 1);
-    const scopedLineText = scopedLineTokens.getLineContent();
-    let embeddedLanguage = false;
-    let beforeEnterText;
-    if (scopedLineTokens.firstCharOffset > 0 && lineTokens.getLanguageId(0) !== scopedLineTokens.languageId) {
-        embeddedLanguage = true;
-        beforeEnterText = scopedLineText.substr(0, range.startColumn - 1 - scopedLineTokens.firstCharOffset);
-    }
-    else {
-        beforeEnterText = lineTokens.getLineContent().substring(0, range.startColumn - 1);
-    }
-    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);
-    }
-    const indentRulesSupport = languageConfigurationService.getLanguageConfiguration(scopedLineTokens.languageId).indentRulesSupport;
+    const languageId = model.getLanguageIdAtPosition(range.startLineNumber, range.startColumn);
+    const indentRulesSupport = languageConfigurationService.getLanguageConfiguration(languageId).indentRulesSupport;
     if (!indentRulesSupport) {
         return null;
     }
-    const beforeEnterResult = beforeEnterText;
-    const beforeEnterIndent = getLeadingWhitespace(beforeEnterText);
-    const virtualModel = {
-        tokenization: {
-            getLineTokens: (lineNumber) => {
-                return model.tokenization.getLineTokens(lineNumber);
-            },
-            getLanguageId: () => {
-                return model.getLanguageId();
-            },
-            getLanguageIdAtPosition: (lineNumber, column) => {
-                return model.getLanguageIdAtPosition(lineNumber, column);
-            },
-        },
-        getLineContent: (lineNumber) => {
-            if (lineNumber === range.startLineNumber) {
-                return beforeEnterResult;
-            }
-            else {
-                return model.getLineContent(lineNumber);
-            }
-        }
-    };
-    const currentLineIndent = getLeadingWhitespace(lineTokens.getLineContent());
+    model.tokenization.forceTokenization(range.startLineNumber);
+    const indentationContextProcessor = ( new IndentationContextProcessor(model, languageConfigurationService));
+    const processedContextTokens = indentationContextProcessor.getProcessedTokenContextAroundRange(range);
+    const afterEnterProcessedTokens = processedContextTokens.afterRangeProcessedTokens;
+    const beforeEnterProcessedTokens = processedContextTokens.beforeRangeProcessedTokens;
+    const beforeEnterIndent = getLeadingWhitespace(beforeEnterProcessedTokens.getLineContent());
+    const virtualModel = createVirtualModelWithModifiedTokensAtLine(model, range.startLineNumber, beforeEnterProcessedTokens);
+    const languageIsDifferentFromLineStart = isLanguageDifferentFromLineStart(model, range.getStartPosition());
+    const currentLine = model.getLineContent(range.startLineNumber);
+    const currentLineIndent = getLeadingWhitespace(currentLine);
     const afterEnterAction = getInheritIndentForLine(autoIndent, virtualModel, range.startLineNumber + 1, undefined, languageConfigurationService);
     if (!afterEnterAction) {
-        const beforeEnter = embeddedLanguage ? currentLineIndent : beforeEnterIndent;
+        const beforeEnter = languageIsDifferentFromLineStart ? currentLineIndent : beforeEnterIndent;
         return {
             beforeEnter: beforeEnter,
             afterEnter: beforeEnter
         };
     }
-    let afterEnterIndent = embeddedLanguage ? currentLineIndent : afterEnterAction.indentation;
+    let afterEnterIndent = languageIsDifferentFromLineStart ? currentLineIndent : afterEnterAction.indentation;
     if (afterEnterAction.action === IndentAction.Indent) {
         afterEnterIndent = indentConverter.shiftIndent(afterEnterIndent);
     }
-    if (indentRulesSupport.shouldDecrease(afterEnterText)) {
+    if (indentRulesSupport.shouldDecrease(afterEnterProcessedTokens.getLineContent())) {
         afterEnterIndent = indentConverter.unshiftIndent(afterEnterIndent);
     }
     return {
-        beforeEnter: embeddedLanguage ? currentLineIndent : beforeEnterIndent,
+        beforeEnter: languageIsDifferentFromLineStart ? currentLineIndent : beforeEnterIndent,
         afterEnter: afterEnterIndent
     };
 }
 function getIndentActionForType(autoIndent, model, range, ch, indentConverter, languageConfigurationService) {
-    if (autoIndent < 4 ) {
+    if (autoIndent < EditorAutoIndentStrategy.Full) {
         return null;
     }
-    const scopedLineTokens = getScopedLineTokens(model, range.startLineNumber, range.startColumn);
-    if (scopedLineTokens.firstCharOffset) {
+    const languageIsDifferentFromLineStart = isLanguageDifferentFromLineStart(model, range.getStartPosition());
+    if (languageIsDifferentFromLineStart) {
         return null;
     }
-    const indentRulesSupport = languageConfigurationService.getLanguageConfiguration(scopedLineTokens.languageId).indentRulesSupport;
+    const languageId = model.getLanguageIdAtPosition(range.startLineNumber, range.startColumn);
+    const indentRulesSupport = languageConfigurationService.getLanguageConfiguration(languageId).indentRulesSupport;
     if (!indentRulesSupport) {
         return null;
     }
-    const scopedLineText = scopedLineTokens.getLineContent();
-    const beforeTypeText = scopedLineText.substr(0, range.startColumn - 1 - scopedLineTokens.firstCharOffset);
-    let afterTypeText;
-    if (range.isEmpty()) {
-        afterTypeText = scopedLineText.substr(range.startColumn - 1 - scopedLineTokens.firstCharOffset);
-    }
-    else {
-        const endScopedLineTokens = getScopedLineTokens(model, range.endLineNumber, range.endColumn);
-        afterTypeText = endScopedLineTokens.getLineContent().substr(range.endColumn - 1 - scopedLineTokens.firstCharOffset);
-    }
-    if (!indentRulesSupport.shouldDecrease(beforeTypeText + afterTypeText) && indentRulesSupport.shouldDecrease(beforeTypeText + ch + afterTypeText)) {
+    const indentationContextProcessor = ( new IndentationContextProcessor(model, languageConfigurationService));
+    const processedContextTokens = indentationContextProcessor.getProcessedTokenContextAroundRange(range);
+    const beforeRangeText = processedContextTokens.beforeRangeProcessedTokens.getLineContent();
+    const afterRangeText = processedContextTokens.afterRangeProcessedTokens.getLineContent();
+    const textAroundRange = beforeRangeText + afterRangeText;
+    const textAroundRangeWithCharacter = beforeRangeText + ch + afterRangeText;
+    if (!indentRulesSupport.shouldDecrease(textAroundRange) && indentRulesSupport.shouldDecrease(textAroundRangeWithCharacter)) {
         const r = getInheritIndentForLine(autoIndent, model, range.startLineNumber, false, languageConfigurationService);
         if (!r) {
             return null;
@@ -330,4 +295,33 @@ function getIndentMetadata(model, lineNumber, languageConfigurationService) {
     }
     return indentRulesSupport.getIndentMetadata(model.getLineContent(lineNumber));
 }
+function createVirtualModelWithModifiedTokensAtLine(model, modifiedLineNumber, modifiedTokens) {
+    const virtualModel = {
+        tokenization: {
+            getLineTokens: (lineNumber) => {
+                if (lineNumber === modifiedLineNumber) {
+                    return modifiedTokens;
+                }
+                else {
+                    return model.tokenization.getLineTokens(lineNumber);
+                }
+            },
+            getLanguageId: () => {
+                return model.getLanguageId();
+            },
+            getLanguageIdAtPosition: (lineNumber, column) => {
+                return model.getLanguageIdAtPosition(lineNumber, column);
+            },
+        },
+        getLineContent: (lineNumber) => {
+            if (lineNumber === modifiedLineNumber) {
+                return modifiedTokens.getLineContent();
+            }
+            else {
+                return model.getLineContent(lineNumber);
+            }
+        }
+    };
+    return virtualModel;
+}
 export { getGoodIndentForLine, getIndentActionForType, getIndentForEnter, getIndentMetadata, getInheritIndentForLine };