monaco-editor11 1.0.9 → 1.1.0

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

@@ -1,210 +0,0 @@
-import { arrayInsert } from '../../../base/common/arrays.js';
-import { LineTokens } from './lineTokens.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-/**
- * Represents sparse tokens in a text model.
- */
-class SparseTokensStore {
-    constructor(languageIdCodec) {
-        this._pieces = [];
-        this._isComplete = false;
-        this._languageIdCodec = languageIdCodec;
-    }
-    flush() {
-        this._pieces = [];
-        this._isComplete = false;
-    }
-    isEmpty() {
-        return (this._pieces.length === 0);
-    }
-    set(pieces, isComplete, textModel = undefined) {
-        this._pieces = pieces || [];
-        this._isComplete = isComplete;
-        if (textModel) {
-            for (const p of this._pieces) {
-                p.reportIfInvalid(textModel);
-            }
-        }
-    }
-    setPartial(_range, pieces) {
-        // console.log(`setPartial ${_range} ${pieces.map(p => p.toString()).join(', ')}`);
-        let range = _range;
-        if (pieces.length > 0) {
-            const _firstRange = pieces[0].getRange();
-            const _lastRange = pieces[pieces.length - 1].getRange();
-            if (!_firstRange || !_lastRange) {
-                return _range;
-            }
-            range = _range.plusRange(_firstRange).plusRange(_lastRange);
-        }
-        let insertPosition = null;
-        for (let i = 0, len = this._pieces.length; i < len; i++) {
-            const piece = this._pieces[i];
-            if (piece.endLineNumber < range.startLineNumber) {
-                // this piece is before the range
-                continue;
-            }
-            if (piece.startLineNumber > range.endLineNumber) {
-                // this piece is after the range, so mark the spot before this piece
-                // as a good insertion position and stop looping
-                insertPosition = insertPosition || { index: i };
-                break;
-            }
-            // this piece might intersect with the range
-            piece.removeTokens(range);
-            if (piece.isEmpty()) {
-                // remove the piece if it became empty
-                this._pieces.splice(i, 1);
-                i--;
-                len--;
-                continue;
-            }
-            if (piece.endLineNumber < range.startLineNumber) {
-                // after removal, this piece is before the range
-                continue;
-            }
-            if (piece.startLineNumber > range.endLineNumber) {
-                // after removal, this piece is after the range
-                insertPosition = insertPosition || { index: i };
-                continue;
-            }
-            // after removal, this piece contains the range
-            const [a, b] = piece.split(range);
-            if (a.isEmpty()) {
-                // this piece is actually after the range
-                insertPosition = insertPosition || { index: i };
-                continue;
-            }
-            if (b.isEmpty()) {
-                // this piece is actually before the range
-                continue;
-            }
-            this._pieces.splice(i, 1, a, b);
-            i++;
-            len++;
-            insertPosition = insertPosition || { index: i };
-        }
-        insertPosition = insertPosition || { index: this._pieces.length };
-        if (pieces.length > 0) {
-            this._pieces = arrayInsert(this._pieces, insertPosition.index, pieces);
-        }
-        // console.log(`I HAVE ${this._pieces.length} pieces`);
-        // console.log(`${this._pieces.map(p => p.toString()).join('\n')}`);
-        return range;
-    }
-    isComplete() {
-        return this._isComplete;
-    }
-    addSparseTokens(lineNumber, aTokens) {
-        if (aTokens.getTextLength() === 0) {
-            // Don't do anything for empty lines
-            return aTokens;
-        }
-        const pieces = this._pieces;
-        if (pieces.length === 0) {
-            return aTokens;
-        }
-        const pieceIndex = SparseTokensStore._findFirstPieceWithLine(pieces, lineNumber);
-        const bTokens = pieces[pieceIndex].getLineTokens(lineNumber);
-        if (!bTokens) {
-            return aTokens;
-        }
-        const aLen = aTokens.getCount();
-        const bLen = bTokens.getCount();
-        let aIndex = 0;
-        const result = [];
-        let resultLen = 0;
-        let lastEndOffset = 0;
-        const emitToken = (endOffset, metadata) => {
-            if (endOffset === lastEndOffset) {
-                return;
-            }
-            lastEndOffset = endOffset;
-            result[resultLen++] = endOffset;
-            result[resultLen++] = metadata;
-        };
-        for (let bIndex = 0; bIndex < bLen; bIndex++) {
-            // bTokens is not validated yet, but aTokens is. We want to make sure that the LineTokens we return
-            // are valid, so we clamp the ranges to ensure that.
-            const bStartCharacter = Math.min(bTokens.getStartCharacter(bIndex), aTokens.getTextLength());
-            const bEndCharacter = Math.min(bTokens.getEndCharacter(bIndex), aTokens.getTextLength());
-            const bMetadata = bTokens.getMetadata(bIndex);
-            const bMask = (((bMetadata & 1 /* MetadataConsts.SEMANTIC_USE_ITALIC */) ? 2048 /* MetadataConsts.ITALIC_MASK */ : 0)
-                | ((bMetadata & 2 /* MetadataConsts.SEMANTIC_USE_BOLD */) ? 4096 /* MetadataConsts.BOLD_MASK */ : 0)
-                | ((bMetadata & 4 /* MetadataConsts.SEMANTIC_USE_UNDERLINE */) ? 8192 /* MetadataConsts.UNDERLINE_MASK */ : 0)
-                | ((bMetadata & 8 /* MetadataConsts.SEMANTIC_USE_STRIKETHROUGH */) ? 16384 /* MetadataConsts.STRIKETHROUGH_MASK */ : 0)
-                | ((bMetadata & 16 /* MetadataConsts.SEMANTIC_USE_FOREGROUND */) ? 16744448 /* MetadataConsts.FOREGROUND_MASK */ : 0)
-                | ((bMetadata & 32 /* MetadataConsts.SEMANTIC_USE_BACKGROUND */) ? 4278190080 /* MetadataConsts.BACKGROUND_MASK */ : 0)) >>> 0;
-            const aMask = (~bMask) >>> 0;
-            // push any token from `a` that is before `b`
-            while (aIndex < aLen && aTokens.getEndOffset(aIndex) <= bStartCharacter) {
-                emitToken(aTokens.getEndOffset(aIndex), aTokens.getMetadata(aIndex));
-                aIndex++;
-            }
-            // push the token from `a` if it intersects the token from `b`
-            if (aIndex < aLen && aTokens.getStartOffset(aIndex) < bStartCharacter) {
-                emitToken(bStartCharacter, aTokens.getMetadata(aIndex));
-            }
-            // skip any tokens from `a` that are contained inside `b`
-            while (aIndex < aLen && aTokens.getEndOffset(aIndex) < bEndCharacter) {
-                emitToken(aTokens.getEndOffset(aIndex), (aTokens.getMetadata(aIndex) & aMask) | (bMetadata & bMask));
-                aIndex++;
-            }
-            if (aIndex < aLen) {
-                emitToken(bEndCharacter, (aTokens.getMetadata(aIndex) & aMask) | (bMetadata & bMask));
-                if (aTokens.getEndOffset(aIndex) === bEndCharacter) {
-                    // `a` ends exactly at the same spot as `b`!
-                    aIndex++;
-                }
-            }
-            else {
-                const aMergeIndex = Math.min(Math.max(0, aIndex - 1), aLen - 1);
-                // push the token from `b`
-                emitToken(bEndCharacter, (aTokens.getMetadata(aMergeIndex) & aMask) | (bMetadata & bMask));
-            }
-        }
-        // push the remaining tokens from `a`
-        while (aIndex < aLen) {
-            emitToken(aTokens.getEndOffset(aIndex), aTokens.getMetadata(aIndex));
-            aIndex++;
-        }
-        return new LineTokens(new Uint32Array(result), aTokens.getLineContent(), this._languageIdCodec);
-    }
-    static _findFirstPieceWithLine(pieces, lineNumber) {
-        let low = 0;
-        let high = pieces.length - 1;
-        while (low < high) {
-            let mid = low + Math.floor((high - low) / 2);
-            if (pieces[mid].endLineNumber < lineNumber) {
-                low = mid + 1;
-            }
-            else if (pieces[mid].startLineNumber > lineNumber) {
-                high = mid - 1;
-            }
-            else {
-                while (mid > low && pieces[mid - 1].startLineNumber <= lineNumber && lineNumber <= pieces[mid - 1].endLineNumber) {
-                    mid--;
-                }
-                return mid;
-            }
-        }
-        return low;
-    }
-    acceptEdit(range, eolCount, firstLineLength, lastLineLength, firstCharCode) {
-        for (let i = 0; i < this._pieces.length; i++) {
-            const piece = this._pieces[i];
-            piece.acceptEdit(range, eolCount, firstLineLength, lastLineLength, firstCharCode);
-            if (piece.isEmpty()) {
-                // Remove empty pieces
-                this._pieces.splice(i, 1);
-                i--;
-            }
-        }
-    }
-}
-
-export { SparseTokensStore };