@codingame/monaco-vscode-api 1.85.4 → 2.0.0-rework-ci.1

package/vscode/src/vs/editor/common/tokens/contiguousMultilineTokensBuilder.js

@@ -0,0 +1,53 @@
+import { writeUInt32BE, readUInt32BE } from '../../../base/common/buffer.js';
+import { ContiguousMultilineTokens } from './contiguousMultilineTokens.js';
+class ContiguousMultilineTokensBuilder {
+    static deserialize(buff) {
+        let offset = 0;
+        const count = readUInt32BE(buff, offset);
+        offset += 4;
+        const result = [];
+        for (let i = 0; i < count; i++) {
+            offset = ContiguousMultilineTokens.deserialize(buff, offset, result);
+        }
+        return result;
+    }
+    constructor() {
+        this._tokens = [];
+    }
+    add(lineNumber, lineTokens) {
+        if (this._tokens.length > 0) {
+            const last = this._tokens[this._tokens.length - 1];
+            if (last.endLineNumber + 1 === lineNumber) {
+                last.appendLineTokens(lineTokens);
+                return;
+            }
+        }
+        this._tokens.push(( new ContiguousMultilineTokens(lineNumber, [lineTokens])));
+    }
+    finalize() {
+        return this._tokens;
+    }
+    serialize() {
+        const size = this._serializeSize();
+        const result = ( new Uint8Array(size));
+        this._serialize(result);
+        return result;
+    }
+    _serializeSize() {
+        let result = 0;
+        result += 4;
+        for (let i = 0; i < this._tokens.length; i++) {
+            result += this._tokens[i].serializeSize();
+        }
+        return result;
+    }
+    _serialize(destination) {
+        let offset = 0;
+        writeUInt32BE(destination, this._tokens.length, offset);
+        offset += 4;
+        for (let i = 0; i < this._tokens.length; i++) {
+            offset = this._tokens[i].serialize(destination, offset);
+        }
+    }
+}
+export { ContiguousMultilineTokensBuilder };

package/vscode/src/vs/editor/common/tokens/contiguousTokensEditing.js

