monaco-editor11 1.0.9 → 1.1.0

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

@@ -1,145 +0,0 @@
-import { CursorColumns } from '../core/cursorColumns.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-class AtomicTabMoveOperations {
-    /**
-     * Get the visible column at the position. If we get to a non-whitespace character first
-     * or past the end of string then return -1.
-     *
-     * **Note** `position` and the return value are 0-based.
-     */
-    static whitespaceVisibleColumn(lineContent, position, tabSize) {
-        const lineLength = lineContent.length;
-        let visibleColumn = 0;
-        let prevTabStopPosition = -1;
-        let prevTabStopVisibleColumn = -1;
-        for (let i = 0; i < lineLength; i++) {
-            if (i === position) {
-                return [prevTabStopPosition, prevTabStopVisibleColumn, visibleColumn];
-            }
-            if (visibleColumn % tabSize === 0) {
-                prevTabStopPosition = i;
-                prevTabStopVisibleColumn = visibleColumn;
-            }
-            const chCode = lineContent.charCodeAt(i);
-            switch (chCode) {
-                case 32 /* CharCode.Space */:
-                    visibleColumn += 1;
-                    break;
-                case 9 /* CharCode.Tab */:
-                    // Skip to the next multiple of tabSize.
-                    visibleColumn = CursorColumns.nextRenderTabStop(visibleColumn, tabSize);
-                    break;
-                default:
-                    return [-1, -1, -1];
-            }
-        }
-        if (position === lineLength) {
-            return [prevTabStopPosition, prevTabStopVisibleColumn, visibleColumn];
-        }
-        return [-1, -1, -1];
-    }
-    /**
-     * Return the position that should result from a move left, right or to the
-     * nearest tab, if atomic tabs are enabled. Left and right are used for the
-     * arrow key movements, nearest is used for mouse selection. It returns
-     * -1 if atomic tabs are not relevant and you should fall back to normal
-     * behaviour.
-     *
-     * **Note**: `position` and the return value are 0-based.
-     */
-    static atomicPosition(lineContent, position, tabSize, direction) {
-        const lineLength = lineContent.length;
-        // Get the 0-based visible column corresponding to the position, or return
-        // -1 if it is not in the initial whitespace.
-        const [prevTabStopPosition, prevTabStopVisibleColumn, visibleColumn] = AtomicTabMoveOperations.whitespaceVisibleColumn(lineContent, position, tabSize);
-        if (visibleColumn === -1) {
-            return -1;
-        }
-        // Is the output left or right of the current position. The case for nearest
-        // where it is the same as the current position is handled in the switch.
-        let left;
-        switch (direction) {
-            case 0 /* Direction.Left */:
-                left = true;
-                break;
-            case 1 /* Direction.Right */:
-                left = false;
-                break;
-            case 2 /* Direction.Nearest */:
-                // The code below assumes the output position is either left or right
-                // of the input position. If it is the same, return immediately.
-                if (visibleColumn % tabSize === 0) {
-                    return position;
-                }
-                // Go to the nearest indentation.
-                left = visibleColumn % tabSize <= (tabSize / 2);
-                break;
-        }
-        // If going left, we can just use the info about the last tab stop position and
-        // last tab stop visible column that we computed in the first walk over the whitespace.
-        if (left) {
-            if (prevTabStopPosition === -1) {
-                return -1;
-            }
-            // If the direction is left, we need to keep scanning right to ensure
-            // that targetVisibleColumn + tabSize is before non-whitespace.
-            // This is so that when we press left at the end of a partial
-            // indentation it only goes one character. For example '      foo' with
-            // tabSize 4, should jump from position 6 to position 5, not 4.
-            let currentVisibleColumn = prevTabStopVisibleColumn;
-            for (let i = prevTabStopPosition; i < lineLength; ++i) {
-                if (currentVisibleColumn === prevTabStopVisibleColumn + tabSize) {
-                    // It is a full indentation.
-                    return prevTabStopPosition;
-                }
-                const chCode = lineContent.charCodeAt(i);
-                switch (chCode) {
-                    case 32 /* CharCode.Space */:
-                        currentVisibleColumn += 1;
-                        break;
-                    case 9 /* CharCode.Tab */:
-                        currentVisibleColumn = CursorColumns.nextRenderTabStop(currentVisibleColumn, tabSize);
-                        break;
-                    default:
-                        return -1;
-                }
-            }
-            if (currentVisibleColumn === prevTabStopVisibleColumn + tabSize) {
-                return prevTabStopPosition;
-            }
-            // It must have been a partial indentation.
-            return -1;
-        }
-        // We are going right.
-        const targetVisibleColumn = CursorColumns.nextRenderTabStop(visibleColumn, tabSize);
-        // We can just continue from where whitespaceVisibleColumn got to.
-        let currentVisibleColumn = visibleColumn;
-        for (let i = position; i < lineLength; i++) {
-            if (currentVisibleColumn === targetVisibleColumn) {
-                return i;
-            }
-            const chCode = lineContent.charCodeAt(i);
-            switch (chCode) {
-                case 32 /* CharCode.Space */:
-                    currentVisibleColumn += 1;
-                    break;
-                case 9 /* CharCode.Tab */:
-                    currentVisibleColumn = CursorColumns.nextRenderTabStop(currentVisibleColumn, tabSize);
-                    break;
-                default:
-                    return -1;
-            }
-        }
-        // This condition handles when the target column is at the end of the line.
-        if (currentVisibleColumn === targetVisibleColumn) {
-            return lineLength;
-        }
-        return -1;
-    }
-}
-
-export { AtomicTabMoveOperations };

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

