monaco-editor11 1.1.1 → 1.1.2

package/dist/workers/whitespace.js

@@ -0,0 +1,277 @@
+import './whitespace.css';
+import { DynamicViewOverlay } from '../../view/dynamicViewOverlay.js';
+import { firstNonWhitespaceIndex, lastNonWhitespaceIndex } from '../../../../base/common/strings.js';
+import { Position } from '../../../common/core/position.js';
+import { editorWhitespaces } from '../../../common/core/editorColorRegistry.js';
+import { OffsetRange } from '../../../common/core/ranges/offsetRange.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * The whitespace overlay will visual certain whitespace depending on the
+ * current editor configuration (boundary, selection, etc.).
+ */
+class WhitespaceOverlay extends DynamicViewOverlay {
+    constructor(context) {
+        super();
+        this._context = context;
+        this._options = new WhitespaceOptions(this._context.configuration);
+        this._selection = [];
+        this._renderResult = null;
+        this._context.addEventHandler(this);
+    }
+    dispose() {
+        this._context.removeEventHandler(this);
+        this._renderResult = null;
+        super.dispose();
+    }
+    // --- begin event handlers
+    onConfigurationChanged(e) {
+        const newOptions = new WhitespaceOptions(this._context.configuration);
+        if (this._options.equals(newOptions)) {
+            return e.hasChanged(165 /* EditorOption.layoutInfo */);
+        }
+        this._options = newOptions;
+        return true;
+    }
+    onCursorStateChanged(e) {
+        this._selection = e.selections;
+        if (this._options.renderWhitespace === 'selection') {
+            return true;
+        }
+        return false;
+    }
+    onDecorationsChanged(e) {
+        return true;
+    }
+    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
+    prepareRender(ctx) {
+        if (this._options.renderWhitespace === 'none') {
+            this._renderResult = null;
+            return;
+        }
+        const startLineNumber = ctx.visibleRange.startLineNumber;
+        const endLineNumber = ctx.visibleRange.endLineNumber;
+        const lineCount = endLineNumber - startLineNumber + 1;
+        const needed = new Array(lineCount);
+        for (let i = 0; i < lineCount; i++) {
+            needed[i] = true;
+        }
+        this._renderResult = [];
+        for (let lineNumber = ctx.viewportData.startLineNumber; lineNumber <= ctx.viewportData.endLineNumber; lineNumber++) {
+            const lineIndex = lineNumber - ctx.viewportData.startLineNumber;
+            const lineData = this._context.viewModel.getViewLineRenderingData(lineNumber);
+            let selectionsOnLine = null;
+            if (this._options.renderWhitespace === 'selection') {
+                const selections = this._selection;
+                for (const selection of selections) {
+                    if (selection.endLineNumber < lineNumber || selection.startLineNumber > lineNumber) {
+                        // Selection does not intersect line
+                        continue;
+                    }
+                    const startColumn = (selection.startLineNumber === lineNumber ? selection.startColumn : lineData.minColumn);
+                    const endColumn = (selection.endLineNumber === lineNumber ? selection.endColumn : lineData.maxColumn);
+                    if (startColumn < endColumn) {
+                        if (!selectionsOnLine) {
+                            selectionsOnLine = [];
+                        }
+                        selectionsOnLine.push(new OffsetRange(startColumn - 1, endColumn - 1));
+                    }
+                }
+            }
+            this._renderResult[lineIndex] = this._applyRenderWhitespace(ctx, lineNumber, selectionsOnLine, lineData);
+        }
+    }
+    _applyRenderWhitespace(ctx, lineNumber, selections, lineData) {
+        if (lineData.hasVariableFonts) {
+            return '';
+        }
+        if (this._options.renderWhitespace === 'selection' && !selections) {
+            return '';
+        }
+        if (this._options.renderWhitespace === 'trailing' && lineData.continuesWithWrappedLine) {
+            return '';
+        }
+        const color = this._context.theme.getColor(editorWhitespaces);
+        const USE_SVG = this._options.renderWithSVG;
+        const lineContent = lineData.content;
+        const len = (this._options.stopRenderingLineAfter === -1 ? lineContent.length : Math.min(this._options.stopRenderingLineAfter, lineContent.length));
+        const continuesWithWrappedLine = lineData.continuesWithWrappedLine;
+        const fauxIndentLength = lineData.minColumn - 1;
+        const onlyBoundary = (this._options.renderWhitespace === 'boundary');
+        const onlyTrailing = (this._options.renderWhitespace === 'trailing');
+        const lineHeight = ctx.getLineHeightForLineNumber(lineNumber);
+        const middotWidth = this._options.middotWidth;
+        const wsmiddotWidth = this._options.wsmiddotWidth;
+        const spaceWidth = this._options.spaceWidth;
+        const wsmiddotDiff = Math.abs(wsmiddotWidth - spaceWidth);
+        const middotDiff = Math.abs(middotWidth - spaceWidth);
+        // U+2E31 - WORD SEPARATOR MIDDLE DOT
+        // U+00B7 - MIDDLE DOT
+        const renderSpaceCharCode = (wsmiddotDiff < middotDiff ? 0x2E31 : 0xB7);
+        const canUseHalfwidthRightwardsArrow = this._options.canUseHalfwidthRightwardsArrow;
+        let result = '';
+        let lineIsEmptyOrWhitespace = false;
+        let firstNonWhitespaceIndex$1 = firstNonWhitespaceIndex(lineContent);
+        let lastNonWhitespaceIndex$1;
+        if (firstNonWhitespaceIndex$1 === -1) {
+            lineIsEmptyOrWhitespace = true;
+            firstNonWhitespaceIndex$1 = len;
+            lastNonWhitespaceIndex$1 = len;
+        }
+        else {
+            lastNonWhitespaceIndex$1 = lastNonWhitespaceIndex(lineContent);
+        }
+        let currentSelectionIndex = 0;
+        let currentSelection = selections && selections[currentSelectionIndex];
+        let maxLeft = 0;
+        for (let charIndex = fauxIndentLength; charIndex < len; charIndex++) {
+            const chCode = lineContent.charCodeAt(charIndex);
+            if (currentSelection && currentSelection.endExclusive <= charIndex) {
+                currentSelectionIndex++;
+                currentSelection = selections && selections[currentSelectionIndex];
+            }
+            if (chCode !== 9 /* CharCode.Tab */ && chCode !== 32 /* CharCode.Space */) {
+                continue;
+            }
+            if (onlyTrailing && !lineIsEmptyOrWhitespace && charIndex <= lastNonWhitespaceIndex$1) {
+                // If rendering only trailing whitespace, check that the charIndex points to trailing whitespace.
+                continue;
+            }
+            if (onlyBoundary && charIndex >= firstNonWhitespaceIndex$1 && charIndex <= lastNonWhitespaceIndex$1 && chCode === 32 /* CharCode.Space */) {
+                // rendering only boundary whitespace
+                const prevChCode = (charIndex - 1 >= 0 ? lineContent.charCodeAt(charIndex - 1) : 0 /* CharCode.Null */);
+                const nextChCode = (charIndex + 1 < len ? lineContent.charCodeAt(charIndex + 1) : 0 /* CharCode.Null */);
+                if (prevChCode !== 32 /* CharCode.Space */ && nextChCode !== 32 /* CharCode.Space */) {
+                    continue;
+                }
+            }
+            if (onlyBoundary && continuesWithWrappedLine && charIndex === len - 1) {
+                const prevCharCode = (charIndex - 1 >= 0 ? lineContent.charCodeAt(charIndex - 1) : 0 /* CharCode.Null */);
+                const isSingleTrailingSpace = (chCode === 32 /* CharCode.Space */ && (prevCharCode !== 32 /* CharCode.Space */ && prevCharCode !== 9 /* CharCode.Tab */));
+                if (isSingleTrailingSpace) {
+                    continue;
+                }
+            }
+            if (selections && !(currentSelection && currentSelection.start <= charIndex && charIndex < currentSelection.endExclusive)) {
+                // If rendering whitespace on selection, check that the charIndex falls within a selection
+                continue;
+            }
+            const visibleRange = ctx.visibleRangeForPosition(new Position(lineNumber, charIndex + 1));
+            if (!visibleRange) {
+                continue;
+            }
+            if (USE_SVG) {
+                maxLeft = Math.max(maxLeft, visibleRange.left);
+                if (chCode === 9 /* CharCode.Tab */) {
+                    result += this._renderArrow(lineHeight, spaceWidth, visibleRange.left);
+                }
+                else {
+                    result += `<circle cx="${(visibleRange.left + spaceWidth / 2).toFixed(2)}" cy="${(lineHeight / 2).toFixed(2)}" r="${(spaceWidth / 7).toFixed(2)}" />`;
+                }
+            }
+            else {
+                if (chCode === 9 /* CharCode.Tab */) {
+                    result += `<div class="mwh" style="left:${visibleRange.left}px;height:${lineHeight}px;">${canUseHalfwidthRightwardsArrow ? String.fromCharCode(0xFFEB) : String.fromCharCode(0x2192)}</div>`;
+                }
+                else {
+                    result += `<div class="mwh" style="left:${visibleRange.left}px;height:${lineHeight}px;">${String.fromCharCode(renderSpaceCharCode)}</div>`;
+                }
+            }
+        }
+        if (USE_SVG) {
+            maxLeft = Math.round(maxLeft + spaceWidth);
+            return (`<svg style="bottom:0;position:absolute;width:${maxLeft}px;height:${lineHeight}px" viewBox="0 0 ${maxLeft} ${lineHeight}" xmlns="http://www.w3.org/2000/svg" fill="${color}">`
+                + result
+                + `</svg>`);
+        }
+        return result;
+    }
+    _renderArrow(lineHeight, spaceWidth, left) {
+        const strokeWidth = spaceWidth / 7;
+        const width = spaceWidth;
+        const dy = lineHeight / 2;
+        const dx = left;
+        const p1 = { x: 0, y: strokeWidth / 2 };
+        const p2 = { x: 100 / 125 * width, y: p1.y };
+        const p3 = { x: p2.x - 0.2 * p2.x, y: p2.y + 0.2 * p2.x };
+        const p4 = { x: p3.x + 0.1 * p2.x, y: p3.y + 0.1 * p2.x };
+        const p5 = { x: p4.x + 0.35 * p2.x, y: p4.y - 0.35 * p2.x };
+        const p6 = { x: p5.x, y: -p5.y };
+        const p7 = { x: p4.x, y: -p4.y };
+        const p8 = { x: p3.x, y: -p3.y };
+        const p9 = { x: p2.x, y: -p2.y };
+        const p10 = { x: p1.x, y: -p1.y };
+        const p = [p1, p2, p3, p4, p5, p6, p7, p8, p9, p10];
+        const parts = p.map((p) => `${(dx + p.x).toFixed(2)} ${(dy + p.y).toFixed(2)}`).join(' L ');
+        return `<path d="M ${parts}" />`;
+    }
+    render(startLineNumber, lineNumber) {
+        if (!this._renderResult) {
+            return '';
+        }
+        const lineIndex = lineNumber - startLineNumber;
+        if (lineIndex < 0 || lineIndex >= this._renderResult.length) {
+            return '';
+        }
+        return this._renderResult[lineIndex];
+    }
+}
+class WhitespaceOptions {
+    constructor(config) {
+        const options = config.options;
+        const fontInfo = options.get(59 /* EditorOption.fontInfo */);
+        const experimentalWhitespaceRendering = options.get(47 /* EditorOption.experimentalWhitespaceRendering */);
+        if (experimentalWhitespaceRendering === 'off') {
+            // whitespace is rendered in the view line
+            this.renderWhitespace = 'none';
+            this.renderWithSVG = false;
+        }
+        else if (experimentalWhitespaceRendering === 'svg') {
+            this.renderWhitespace = options.get(113 /* EditorOption.renderWhitespace */);
+            this.renderWithSVG = true;
+        }
+        else {
+            this.renderWhitespace = options.get(113 /* EditorOption.renderWhitespace */);
+            this.renderWithSVG = false;
+        }
+        this.spaceWidth = fontInfo.spaceWidth;
+        this.middotWidth = fontInfo.middotWidth;
+        this.wsmiddotWidth = fontInfo.wsmiddotWidth;
+        this.canUseHalfwidthRightwardsArrow = fontInfo.canUseHalfwidthRightwardsArrow;
+        this.lineHeight = options.get(75 /* EditorOption.lineHeight */);
+        this.stopRenderingLineAfter = options.get(133 /* EditorOption.stopRenderingLineAfter */);
+    }
+    equals(other) {
+        return (this.renderWhitespace === other.renderWhitespace
+            && this.renderWithSVG === other.renderWithSVG
+            && this.spaceWidth === other.spaceWidth
+            && this.middotWidth === other.middotWidth
+            && this.wsmiddotWidth === other.wsmiddotWidth
+            && this.canUseHalfwidthRightwardsArrow === other.canUseHalfwidthRightwardsArrow
+            && this.lineHeight === other.lineHeight
+            && this.stopRenderingLineAfter === other.stopRenderingLineAfter);
+    }
+}
+
+export { WhitespaceOverlay };

