monaco-editor11 1.0.7 → 1.0.9

package/dist/workers/editor/common/semanticTokensProviderStyling.js

@@ -0,0 +1,263 @@
+import { IThemeService } from '../../../platform/theme/common/themeService.js';
+import { ILogService } from '../../../platform/log/common/log.js';
+import { SparseMultilineTokens } from '../tokens/sparseMultilineTokens.js';
+import { ILanguageService } from '../languages/language.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (undefined && undefined.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+let SemanticTokensProviderStyling = class SemanticTokensProviderStyling {
+    constructor(_legend, _themeService, _languageService, _logService) {
+        this._legend = _legend;
+        this._themeService = _themeService;
+        this._languageService = _languageService;
+        this._logService = _logService;
+        this._hasWarnedOverlappingTokens = false;
+        this._hasWarnedInvalidLengthTokens = false;
+        this._hasWarnedInvalidEditStart = false;
+        this._hashTable = new HashTable();
+    }
+    getMetadata(tokenTypeIndex, tokenModifierSet, languageId) {
+        const encodedLanguageId = this._languageService.languageIdCodec.encodeLanguageId(languageId);
+        const entry = this._hashTable.get(tokenTypeIndex, tokenModifierSet, encodedLanguageId);
+        let metadata;
+        if (entry) {
+            metadata = entry.metadata;
+        }
+        else {
+            let tokenType = this._legend.tokenTypes[tokenTypeIndex];
+            const tokenModifiers = [];
+            if (tokenType) {
+                let modifierSet = tokenModifierSet;
+                for (let modifierIndex = 0; modifierSet > 0 && modifierIndex < this._legend.tokenModifiers.length; modifierIndex++) {
+                    if (modifierSet & 1) {
+                        tokenModifiers.push(this._legend.tokenModifiers[modifierIndex]);
+                    }
+                    modifierSet = modifierSet >> 1;
+                }
+                const tokenStyle = this._themeService.getColorTheme().getTokenStyleMetadata(tokenType, tokenModifiers, languageId);
+                if (typeof tokenStyle === 'undefined') {
+                    metadata = 2147483647 /* SemanticTokensProviderStylingConstants.NO_STYLING */;
+                }
+                else {
+                    metadata = 0;
+                    if (typeof tokenStyle.italic !== 'undefined') {
+                        const italicBit = (tokenStyle.italic ? 1 /* FontStyle.Italic */ : 0) << 11 /* MetadataConsts.FONT_STYLE_OFFSET */;
+                        metadata |= italicBit | 1 /* MetadataConsts.SEMANTIC_USE_ITALIC */;
+                    }
+                    if (typeof tokenStyle.bold !== 'undefined') {
+                        const boldBit = (tokenStyle.bold ? 2 /* FontStyle.Bold */ : 0) << 11 /* MetadataConsts.FONT_STYLE_OFFSET */;
+                        metadata |= boldBit | 2 /* MetadataConsts.SEMANTIC_USE_BOLD */;
+                    }
+                    if (typeof tokenStyle.underline !== 'undefined') {
+                        const underlineBit = (tokenStyle.underline ? 4 /* FontStyle.Underline */ : 0) << 11 /* MetadataConsts.FONT_STYLE_OFFSET */;
+                        metadata |= underlineBit | 4 /* MetadataConsts.SEMANTIC_USE_UNDERLINE */;
+                    }
+                    if (typeof tokenStyle.strikethrough !== 'undefined') {
+                        const strikethroughBit = (tokenStyle.strikethrough ? 8 /* FontStyle.Strikethrough */ : 0) << 11 /* MetadataConsts.FONT_STYLE_OFFSET */;
+                        metadata |= strikethroughBit | 8 /* MetadataConsts.SEMANTIC_USE_STRIKETHROUGH */;
+                    }
+                    if (tokenStyle.foreground) {
+                        const foregroundBits = (tokenStyle.foreground) << 15 /* MetadataConsts.FOREGROUND_OFFSET */;
+                        metadata |= foregroundBits | 16 /* MetadataConsts.SEMANTIC_USE_FOREGROUND */;
+                    }
+                    if (metadata === 0) {
+                        // Nothing!
+                        metadata = 2147483647 /* SemanticTokensProviderStylingConstants.NO_STYLING */;
+                    }
+                }
+            }
+            else {
+                metadata = 2147483647 /* SemanticTokensProviderStylingConstants.NO_STYLING */;
+                tokenType = 'not-in-legend';
+            }
+            this._hashTable.add(tokenTypeIndex, tokenModifierSet, encodedLanguageId, metadata);
+        }
+        return metadata;
+    }
+    warnOverlappingSemanticTokens(lineNumber, startColumn) {
+        if (!this._hasWarnedOverlappingTokens) {
+            this._hasWarnedOverlappingTokens = true;
+            this._logService.warn(`Overlapping semantic tokens detected at lineNumber ${lineNumber}, column ${startColumn}`);
+        }
+    }
+    warnInvalidLengthSemanticTokens(lineNumber, startColumn) {
+        if (!this._hasWarnedInvalidLengthTokens) {
+            this._hasWarnedInvalidLengthTokens = true;
+            this._logService.warn(`Semantic token with invalid length detected at lineNumber ${lineNumber}, column ${startColumn}`);
+        }
+    }
+    warnInvalidEditStart(previousResultId, resultId, editIndex, editStart, maxExpectedStart) {
+        if (!this._hasWarnedInvalidEditStart) {
+            this._hasWarnedInvalidEditStart = true;
+            this._logService.warn(`Invalid semantic tokens edit detected (previousResultId: ${previousResultId}, resultId: ${resultId}) at edit #${editIndex}: The provided start offset ${editStart} is outside the previous data (length ${maxExpectedStart}).`);
+        }
+    }
+};
+SemanticTokensProviderStyling = __decorate([
+    __param(1, IThemeService),
+    __param(2, ILanguageService),
+    __param(3, ILogService)
+], SemanticTokensProviderStyling);
+function toMultilineTokens2(tokens, styling, languageId) {
+    const srcData = tokens.data;
+    const tokenCount = (tokens.data.length / 5) | 0;
+    const tokensPerArea = Math.max(Math.ceil(tokenCount / 1024 /* SemanticColoringConstants.DesiredMaxAreas */), 400 /* SemanticColoringConstants.DesiredTokensPerArea */);
+    const result = [];
+    let tokenIndex = 0;
+    let lastLineNumber = 1;
+    let lastStartCharacter = 0;
+    while (tokenIndex < tokenCount) {
+        const tokenStartIndex = tokenIndex;
+        let tokenEndIndex = Math.min(tokenStartIndex + tokensPerArea, tokenCount);
+        // Keep tokens on the same line in the same area...
+        if (tokenEndIndex < tokenCount) {
+            let smallTokenEndIndex = tokenEndIndex;
+            while (smallTokenEndIndex - 1 > tokenStartIndex && srcData[5 * smallTokenEndIndex] === 0) {
+                smallTokenEndIndex--;
+            }
+            if (smallTokenEndIndex - 1 === tokenStartIndex) {
+                // there are so many tokens on this line that our area would be empty, we must now go right
+                let bigTokenEndIndex = tokenEndIndex;
+                while (bigTokenEndIndex + 1 < tokenCount && srcData[5 * bigTokenEndIndex] === 0) {
+                    bigTokenEndIndex++;
+                }
+                tokenEndIndex = bigTokenEndIndex;
+            }
+            else {
+                tokenEndIndex = smallTokenEndIndex;
+            }
+        }
+        let destData = new Uint32Array((tokenEndIndex - tokenStartIndex) * 4);
+        let destOffset = 0;
+        let areaLine = 0;
+        let prevLineNumber = 0;
+        let prevEndCharacter = 0;
+        while (tokenIndex < tokenEndIndex) {
+            const srcOffset = 5 * tokenIndex;
+            const deltaLine = srcData[srcOffset];
+            const deltaCharacter = srcData[srcOffset + 1];
+            // Casting both `lineNumber`, `startCharacter` and `endCharacter` here to uint32 using `|0`
+            // to validate below with the actual values that will be inserted in the Uint32Array result
+            const lineNumber = (lastLineNumber + deltaLine) | 0;
+            const startCharacter = (deltaLine === 0 ? (lastStartCharacter + deltaCharacter) | 0 : deltaCharacter);
+            const length = srcData[srcOffset + 2];
+            const endCharacter = (startCharacter + length) | 0;
+            const tokenTypeIndex = srcData[srcOffset + 3];
+            const tokenModifierSet = srcData[srcOffset + 4];
+            if (endCharacter <= startCharacter) {
+                // this token is invalid (most likely a negative length casted to uint32)
+                styling.warnInvalidLengthSemanticTokens(lineNumber, startCharacter + 1);
+            }
+            else if (prevLineNumber === lineNumber && prevEndCharacter > startCharacter) {
+                // this token overlaps with the previous token
+                styling.warnOverlappingSemanticTokens(lineNumber, startCharacter + 1);
+            }
+            else {
+                const metadata = styling.getMetadata(tokenTypeIndex, tokenModifierSet, languageId);
+                if (metadata !== 2147483647 /* SemanticTokensProviderStylingConstants.NO_STYLING */) {
+                    if (areaLine === 0) {
+                        areaLine = lineNumber;
+                    }
+                    destData[destOffset] = lineNumber - areaLine;
+                    destData[destOffset + 1] = startCharacter;
+                    destData[destOffset + 2] = endCharacter;
+                    destData[destOffset + 3] = metadata;
+                    destOffset += 4;
+                    prevLineNumber = lineNumber;
+                    prevEndCharacter = endCharacter;
+                }
+            }
+            lastLineNumber = lineNumber;
+            lastStartCharacter = startCharacter;
+            tokenIndex++;
+        }
+        if (destOffset !== destData.length) {
+            destData = destData.subarray(0, destOffset);
+        }
+        const tokens = SparseMultilineTokens.create(areaLine, destData);
+        result.push(tokens);
+    }
+    return result;
+}
+class HashTableEntry {
+    constructor(tokenTypeIndex, tokenModifierSet, languageId, metadata) {
+        this.tokenTypeIndex = tokenTypeIndex;
+        this.tokenModifierSet = tokenModifierSet;
+        this.languageId = languageId;
+        this.metadata = metadata;
+        this.next = null;
+    }
+}
+class HashTable {
+    static { this._SIZES = [3, 7, 13, 31, 61, 127, 251, 509, 1021, 2039, 4093, 8191, 16381, 32749, 65521, 131071, 262139, 524287, 1048573, 2097143]; }
+    constructor() {
+        this._elementsCount = 0;
+        this._currentLengthIndex = 0;
+        this._currentLength = HashTable._SIZES[this._currentLengthIndex];
+        this._growCount = Math.round(this._currentLengthIndex + 1 < HashTable._SIZES.length ? 2 / 3 * this._currentLength : 0);
+        this._elements = [];
+        HashTable._nullOutEntries(this._elements, this._currentLength);
+    }
+    static _nullOutEntries(entries, length) {
+        for (let i = 0; i < length; i++) {
+            entries[i] = null;
+        }
+    }
+    _hash2(n1, n2) {
+        return (((n1 << 5) - n1) + n2) | 0; // n1 * 31 + n2, keep as int32
+    }
+    _hashFunc(tokenTypeIndex, tokenModifierSet, languageId) {
+        return this._hash2(this._hash2(tokenTypeIndex, tokenModifierSet), languageId) % this._currentLength;
+    }
+    get(tokenTypeIndex, tokenModifierSet, languageId) {
+        const hash = this._hashFunc(tokenTypeIndex, tokenModifierSet, languageId);
+        let p = this._elements[hash];
+        while (p) {
+            if (p.tokenTypeIndex === tokenTypeIndex && p.tokenModifierSet === tokenModifierSet && p.languageId === languageId) {
+                return p;
+            }
+            p = p.next;
+        }
+        return null;
+    }
+    add(tokenTypeIndex, tokenModifierSet, languageId, metadata) {
+        this._elementsCount++;
+        if (this._growCount !== 0 && this._elementsCount >= this._growCount) {
+            // expand!
+            const oldElements = this._elements;
+            this._currentLengthIndex++;
+            this._currentLength = HashTable._SIZES[this._currentLengthIndex];
+            this._growCount = Math.round(this._currentLengthIndex + 1 < HashTable._SIZES.length ? 2 / 3 * this._currentLength : 0);
+            this._elements = [];
+            HashTable._nullOutEntries(this._elements, this._currentLength);
+            for (const first of oldElements) {
+                let p = first;
+                while (p) {
+                    const oldNext = p.next;
+                    p.next = null;
+                    this._add(p);
+                    p = oldNext;
+                }
+            }
+        }
+        this._add(new HashTableEntry(tokenTypeIndex, tokenModifierSet, languageId, metadata));
+    }
+    _add(element) {
+        const hash = this._hashFunc(element.tokenTypeIndex, element.tokenModifierSet, element.languageId);
+        element.next = this._elements[hash];
+        this._elements[hash] = element;
+    }
+}
+
+export { SemanticTokensProviderStyling, toMultilineTokens2 };