@@ -1,194 +0,0 @@
-import { compareBy } from '../../../base/common/arrays.js';
-import { findFirstMin, findLastMax } from '../../../base/common/arraysFind.js';
-import { CursorState } from '../cursorCommon.js';
-import { Cursor } from './oneCursor.js';
-import { Position } from '../core/position.js';
-import { Range } from '../core/range.js';
-import { Selection } from '../core/selection.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-class CursorCollection {
-    constructor(context) {
-        this.context = context;
-        this.cursors = [new Cursor(context)];
-        this.lastAddedCursorIndex = 0;
-    }
-    dispose() {
-        for (const cursor of this.cursors) {
-            cursor.dispose(this.context);
-        }
-    }
-    startTrackingSelections() {
-        for (const cursor of this.cursors) {
-            cursor.startTrackingSelection(this.context);
-        }
-    }
-    stopTrackingSelections() {
-        for (const cursor of this.cursors) {
-            cursor.stopTrackingSelection(this.context);
-        }
-    }
-    updateContext(context) {
-        this.context = context;
-    }
-    ensureValidState() {
-        for (const cursor of this.cursors) {
-            cursor.ensureValidState(this.context);
-        }
-    }
-    readSelectionFromMarkers() {
-        return this.cursors.map(c => c.readSelectionFromMarkers(this.context));
-    }
-    getAll() {
-        return this.cursors.map(c => c.asCursorState());
-    }
-    getViewPositions() {
-        return this.cursors.map(c => c.viewState.position);
-    }
-    getTopMostViewPosition() {
-        return findFirstMin(this.cursors, compareBy(c => c.viewState.position, Position.compare)).viewState.position;
-    }
-    getBottomMostViewPosition() {
-        return findLastMax(this.cursors, compareBy(c => c.viewState.position, Position.compare)).viewState.position;
-    }
-    getSelections() {
-        return this.cursors.map(c => c.modelState.selection);
-    }
-    getViewSelections() {
-        return this.cursors.map(c => c.viewState.selection);
-    }
-    setSelections(selections) {
-        this.setStates(CursorState.fromModelSelections(selections));
-    }
-    getPrimaryCursor() {
-        return this.cursors[0].asCursorState();
-    }
-    setStates(states) {
-        if (states === null) {
-            return;
-        }
-        this.cursors[0].setState(this.context, states[0].modelState, states[0].viewState);
-        this._setSecondaryStates(states.slice(1));
-    }
-    /**
-     * Creates or disposes secondary cursors as necessary to match the number of `secondarySelections`.
-     */
-    _setSecondaryStates(secondaryStates) {
-        const secondaryCursorsLength = this.cursors.length - 1;
-        const secondaryStatesLength = secondaryStates.length;
-        if (secondaryCursorsLength < secondaryStatesLength) {
-            const createCnt = secondaryStatesLength - secondaryCursorsLength;
-            for (let i = 0; i < createCnt; i++) {
-                this._addSecondaryCursor();
-            }
-        }
-        else if (secondaryCursorsLength > secondaryStatesLength) {
-            const removeCnt = secondaryCursorsLength - secondaryStatesLength;
-            for (let i = 0; i < removeCnt; i++) {
-                this._removeSecondaryCursor(this.cursors.length - 2);
-            }
-        }
-        for (let i = 0; i < secondaryStatesLength; i++) {
-            this.cursors[i + 1].setState(this.context, secondaryStates[i].modelState, secondaryStates[i].viewState);
-        }
-    }
-    killSecondaryCursors() {
-        this._setSecondaryStates([]);
-    }
-    _addSecondaryCursor() {
-        this.cursors.push(new Cursor(this.context));
-        this.lastAddedCursorIndex = this.cursors.length - 1;
-    }
-    getLastAddedCursorIndex() {
-        if (this.cursors.length === 1 || this.lastAddedCursorIndex === 0) {
-            return 0;
-        }
-        return this.lastAddedCursorIndex;
-    }
-    _removeSecondaryCursor(removeIndex) {
-        if (this.lastAddedCursorIndex >= removeIndex + 1) {
-            this.lastAddedCursorIndex--;
-        }
-        this.cursors[removeIndex + 1].dispose(this.context);
-        this.cursors.splice(removeIndex + 1, 1);
-    }
-    normalize() {
-        if (this.cursors.length === 1) {
-            return;
-        }
-        const cursors = this.cursors.slice(0);
-        const sortedCursors = [];
-        for (let i = 0, len = cursors.length; i < len; i++) {
-            sortedCursors.push({
-                index: i,
-                selection: cursors[i].modelState.selection,
-            });
-        }
-        sortedCursors.sort(compareBy(s => s.selection, Range.compareRangesUsingStarts));
-        for (let sortedCursorIndex = 0; sortedCursorIndex < sortedCursors.length - 1; sortedCursorIndex++) {
-            const current = sortedCursors[sortedCursorIndex];
-            const next = sortedCursors[sortedCursorIndex + 1];
-            const currentSelection = current.selection;
-            const nextSelection = next.selection;
-            if (!this.context.cursorConfig.multiCursorMergeOverlapping) {
-                continue;
-            }
-            let shouldMergeCursors;
-            if (nextSelection.isEmpty() || currentSelection.isEmpty()) {
-                // Merge touching cursors if one of them is collapsed
-                shouldMergeCursors = nextSelection.getStartPosition().isBeforeOrEqual(currentSelection.getEndPosition());
-            }
-            else {
-                // Merge only overlapping cursors (i.e. allow touching ranges)
-                shouldMergeCursors = nextSelection.getStartPosition().isBefore(currentSelection.getEndPosition());
-            }
-            if (shouldMergeCursors) {
-                const winnerSortedCursorIndex = current.index < next.index ? sortedCursorIndex : sortedCursorIndex + 1;
-                const looserSortedCursorIndex = current.index < next.index ? sortedCursorIndex + 1 : sortedCursorIndex;
-                const looserIndex = sortedCursors[looserSortedCursorIndex].index;
-                const winnerIndex = sortedCursors[winnerSortedCursorIndex].index;
-                const looserSelection = sortedCursors[looserSortedCursorIndex].selection;
-                const winnerSelection = sortedCursors[winnerSortedCursorIndex].selection;
-                if (!looserSelection.equalsSelection(winnerSelection)) {
-                    const resultingRange = looserSelection.plusRange(winnerSelection);
-                    const looserSelectionIsLTR = (looserSelection.selectionStartLineNumber === looserSelection.startLineNumber && looserSelection.selectionStartColumn === looserSelection.startColumn);
-                    const winnerSelectionIsLTR = (winnerSelection.selectionStartLineNumber === winnerSelection.startLineNumber && winnerSelection.selectionStartColumn === winnerSelection.startColumn);
-                    // Give more importance to the last added cursor (think Ctrl-dragging + hitting another cursor)
-                    let resultingSelectionIsLTR;
-                    if (looserIndex === this.lastAddedCursorIndex) {
-                        resultingSelectionIsLTR = looserSelectionIsLTR;
-                        this.lastAddedCursorIndex = winnerIndex;
-                    }
-                    else {
-                        // Winner takes it all
-                        resultingSelectionIsLTR = winnerSelectionIsLTR;
-                    }
-                    let resultingSelection;
-                    if (resultingSelectionIsLTR) {
-                        resultingSelection = new Selection(resultingRange.startLineNumber, resultingRange.startColumn, resultingRange.endLineNumber, resultingRange.endColumn);
-                    }
-                    else {
-                        resultingSelection = new Selection(resultingRange.endLineNumber, resultingRange.endColumn, resultingRange.startLineNumber, resultingRange.startColumn);
-                    }
-                    sortedCursors[winnerSortedCursorIndex].selection = resultingSelection;
-                    const resultingState = CursorState.fromModelSelection(resultingSelection);
-                    cursors[winnerIndex].setState(this.context, resultingState.modelState, resultingState.viewState);
-                }
-                for (const sortedCursor of sortedCursors) {
-                    if (sortedCursor.index > looserIndex) {
-                        sortedCursor.index--;
-                    }
-                }
-                cursors.splice(looserIndex, 1);
-                sortedCursors.splice(looserSortedCursorIndex, 1);
-                this._removeSecondaryCursor(looserIndex - 1);
-                sortedCursorIndex--;
-            }
-        }
-    }
-}
-
-export { CursorCollection };

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

