monaco-editor11 1.1.1 → 1.1.2

package/dist/workers/selectBoxNative.js

@@ -0,0 +1,142 @@
+import { addDisposableListener, addStandardDisposableListener, EventHelper } from '../../dom.js';
+import { Gesture, EventType } from '../../touch.js';
+import { equals } from '../../../common/arrays.js';
+import { Emitter } from '../../../common/event.js';
+import { Disposable } from '../../../common/lifecycle.js';
+import { isMacintosh } from '../../../common/platform.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class SelectBoxNative extends Disposable {
+    constructor(options, selected, styles, selectBoxOptions) {
+        super();
+        this.selected = 0;
+        this.selectBoxOptions = selectBoxOptions || Object.create(null);
+        this.options = [];
+        this.selectElement = document.createElement('select');
+        this.selectElement.className = 'monaco-select-box';
+        if (typeof this.selectBoxOptions.ariaLabel === 'string') {
+            this.selectElement.setAttribute('aria-label', this.selectBoxOptions.ariaLabel);
+        }
+        if (typeof this.selectBoxOptions.ariaDescription === 'string') {
+            this.selectElement.setAttribute('aria-description', this.selectBoxOptions.ariaDescription);
+        }
+        this._onDidSelect = this._register(new Emitter());
+        this.styles = styles;
+        this.registerListeners();
+        this.setOptions(options, selected);
+    }
+    registerListeners() {
+        this._register(Gesture.addTarget(this.selectElement));
+        [EventType.Tap].forEach(eventType => {
+            this._register(addDisposableListener(this.selectElement, eventType, (e) => {
+                this.selectElement.focus();
+            }));
+        });
+        this._register(addStandardDisposableListener(this.selectElement, 'click', (e) => {
+            EventHelper.stop(e, true);
+        }));
+        this._register(addStandardDisposableListener(this.selectElement, 'change', (e) => {
+            this.selectElement.title = e.target.value;
+            this._onDidSelect.fire({
+                index: e.target.selectedIndex,
+                selected: e.target.value
+            });
+        }));
+        this._register(addStandardDisposableListener(this.selectElement, 'keydown', (e) => {
+            let showSelect = false;
+            if (isMacintosh) {
+                if (e.keyCode === 18 /* KeyCode.DownArrow */ || e.keyCode === 16 /* KeyCode.UpArrow */ || e.keyCode === 10 /* KeyCode.Space */) {
+                    showSelect = true;
+                }
+            }
+            else {
+                if (e.keyCode === 18 /* KeyCode.DownArrow */ && e.altKey || e.keyCode === 10 /* KeyCode.Space */ || e.keyCode === 3 /* KeyCode.Enter */) {
+                    showSelect = true;
+                }
+            }
+            if (showSelect) {
+                // Space, Enter, is used to expand select box, do not propagate it (prevent action bar action run)
+                e.stopPropagation();
+            }
+        }));
+    }
+    get onDidSelect() {
+        return this._onDidSelect.event;
+    }
+    setOptions(options, selected) {
+        if (!this.options || !equals(this.options, options)) {
+            this.options = options;
+            this.selectElement.options.length = 0;
+            this.options.forEach((option, index) => {
+                this.selectElement.add(this.createOption(option.text, index, option.isDisabled));
+            });
+        }
+        if (selected !== undefined) {
+            this.select(selected);
+        }
+    }
+    select(index) {
+        if (this.options.length === 0) {
+            this.selected = 0;
+        }
+        else if (index >= 0 && index < this.options.length) {
+            this.selected = index;
+        }
+        else if (index > this.options.length - 1) {
+            // Adjust index to end of list
+            // This could make client out of sync with the select
+            this.select(this.options.length - 1);
+        }
+        else if (this.selected < 0) {
+            this.selected = 0;
+        }
+        this.selectElement.selectedIndex = this.selected;
+        if ((this.selected < this.options.length) && typeof this.options[this.selected].text === 'string') {
+            this.selectElement.title = this.options[this.selected].text;
+        }
+        else {
+            this.selectElement.title = '';
+        }
+    }
+    focus() {
+        if (this.selectElement) {
+            this.selectElement.tabIndex = 0;
+            this.selectElement.focus();
+        }
+    }
+    blur() {
+        if (this.selectElement) {
+            this.selectElement.tabIndex = -1;
+            this.selectElement.blur();
+        }
+    }
+    setFocusable(focusable) {
+        this.selectElement.tabIndex = focusable ? 0 : -1;
+    }
+    render(container) {
+        container.classList.add('select-container');
+        container.appendChild(this.selectElement);
+        this.setOptions(this.options, this.selected);
+        this.applyStyles();
+    }
+    applyStyles() {
+        // Style native select
+        if (this.selectElement) {
+            this.selectElement.style.backgroundColor = this.styles.selectBackground ?? '';
+            this.selectElement.style.color = this.styles.selectForeground ?? '';
+            this.selectElement.style.borderColor = this.styles.selectBorder ?? '';
+        }
+    }
+    createOption(value, index, disabled) {
+        const option = document.createElement('option');
+        option.value = value;
+        option.text = value;
+        option.disabled = !!disabled;
+        return option;
+    }
+}
+
+export { SelectBoxNative };