package/dist/workers/widget.js

@@ -0,0 +1,44 @@
+import { addDisposableListener, getWindow, EventType } from '../dom.js';
+import { StandardKeyboardEvent } from '../keyboardEvent.js';
+import { StandardMouseEvent } from '../mouseEvent.js';
+import { Gesture } from '../touch.js';
+import { Disposable } from '../../common/lifecycle.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class Widget extends Disposable {
+    onclick(domNode, listener) {
+        this._register(addDisposableListener(domNode, EventType.CLICK, (e) => listener(new StandardMouseEvent(getWindow(domNode), e))));
+    }
+    onmousedown(domNode, listener) {
+        this._register(addDisposableListener(domNode, EventType.MOUSE_DOWN, (e) => listener(new StandardMouseEvent(getWindow(domNode), e))));
+    }
+    onmouseover(domNode, listener) {
+        this._register(addDisposableListener(domNode, EventType.MOUSE_OVER, (e) => listener(new StandardMouseEvent(getWindow(domNode), e))));
+    }
+    onmouseleave(domNode, listener) {
+        this._register(addDisposableListener(domNode, EventType.MOUSE_LEAVE, (e) => listener(new StandardMouseEvent(getWindow(domNode), e))));
+    }
+    onkeydown(domNode, listener) {
+        this._register(addDisposableListener(domNode, EventType.KEY_DOWN, (e) => listener(new StandardKeyboardEvent(e))));
+    }
+    onkeyup(domNode, listener) {
+        this._register(addDisposableListener(domNode, EventType.KEY_UP, (e) => listener(new StandardKeyboardEvent(e))));
+    }
+    oninput(domNode, listener) {
+        this._register(addDisposableListener(domNode, EventType.INPUT, listener));
+    }
+    onblur(domNode, listener) {
+        this._register(addDisposableListener(domNode, EventType.BLUR, listener));
+    }
+    onfocus(domNode, listener) {
+        this._register(addDisposableListener(domNode, EventType.FOCUS, listener));
+    }
+    ignoreGesture(domNode) {
+        return Gesture.ignoreTarget(domNode);
+    }
+}
+
+export { Widget };

