monaco-editor11 1.0.9 → 1.1.1

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

@@ -1,263 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,241 +0,0 @@
-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

@@ -1,108 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  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 };