package/dist/workers/editor/common/semanticTokensStyling.js

@@ -0,0 +1,9 @@
+import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const ISemanticTokensStylingService = createDecorator('semanticTokensStylingService');
+
+export { ISemanticTokensStylingService };

package/dist/workers/editor/common/semanticTokensStylingService.js

@@ -0,0 +1,47 @@
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { ILanguageService } from '../languages/language.js';
+import { IThemeService } from '../../../platform/theme/common/themeService.js';
+import { ILogService } from '../../../platform/log/common/log.js';
+import { SemanticTokensProviderStyling } from './semanticTokensProviderStyling.js';
+import { ISemanticTokensStylingService } from './semanticTokensStyling.js';
+import { registerSingleton } from '../../../platform/instantiation/common/extensions.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (undefined && undefined.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+let SemanticTokensStylingService = class SemanticTokensStylingService extends Disposable {
+    constructor(_themeService, _logService, _languageService) {
+        super();
+        this._themeService = _themeService;
+        this._logService = _logService;
+        this._languageService = _languageService;
+        this._caches = new WeakMap();
+        this._register(this._themeService.onDidColorThemeChange(() => {
+            this._caches = new WeakMap();
+        }));
+    }
+    getStyling(provider) {
+        if (!this._caches.has(provider)) {
+            this._caches.set(provider, new SemanticTokensProviderStyling(provider.getLegend(), this._themeService, this._languageService, this._logService));
+        }
+        return this._caches.get(provider);
+    }
+};
+SemanticTokensStylingService = __decorate([
+    __param(0, IThemeService),
+    __param(1, ILogService),
+    __param(2, ILanguageService)
+], SemanticTokensStylingService);
+registerSingleton(ISemanticTokensStylingService, SemanticTokensStylingService, 1 /* InstantiationType.Delayed */);
+
+export { SemanticTokensStylingService };