package/dist/workers/window.js

@@ -0,0 +1,60 @@
+import { isWeb, isMacintosh } from '../../../base/common/platform.js';
+
+function hasNativeContextMenu(configurationService, titleBarStyle) {
+    if (isWeb) {
+        return false;
+    }
+    const nativeTitle = hasNativeTitlebar(configurationService, titleBarStyle);
+    const windowConfigurations = configurationService.getValue('window');
+    if (windowConfigurations?.menuStyle === "native" /* MenuStyleConfiguration.NATIVE */) {
+        // Do not support native menu with custom title bar
+        if (!isMacintosh && !nativeTitle) {
+            return false;
+        }
+        return true;
+    }
+    if (windowConfigurations?.menuStyle === "custom" /* MenuStyleConfiguration.CUSTOM */) {
+        return false;
+    }
+    return nativeTitle; // Default to inherit from title bar style
+}
+function hasNativeTitlebar(configurationService, titleBarStyle) {
+    if (!titleBarStyle) {
+        titleBarStyle = getTitleBarStyle(configurationService);
+    }
+    return titleBarStyle === "native" /* TitlebarStyle.NATIVE */;
+}
+function getTitleBarStyle(configurationService) {
+    if (isWeb) {
+        return "custom" /* TitlebarStyle.CUSTOM */;
+    }
+    const configuration = configurationService.getValue('window');
+    if (configuration) {
+        const useNativeTabs = isMacintosh && configuration.nativeTabs === true;
+        if (useNativeTabs) {
+            return "native" /* TitlebarStyle.NATIVE */; // native tabs on sierra do not work with custom title style
+        }
+        const useSimpleFullScreen = isMacintosh && configuration.nativeFullScreen === false;
+        if (useSimpleFullScreen) {
+            return "native" /* TitlebarStyle.NATIVE */; // simple fullscreen does not work well with custom title style (https://github.com/microsoft/vscode/issues/63291)
+        }
+        const style = configuration.titleBarStyle;
+        if (style === "native" /* TitlebarStyle.NATIVE */ || style === "custom" /* TitlebarStyle.CUSTOM */) {
+            return style;
+        }
+    }
+    return "custom" /* TitlebarStyle.CUSTOM */; // default to custom on all OS
+}
+function getWindowControlsStyle(configurationService) {
+    if (isWeb || isMacintosh || getTitleBarStyle(configurationService) === "native" /* TitlebarStyle.NATIVE */) {
+        return "native" /* WindowControlsStyle.NATIVE */; // only supported on Windows/Linux desktop with custom titlebar
+    }
+    const configuration = configurationService.getValue('window');
+    const style = configuration?.controlsStyle;
+    if (style === "custom" /* WindowControlsStyle.CUSTOM */ || style === "hidden" /* WindowControlsStyle.HIDDEN */) {
+        return style;
+    }
+    return "native" /* WindowControlsStyle.NATIVE */; // default to native on all OS
+}
+
+export { getTitleBarStyle, getWindowControlsStyle, hasNativeContextMenu, hasNativeTitlebar };

