monaco-editor11 1.0.9 → 1.1.1

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

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

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

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