package/dist/workers/editor/common/shiftCommand.js

@@ -0,0 +1,241 @@
+import { firstNonWhitespaceIndex } from '../../../base/common/strings.js';
+import { CursorColumns } from '../core/cursorColumns.js';
+import { Range } from '../core/range.js';
+import { Selection } from '../core/selection.js';
+import { getEnterAction } from '../languages/enterAction.js';
+import { ILanguageConfigurationService } from '../languages/languageConfigurationRegistry.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (undefined && undefined.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var ShiftCommand_1;
+const repeatCache = Object.create(null);
+function cachedStringRepeat(str, count) {
+    if (count <= 0) {
+        return '';
+    }
+    if (!repeatCache[str]) {
+        repeatCache[str] = ['', str];
+    }
+    const cache = repeatCache[str];
+    for (let i = cache.length; i <= count; i++) {
+        cache[i] = cache[i - 1] + str;
+    }
+    return cache[count];
+}
+let ShiftCommand = ShiftCommand_1 = class ShiftCommand {
+    static unshiftIndent(line, column, tabSize, indentSize, insertSpaces) {
+        // Determine the visible column where the content starts
+        const contentStartVisibleColumn = CursorColumns.visibleColumnFromColumn(line, column, tabSize);
+        if (insertSpaces) {
+            const indent = cachedStringRepeat(' ', indentSize);
+            const desiredTabStop = CursorColumns.prevIndentTabStop(contentStartVisibleColumn, indentSize);
+            const indentCount = desiredTabStop / indentSize; // will be an integer
+            return cachedStringRepeat(indent, indentCount);
+        }
+        else {
+            const indent = '\t';
+            const desiredTabStop = CursorColumns.prevRenderTabStop(contentStartVisibleColumn, tabSize);
+            const indentCount = desiredTabStop / tabSize; // will be an integer
+            return cachedStringRepeat(indent, indentCount);
+        }
+    }
+    static shiftIndent(line, column, tabSize, indentSize, insertSpaces) {
+        // Determine the visible column where the content starts
+        const contentStartVisibleColumn = CursorColumns.visibleColumnFromColumn(line, column, tabSize);
+        if (insertSpaces) {
+            const indent = cachedStringRepeat(' ', indentSize);
+            const desiredTabStop = CursorColumns.nextIndentTabStop(contentStartVisibleColumn, indentSize);
+            const indentCount = desiredTabStop / indentSize; // will be an integer
+            return cachedStringRepeat(indent, indentCount);
+        }
+        else {
+            const indent = '\t';
+            const desiredTabStop = CursorColumns.nextRenderTabStop(contentStartVisibleColumn, tabSize);
+            const indentCount = desiredTabStop / tabSize; // will be an integer
+            return cachedStringRepeat(indent, indentCount);
+        }
+    }
+    constructor(range, opts, _languageConfigurationService) {
+        this._languageConfigurationService = _languageConfigurationService;
+        this._opts = opts;
+        this._selection = range;
+        this._selectionId = null;
+        this._useLastEditRangeForCursorEndPosition = false;
+        this._selectionStartColumnStaysPut = false;
+    }
+    _addEditOperation(builder, range, text) {
+        if (this._useLastEditRangeForCursorEndPosition) {
+            builder.addTrackedEditOperation(range, text);
+        }
+        else {
+            builder.addEditOperation(range, text);
+        }
+    }
+    getEditOperations(model, builder) {
+        const startLine = this._selection.startLineNumber;
+        let endLine = this._selection.endLineNumber;
+        if (this._selection.endColumn === 1 && startLine !== endLine) {
+            endLine = endLine - 1;
+        }
+        const { tabSize, indentSize, insertSpaces } = this._opts;
+        const shouldIndentEmptyLines = (startLine === endLine);
+        if (this._opts.useTabStops) {
+            // if indenting or outdenting on a whitespace only line
+            if (this._selection.isEmpty()) {
+                if (/^\s*$/.test(model.getLineContent(startLine))) {
+                    this._useLastEditRangeForCursorEndPosition = true;
+                }
+            }
+            // keep track of previous line's "miss-alignment"
+            let previousLineExtraSpaces = 0, extraSpaces = 0;
+            for (let lineNumber = startLine; lineNumber <= endLine; lineNumber++, previousLineExtraSpaces = extraSpaces) {
+                extraSpaces = 0;
+                const lineText = model.getLineContent(lineNumber);
+                let indentationEndIndex = firstNonWhitespaceIndex(lineText);
+                if (this._opts.isUnshift && (lineText.length === 0 || indentationEndIndex === 0)) {
+                    // empty line or line with no leading whitespace => nothing to do
+                    continue;
+                }
+                if (!shouldIndentEmptyLines && !this._opts.isUnshift && lineText.length === 0) {
+                    // do not indent empty lines => nothing to do
+                    continue;
+                }
+                if (indentationEndIndex === -1) {
+                    // the entire line is whitespace
+                    indentationEndIndex = lineText.length;
+                }
+                if (lineNumber > 1) {
+                    const contentStartVisibleColumn = CursorColumns.visibleColumnFromColumn(lineText, indentationEndIndex + 1, tabSize);
+                    if (contentStartVisibleColumn % indentSize !== 0) {
+                        // The current line is "miss-aligned", so let's see if this is expected...
+                        // This can only happen when it has trailing commas in the indent
+                        if (model.tokenization.isCheapToTokenize(lineNumber - 1)) {
+                            const enterAction = getEnterAction(this._opts.autoIndent, model, new Range(lineNumber - 1, model.getLineMaxColumn(lineNumber - 1), lineNumber - 1, model.getLineMaxColumn(lineNumber - 1)), this._languageConfigurationService);
+                            if (enterAction) {
+                                extraSpaces = previousLineExtraSpaces;
+                                if (enterAction.appendText) {
+                                    for (let j = 0, lenJ = enterAction.appendText.length; j < lenJ && extraSpaces < indentSize; j++) {
+                                        if (enterAction.appendText.charCodeAt(j) === 32 /* CharCode.Space */) {
+                                            extraSpaces++;
+                                        }
+                                        else {
+                                            break;
+                                        }
+                                    }
+                                }
+                                if (enterAction.removeText) {
+                                    extraSpaces = Math.max(0, extraSpaces - enterAction.removeText);
+                                }
+                                // Act as if `prefixSpaces` is not part of the indentation
+                                for (let j = 0; j < extraSpaces; j++) {
+                                    if (indentationEndIndex === 0 || lineText.charCodeAt(indentationEndIndex - 1) !== 32 /* CharCode.Space */) {
+                                        break;
+                                    }
+                                    indentationEndIndex--;
+                                }
+                            }
+                        }
+                    }
+                }
+                if (this._opts.isUnshift && indentationEndIndex === 0) {
+                    // line with no leading whitespace => nothing to do
+                    continue;
+                }
+                let desiredIndent;
+                if (this._opts.isUnshift) {
+                    desiredIndent = ShiftCommand_1.unshiftIndent(lineText, indentationEndIndex + 1, tabSize, indentSize, insertSpaces);
+                }
+                else {
+                    desiredIndent = ShiftCommand_1.shiftIndent(lineText, indentationEndIndex + 1, tabSize, indentSize, insertSpaces);
+                }
+                this._addEditOperation(builder, new Range(lineNumber, 1, lineNumber, indentationEndIndex + 1), desiredIndent);
+                if (lineNumber === startLine && !this._selection.isEmpty()) {
+                    // Force the startColumn to stay put because we're inserting after it
+                    this._selectionStartColumnStaysPut = (this._selection.startColumn <= indentationEndIndex + 1);
+                }
+            }
+        }
+        else {
+            // if indenting or outdenting on a whitespace only line
+            if (!this._opts.isUnshift && this._selection.isEmpty() && model.getLineLength(startLine) === 0) {
+                this._useLastEditRangeForCursorEndPosition = true;
+            }
+            const oneIndent = (insertSpaces ? cachedStringRepeat(' ', indentSize) : '\t');
+            for (let lineNumber = startLine; lineNumber <= endLine; lineNumber++) {
+                const lineText = model.getLineContent(lineNumber);
+                let indentationEndIndex = firstNonWhitespaceIndex(lineText);
+                if (this._opts.isUnshift && (lineText.length === 0 || indentationEndIndex === 0)) {
+                    // empty line or line with no leading whitespace => nothing to do
+                    continue;
+                }
+                if (!shouldIndentEmptyLines && !this._opts.isUnshift && lineText.length === 0) {
+                    // do not indent empty lines => nothing to do
+                    continue;
+                }
+                if (indentationEndIndex === -1) {
+                    // the entire line is whitespace
+                    indentationEndIndex = lineText.length;
+                }
+                if (this._opts.isUnshift && indentationEndIndex === 0) {
+                    // line with no leading whitespace => nothing to do
+                    continue;
+                }
+                if (this._opts.isUnshift) {
+                    indentationEndIndex = Math.min(indentationEndIndex, indentSize);
+                    for (let i = 0; i < indentationEndIndex; i++) {
+                        const chr = lineText.charCodeAt(i);
+                        if (chr === 9 /* CharCode.Tab */) {
+                            indentationEndIndex = i + 1;
+                            break;
+                        }
+                    }
+                    this._addEditOperation(builder, new Range(lineNumber, 1, lineNumber, indentationEndIndex + 1), '');
+                }
+                else {
+                    this._addEditOperation(builder, new Range(lineNumber, 1, lineNumber, 1), oneIndent);
+                    if (lineNumber === startLine && !this._selection.isEmpty()) {
+                        // Force the startColumn to stay put because we're inserting after it
+                        this._selectionStartColumnStaysPut = (this._selection.startColumn === 1);
+                    }
+                }
+            }
+        }
+        this._selectionId = builder.trackSelection(this._selection);
+    }
+    computeCursorState(model, helper) {
+        if (this._useLastEditRangeForCursorEndPosition) {
+            const lastOp = helper.getInverseEditOperations()[0];
+            return new Selection(lastOp.range.endLineNumber, lastOp.range.endColumn, lastOp.range.endLineNumber, lastOp.range.endColumn);
+        }
+        const result = helper.getTrackedSelection(this._selectionId);
+        if (this._selectionStartColumnStaysPut) {
+            // The selection start should not move
+            const initialStartColumn = this._selection.startColumn;
+            const resultStartColumn = result.startColumn;
+            if (resultStartColumn <= initialStartColumn) {
+                return result;
+            }
+            if (result.getDirection() === 0 /* SelectionDirection.LTR */) {
+                return new Selection(result.startLineNumber, initialStartColumn, result.endLineNumber, result.endColumn);
+            }
+            return new Selection(result.endLineNumber, result.endColumn, result.startLineNumber, initialStartColumn);
+        }
+        return result;
+    }
+};
+ShiftCommand = ShiftCommand_1 = __decorate([
+    __param(2, ILanguageConfigurationService)
+], ShiftCommand);
+
+export { ShiftCommand };

