monaco-editor11 1.0.7 → 1.0.9

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

@@ -0,0 +1,128 @@
+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.
+ *--------------------------------------------------------------------------------------------*/
+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);
+        // special case: deleting everything
+        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) {
+            // the delete range is inside a single token
+            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) {
+            // nothing to trim
+            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) {
+            // cannot determine combined line length...
+            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) {
+            // nothing to do
+            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/dist/workers/editor/common/contiguousTokensStore.js

@@ -0,0 +1,207 @@
+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';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * Represents contiguous tokens in a text model.
+ */
+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;
+        }
+        // Ensure the last token covers the end of the text
+        tokens[tokens.length - 2] = lineTextLength;
+        if (tokens.byteOffset === 0 && tokens.byteLength === tokens.buffer.byteLength) {
+            // Store directly the ArrayBuffer pointer to save an object
+            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;
+    }
+    //#region Editing
+    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) {
+                // Nothing to delete
+                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);
+        }
+        // Take remaining text on last line and append it to remaining text on first line
+        this._lineTokens[firstLineIndex] = ContiguousTokensEditing.append(this._lineTokens[firstLineIndex], lastLineTokens);
+        // Delete middle lines
+        this._deleteLines(range.startLineNumber, range.endLineNumber - range.startLineNumber);
+    }
+    _acceptInsertText(position, eolCount, firstLineLength) {
+        if (eolCount === 0 && firstLineLength === 0) {
+            // Nothing to insert
+            return;
+        }
+        const lineIndex = position.lineNumber - 1;
+        if (lineIndex >= this._len) {
+            return;
+        }
+        if (eolCount === 0) {
+            // Inserting text on one line
+            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);
+    }
+    //#endregion
+    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 /* MetadataConsts.LANGUAGEID_OFFSET */)
+        | (0 /* StandardTokenType.Other */ << 8 /* MetadataConsts.TOKEN_TYPE_OFFSET */)
+        | (0 /* FontStyle.None */ << 11 /* MetadataConsts.FONT_STYLE_OFFSET */)
+        | (1 /* ColorId.DefaultForeground */ << 15 /* MetadataConsts.FOREGROUND_OFFSET */)
+        | (2 /* ColorId.DefaultBackground */ << 24 /* MetadataConsts.BACKGROUND_OFFSET */)
+        // If there is no grammar, we just take a guess and try to match brackets.
+        | (1024 /* MetadataConsts.BALANCED_BRACKETS_MASK */)) >>> 0;
+}
+
+export { ContiguousTokensStore };

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

@@ -0,0 +1,51 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class IdentityCoordinatesConverter {
+    constructor(model) {
+        this._model = model;
+    }
+    _validPosition(pos) {
+        return this._model.validatePosition(pos);
+    }
+    _validRange(range) {
+        return this._model.validateRange(range);
+    }
+    // View -> Model conversion and related methods
+    convertViewPositionToModelPosition(viewPosition) {
+        return this._validPosition(viewPosition);
+    }
+    convertViewRangeToModelRange(viewRange) {
+        return this._validRange(viewRange);
+    }
+    validateViewPosition(_viewPosition, expectedModelPosition) {
+        return this._validPosition(expectedModelPosition);
+    }
+    validateViewRange(_viewRange, expectedModelRange) {
+        return this._validRange(expectedModelRange);
+    }
+    // Model -> View conversion and related methods
+    convertModelPositionToViewPosition(modelPosition) {
+        return this._validPosition(modelPosition);
+    }
+    convertModelRangeToViewRange(modelRange) {
+        return this._validRange(modelRange);
+    }
+    modelPositionIsVisible(modelPosition) {
+        const lineCount = this._model.getLineCount();
+        if (modelPosition.lineNumber < 1 || modelPosition.lineNumber > lineCount) {
+            // invalid arguments
+            return false;
+        }
+        return true;
+    }
+    getModelLineViewLineCount(modelLineNumber) {
+        return 1;
+    }
+    getViewLineNumberOfModelPosition(modelLineNumber, modelColumn) {
+        return modelLineNumber;
+    }
+}
+
+export { IdentityCoordinatesConverter };