package/dist/workers/wordCharacterClassifier.js

@@ -0,0 +1,87 @@
+import { safeIntl } from '../../../base/common/date.js';
+import { LRUCache } from '../../../base/common/map.js';
+import { CharacterClassifier } from './characterClassifier.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class WordCharacterClassifier extends CharacterClassifier {
+    constructor(wordSeparators, intlSegmenterLocales) {
+        super(0 /* WordCharacterClass.Regular */);
+        this._segmenter = null;
+        this._cachedLine = null;
+        this._cachedSegments = [];
+        this.intlSegmenterLocales = intlSegmenterLocales;
+        if (this.intlSegmenterLocales.length > 0) {
+            this._segmenter = safeIntl.Segmenter(this.intlSegmenterLocales, { granularity: 'word' });
+        }
+        else {
+            this._segmenter = null;
+        }
+        for (let i = 0, len = wordSeparators.length; i < len; i++) {
+            this.set(wordSeparators.charCodeAt(i), 2 /* WordCharacterClass.WordSeparator */);
+        }
+        this.set(32 /* CharCode.Space */, 1 /* WordCharacterClass.Whitespace */);
+        this.set(9 /* CharCode.Tab */, 1 /* WordCharacterClass.Whitespace */);
+    }
+    findPrevIntlWordBeforeOrAtOffset(line, offset) {
+        let candidate = null;
+        for (const segment of this._getIntlSegmenterWordsOnLine(line)) {
+            if (segment.index > offset) {
+                break;
+            }
+            candidate = segment;
+        }
+        return candidate;
+    }
+    findNextIntlWordAtOrAfterOffset(lineContent, offset) {
+        for (const segment of this._getIntlSegmenterWordsOnLine(lineContent)) {
+            if (segment.index < offset) {
+                continue;
+            }
+            return segment;
+        }
+        return null;
+    }
+    _getIntlSegmenterWordsOnLine(line) {
+        if (!this._segmenter) {
+            return [];
+        }
+        // Check if the line has changed from the previous call
+        if (this._cachedLine === line) {
+            return this._cachedSegments;
+        }
+        // Update the cache with the new line
+        this._cachedLine = line;
+        this._cachedSegments = this._filterWordSegments(this._segmenter.value.segment(line));
+        return this._cachedSegments;
+    }
+    _filterWordSegments(segments) {
+        const result = [];
+        for (const segment of segments) {
+            if (this._isWordLike(segment)) {
+                result.push(segment);
+            }
+        }
+        return result;
+    }
+    _isWordLike(segment) {
+        if (segment.isWordLike) {
+            return true;
+        }
+        return false;
+    }
+}
+const wordClassifierCache = new LRUCache(10);
+function getMapForWordSeparators(wordSeparators, intlSegmenterLocales) {
+    const key = `${wordSeparators}/${intlSegmenterLocales.join(',')}`;
+    let result = wordClassifierCache.get(key);
+    if (!result) {
+        result = new WordCharacterClassifier(wordSeparators, intlSegmenterLocales);
+        wordClassifierCache.set(key, result);
+    }
+    return result;
+}
+
+export { WordCharacterClassifier, getMapForWordSeparators };