package/dist/workers/editor/common/smallImmutableSet.js

@@ -0,0 +1,108 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const emptyArr = [];
+/**
+ * Represents an immutable set that works best for a small number of elements (less than 32).
+ * It uses bits to encode element membership efficiently.
+*/
+class SmallImmutableSet {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static { this.cache = new Array(129); }
+    static create(items, additionalItems) {
+        if (items <= 128 && additionalItems.length === 0) {
+            // We create a cache of 128=2^7 elements to cover all sets with up to 7 (dense) elements.
+            let cached = SmallImmutableSet.cache[items];
+            if (!cached) {
+                cached = new SmallImmutableSet(items, additionalItems);
+                SmallImmutableSet.cache[items] = cached;
+            }
+            return cached;
+        }
+        return new SmallImmutableSet(items, additionalItems);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static { this.empty = SmallImmutableSet.create(0, emptyArr); }
+    static getEmpty() {
+        return this.empty;
+    }
+    constructor(items, additionalItems) {
+        this.items = items;
+        this.additionalItems = additionalItems;
+    }
+    add(value, keyProvider) {
+        const key = keyProvider.getKey(value);
+        let idx = key >> 5; // divided by 32
+        if (idx === 0) {
+            // fast path
+            const newItem = (1 << key) | this.items;
+            if (newItem === this.items) {
+                return this;
+            }
+            return SmallImmutableSet.create(newItem, this.additionalItems);
+        }
+        idx--;
+        const newItems = this.additionalItems.slice(0);
+        while (newItems.length < idx) {
+            newItems.push(0);
+        }
+        newItems[idx] |= 1 << (key & 31);
+        return SmallImmutableSet.create(this.items, newItems);
+    }
+    merge(other) {
+        const merged = this.items | other.items;
+        if (this.additionalItems === emptyArr && other.additionalItems === emptyArr) {
+            // fast path
+            if (merged === this.items) {
+                return this;
+            }
+            if (merged === other.items) {
+                return other;
+            }
+            return SmallImmutableSet.create(merged, emptyArr);
+        }
+        // This can be optimized, but it's not a common case
+        const newItems = [];
+        for (let i = 0; i < Math.max(this.additionalItems.length, other.additionalItems.length); i++) {
+            const item1 = this.additionalItems[i] || 0;
+            const item2 = other.additionalItems[i] || 0;
+            newItems.push(item1 | item2);
+        }
+        return SmallImmutableSet.create(merged, newItems);
+    }
+    intersects(other) {
+        if ((this.items & other.items) !== 0) {
+            return true;
+        }
+        for (let i = 0; i < Math.min(this.additionalItems.length, other.additionalItems.length); i++) {
+            if ((this.additionalItems[i] & other.additionalItems[i]) !== 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+const identityKeyProvider = {
+    getKey(value) {
+        return value;
+    }
+};
+/**
+ * Assigns values a unique incrementing key.
+*/
+class DenseKeyProvider {
+    constructor() {
+        this.items = new Map();
+    }
+    getKey(value) {
+        let existing = this.items.get(value);
+        if (existing === undefined) {
+            existing = this.items.size;
+            this.items.set(value, existing);
+        }
+        return existing;
+    }
+}
+
+export { DenseKeyProvider, SmallImmutableSet, identityKeyProvider };