@@ -0,0 +1,117 @@
+import { LineTokens } from './lineTokens.js';
+const EMPTY_LINE_TOKENS = (( new Uint32Array(0))).buffer;
+class ContiguousTokensEditing {
+    static deleteBeginning(lineTokens, toChIndex) {
+        if (lineTokens === null || lineTokens === EMPTY_LINE_TOKENS) {
+            return lineTokens;
+        }
+        return ContiguousTokensEditing.delete(lineTokens, 0, toChIndex);
+    }
+    static deleteEnding(lineTokens, fromChIndex) {
+        if (lineTokens === null || lineTokens === EMPTY_LINE_TOKENS) {
+            return lineTokens;
+        }
+        const tokens = toUint32Array(lineTokens);
+        const lineTextLength = tokens[tokens.length - 2];
+        return ContiguousTokensEditing.delete(lineTokens, fromChIndex, lineTextLength);
+    }
+    static delete(lineTokens, fromChIndex, toChIndex) {
+        if (lineTokens === null || lineTokens === EMPTY_LINE_TOKENS || fromChIndex === toChIndex) {
+            return lineTokens;
+        }
+        const tokens = toUint32Array(lineTokens);
+        const tokensCount = (tokens.length >>> 1);
+        if (fromChIndex === 0 && tokens[tokens.length - 2] === toChIndex) {
+            return EMPTY_LINE_TOKENS;
+        }
+        const fromTokenIndex = LineTokens.findIndexInTokensArray(tokens, fromChIndex);
+        const fromTokenStartOffset = (fromTokenIndex > 0 ? tokens[(fromTokenIndex - 1) << 1] : 0);
+        const fromTokenEndOffset = tokens[fromTokenIndex << 1];
+        if (toChIndex < fromTokenEndOffset) {
+            const delta = (toChIndex - fromChIndex);
+            for (let i = fromTokenIndex; i < tokensCount; i++) {
+                tokens[i << 1] -= delta;
+            }
+            return lineTokens;
+        }
+        let dest;
+        let lastEnd;
+        if (fromTokenStartOffset !== fromChIndex) {
+            tokens[fromTokenIndex << 1] = fromChIndex;
+            dest = ((fromTokenIndex + 1) << 1);
+            lastEnd = fromChIndex;
+        }
+        else {
+            dest = (fromTokenIndex << 1);
+            lastEnd = fromTokenStartOffset;
+        }
+        const delta = (toChIndex - fromChIndex);
+        for (let tokenIndex = fromTokenIndex + 1; tokenIndex < tokensCount; tokenIndex++) {
+            const tokenEndOffset = tokens[tokenIndex << 1] - delta;
+            if (tokenEndOffset > lastEnd) {
+                tokens[dest++] = tokenEndOffset;
+                tokens[dest++] = tokens[(tokenIndex << 1) + 1];
+                lastEnd = tokenEndOffset;
+            }
+        }
+        if (dest === tokens.length) {
+            return lineTokens;
+        }
+        const tmp = ( new Uint32Array(dest));
+        tmp.set(tokens.subarray(0, dest), 0);
+        return tmp.buffer;
+    }
+    static append(lineTokens, _otherTokens) {
+        if (_otherTokens === EMPTY_LINE_TOKENS) {
+            return lineTokens;
+        }
+        if (lineTokens === EMPTY_LINE_TOKENS) {
+            return _otherTokens;
+        }
+        if (lineTokens === null) {
+            return lineTokens;
+        }
+        if (_otherTokens === null) {
+            return null;
+        }
+        const myTokens = toUint32Array(lineTokens);
+        const otherTokens = toUint32Array(_otherTokens);
+        const otherTokensCount = (otherTokens.length >>> 1);
+        const result = ( new Uint32Array(myTokens.length + otherTokens.length));
+        result.set(myTokens, 0);
+        let dest = myTokens.length;
+        const delta = myTokens[myTokens.length - 2];
+        for (let i = 0; i < otherTokensCount; i++) {
+            result[dest++] = otherTokens[(i << 1)] + delta;
+            result[dest++] = otherTokens[(i << 1) + 1];
+        }
+        return result.buffer;
+    }
+    static insert(lineTokens, chIndex, textLength) {
+        if (lineTokens === null || lineTokens === EMPTY_LINE_TOKENS) {
+            return lineTokens;
+        }
+        const tokens = toUint32Array(lineTokens);
+        const tokensCount = (tokens.length >>> 1);
+        let fromTokenIndex = LineTokens.findIndexInTokensArray(tokens, chIndex);
+        if (fromTokenIndex > 0) {
+            const fromTokenStartOffset = tokens[(fromTokenIndex - 1) << 1];
+            if (fromTokenStartOffset === chIndex) {
+                fromTokenIndex--;
+            }
+        }
+        for (let tokenIndex = fromTokenIndex; tokenIndex < tokensCount; tokenIndex++) {
+            tokens[tokenIndex << 1] += textLength;
+        }
+        return lineTokens;
+    }
+}
+function toUint32Array(arr) {
+    if (arr instanceof Uint32Array) {
+        return arr;
+    }
+    else {
+        return ( new Uint32Array(arr));
+    }
+}
+export { ContiguousTokensEditing, EMPTY_LINE_TOKENS, toUint32Array };

package/vscode/src/vs/editor/common/tokens/contiguousTokensStore.js