package/dist/workers/selection.js

@@ -0,0 +1,145 @@
+import { Position } from './position.js';
+import { Range } from './range.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * A selection in the editor.
+ * The selection is a range that has an orientation.
+ */
+class Selection extends Range {
+    constructor(selectionStartLineNumber, selectionStartColumn, positionLineNumber, positionColumn) {
+        super(selectionStartLineNumber, selectionStartColumn, positionLineNumber, positionColumn);
+        this.selectionStartLineNumber = selectionStartLineNumber;
+        this.selectionStartColumn = selectionStartColumn;
+        this.positionLineNumber = positionLineNumber;
+        this.positionColumn = positionColumn;
+    }
+    /**
+     * Transform to a human-readable representation.
+     */
+    toString() {
+        return '[' + this.selectionStartLineNumber + ',' + this.selectionStartColumn + ' -> ' + this.positionLineNumber + ',' + this.positionColumn + ']';
+    }
+    /**
+     * Test if equals other selection.
+     */
+    equalsSelection(other) {
+        return (Selection.selectionsEqual(this, other));
+    }
+    /**
+     * Test if the two selections are equal.
+     */
+    static selectionsEqual(a, b) {
+        return (a.selectionStartLineNumber === b.selectionStartLineNumber &&
+            a.selectionStartColumn === b.selectionStartColumn &&
+            a.positionLineNumber === b.positionLineNumber &&
+            a.positionColumn === b.positionColumn);
+    }
+    /**
+     * Get directions (LTR or RTL).
+     */
+    getDirection() {
+        if (this.selectionStartLineNumber === this.startLineNumber && this.selectionStartColumn === this.startColumn) {
+            return 0 /* SelectionDirection.LTR */;
+        }
+        return 1 /* SelectionDirection.RTL */;
+    }
+    /**
+     * Create a new selection with a different `positionLineNumber` and `positionColumn`.
+     */
+    setEndPosition(endLineNumber, endColumn) {
+        if (this.getDirection() === 0 /* SelectionDirection.LTR */) {
+            return new Selection(this.startLineNumber, this.startColumn, endLineNumber, endColumn);
+        }
+        return new Selection(endLineNumber, endColumn, this.startLineNumber, this.startColumn);
+    }
+    /**
+     * Get the position at `positionLineNumber` and `positionColumn`.
+     */
+    getPosition() {
+        return new Position(this.positionLineNumber, this.positionColumn);
+    }
+    /**
+     * Get the position at the start of the selection.
+    */
+    getSelectionStart() {
+        return new Position(this.selectionStartLineNumber, this.selectionStartColumn);
+    }
+    /**
+     * Create a new selection with a different `selectionStartLineNumber` and `selectionStartColumn`.
+     */
+    setStartPosition(startLineNumber, startColumn) {
+        if (this.getDirection() === 0 /* SelectionDirection.LTR */) {
+            return new Selection(startLineNumber, startColumn, this.endLineNumber, this.endColumn);
+        }
+        return new Selection(this.endLineNumber, this.endColumn, startLineNumber, startColumn);
+    }
+    // ----
+    /**
+     * Create a `Selection` from one or two positions
+     */
+    static fromPositions(start, end = start) {
+        return new Selection(start.lineNumber, start.column, end.lineNumber, end.column);
+    }
+    /**
+     * Creates a `Selection` from a range, given a direction.
+     */
+    static fromRange(range, direction) {
+        if (direction === 0 /* SelectionDirection.LTR */) {
+            return new Selection(range.startLineNumber, range.startColumn, range.endLineNumber, range.endColumn);
+        }
+        else {
+            return new Selection(range.endLineNumber, range.endColumn, range.startLineNumber, range.startColumn);
+        }
+    }
+    /**
+     * Create a `Selection` from an `ISelection`.
+     */
+    static liftSelection(sel) {
+        return new Selection(sel.selectionStartLineNumber, sel.selectionStartColumn, sel.positionLineNumber, sel.positionColumn);
+    }
+    /**
+     * `a` equals `b`.
+     */
+    static selectionsArrEqual(a, b) {
+        if (a && !b || !a && b) {
+            return false;
+        }
+        if (!a && !b) {
+            return true;
+        }
+        if (a.length !== b.length) {
+            return false;
+        }
+        for (let i = 0, len = a.length; i < len; i++) {
+            if (!this.selectionsEqual(a[i], b[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Test if `obj` is an `ISelection`.
+     */
+    static isISelection(obj) {
+        return (!!obj
+            && (typeof obj.selectionStartLineNumber === 'number')
+            && (typeof obj.selectionStartColumn === 'number')
+            && (typeof obj.positionLineNumber === 'number')
+            && (typeof obj.positionColumn === 'number'));
+    }
+    /**
+     * Create with a direction.
+     */
+    static createWithDirection(startLineNumber, startColumn, endLineNumber, endColumn, direction) {
+        if (direction === 0 /* SelectionDirection.LTR */) {
+            return new Selection(startLineNumber, startColumn, endLineNumber, endColumn);
+        }
+        return new Selection(endLineNumber, endColumn, startLineNumber, startColumn);
+    }
+}
+
+export { Selection };

package/dist/workers/selections.js

@@ -0,0 +1,338 @@
+import './selections.css';
+import { DynamicViewOverlay } from '../../view/dynamicViewOverlay.js';
+import '../../../../platform/theme/common/colorUtils.js';
+import '../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../platform/theme/common/colors/chartsColors.js';
+import { editorSelectionForeground } from '../../../../platform/theme/common/colors/editorColors.js';
+import '../../../../platform/theme/common/colors/inputColors.js';
+import '../../../../platform/theme/common/colors/listColors.js';
+import '../../../../platform/theme/common/colors/menuColors.js';
+import '../../../../platform/theme/common/colors/minimapColors.js';
+import '../../../../platform/theme/common/colors/miscColors.js';
+import '../../../../platform/theme/common/colors/quickpickColors.js';
+import '../../../../platform/theme/common/colors/searchColors.js';
+import { registerThemingParticipant } from '../../../../platform/theme/common/themeService.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class HorizontalRangeWithStyle {
+    constructor(other) {
+        this.left = other.left;
+        this.width = other.width;
+        this.startStyle = null;
+        this.endStyle = null;
+    }
+}
+class LineVisibleRangesWithStyle {
+    constructor(lineNumber, ranges) {
+        this.lineNumber = lineNumber;
+        this.ranges = ranges;
+    }
+}
+function toStyledRange(item) {
+    return new HorizontalRangeWithStyle(item);
+}
+function toStyled(item) {
+    return new LineVisibleRangesWithStyle(item.lineNumber, item.ranges.map(toStyledRange));
+}
+/**
+ * This view part displays selected text to the user. Every line has its own selection overlay.
+ */
+class SelectionsOverlay extends DynamicViewOverlay {
+    static { this.SELECTION_CLASS_NAME = 'selected-text'; }
+    static { this.SELECTION_TOP_LEFT = 'top-left-radius'; }
+    static { this.SELECTION_BOTTOM_LEFT = 'bottom-left-radius'; }
+    static { this.SELECTION_TOP_RIGHT = 'top-right-radius'; }
+    static { this.SELECTION_BOTTOM_RIGHT = 'bottom-right-radius'; }
+    static { this.EDITOR_BACKGROUND_CLASS_NAME = 'monaco-editor-background'; }
+    static { this.ROUNDED_PIECE_WIDTH = 10; }
+    constructor(context) {
+        super();
+        this._previousFrameVisibleRangesWithStyle = [];
+        this._context = context;
+        const options = this._context.configuration.options;
+        this._roundedSelection = options.get(115 /* EditorOption.roundedSelection */);
+        this._typicalHalfwidthCharacterWidth = options.get(59 /* EditorOption.fontInfo */).typicalHalfwidthCharacterWidth;
+        this._selections = [];
+        this._renderResult = null;
+        this._context.addEventHandler(this);
+    }
+    dispose() {
+        this._context.removeEventHandler(this);
+        this._renderResult = null;
+        super.dispose();
+    }
+    // --- begin event handlers
+    onConfigurationChanged(e) {
+        const options = this._context.configuration.options;
+        this._roundedSelection = options.get(115 /* EditorOption.roundedSelection */);
+        this._typicalHalfwidthCharacterWidth = options.get(59 /* EditorOption.fontInfo */).typicalHalfwidthCharacterWidth;
+        return true;
+    }
+    onCursorStateChanged(e) {
+        this._selections = e.selections.slice(0);
+        return true;
+    }
+    onDecorationsChanged(e) {
+        // true for inline decorations that can end up relayouting text
+        return true; //e.inlineDecorationsChanged;
+    }
+    onFlushed(e) {
+        return true;
+    }
+    onLinesChanged(e) {
+        return true;
+    }
+    onLinesDeleted(e) {
+        return true;
+    }
+    onLinesInserted(e) {
+        return true;
+    }
+    onScrollChanged(e) {
+        return e.scrollTopChanged;
+    }
+    onZonesChanged(e) {
+        return true;
+    }
+    // --- end event handlers
+    _visibleRangesHaveGaps(linesVisibleRanges) {
+        for (let i = 0, len = linesVisibleRanges.length; i < len; i++) {
+            const lineVisibleRanges = linesVisibleRanges[i];
+            if (lineVisibleRanges.ranges.length > 1) {
+                // There are two ranges on the same line
+                return true;
+            }
+        }
+        return false;
+    }
+    _enrichVisibleRangesWithStyle(viewport, linesVisibleRanges, previousFrame) {
+        const epsilon = this._typicalHalfwidthCharacterWidth / 4;
+        let previousFrameTop = null;
+        let previousFrameBottom = null;
+        if (previousFrame && previousFrame.length > 0 && linesVisibleRanges.length > 0) {
+            const topLineNumber = linesVisibleRanges[0].lineNumber;
+            if (topLineNumber === viewport.startLineNumber) {
+                for (let i = 0; !previousFrameTop && i < previousFrame.length; i++) {
+                    if (previousFrame[i].lineNumber === topLineNumber) {
+                        previousFrameTop = previousFrame[i].ranges[0];
+                    }
+                }
+            }
+            const bottomLineNumber = linesVisibleRanges[linesVisibleRanges.length - 1].lineNumber;
+            if (bottomLineNumber === viewport.endLineNumber) {
+                for (let i = previousFrame.length - 1; !previousFrameBottom && i >= 0; i--) {
+                    if (previousFrame[i].lineNumber === bottomLineNumber) {
+                        previousFrameBottom = previousFrame[i].ranges[0];
+                    }
+                }
+            }
+            if (previousFrameTop && !previousFrameTop.startStyle) {
+                previousFrameTop = null;
+            }
+            if (previousFrameBottom && !previousFrameBottom.startStyle) {
+                previousFrameBottom = null;
+            }
+        }
+        for (let i = 0, len = linesVisibleRanges.length; i < len; i++) {
+            // We know for a fact that there is precisely one range on each line
+            const curLineRange = linesVisibleRanges[i].ranges[0];
+            const curLeft = curLineRange.left;
+            const curRight = curLineRange.left + curLineRange.width;
+            const startStyle = {
+                top: 0 /* CornerStyle.EXTERN */,
+                bottom: 0 /* CornerStyle.EXTERN */
+            };
+            const endStyle = {
+                top: 0 /* CornerStyle.EXTERN */,
+                bottom: 0 /* CornerStyle.EXTERN */
+            };
+            if (i > 0) {
+                // Look above
+                const prevLeft = linesVisibleRanges[i - 1].ranges[0].left;
+                const prevRight = linesVisibleRanges[i - 1].ranges[0].left + linesVisibleRanges[i - 1].ranges[0].width;
+                if (abs(curLeft - prevLeft) < epsilon) {
+                    startStyle.top = 2 /* CornerStyle.FLAT */;
+                }
+                else if (curLeft > prevLeft) {
+                    startStyle.top = 1 /* CornerStyle.INTERN */;
+                }
+                if (abs(curRight - prevRight) < epsilon) {
+                    endStyle.top = 2 /* CornerStyle.FLAT */;
+                }
+                else if (prevLeft < curRight && curRight < prevRight) {
+                    endStyle.top = 1 /* CornerStyle.INTERN */;
+                }
+            }
+            else if (previousFrameTop) {
+                // Accept some hiccups near the viewport edges to save on repaints
+                startStyle.top = previousFrameTop.startStyle.top;
+                endStyle.top = previousFrameTop.endStyle.top;
+            }
+            if (i + 1 < len) {
+                // Look below
+                const nextLeft = linesVisibleRanges[i + 1].ranges[0].left;
+                const nextRight = linesVisibleRanges[i + 1].ranges[0].left + linesVisibleRanges[i + 1].ranges[0].width;
+                if (abs(curLeft - nextLeft) < epsilon) {
+                    startStyle.bottom = 2 /* CornerStyle.FLAT */;
+                }
+                else if (nextLeft < curLeft && curLeft < nextRight) {
+                    startStyle.bottom = 1 /* CornerStyle.INTERN */;
+                }
+                if (abs(curRight - nextRight) < epsilon) {
+                    endStyle.bottom = 2 /* CornerStyle.FLAT */;
+                }
+                else if (curRight < nextRight) {
+                    endStyle.bottom = 1 /* CornerStyle.INTERN */;
+                }
+            }
+            else if (previousFrameBottom) {
+                // Accept some hiccups near the viewport edges to save on repaints
+                startStyle.bottom = previousFrameBottom.startStyle.bottom;
+                endStyle.bottom = previousFrameBottom.endStyle.bottom;
+            }
+            curLineRange.startStyle = startStyle;
+            curLineRange.endStyle = endStyle;
+        }
+    }
+    _getVisibleRangesWithStyle(selection, ctx, previousFrame) {
+        const _linesVisibleRanges = ctx.linesVisibleRangesForRange(selection, true) || [];
+        const linesVisibleRanges = _linesVisibleRanges.map(toStyled);
+        const visibleRangesHaveGaps = this._visibleRangesHaveGaps(linesVisibleRanges);
+        if (!visibleRangesHaveGaps && this._roundedSelection) {
+            this._enrichVisibleRangesWithStyle(ctx.visibleRange, linesVisibleRanges, previousFrame);
+        }
+        // The visible ranges are sorted TOP-BOTTOM and LEFT-RIGHT
+        return linesVisibleRanges;
+    }
+    _createSelectionPiece(top, bottom, className, left, width) {
+        return ('<div class="cslr '
+            + className
+            + '" style="'
+            + 'top:' + top.toString() + 'px;'
+            + 'bottom:' + bottom.toString() + 'px;'
+            + 'left:' + left.toString() + 'px;'
+            + 'width:' + width.toString() + 'px;'
+            + '"></div>');
+    }
+    _actualRenderOneSelection(output2, visibleStartLineNumber, hasMultipleSelections, visibleRanges) {
+        if (visibleRanges.length === 0) {
+            return;
+        }
+        const visibleRangesHaveStyle = !!visibleRanges[0].ranges[0].startStyle;
+        const firstLineNumber = visibleRanges[0].lineNumber;
+        const lastLineNumber = visibleRanges[visibleRanges.length - 1].lineNumber;
+        for (let i = 0, len = visibleRanges.length; i < len; i++) {
+            const lineVisibleRanges = visibleRanges[i];
+            const lineNumber = lineVisibleRanges.lineNumber;
+            const lineIndex = lineNumber - visibleStartLineNumber;
+            const top = hasMultipleSelections ? (lineNumber === firstLineNumber ? 1 : 0) : 0;
+            const bottom = hasMultipleSelections ? (lineNumber !== firstLineNumber && lineNumber === lastLineNumber ? 1 : 0) : 0;
+            let innerCornerOutput = '';
+            let restOfSelectionOutput = '';
+            for (let j = 0, lenJ = lineVisibleRanges.ranges.length; j < lenJ; j++) {
+                const visibleRange = lineVisibleRanges.ranges[j];
+                if (visibleRangesHaveStyle) {
+                    const startStyle = visibleRange.startStyle;
+                    const endStyle = visibleRange.endStyle;
+                    if (startStyle.top === 1 /* CornerStyle.INTERN */ || startStyle.bottom === 1 /* CornerStyle.INTERN */) {
+                        // Reverse rounded corner to the left
+                        // First comes the selection (blue layer)
+                        innerCornerOutput += this._createSelectionPiece(top, bottom, SelectionsOverlay.SELECTION_CLASS_NAME, visibleRange.left - SelectionsOverlay.ROUNDED_PIECE_WIDTH, SelectionsOverlay.ROUNDED_PIECE_WIDTH);
+                        // Second comes the background (white layer) with inverse border radius
+                        let className = SelectionsOverlay.EDITOR_BACKGROUND_CLASS_NAME;
+                        if (startStyle.top === 1 /* CornerStyle.INTERN */) {
+                            className += ' ' + SelectionsOverlay.SELECTION_TOP_RIGHT;
+                        }
+                        if (startStyle.bottom === 1 /* CornerStyle.INTERN */) {
+                            className += ' ' + SelectionsOverlay.SELECTION_BOTTOM_RIGHT;
+                        }
+                        innerCornerOutput += this._createSelectionPiece(top, bottom, className, visibleRange.left - SelectionsOverlay.ROUNDED_PIECE_WIDTH, SelectionsOverlay.ROUNDED_PIECE_WIDTH);
+                    }
+                    if (endStyle.top === 1 /* CornerStyle.INTERN */ || endStyle.bottom === 1 /* CornerStyle.INTERN */) {
+                        // Reverse rounded corner to the right
+                        // First comes the selection (blue layer)
+                        innerCornerOutput += this._createSelectionPiece(top, bottom, SelectionsOverlay.SELECTION_CLASS_NAME, visibleRange.left + visibleRange.width, SelectionsOverlay.ROUNDED_PIECE_WIDTH);
+                        // Second comes the background (white layer) with inverse border radius
+                        let className = SelectionsOverlay.EDITOR_BACKGROUND_CLASS_NAME;
+                        if (endStyle.top === 1 /* CornerStyle.INTERN */) {
+                            className += ' ' + SelectionsOverlay.SELECTION_TOP_LEFT;
+                        }
+                        if (endStyle.bottom === 1 /* CornerStyle.INTERN */) {
+                            className += ' ' + SelectionsOverlay.SELECTION_BOTTOM_LEFT;
+                        }
+                        innerCornerOutput += this._createSelectionPiece(top, bottom, className, visibleRange.left + visibleRange.width, SelectionsOverlay.ROUNDED_PIECE_WIDTH);
+                    }
+                }
+                let className = SelectionsOverlay.SELECTION_CLASS_NAME;
+                if (visibleRangesHaveStyle) {
+                    const startStyle = visibleRange.startStyle;
+                    const endStyle = visibleRange.endStyle;
+                    if (startStyle.top === 0 /* CornerStyle.EXTERN */) {
+                        className += ' ' + SelectionsOverlay.SELECTION_TOP_LEFT;
+                    }
+                    if (startStyle.bottom === 0 /* CornerStyle.EXTERN */) {
+                        className += ' ' + SelectionsOverlay.SELECTION_BOTTOM_LEFT;
+                    }
+                    if (endStyle.top === 0 /* CornerStyle.EXTERN */) {
+                        className += ' ' + SelectionsOverlay.SELECTION_TOP_RIGHT;
+                    }
+                    if (endStyle.bottom === 0 /* CornerStyle.EXTERN */) {
+                        className += ' ' + SelectionsOverlay.SELECTION_BOTTOM_RIGHT;
+                    }
+                }
+                restOfSelectionOutput += this._createSelectionPiece(top, bottom, className, visibleRange.left, visibleRange.width);
+            }
+            output2[lineIndex][0] += innerCornerOutput;
+            output2[lineIndex][1] += restOfSelectionOutput;
+        }
+    }
+    prepareRender(ctx) {
+        // Build HTML for inner corners separate from HTML for the rest of selections,
+        // as the inner corner HTML can interfere with that of other selections.
+        // In final render, make sure to place the inner corner HTML before the rest of selection HTML. See issue #77777.
+        const output = [];
+        const visibleStartLineNumber = ctx.visibleRange.startLineNumber;
+        const visibleEndLineNumber = ctx.visibleRange.endLineNumber;
+        for (let lineNumber = visibleStartLineNumber; lineNumber <= visibleEndLineNumber; lineNumber++) {
+            const lineIndex = lineNumber - visibleStartLineNumber;
+            output[lineIndex] = ['', ''];
+        }
+        const thisFrameVisibleRangesWithStyle = [];
+        for (let i = 0, len = this._selections.length; i < len; i++) {
+            const selection = this._selections[i];
+            if (selection.isEmpty()) {
+                thisFrameVisibleRangesWithStyle[i] = null;
+                continue;
+            }
+            const visibleRangesWithStyle = this._getVisibleRangesWithStyle(selection, ctx, this._previousFrameVisibleRangesWithStyle[i]);
+            thisFrameVisibleRangesWithStyle[i] = visibleRangesWithStyle;
+            this._actualRenderOneSelection(output, visibleStartLineNumber, this._selections.length > 1, visibleRangesWithStyle);
+        }
+        this._previousFrameVisibleRangesWithStyle = thisFrameVisibleRangesWithStyle;
+        this._renderResult = output.map(([internalCorners, restOfSelection]) => internalCorners + restOfSelection);
+    }
+    render(startLineNumber, lineNumber) {
+        if (!this._renderResult) {
+            return '';
+        }
+        const lineIndex = lineNumber - startLineNumber;
+        if (lineIndex < 0 || lineIndex >= this._renderResult.length) {
+            return '';
+        }
+        return this._renderResult[lineIndex];
+    }
+}
+registerThemingParticipant((theme, collector) => {
+    const editorSelectionForegroundColor = theme.getColor(editorSelectionForeground);
+    if (editorSelectionForegroundColor && !editorSelectionForegroundColor.isTransparent()) {
+        collector.addRule(`.monaco-editor .view-line span.inline-selected-text { color: ${editorSelectionForegroundColor}; }`);
+    }
+});
+function abs(n) {
+    return n < 0 ? -n : n;
+}
+
+export { SelectionsOverlay };

package/dist/workers/semanticTokensConfig.js

@@ -0,0 +1,14 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const SEMANTIC_HIGHLIGHTING_SETTING_ID = 'editor.semanticHighlighting';
+function isSemanticColoringEnabled(model, themeService, configurationService) {
+    const setting = configurationService.getValue(SEMANTIC_HIGHLIGHTING_SETTING_ID, { overrideIdentifier: model.getLanguageId(), resource: model.uri })?.enabled;
+    if (typeof setting === 'boolean') {
+        return setting;
+    }
+    return themeService.getColorTheme().semanticHighlighting;
+}
+
+export { SEMANTIC_HIGHLIGHTING_SETTING_ID, isSemanticColoringEnabled };