@@ -1,93 +0,0 @@
-import { SingleCursorState } from '../cursorCommon.js';
-import { Position } from '../core/position.js';
-import { Range } from '../core/range.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-class ColumnSelection {
-    static columnSelect(config, model, fromLineNumber, fromVisibleColumn, toLineNumber, toVisibleColumn) {
-        const lineCount = Math.abs(toLineNumber - fromLineNumber) + 1;
-        const reversed = (fromLineNumber > toLineNumber);
-        const isRTL = (fromVisibleColumn > toVisibleColumn);
-        const isLTR = (fromVisibleColumn < toVisibleColumn);
-        const result = [];
-        // console.log(`fromVisibleColumn: ${fromVisibleColumn}, toVisibleColumn: ${toVisibleColumn}`);
-        for (let i = 0; i < lineCount; i++) {
-            const lineNumber = fromLineNumber + (reversed ? -i : i);
-            const startColumn = config.columnFromVisibleColumn(model, lineNumber, fromVisibleColumn);
-            const endColumn = config.columnFromVisibleColumn(model, lineNumber, toVisibleColumn);
-            const visibleStartColumn = config.visibleColumnFromColumn(model, new Position(lineNumber, startColumn));
-            const visibleEndColumn = config.visibleColumnFromColumn(model, new Position(lineNumber, endColumn));
-            // console.log(`lineNumber: ${lineNumber}: visibleStartColumn: ${visibleStartColumn}, visibleEndColumn: ${visibleEndColumn}`);
-            if (isLTR) {
-                if (visibleStartColumn > toVisibleColumn) {
-                    continue;
-                }
-                if (visibleEndColumn < fromVisibleColumn) {
-                    continue;
-                }
-            }
-            if (isRTL) {
-                if (visibleEndColumn > fromVisibleColumn) {
-                    continue;
-                }
-                if (visibleStartColumn < toVisibleColumn) {
-                    continue;
-                }
-            }
-            result.push(new SingleCursorState(new Range(lineNumber, startColumn, lineNumber, startColumn), 0 /* SelectionStartKind.Simple */, 0, new Position(lineNumber, endColumn), 0));
-        }
-        if (result.length === 0) {
-            // We are after all the lines, so add cursor at the end of each line
-            for (let i = 0; i < lineCount; i++) {
-                const lineNumber = fromLineNumber + (reversed ? -i : i);
-                const maxColumn = model.getLineMaxColumn(lineNumber);
-                result.push(new SingleCursorState(new Range(lineNumber, maxColumn, lineNumber, maxColumn), 0 /* SelectionStartKind.Simple */, 0, new Position(lineNumber, maxColumn), 0));
-            }
-        }
-        return {
-            viewStates: result,
-            reversed: reversed,
-            fromLineNumber: fromLineNumber,
-            fromVisualColumn: fromVisibleColumn,
-            toLineNumber: toLineNumber,
-            toVisualColumn: toVisibleColumn
-        };
-    }
-    static columnSelectLeft(config, model, prevColumnSelectData) {
-        let toViewVisualColumn = prevColumnSelectData.toViewVisualColumn;
-        if (toViewVisualColumn > 0) {
-            toViewVisualColumn--;
-        }
-        return ColumnSelection.columnSelect(config, model, prevColumnSelectData.fromViewLineNumber, prevColumnSelectData.fromViewVisualColumn, prevColumnSelectData.toViewLineNumber, toViewVisualColumn);
-    }
-    static columnSelectRight(config, model, prevColumnSelectData) {
-        let maxVisualViewColumn = 0;
-        const minViewLineNumber = Math.min(prevColumnSelectData.fromViewLineNumber, prevColumnSelectData.toViewLineNumber);
-        const maxViewLineNumber = Math.max(prevColumnSelectData.fromViewLineNumber, prevColumnSelectData.toViewLineNumber);
-        for (let lineNumber = minViewLineNumber; lineNumber <= maxViewLineNumber; lineNumber++) {
-            const lineMaxViewColumn = model.getLineMaxColumn(lineNumber);
-            const lineMaxVisualViewColumn = config.visibleColumnFromColumn(model, new Position(lineNumber, lineMaxViewColumn));
-            maxVisualViewColumn = Math.max(maxVisualViewColumn, lineMaxVisualViewColumn);
-        }
-        let toViewVisualColumn = prevColumnSelectData.toViewVisualColumn;
-        if (toViewVisualColumn < maxVisualViewColumn) {
-            toViewVisualColumn++;
-        }
-        return this.columnSelect(config, model, prevColumnSelectData.fromViewLineNumber, prevColumnSelectData.fromViewVisualColumn, prevColumnSelectData.toViewLineNumber, toViewVisualColumn);
-    }
-    static columnSelectUp(config, model, prevColumnSelectData, isPaged) {
-        const linesCount = isPaged ? config.pageSize : 1;
-        const toViewLineNumber = Math.max(1, prevColumnSelectData.toViewLineNumber - linesCount);
-        return this.columnSelect(config, model, prevColumnSelectData.fromViewLineNumber, prevColumnSelectData.fromViewVisualColumn, toViewLineNumber, prevColumnSelectData.toViewVisualColumn);
-    }
-    static columnSelectDown(config, model, prevColumnSelectData, isPaged) {
-        const linesCount = isPaged ? config.pageSize : 1;
-        const toViewLineNumber = Math.min(model.getLineCount(), prevColumnSelectData.toViewLineNumber + linesCount);
-        return this.columnSelect(config, model, prevColumnSelectData.fromViewLineNumber, prevColumnSelectData.fromViewVisualColumn, toViewLineNumber, prevColumnSelectData.toViewVisualColumn);
-    }
-}
-
-export { ColumnSelection };

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

