@codingame/monaco-vscode-api 15.0.0 → 15.0.2

package/vscode/src/vs/editor/contrib/suggest/browser/suggest.js

@@ -21,21 +21,21 @@ import { StandardTokenType } from '../../../common/encodedTokenAttributes.js';
 
 const Context = {
     Visible: historyNavigationVisible,
-    HasFocusedSuggestion: ( new RawContextKey('suggestWidgetHasFocusedSuggestion', false, ( localize(1472, "Whether any suggestion is focused")))),
-    DetailsVisible: ( new RawContextKey('suggestWidgetDetailsVisible', false, ( localize(1473, "Whether suggestion details are visible")))),
-    MultipleSuggestions: ( new RawContextKey('suggestWidgetMultipleSuggestions', false, ( localize(1474, "Whether there are multiple suggestions to pick from")))),
+    HasFocusedSuggestion: ( new RawContextKey('suggestWidgetHasFocusedSuggestion', false, ( localize(1475, "Whether any suggestion is focused")))),
+    DetailsVisible: ( new RawContextKey('suggestWidgetDetailsVisible', false, ( localize(1476, "Whether suggestion details are visible")))),
+    MultipleSuggestions: ( new RawContextKey('suggestWidgetMultipleSuggestions', false, ( localize(1477, "Whether there are multiple suggestions to pick from")))),
     MakesTextEdit: ( new RawContextKey('suggestionMakesTextEdit', true, ( localize(
-        1475,
+        1478,
         "Whether inserting the current suggestion yields in a change or has everything already been typed"
     )))),
-    AcceptSuggestionsOnEnter: ( new RawContextKey('acceptSuggestionOnEnter', true, ( localize(1476, "Whether suggestions are inserted when pressing Enter")))),
-    HasInsertAndReplaceRange: ( new RawContextKey('suggestionHasInsertAndReplaceRange', false, ( localize(1477, "Whether the current suggestion has insert and replace behaviour")))),
+    AcceptSuggestionsOnEnter: ( new RawContextKey('acceptSuggestionOnEnter', true, ( localize(1479, "Whether suggestions are inserted when pressing Enter")))),
+    HasInsertAndReplaceRange: ( new RawContextKey('suggestionHasInsertAndReplaceRange', false, ( localize(1480, "Whether the current suggestion has insert and replace behaviour")))),
     InsertMode: ( new RawContextKey(
         'suggestionInsertMode',
         undefined,
-        { type: 'string', description: ( localize(1478, "Whether the default behaviour is to insert or replace")) }
+        { type: 'string', description: ( localize(1481, "Whether the default behaviour is to insert or replace")) }
     )),
-    CanResolve: ( new RawContextKey('suggestionCanResolve', false, ( localize(1479, "Whether the current suggestion supports to resolve further details")))),
+    CanResolve: ( new RawContextKey('suggestionCanResolve', false, ( localize(1482, "Whether the current suggestion supports to resolve further details")))),
 };
 const suggestWidgetStatusbarMenu = ( new MenuId('suggestWidgetStatusBar'));
 class CompletionItem {

package/vscode/src/vs/editor/contrib/suggest/browser/suggestController.js

@@ -449,7 +449,7 @@ let SuggestController = class SuggestController {
     _alertCompletionItem(item) {
         if (isNonEmptyArray(item.completion.additionalTextEdits)) {
             const msg = ( localize(
-                1480,
+                1483,
                 "Accepting '{0}' made {1} additional edits",
                 item.textLabel,
                 item.completion.additionalTextEdits.length
@@ -626,7 +626,7 @@ class TriggerSuggestAction extends EditorAction {
     constructor() {
         super({
             id: TriggerSuggestAction.id,
-            label: ( localize2(1481, "Trigger Suggest")),
+            label: ( localize2(1484, "Trigger Suggest")),
             precondition: ( ContextKeyExpr.and(
                 EditorContextKeys.writable,
                 EditorContextKeys.hasCompletionItemProvider,
@@ -681,19 +681,19 @@ registerEditorCommand(( new SuggestCommand({
         }],
     menuOpts: [{
             menuId: suggestWidgetStatusbarMenu,
-            title: ( localize(1482, "Insert")),
+            title: ( localize(1485, "Insert")),
             group: 'left',
             order: 1,
             when: ( Context.HasInsertAndReplaceRange.toNegated())
         }, {
             menuId: suggestWidgetStatusbarMenu,
-            title: ( localize(1482, "Insert")),
+            title: ( localize(1485, "Insert")),
             group: 'left',
             order: 1,
             when: ( ContextKeyExpr.and(Context.HasInsertAndReplaceRange, ( Context.InsertMode.isEqualTo('insert'))))
         }, {
             menuId: suggestWidgetStatusbarMenu,
-            title: ( localize(1483, "Replace")),
+            title: ( localize(1486, "Replace")),
             group: 'left',
             order: 1,
             when: ( ContextKeyExpr.and(Context.HasInsertAndReplaceRange, ( Context.InsertMode.isEqualTo('replace'))))
@@ -720,13 +720,13 @@ registerEditorCommand(( new SuggestCommand({
             group: 'left',
             order: 2,
             when: ( ContextKeyExpr.and(Context.HasInsertAndReplaceRange, ( Context.InsertMode.isEqualTo('insert')))),
-            title: ( localize(1483, "Replace"))
+            title: ( localize(1486, "Replace"))
         }, {
             menuId: suggestWidgetStatusbarMenu,
             group: 'left',
             order: 2,
             when: ( ContextKeyExpr.and(Context.HasInsertAndReplaceRange, ( Context.InsertMode.isEqualTo('replace')))),
-            title: ( localize(1482, "Insert"))
+            title: ( localize(1485, "Insert"))
         }]
 })));
 CommandsRegistry.registerCommandAlias('acceptSelectedSuggestionOnEnter', 'acceptSelectedSuggestion');
@@ -833,13 +833,13 @@ registerEditorCommand(( new SuggestCommand({
             group: 'right',
             order: 1,
             when: ( ContextKeyExpr.and(Context.DetailsVisible, Context.CanResolve)),
-            title: ( localize(1484, "Show Less"))
+            title: ( localize(1487, "Show Less"))
         }, {
             menuId: suggestWidgetStatusbarMenu,
             group: 'right',
             order: 1,
             when: ( ContextKeyExpr.and(( Context.DetailsVisible.toNegated()), Context.CanResolve)),
-            title: ( localize(1485, "Show More"))
+            title: ( localize(1488, "Show More"))
         }]
 })));
 registerEditorCommand(( new SuggestCommand({
@@ -897,7 +897,7 @@ registerEditorAction(class extends EditorAction {
     constructor() {
         super({
             id: 'editor.action.resetSuggestSize',
-            label: ( localize2(1486, "Reset Suggest Widget Size")),
+            label: ( localize2(1489, "Reset Suggest Widget Size")),
             precondition: undefined
         });
     }

package/vscode/src/vs/editor/contrib/suggest/browser/suggestMemory.d.ts

@@ -0,0 +1,67 @@
+import { IPosition } from "../../../common/core/position.js";
+import { ITextModel } from "../../../common/model.js";
+import { CompletionItemKind } from "../../../common/languages.js";
+import { CompletionItem } from "./suggest.js";
+import { IConfigurationService } from "../../../../platform/configuration/common/configuration.service.js";
+import { IStorageService } from "../../../../platform/storage/common/storage.service.js";
+import { ISuggestMemoryService } from "./suggestMemory.service.js";
+export declare abstract class Memory {
+    readonly name: MemMode;
+    constructor(name: MemMode);
+    select(model: ITextModel, pos: IPosition, items: CompletionItem[]): number;
+    abstract memorize(model: ITextModel, pos: IPosition, item: CompletionItem): void;
+    abstract toJSON(): object | undefined;
+    abstract fromJSON(data: object): void;
+}
+export declare class NoMemory extends Memory {
+    constructor();
+    memorize(model: ITextModel, pos: IPosition, item: CompletionItem): void;
+    toJSON(): undefined;
+    fromJSON(): void;
+}
+export interface MemItem {
+    type: string | CompletionItemKind;
+    insertText: string;
+    touch: number;
+}
+export declare class LRUMemory extends Memory {
+    constructor();
+    private _cache;
+    private _seq;
+    memorize(model: ITextModel, pos: IPosition, item: CompletionItem): void;
+    select(model: ITextModel, pos: IPosition, items: CompletionItem[]): number;
+    toJSON(): object;
+    fromJSON(data: [
+        string,
+        MemItem
+    ][]): void;
+}
+export declare class PrefixMemory extends Memory {
+    constructor();
+    private _trie;
+    private _seq;
+    memorize(model: ITextModel, pos: IPosition, item: CompletionItem): void;
+    select(model: ITextModel, pos: IPosition, items: CompletionItem[]): number;
+    toJSON(): object;
+    fromJSON(data: [
+        string,
+        MemItem
+    ][]): void;
+}
+export type MemMode = "first" | "recentlyUsed" | "recentlyUsedByPrefix";
+export declare class SuggestMemoryService implements ISuggestMemoryService {
+    private readonly _storageService;
+    private readonly _configService;
+    private static readonly _strategyCtors;
+    private static readonly _storagePrefix;
+    readonly _serviceBrand: undefined;
+    private readonly _persistSoon;
+    private readonly _disposables;
+    private _strategy?;
+    constructor(_storageService: IStorageService, _configService: IConfigurationService);
+    dispose(): void;
+    memorize(model: ITextModel, pos: IPosition, item: CompletionItem): void;
+    select(model: ITextModel, pos: IPosition, items: CompletionItem[]): number;
+    private _withStrategy;
+    private _saveState;
+}

package/vscode/src/vs/editor/contrib/suggest/browser/suggestMemory.js

@@ -0,0 +1,232 @@
+
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { RunOnceScheduler } from '../../../../base/common/async.js';
+import { DisposableStore } from '../../../../base/common/lifecycle.js';
+import { LRUCache } from '../../../../base/common/map.js';
+import { TernarySearchTree } from '../../../../base/common/ternarySearchTree.js';
+import { CompletionItemKinds } from '../../../common/languages.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
+import '../../../../platform/instantiation/common/extensions.js';
+import { WillSaveStateReason, StorageScope, StorageTarget } from '../../../../platform/storage/common/storage.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.service.js';
+import '../../../../platform/instantiation/common/instantiation.js';
+
+var SuggestMemoryService_1;
+class Memory {
+    constructor(name) {
+        this.name = name;
+    }
+    select(model, pos, items) {
+        if (items.length === 0) {
+            return 0;
+        }
+        const topScore = items[0].score[0];
+        for (let i = 0; i < items.length; i++) {
+            const { score, completion: suggestion } = items[i];
+            if (score[0] !== topScore) {
+                break;
+            }
+            if (suggestion.preselect) {
+                return i;
+            }
+        }
+        return 0;
+    }
+}
+class NoMemory extends Memory {
+    constructor() {
+        super('first');
+    }
+    memorize(model, pos, item) {
+    }
+    toJSON() {
+        return undefined;
+    }
+    fromJSON() {
+    }
+}
+class LRUMemory extends Memory {
+    constructor() {
+        super('recentlyUsed');
+        this._cache = ( new LRUCache(300, 0.66));
+        this._seq = 0;
+    }
+    memorize(model, pos, item) {
+        const key = `${model.getLanguageId()}/${item.textLabel}`;
+        this._cache.set(key, {
+            touch: this._seq++,
+            type: item.completion.kind,
+            insertText: item.completion.insertText
+        });
+    }
+    select(model, pos, items) {
+        if (items.length === 0) {
+            return 0;
+        }
+        const lineSuffix = model.getLineContent(pos.lineNumber).substr(pos.column - 10, pos.column - 1);
+        if (/\s$/.test(lineSuffix)) {
+            return super.select(model, pos, items);
+        }
+        const topScore = items[0].score[0];
+        let indexPreselect = -1;
+        let indexRecency = -1;
+        let seq = -1;
+        for (let i = 0; i < items.length; i++) {
+            if (items[i].score[0] !== topScore) {
+                break;
+            }
+            const key = `${model.getLanguageId()}/${items[i].textLabel}`;
+            const item = this._cache.peek(key);
+            if (item && item.touch > seq && item.type === items[i].completion.kind && item.insertText === items[i].completion.insertText) {
+                seq = item.touch;
+                indexRecency = i;
+            }
+            if (items[i].completion.preselect && indexPreselect === -1) {
+                return indexPreselect = i;
+            }
+        }
+        if (indexRecency !== -1) {
+            return indexRecency;
+        }
+        else if (indexPreselect !== -1) {
+            return indexPreselect;
+        }
+        else {
+            return 0;
+        }
+    }
+    toJSON() {
+        return this._cache.toJSON();
+    }
+    fromJSON(data) {
+        this._cache.clear();
+        const seq = 0;
+        for (const [key, value] of data) {
+            value.touch = seq;
+            value.type = typeof value.type === 'number' ? value.type : CompletionItemKinds.fromString(value.type);
+            this._cache.set(key, value);
+        }
+        this._seq = this._cache.size;
+    }
+}
+class PrefixMemory extends Memory {
+    constructor() {
+        super('recentlyUsedByPrefix');
+        this._trie = TernarySearchTree.forStrings();
+        this._seq = 0;
+    }
+    memorize(model, pos, item) {
+        const { word } = model.getWordUntilPosition(pos);
+        const key = `${model.getLanguageId()}/${word}`;
+        this._trie.set(key, {
+            type: item.completion.kind,
+            insertText: item.completion.insertText,
+            touch: this._seq++
+        });
+    }
+    select(model, pos, items) {
+        const { word } = model.getWordUntilPosition(pos);
+        if (!word) {
+            return super.select(model, pos, items);
+        }
+        const key = `${model.getLanguageId()}/${word}`;
+        let item = this._trie.get(key);
+        if (!item) {
+            item = this._trie.findSubstr(key);
+        }
+        if (item) {
+            for (let i = 0; i < items.length; i++) {
+                const { kind, insertText } = items[i].completion;
+                if (kind === item.type && insertText === item.insertText) {
+                    return i;
+                }
+            }
+        }
+        return super.select(model, pos, items);
+    }
+    toJSON() {
+        const entries = [];
+        this._trie.forEach((value, key) => entries.push([key, value]));
+        entries
+            .sort((a, b) => -(a[1].touch - b[1].touch))
+            .forEach((value, i) => value[1].touch = i);
+        return entries.slice(0, 200);
+    }
+    fromJSON(data) {
+        this._trie.clear();
+        if (data.length > 0) {
+            this._seq = data[0][1].touch + 1;
+            for (const [key, value] of data) {
+                value.type = typeof value.type === 'number' ? value.type : CompletionItemKinds.fromString(value.type);
+                this._trie.set(key, value);
+            }
+        }
+    }
+}
+let SuggestMemoryService = class SuggestMemoryService {
+    static { SuggestMemoryService_1 = this; }
+    static { this._strategyCtors = ( new Map([
+        ['recentlyUsedByPrefix', PrefixMemory],
+        ['recentlyUsed', LRUMemory],
+        ['first', NoMemory]
+    ])); }
+    static { this._storagePrefix = 'suggest/memories'; }
+    constructor(_storageService, _configService) {
+        this._storageService = _storageService;
+        this._configService = _configService;
+        this._disposables = ( new DisposableStore());
+        this._persistSoon = ( new RunOnceScheduler(() => this._saveState(), 500));
+        this._disposables.add(_storageService.onWillSaveState(e => {
+            if (e.reason === WillSaveStateReason.SHUTDOWN) {
+                this._saveState();
+            }
+        }));
+    }
+    dispose() {
+        this._disposables.dispose();
+        this._persistSoon.dispose();
+    }
+    memorize(model, pos, item) {
+        this._withStrategy(model, pos).memorize(model, pos, item);
+        this._persistSoon.schedule();
+    }
+    select(model, pos, items) {
+        return this._withStrategy(model, pos).select(model, pos, items);
+    }
+    _withStrategy(model, pos) {
+        const mode = this._configService.getValue('editor.suggestSelection', {
+            overrideIdentifier: model.getLanguageIdAtPosition(pos.lineNumber, pos.column),
+            resource: model.uri
+        });
+        if (this._strategy?.name !== mode) {
+            this._saveState();
+            const ctor = SuggestMemoryService_1._strategyCtors.get(mode) || NoMemory;
+            this._strategy = ( new ctor());
+            try {
+                const share = this._configService.getValue('editor.suggest.shareSuggestSelections');
+                const scope = share ? StorageScope.PROFILE : StorageScope.WORKSPACE;
+                const raw = this._storageService.get(`${SuggestMemoryService_1._storagePrefix}/${mode}`, scope);
+                if (raw) {
+                    this._strategy.fromJSON(JSON.parse(raw));
+                }
+            }
+            catch (e) {
+            }
+        }
+        return this._strategy;
+    }
+    _saveState() {
+        if (this._strategy) {
+            const share = this._configService.getValue('editor.suggest.shareSuggestSelections');
+            const scope = share ? StorageScope.PROFILE : StorageScope.WORKSPACE;
+            const raw = JSON.stringify(this._strategy);
+            this._storageService.store(`${SuggestMemoryService_1._storagePrefix}/${this._strategy.name}`, raw, scope, StorageTarget.MACHINE);
+        }
+    }
+};
+SuggestMemoryService = SuggestMemoryService_1 = ( __decorate([
+    ( __param(0, IStorageService)),
+    ( __param(1, IConfigurationService))
+], SuggestMemoryService));
+
+export { LRUMemory, Memory, NoMemory, PrefixMemory, SuggestMemoryService };

package/vscode/src/vs/editor/contrib/suggest/browser/suggestWidget.js

@@ -42,18 +42,18 @@ import { getListStyles } from '../../../../platform/theme/browser/defaultStyles.
 import { status } from '../../../../base/browser/ui/aria/aria.js';
 
 var SuggestWidget_1;
-registerColor('editorSuggestWidget.background', editorWidgetBackground, ( localize(1487, 'Background color of the suggest widget.')));
-registerColor('editorSuggestWidget.border', editorWidgetBorder, ( localize(1488, 'Border color of the suggest widget.')));
-const editorSuggestWidgetForeground = registerColor('editorSuggestWidget.foreground', editorForeground, ( localize(1489, 'Foreground color of the suggest widget.')));
-registerColor('editorSuggestWidget.selectedForeground', quickInputListFocusForeground, ( localize(1490, 'Foreground color of the selected entry in the suggest widget.')));
-registerColor('editorSuggestWidget.selectedIconForeground', quickInputListFocusIconForeground, ( localize(1491, 'Icon foreground color of the selected entry in the suggest widget.')));
-const editorSuggestWidgetSelectedBackground = registerColor('editorSuggestWidget.selectedBackground', quickInputListFocusBackground, ( localize(1492, 'Background color of the selected entry in the suggest widget.')));
-registerColor('editorSuggestWidget.highlightForeground', listHighlightForeground, ( localize(1493, 'Color of the match highlights in the suggest widget.')));
+registerColor('editorSuggestWidget.background', editorWidgetBackground, ( localize(1490, 'Background color of the suggest widget.')));
+registerColor('editorSuggestWidget.border', editorWidgetBorder, ( localize(1491, 'Border color of the suggest widget.')));
+const editorSuggestWidgetForeground = registerColor('editorSuggestWidget.foreground', editorForeground, ( localize(1492, 'Foreground color of the suggest widget.')));
+registerColor('editorSuggestWidget.selectedForeground', quickInputListFocusForeground, ( localize(1493, 'Foreground color of the selected entry in the suggest widget.')));
+registerColor('editorSuggestWidget.selectedIconForeground', quickInputListFocusIconForeground, ( localize(1494, 'Icon foreground color of the selected entry in the suggest widget.')));
+const editorSuggestWidgetSelectedBackground = registerColor('editorSuggestWidget.selectedBackground', quickInputListFocusBackground, ( localize(1495, 'Background color of the selected entry in the suggest widget.')));
+registerColor('editorSuggestWidget.highlightForeground', listHighlightForeground, ( localize(1496, 'Color of the match highlights in the suggest widget.')));
 registerColor('editorSuggestWidget.focusHighlightForeground', listFocusHighlightForeground, ( localize(
-    1494,
+    1497,
     'Color of the match highlights in the suggest widget when an item is focused.'
 )));
-registerColor('editorSuggestWidgetStatus.foreground', ( transparent(editorSuggestWidgetForeground, .5)), ( localize(1495, 'Foreground color of the suggest widget status.')));
+registerColor('editorSuggestWidgetStatus.foreground', ( transparent(editorSuggestWidgetForeground, .5)), ( localize(1498, 'Foreground color of the suggest widget status.')));
 var State;
 (function (State) {
     State[State["Hidden"] = 0] = "Hidden";
@@ -90,8 +90,8 @@ class PersistedWidgetSize {
 }
 let SuggestWidget = class SuggestWidget {
     static { SuggestWidget_1 = this; }
-    static { this.LOADING_MESSAGE = ( localize(1496, "Loading...")); }
-    static { this.NO_SUGGESTIONS_MESSAGE = ( localize(1497, "No suggestions.")); }
+    static { this.LOADING_MESSAGE = ( localize(1499, "Loading...")); }
+    static { this.NO_SUGGESTIONS_MESSAGE = ( localize(1500, "No suggestions.")); }
     constructor(editor, _storageService, _contextKeyService, _themeService, instantiationService) {
         this.editor = editor;
         this._storageService = _storageService;
@@ -175,20 +175,20 @@ let SuggestWidget = class SuggestWidget {
             multipleSelectionSupport: false,
             accessibilityProvider: {
                 getRole: () => 'option',
-                getWidgetAriaLabel: () => ( localize(1498, "Suggest")),
+                getWidgetAriaLabel: () => ( localize(1501, "Suggest")),
                 getWidgetRole: () => 'listbox',
                 getAriaLabel: (item) => {
                     let label = item.textLabel;
                     if (typeof item.completion.label !== 'string') {
                         const { detail, description } = item.completion.label;
                         if (detail && description) {
-                            label = ( localize(1499, '{0} {1}, {2}', label, detail, description));
+                            label = ( localize(1502, '{0} {1}, {2}', label, detail, description));
                         }
                         else if (detail) {
-                            label = ( localize(1500, '{0} {1}', label, detail));
+                            label = ( localize(1503, '{0} {1}', label, detail));
                         }
                         else if (description) {
-                            label = ( localize(1501, '{0}, {1}', label, description));
+                            label = ( localize(1504, '{0}, {1}', label, description));
                         }
                     }
                     if (!item.isResolved || !this._isDetailsVisible()) {
@@ -196,7 +196,7 @@ let SuggestWidget = class SuggestWidget {
                     }
                     const { documentation, detail } = item.completion;
                     const docs = format('{0}{1}', detail || '', documentation ? (typeof documentation === 'string' ? documentation : documentation.value) : '');
-                    return localize(1502, "{0}, docs: {1}", label, docs);
+                    return localize(1505, "{0}, docs: {1}", label, docs);
                 },
             }
         }));

package/vscode/src/vs/editor/contrib/suggest/browser/suggestWidgetDetails.js

@@ -38,7 +38,7 @@ let SuggestDetailsWidget = class SuggestDetailsWidget {
         this._disposables.add(this._scrollbar);
         this._header = append(this._body, $('.header'));
         this._close = append(this._header, $('span' + ThemeIcon.asCSSSelector(Codicon.close)));
-        this._close.title = ( localize(1503, "Close"));
+        this._close.title = ( localize(1506, "Close"));
         this._close.role = 'button';
         this._close.tabIndex = -1;
         this._type = append(this._header, $('p.type'));
@@ -84,7 +84,7 @@ let SuggestDetailsWidget = class SuggestDetailsWidget {
         };
     }
     renderLoading() {
-        this._type.textContent = ( localize(1504, "Loading..."));
+        this._type.textContent = ( localize(1507, "Loading..."));
         this._docs.textContent = '';
         this.domNode.classList.remove('no-docs', 'no-type');
         this.layout(this.size.width, this.getLayoutInfo().lineHeight * 2);

package/vscode/src/vs/editor/contrib/suggest/browser/suggestWidgetRenderer.js

@@ -19,7 +19,7 @@ import { registerIcon } from '../../../../platform/theme/common/iconRegistry.js'
 import { IThemeService } from '../../../../platform/theme/common/themeService.service.js';
 import { canExpandCompletionItem } from './suggestWidgetDetails.js';
 
-const suggestMoreInfoIcon = registerIcon('suggest-more-info', Codicon.chevronRight, ( localize(1505, 'Icon for more information in the suggest widget.')));
+const suggestMoreInfoIcon = registerIcon('suggest-more-info', Codicon.chevronRight, ( localize(1508, 'Icon for more information in the suggest widget.')));
 const _completionItemColor = new (class ColorExtractor {
     static { this._regexRelaxed = /(#([\da-fA-F]{3}){1,2}|(rgb|hsl)a\(\s*(\d{1,3}%?\s*,\s*){3}(1|0?\.\d+)\)|(rgb|hsl)\(\s*\d{1,3}%?(\s*,\s*\d{1,3}%?){2}\s*\))/; }
     static { this._regexStrict = ( new RegExp(`^${ColorExtractor._regexRelaxed.source}$`, 'i')); }
@@ -75,7 +75,7 @@ let ItemRenderer = class ItemRenderer {
         const qualifierLabel = append(left, $('span.qualifier-label'));
         const detailsLabel = append(right, $('span.details-label'));
         const readMore = append(right, $('span.readMore' + ThemeIcon.asCSSSelector(suggestMoreInfoIcon)));
-        readMore.title = ( localize(1506, "Read More"));
+        readMore.title = ( localize(1509, "Read More"));
         const configureFont = () => {
             const options = this._editor.getOptions();
             const fontInfo = options.get(EditorOption.fontInfo);

package/vscode/src/vs/editor/contrib/suggest/browser/wordContextKey.js

@@ -9,7 +9,7 @@ var WordContextKey_1;
 let WordContextKey = class WordContextKey {
     static { WordContextKey_1 = this; }
     static { this.AtEnd = ( new RawContextKey('atEndOfWord', false, { type: 'boolean', description: ( localize(
-        1507,
+        1510,
         "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) {