package/dist/workers/wordContextKey.js

@@ -0,0 +1,69 @@
+import { RawContextKey, IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { localize } from '../../../../nls.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (undefined && undefined.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var WordContextKey_1;
+let WordContextKey = class WordContextKey {
+    static { WordContextKey_1 = this; }
+    static { this.AtEnd = new RawContextKey('atEndOfWord', false, { type: 'boolean', description: localize(1494, "A context key that is true when at the end of a word. Note that this is only defined when tab-completions are enabled") }); }
+    constructor(_editor, contextKeyService) {
+        this._editor = _editor;
+        this._enabled = false;
+        this._ckAtEnd = WordContextKey_1.AtEnd.bindTo(contextKeyService);
+        this._configListener = this._editor.onDidChangeConfiguration(e => e.hasChanged(139 /* EditorOption.tabCompletion */) && this._update());
+        this._update();
+    }
+    dispose() {
+        this._configListener.dispose();
+        this._selectionListener?.dispose();
+        this._ckAtEnd.reset();
+    }
+    _update() {
+        // only update this when tab completions are enabled
+        const enabled = this._editor.getOption(139 /* EditorOption.tabCompletion */) === 'on';
+        if (this._enabled === enabled) {
+            return;
+        }
+        this._enabled = enabled;
+        if (this._enabled) {
+            const checkForWordEnd = () => {
+                if (!this._editor.hasModel()) {
+                    this._ckAtEnd.set(false);
+                    return;
+                }
+                const model = this._editor.getModel();
+                const selection = this._editor.getSelection();
+                const word = model.getWordAtPosition(selection.getStartPosition());
+                if (!word) {
+                    this._ckAtEnd.set(false);
+                    return;
+                }
+                this._ckAtEnd.set(word.endColumn === selection.getStartPosition().column && selection.getStartPosition().lineNumber === selection.getEndPosition().lineNumber);
+            };
+            this._selectionListener = this._editor.onDidChangeCursorSelection(checkForWordEnd);
+            checkForWordEnd();
+        }
+        else if (this._selectionListener) {
+            this._ckAtEnd.reset();
+            this._selectionListener.dispose();
+            this._selectionListener = undefined;
+        }
+    }
+};
+WordContextKey = WordContextKey_1 = __decorate([
+    __param(1, IContextKeyService)
+], WordContextKey);
+
+export { WordContextKey };

package/dist/workers/wordDistance.js

@@ -0,0 +1,64 @@
+import { isFalsyOrEmpty, binarySearch } from '../../../../base/common/arrays.js';
+import { Range } from '../../../common/core/range.js';
+import { BracketSelectionRangeProvider } from '../../smartSelect/browser/bracketSelections.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class WordDistance {
+    static { this.None = new class extends WordDistance {
+        distance() { return 0; }
+    }; }
+    static async create(service, editor) {
+        if (!editor.getOption(134 /* EditorOption.suggest */).localityBonus) {
+            return WordDistance.None;
+        }
+        if (!editor.hasModel()) {
+            return WordDistance.None;
+        }
+        const model = editor.getModel();
+        const position = editor.getPosition();
+        if (!service.canComputeWordRanges(model.uri)) {
+            return WordDistance.None;
+        }
+        const [ranges] = await new BracketSelectionRangeProvider().provideSelectionRanges(model, [position]);
+        if (ranges.length === 0) {
+            return WordDistance.None;
+        }
+        const wordRanges = await service.computeWordRanges(model.uri, ranges[0].range);
+        if (!wordRanges) {
+            return WordDistance.None;
+        }
+        // remove current word
+        const wordUntilPos = model.getWordUntilPosition(position);
+        delete wordRanges[wordUntilPos.word];
+        return new class extends WordDistance {
+            distance(anchor, item) {
+                if (!position.equals(editor.getPosition())) {
+                    return 0;
+                }
+                if (item.kind === 17 /* CompletionItemKind.Keyword */) {
+                    return 2 << 20;
+                }
+                const word = typeof item.label === 'string' ? item.label : item.label.label;
+                const wordLines = wordRanges[word];
+                if (isFalsyOrEmpty(wordLines)) {
+                    return 2 << 20;
+                }
+                const idx = binarySearch(wordLines, Range.fromPositions(anchor), Range.compareRangesUsingStarts);
+                const bestWordRange = idx >= 0 ? wordLines[idx] : wordLines[Math.max(0, ~idx - 1)];
+                let blockDistance = ranges.length;
+                for (const range of ranges) {
+                    if (!Range.containsRange(range.range, bestWordRange)) {
+                        break;
+                    }
+                    blockDistance -= 1;
+                }
+                return blockDistance;
+            }
+        };
+    }
+}
+
+export { WordDistance };