@@ -0,0 +1,188 @@
+import { arrayInsert } from '../../../base/common/arrays.js';
+import { Position } from '../core/position.js';
+import { EMPTY_LINE_TOKENS, toUint32Array, ContiguousTokensEditing } from './contiguousTokensEditing.js';
+import { LineTokens } from './lineTokens.js';
+import { TokenMetadata } from '../encodedTokenAttributes.js';
+class ContiguousTokensStore {
+    constructor(languageIdCodec) {
+        this._lineTokens = [];
+        this._len = 0;
+        this._languageIdCodec = languageIdCodec;
+    }
+    flush() {
+        this._lineTokens = [];
+        this._len = 0;
+    }
+    get hasTokens() {
+        return this._lineTokens.length > 0;
+    }
+    getTokens(topLevelLanguageId, lineIndex, lineText) {
+        let rawLineTokens = null;
+        if (lineIndex < this._len) {
+            rawLineTokens = this._lineTokens[lineIndex];
+        }
+        if (rawLineTokens !== null && rawLineTokens !== EMPTY_LINE_TOKENS) {
+            return ( new LineTokens(toUint32Array(rawLineTokens), lineText, this._languageIdCodec));
+        }
+        const lineTokens = ( new Uint32Array(2));
+        lineTokens[0] = lineText.length;
+        lineTokens[1] = getDefaultMetadata(this._languageIdCodec.encodeLanguageId(topLevelLanguageId));
+        return ( new LineTokens(lineTokens, lineText, this._languageIdCodec));
+    }
+    static _massageTokens(topLevelLanguageId, lineTextLength, _tokens) {
+        const tokens = _tokens ? toUint32Array(_tokens) : null;
+        if (lineTextLength === 0) {
+            let hasDifferentLanguageId = false;
+            if (tokens && tokens.length > 1) {
+                hasDifferentLanguageId = (TokenMetadata.getLanguageId(tokens[1]) !== topLevelLanguageId);
+            }
+            if (!hasDifferentLanguageId) {
+                return EMPTY_LINE_TOKENS;
+            }
+        }
+        if (!tokens || tokens.length === 0) {
+            const tokens = ( new Uint32Array(2));
+            tokens[0] = lineTextLength;
+            tokens[1] = getDefaultMetadata(topLevelLanguageId);
+            return tokens.buffer;
+        }
+        tokens[tokens.length - 2] = lineTextLength;
+        if (tokens.byteOffset === 0 && tokens.byteLength === tokens.buffer.byteLength) {
+            return tokens.buffer;
+        }
+        return tokens;
+    }
+    _ensureLine(lineIndex) {
+        while (lineIndex >= this._len) {
+            this._lineTokens[this._len] = null;
+            this._len++;
+        }
+    }
+    _deleteLines(start, deleteCount) {
+        if (deleteCount === 0) {
+            return;
+        }
+        if (start + deleteCount > this._len) {
+            deleteCount = this._len - start;
+        }
+        this._lineTokens.splice(start, deleteCount);
+        this._len -= deleteCount;
+    }
+    _insertLines(insertIndex, insertCount) {
+        if (insertCount === 0) {
+            return;
+        }
+        const lineTokens = [];
+        for (let i = 0; i < insertCount; i++) {
+            lineTokens[i] = null;
+        }
+        this._lineTokens = arrayInsert(this._lineTokens, insertIndex, lineTokens);
+        this._len += insertCount;
+    }
+    setTokens(topLevelLanguageId, lineIndex, lineTextLength, _tokens, checkEquality) {
+        const tokens = ContiguousTokensStore._massageTokens(this._languageIdCodec.encodeLanguageId(topLevelLanguageId), lineTextLength, _tokens);
+        this._ensureLine(lineIndex);
+        const oldTokens = this._lineTokens[lineIndex];
+        this._lineTokens[lineIndex] = tokens;
+        if (checkEquality) {
+            return !ContiguousTokensStore._equals(oldTokens, tokens);
+        }
+        return false;
+    }
+    static _equals(_a, _b) {
+        if (!_a || !_b) {
+            return !_a && !_b;
+        }
+        const a = toUint32Array(_a);
+        const b = toUint32Array(_b);
+        if (a.length !== b.length) {
+            return false;
+        }
+        for (let i = 0, len = a.length; i < len; i++) {
+            if (a[i] !== b[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    acceptEdit(range, eolCount, firstLineLength) {
+        this._acceptDeleteRange(range);
+        this._acceptInsertText(( new Position(range.startLineNumber, range.startColumn)), eolCount, firstLineLength);
+    }
+    _acceptDeleteRange(range) {
+        const firstLineIndex = range.startLineNumber - 1;
+        if (firstLineIndex >= this._len) {
+            return;
+        }
+        if (range.startLineNumber === range.endLineNumber) {
+            if (range.startColumn === range.endColumn) {
+                return;
+            }
+            this._lineTokens[firstLineIndex] = ContiguousTokensEditing.delete(this._lineTokens[firstLineIndex], range.startColumn - 1, range.endColumn - 1);
+            return;
+        }
+        this._lineTokens[firstLineIndex] = ContiguousTokensEditing.deleteEnding(this._lineTokens[firstLineIndex], range.startColumn - 1);
+        const lastLineIndex = range.endLineNumber - 1;
+        let lastLineTokens = null;
+        if (lastLineIndex < this._len) {
+            lastLineTokens = ContiguousTokensEditing.deleteBeginning(this._lineTokens[lastLineIndex], range.endColumn - 1);
+        }
+        this._lineTokens[firstLineIndex] = ContiguousTokensEditing.append(this._lineTokens[firstLineIndex], lastLineTokens);
+        this._deleteLines(range.startLineNumber, range.endLineNumber - range.startLineNumber);
+    }
+    _acceptInsertText(position, eolCount, firstLineLength) {
+        if (eolCount === 0 && firstLineLength === 0) {
+            return;
+        }
+        const lineIndex = position.lineNumber - 1;
+        if (lineIndex >= this._len) {
+            return;
+        }
+        if (eolCount === 0) {
+            this._lineTokens[lineIndex] = ContiguousTokensEditing.insert(this._lineTokens[lineIndex], position.column - 1, firstLineLength);
+            return;
+        }
+        this._lineTokens[lineIndex] = ContiguousTokensEditing.deleteEnding(this._lineTokens[lineIndex], position.column - 1);
+        this._lineTokens[lineIndex] = ContiguousTokensEditing.insert(this._lineTokens[lineIndex], position.column - 1, firstLineLength);
+        this._insertLines(position.lineNumber, eolCount);
+    }
+    setMultilineTokens(tokens, textModel) {
+        if (tokens.length === 0) {
+            return { changes: [] };
+        }
+        const ranges = [];
+        for (let i = 0, len = tokens.length; i < len; i++) {
+            const element = tokens[i];
+            let minChangedLineNumber = 0;
+            let maxChangedLineNumber = 0;
+            let hasChange = false;
+            for (let lineNumber = element.startLineNumber; lineNumber <= element.endLineNumber; lineNumber++) {
+                if (hasChange) {
+                    this.setTokens(textModel.getLanguageId(), lineNumber - 1, textModel.getLineLength(lineNumber), element.getLineTokens(lineNumber), false);
+                    maxChangedLineNumber = lineNumber;
+                }
+                else {
+                    const lineHasChange = this.setTokens(textModel.getLanguageId(), lineNumber - 1, textModel.getLineLength(lineNumber), element.getLineTokens(lineNumber), true);
+                    if (lineHasChange) {
+                        hasChange = true;
+                        minChangedLineNumber = lineNumber;
+                        maxChangedLineNumber = lineNumber;
+                    }
+                }
+            }
+            if (hasChange) {
+                ranges.push({ fromLineNumber: minChangedLineNumber, toLineNumber: maxChangedLineNumber, });
+            }
+        }
+        return { changes: ranges };
+    }
+}
+function getDefaultMetadata(topLevelLanguageId) {
+    return (((topLevelLanguageId << 0) )
+        | ((0  << 8) )
+        | ((0  << 11) )
+        | ((1  << 15) )
+        | ((2  << 24) )
+        | ((1024) )) >>> 0;
+}
+export { ContiguousTokensStore };

package/vscode/src/vs/editor/common/tokens/lineTokens.js

@@ -0,0 +1,218 @@
+import { TokenMetadata } from '../encodedTokenAttributes.js';
+class LineTokens {
+    static { this.defaultTokenMetadata = (((0  << 11) )
+        | ((1  << 15) )
+        | ((2  << 24) )) >>> 0; }
+    static createEmpty(lineContent, decoder) {
+        const defaultMetadata = LineTokens.defaultTokenMetadata;
+        const tokens = ( new Uint32Array(2));
+        tokens[0] = lineContent.length;
+        tokens[1] = defaultMetadata;
+        return ( new LineTokens(tokens, lineContent, decoder));
+    }
+    constructor(tokens, text, decoder) {
+        this._lineTokensBrand = undefined;
+        this._tokens = tokens;
+        this._tokensCount = (this._tokens.length >>> 1);
+        this._text = text;
+        this._languageIdCodec = decoder;
+    }
+    equals(other) {
+        if (other instanceof LineTokens) {
+            return this.slicedEquals(other, 0, this._tokensCount);
+        }
+        return false;
+    }
+    slicedEquals(other, sliceFromTokenIndex, sliceTokenCount) {
+        if (this._text !== other._text) {
+            return false;
+        }
+        if (this._tokensCount !== other._tokensCount) {
+            return false;
+        }
+        const from = (sliceFromTokenIndex << 1);
+        const to = from + (sliceTokenCount << 1);
+        for (let i = from; i < to; i++) {
+            if (this._tokens[i] !== other._tokens[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getLineContent() {
+        return this._text;
+    }
+    getCount() {
+        return this._tokensCount;
+    }
+    getStartOffset(tokenIndex) {
+        if (tokenIndex > 0) {
+            return this._tokens[(tokenIndex - 1) << 1];
+        }
+        return 0;
+    }
+    getMetadata(tokenIndex) {
+        const metadata = this._tokens[(tokenIndex << 1) + 1];
+        return metadata;
+    }
+    getLanguageId(tokenIndex) {
+        const metadata = this._tokens[(tokenIndex << 1) + 1];
+        const languageId = TokenMetadata.getLanguageId(metadata);
+        return this._languageIdCodec.decodeLanguageId(languageId);
+    }
+    getStandardTokenType(tokenIndex) {
+        const metadata = this._tokens[(tokenIndex << 1) + 1];
+        return TokenMetadata.getTokenType(metadata);
+    }
+    getForeground(tokenIndex) {
+        const metadata = this._tokens[(tokenIndex << 1) + 1];
+        return TokenMetadata.getForeground(metadata);
+    }
+    getClassName(tokenIndex) {
+        const metadata = this._tokens[(tokenIndex << 1) + 1];
+        return TokenMetadata.getClassNameFromMetadata(metadata);
+    }
+    getInlineStyle(tokenIndex, colorMap) {
+        const metadata = this._tokens[(tokenIndex << 1) + 1];
+        return TokenMetadata.getInlineStyleFromMetadata(metadata, colorMap);
+    }
+    getPresentation(tokenIndex) {
+        const metadata = this._tokens[(tokenIndex << 1) + 1];
+        return TokenMetadata.getPresentationFromMetadata(metadata);
+    }
+    getEndOffset(tokenIndex) {
+        return this._tokens[tokenIndex << 1];
+    }
+    findTokenIndexAtOffset(offset) {
+        return LineTokens.findIndexInTokensArray(this._tokens, offset);
+    }
+    inflate() {
+        return this;
+    }
+    sliceAndInflate(startOffset, endOffset, deltaOffset) {
+        return ( new SliceLineTokens(this, startOffset, endOffset, deltaOffset));
+    }
+    static convertToEndOffset(tokens, lineTextLength) {
+        const tokenCount = (tokens.length >>> 1);
+        const lastTokenIndex = tokenCount - 1;
+        for (let tokenIndex = 0; tokenIndex < lastTokenIndex; tokenIndex++) {
+            tokens[tokenIndex << 1] = tokens[(tokenIndex + 1) << 1];
+        }
+        tokens[lastTokenIndex << 1] = lineTextLength;
+    }
+    static findIndexInTokensArray(tokens, desiredIndex) {
+        if (tokens.length <= 2) {
+            return 0;
+        }
+        let low = 0;
+        let high = (tokens.length >>> 1) - 1;
+        while (low < high) {
+            const mid = low + Math.floor((high - low) / 2);
+            const endOffset = tokens[(mid << 1)];
+            if (endOffset === desiredIndex) {
+                return mid + 1;
+            }
+            else if (endOffset < desiredIndex) {
+                low = mid + 1;
+            }
+            else if (endOffset > desiredIndex) {
+                high = mid;
+            }
+        }
+        return low;
+    }
+    withInserted(insertTokens) {
+        if (insertTokens.length === 0) {
+            return this;
+        }
+        let nextOriginalTokenIdx = 0;
+        let nextInsertTokenIdx = 0;
+        let text = '';
+        const newTokens = ( new Array());
+        let originalEndOffset = 0;
+        while (true) {
+            const nextOriginalTokenEndOffset = nextOriginalTokenIdx < this._tokensCount ? this._tokens[nextOriginalTokenIdx << 1] : -1;
+            const nextInsertToken = nextInsertTokenIdx < insertTokens.length ? insertTokens[nextInsertTokenIdx] : null;
+            if (nextOriginalTokenEndOffset !== -1 && (nextInsertToken === null || nextOriginalTokenEndOffset <= nextInsertToken.offset)) {
+                text += this._text.substring(originalEndOffset, nextOriginalTokenEndOffset);
+                const metadata = this._tokens[(nextOriginalTokenIdx << 1) + 1];
+                newTokens.push(text.length, metadata);
+                nextOriginalTokenIdx++;
+                originalEndOffset = nextOriginalTokenEndOffset;
+            }
+            else if (nextInsertToken) {
+                if (nextInsertToken.offset > originalEndOffset) {
+                    text += this._text.substring(originalEndOffset, nextInsertToken.offset);
+                    const metadata = this._tokens[(nextOriginalTokenIdx << 1) + 1];
+                    newTokens.push(text.length, metadata);
+                    originalEndOffset = nextInsertToken.offset;
+                }
+                text += nextInsertToken.text;
+                newTokens.push(text.length, nextInsertToken.tokenMetadata);
+                nextInsertTokenIdx++;
+            }
+            else {
+                break;
+            }
+        }
+        return ( new LineTokens(( new Uint32Array(newTokens)), text, this._languageIdCodec));
+    }
+}
+class SliceLineTokens {
+    constructor(source, startOffset, endOffset, deltaOffset) {
+        this._source = source;
+        this._startOffset = startOffset;
+        this._endOffset = endOffset;
+        this._deltaOffset = deltaOffset;
+        this._firstTokenIndex = source.findTokenIndexAtOffset(startOffset);
+        this._tokensCount = 0;
+        for (let i = this._firstTokenIndex, len = source.getCount(); i < len; i++) {
+            const tokenStartOffset = source.getStartOffset(i);
+            if (tokenStartOffset >= endOffset) {
+                break;
+            }
+            this._tokensCount++;
+        }
+    }
+    getMetadata(tokenIndex) {
+        return this._source.getMetadata(this._firstTokenIndex + tokenIndex);
+    }
+    getLanguageId(tokenIndex) {
+        return this._source.getLanguageId(this._firstTokenIndex + tokenIndex);
+    }
+    getLineContent() {
+        return this._source.getLineContent().substring(this._startOffset, this._endOffset);
+    }
+    equals(other) {
+        if (other instanceof SliceLineTokens) {
+            return (this._startOffset === other._startOffset
+                && this._endOffset === other._endOffset
+                && this._deltaOffset === other._deltaOffset
+                && this._source.slicedEquals(other._source, this._firstTokenIndex, this._tokensCount));
+        }
+        return false;
+    }
+    getCount() {
+        return this._tokensCount;
+    }
+    getForeground(tokenIndex) {
+        return this._source.getForeground(this._firstTokenIndex + tokenIndex);
+    }
+    getEndOffset(tokenIndex) {
+        const tokenEndOffset = this._source.getEndOffset(this._firstTokenIndex + tokenIndex);
+        return Math.min(this._endOffset, tokenEndOffset) - this._startOffset + this._deltaOffset;
+    }
+    getClassName(tokenIndex) {
+        return this._source.getClassName(this._firstTokenIndex + tokenIndex);
+    }
+    getInlineStyle(tokenIndex, colorMap) {
+        return this._source.getInlineStyle(this._firstTokenIndex + tokenIndex, colorMap);
+    }
+    getPresentation(tokenIndex) {
+        return this._source.getPresentation(this._firstTokenIndex + tokenIndex);
+    }
+    findTokenIndexAtOffset(offset) {
+        return this._source.findTokenIndexAtOffset(offset + this._startOffset - this._deltaOffset) - this._firstTokenIndex;
+    }
+}
+export { LineTokens };