@@ -1,112 +0,0 @@
-import { isFullWidthCharacter, isEmojiImprecise, GraphemeIterator, getNextCodePoint } from '../../../base/common/strings.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-/**
- * A column in a position is the gap between two adjacent characters. The methods here
- * work with a concept called "visible column". A visible column is a very rough approximation
- * of the horizontal screen position of a column. For example, using a tab size of 4:
- * ```txt
- * |<TAB>|<TAB>|T|ext
- * |     |     | \---- column = 4, visible column = 9
- * |     |     \------ column = 3, visible column = 8
- * |     \------------ column = 2, visible column = 4
- * \------------------ column = 1, visible column = 0
- * ```
- *
- * **NOTE**: Visual columns do not work well for RTL text or variable-width fonts or characters.
- *
- * **NOTE**: These methods work and make sense both on the model and on the view model.
- */
-class CursorColumns {
-    static _nextVisibleColumn(codePoint, visibleColumn, tabSize) {
-        if (codePoint === 9 /* CharCode.Tab */) {
-            return CursorColumns.nextRenderTabStop(visibleColumn, tabSize);
-        }
-        if (isFullWidthCharacter(codePoint) || isEmojiImprecise(codePoint)) {
-            return visibleColumn + 2;
-        }
-        return visibleColumn + 1;
-    }
-    /**
-     * Returns a visible column from a column.
-     * @see {@link CursorColumns}
-     */
-    static visibleColumnFromColumn(lineContent, column, tabSize) {
-        const textLen = Math.min(column - 1, lineContent.length);
-        const text = lineContent.substring(0, textLen);
-        const iterator = new GraphemeIterator(text);
-        let result = 0;
-        while (!iterator.eol()) {
-            const codePoint = getNextCodePoint(text, textLen, iterator.offset);
-            iterator.nextGraphemeLength();
-            result = this._nextVisibleColumn(codePoint, result, tabSize);
-        }
-        return result;
-    }
-    /**
-     * Returns a column from a visible column.
-     * @see {@link CursorColumns}
-     */
-    static columnFromVisibleColumn(lineContent, visibleColumn, tabSize) {
-        if (visibleColumn <= 0) {
-            return 1;
-        }
-        const lineContentLength = lineContent.length;
-        const iterator = new GraphemeIterator(lineContent);
-        let beforeVisibleColumn = 0;
-        let beforeColumn = 1;
-        while (!iterator.eol()) {
-            const codePoint = getNextCodePoint(lineContent, lineContentLength, iterator.offset);
-            iterator.nextGraphemeLength();
-            const afterVisibleColumn = this._nextVisibleColumn(codePoint, beforeVisibleColumn, tabSize);
-            const afterColumn = iterator.offset + 1;
-            if (afterVisibleColumn >= visibleColumn) {
-                const beforeDelta = visibleColumn - beforeVisibleColumn;
-                const afterDelta = afterVisibleColumn - visibleColumn;
-                if (afterDelta < beforeDelta) {
-                    return afterColumn;
-                }
-                else {
-                    return beforeColumn;
-                }
-            }
-            beforeVisibleColumn = afterVisibleColumn;
-            beforeColumn = afterColumn;
-        }
-        // walked the entire string
-        return lineContentLength + 1;
-    }
-    /**
-     * ATTENTION: This works with 0-based columns (as opposed to the regular 1-based columns)
-     * @see {@link CursorColumns}
-     */
-    static nextRenderTabStop(visibleColumn, tabSize) {
-        return visibleColumn + tabSize - visibleColumn % tabSize;
-    }
-    /**
-     * ATTENTION: This works with 0-based columns (as opposed to the regular 1-based columns)
-     * @see {@link CursorColumns}
-     */
-    static nextIndentTabStop(visibleColumn, indentSize) {
-        return CursorColumns.nextRenderTabStop(visibleColumn, indentSize);
-    }
-    /**
-     * ATTENTION: This works with 0-based columns (as opposed to the regular 1-based columns)
-     * @see {@link CursorColumns}
-     */
-    static prevRenderTabStop(column, tabSize) {
-        return Math.max(0, column - 1 - (column - 1) % tabSize);
-    }
-    /**
-     * ATTENTION: This works with 0-based columns (as opposed to the regular 1-based columns)
-     * @see {@link CursorColumns}
-     */
-    static prevIndentTabStop(column, indentSize) {
-        return CursorColumns.prevRenderTabStop(column, indentSize);
-    }
-}
-
-export { CursorColumns };