@codingame/monaco-vscode-api 1.83.15 → 1.83.16

package/vscode/src/vs/workbench/contrib/testing/common/testService.js

@@ -1,3 +1,77 @@
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { TestId } from './testId.js';
 const ITestService = ( createDecorator('testService'));
-export { ITestService };
+const testCollectionIsEmpty = (collection) => !( Iterable.some(collection.rootItems, r => r.children.size > 0));
+const getContextForTestItem = (collection, id) => {
+    if (typeof id === 'string') {
+        id = TestId.fromString(id);
+    }
+    if (id.isRoot) {
+        return { controller: ( id.toString()) };
+    }
+    const context = { $mid: 16 , tests: [] };
+    for (const i of id.idsFromRoot()) {
+        if (!i.isRoot) {
+            const test = collection.getNodeById(( i.toString()));
+            if (test) {
+                context.tests.push(test);
+            }
+        }
+    }
+    return context;
+};
+const expandAndGetTestById = async (collection, id, ct = CancellationToken.None) => {
+    const idPath = [...TestId.fromString(id).idsFromRoot()];
+    let expandToLevel = 0;
+    for (let i = idPath.length - 1; !ct.isCancellationRequested && i >= expandToLevel;) {
+        const id = ( idPath[i].toString());
+        const existing = collection.getNodeById(id);
+        if (!existing) {
+            i--;
+            continue;
+        }
+        if (i === idPath.length - 1) {
+            return existing;
+        }
+        if (!( existing.children.has(( idPath[i + 1].toString())))) {
+            await collection.expand(id, 0);
+        }
+        expandToLevel = i + 1;
+        i = idPath.length - 1;
+    }
+    return undefined;
+};
+const waitForTestToBeIdle = (testService, test) => {
+    if (!test.item.busy) {
+        return;
+    }
+    return ( new Promise(resolve => {
+        const l = testService.onDidProcessDiff(() => {
+            if (testService.collection.getNodeById(test.item.extId)?.item.busy !== true) {
+                resolve();
+                l.dispose();
+            }
+        });
+    }));
+};
+const testsInFile = async function* (testService, ident, uri, waitForIdle = true) {
+    for (const test of testService.collection.all) {
+        if (!test.item.uri) {
+            continue;
+        }
+        if (ident.extUri.isEqual(uri, test.item.uri)) {
+            yield test;
+        }
+        if (ident.extUri.isEqualOrParent(uri, test.item.uri)) {
+            if (test.expand === 1 ) {
+                await testService.collection.expand(test.item.extId, 1);
+            }
+            if (waitForIdle) {
+                await waitForTestToBeIdle(testService, test);
+            }
+        }
+    }
+};
+export { ITestService, expandAndGetTestById, getContextForTestItem, testCollectionIsEmpty, testsInFile };

package/vscode/src/vs/workbench/contrib/testing/common/testTypes.js

@@ -1,6 +1,14 @@
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
 import { TestId } from './testId.js';
+const testRunProfileBitsetList = [
+    2 ,
+    4 ,
+    8 ,
+    16 ,
+    32 ,
+    64 ,
+];
 const isStartControllerTests = (t) => 'runId' in t;
 var IRichLocation;
 ( (function(IRichLocation) {
@@ -354,4 +362,4 @@ class AbstractIncrementalTestCollection {
         return {};
     }
 }
-export { AbstractIncrementalTestCollection, IRichLocation, ITestErrorMessage, ITestItem, ITestItemUpdate, ITestMessage, ITestOutputMessage, ITestTaskState, InternalTestItem, TestResultItem, TestsDiffOp, applyTestItemUpdate, denamespaceTestTag, getMarkId, isStartControllerTests, namespaceTestTag };
+export { AbstractIncrementalTestCollection, IRichLocation, ITestErrorMessage, ITestItem, ITestItemUpdate, ITestMessage, ITestOutputMessage, ITestTaskState, InternalTestItem, TestResultItem, TestsDiffOp, applyTestItemUpdate, denamespaceTestTag, getMarkId, isStartControllerTests, namespaceTestTag, testRunProfileBitsetList };

package/vscode/src/vs/workbench/contrib/testing/common/testingContextKeys.js

@@ -0,0 +1,179 @@
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+var TestingContextKeys;
+( (function(TestingContextKeys) {
+    TestingContextKeys.providerCount = ( new RawContextKey('testing.providerCount', 0));
+    TestingContextKeys.canRefreshTests = ( new RawContextKey(
+        'testing.canRefresh',
+        false,
+        { type: 'boolean', description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.canRefresh',
+            'Indicates whether any test controller has an attached refresh handler.'
+        )) }
+    ));
+    TestingContextKeys.isRefreshingTests = ( new RawContextKey(
+        'testing.isRefreshing',
+        false,
+        { type: 'boolean', description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.isRefreshing',
+            'Indicates whether any test controller is currently refreshing tests.'
+        )) }
+    ));
+    TestingContextKeys.isContinuousModeOn = ( new RawContextKey(
+        'testing.isContinuousModeOn',
+        false,
+        { type: 'boolean', description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.isContinuousModeOn',
+            'Indicates whether continuous test mode is on.'
+        )) }
+    ));
+    TestingContextKeys.hasDebuggableTests = ( new RawContextKey(
+        'testing.hasDebuggableTests',
+        false,
+        { type: 'boolean', description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.hasDebuggableTests',
+            'Indicates whether any test controller has registered a debug configuration'
+        )) }
+    ));
+    TestingContextKeys.hasRunnableTests = ( new RawContextKey(
+        'testing.hasRunnableTests',
+        false,
+        { type: 'boolean', description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.hasRunnableTests',
+            'Indicates whether any test controller has registered a run configuration'
+        )) }
+    ));
+    TestingContextKeys.hasCoverableTests = ( new RawContextKey(
+        'testing.hasCoverableTests',
+        false,
+        { type: 'boolean', description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.hasCoverableTests',
+            'Indicates whether any test controller has registered a coverage configuration'
+        )) }
+    ));
+    TestingContextKeys.hasNonDefaultProfile = ( new RawContextKey(
+        'testing.hasNonDefaultProfile',
+        false,
+        { type: 'boolean', description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.hasNonDefaultConfig',
+            'Indicates whether any test controller has registered a non-default configuration'
+        )) }
+    ));
+    TestingContextKeys.hasConfigurableProfile = ( new RawContextKey(
+        'testing.hasConfigurableProfile',
+        false,
+        { type: 'boolean', description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.hasConfigurableConfig',
+            'Indicates whether any test configuration can be configured'
+        )) }
+    ));
+    TestingContextKeys.supportsContinuousRun = ( new RawContextKey(
+        'testing.supportsContinuousRun',
+        false,
+        { type: 'boolean', description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.supportsContinuousRun',
+            'Indicates whether continous test running is supported'
+        )) }
+    ));
+    TestingContextKeys.isParentRunningContinuously = ( new RawContextKey(
+        'testing.isParentRunningContinuously',
+        false,
+        { type: 'boolean', description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.isParentRunningContinuously',
+            'Indicates whether the parent of a test is continuously running, set in the menu context of test items'
+        )) }
+    ));
+    TestingContextKeys.activeEditorHasTests = ( new RawContextKey(
+        'testing.activeEditorHasTests',
+        false,
+        { type: 'boolean', description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.activeEditorHasTests',
+            'Indicates whether any tests are present in the current editor'
+        )) }
+    ));
+    TestingContextKeys.capabilityToContextKey = {
+        [2 ]: TestingContextKeys.hasRunnableTests,
+        [8 ]: TestingContextKeys.hasCoverableTests,
+        [4 ]: TestingContextKeys.hasDebuggableTests,
+        [16 ]: TestingContextKeys.hasNonDefaultProfile,
+        [32 ]: TestingContextKeys.hasConfigurableProfile,
+        [64 ]: TestingContextKeys.supportsContinuousRun,
+    };
+    TestingContextKeys.hasAnyResults = ( new RawContextKey('testing.hasAnyResults', false));
+    TestingContextKeys.viewMode = ( new RawContextKey('testing.explorerViewMode', "list" ));
+    TestingContextKeys.viewSorting = ( new RawContextKey(
+        'testing.explorerViewSorting',
+        "location"
+    ));
+    TestingContextKeys.isRunning = ( new RawContextKey('testing.isRunning', false));
+    TestingContextKeys.isInPeek = ( new RawContextKey('testing.isInPeek', false));
+    TestingContextKeys.isPeekVisible = ( new RawContextKey('testing.isPeekVisible', false));
+    TestingContextKeys.peekItemType = ( new RawContextKey('peekItemType', undefined, {
+        type: 'string',
+        description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.peekItemType',
+            'Type of the item in the output peek view. Either a "test", "message", "task", or "result".'
+        )),
+    }));
+    TestingContextKeys.controllerId = ( new RawContextKey('controllerId', undefined, {
+        type: 'string',
+        description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.controllerId',
+            'Controller ID of the current test item'
+        ))
+    }));
+    TestingContextKeys.testItemExtId = ( new RawContextKey('testId', undefined, {
+        type: 'string',
+        description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.testId',
+            'ID of the current test item, set when creating or opening menus on test items'
+        ))
+    }));
+    TestingContextKeys.testItemHasUri = ( new RawContextKey('testing.testItemHasUri', false, {
+        type: 'boolean',
+        description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.testItemHasUri',
+            'Boolean indicating whether the test item has a URI defined'
+        ))
+    }));
+    TestingContextKeys.testItemIsHidden = ( new RawContextKey('testing.testItemIsHidden', false, {
+        type: 'boolean',
+        description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.testItemIsHidden',
+            'Boolean indicating whether the test item is hidden'
+        ))
+    }));
+    TestingContextKeys.testMessageContext = ( new RawContextKey('testMessage', undefined, {
+        type: 'string',
+        description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.testMessage',
+            'Value set in `testMessage.contextValue`, available in editor/content and testing/message/context'
+        ))
+    }));
+    TestingContextKeys.testResultOutdated = ( new RawContextKey('testResultOutdated', undefined, {
+        type: 'boolean',
+        description: ( localizeWithPath(
+            'vs/workbench/contrib/testing/common/testingContextKeys',
+            'testing.testResultOutdated',
+            'Value available in editor/content and testing/message/context when the result is outdated'
+        ))
+    }));
+})(TestingContextKeys || (TestingContextKeys = {})));
+export { TestingContextKeys };

package/vscode/src/vs/workbench/contrib/testing/common/testingContinuousRunService.js

@@ -0,0 +1,102 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { StoredValue } from './storedValue.js';
+import { TestingContextKeys } from './testingContextKeys.js';
+import { ITestService } from './testService.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { TestId } from './testId.js';
+import { WellDefinedPrefixTree } from '../../../../base/common/prefixTree.js';
+const ITestingContinuousRunService = ( createDecorator('testingContinuousRunService'));
+let TestingContinuousRunService = class TestingContinuousRunService extends Disposable {
+    get lastRunProfileIds() {
+        return this.lastRun.get(( new Set()));
+    }
+    constructor(testService, storageService, contextKeyService) {
+        super();
+        this.testService = testService;
+        this.changeEmitter = ( new Emitter());
+        this.running = ( new WellDefinedPrefixTree());
+        this.onDidChange = this.changeEmitter.event;
+        this.isGloballyOn = TestingContextKeys.isContinuousModeOn.bindTo(contextKeyService);
+        this.lastRun = this._register(( new StoredValue({
+            key: 'lastContinuousRunProfileIds',
+            scope: 1 ,
+            target: 1 ,
+            serialization: {
+                deserialize: v => ( new Set(JSON.parse(v))),
+                serialize: v => JSON.stringify([...v])
+            },
+        }, storageService)));
+        this._register(toDisposable(() => {
+            this.globallyRunning?.dispose();
+            for (const cts of ( this.running.values())) {
+                cts.dispose();
+            }
+        }));
+    }
+    isSpecificallyEnabledFor(testId) {
+        return this.running.size > 0 && this.running.hasKey(TestId.fromString(testId).path);
+    }
+    isEnabledForAParentOf(testId) {
+        if (this.globallyRunning) {
+            return true;
+        }
+        return this.running.size > 0 && this.running.hasKeyOrParent(TestId.fromString(testId).path);
+    }
+    isEnabledForAChildOf(testId) {
+        return this.running.size > 0 && this.running.hasKeyOrChildren(TestId.fromString(testId).path);
+    }
+    isEnabled() {
+        return !!this.globallyRunning || this.running.size > 0;
+    }
+    start(profile, testId) {
+        const cts = ( new CancellationTokenSource());
+        if (testId === undefined) {
+            this.isGloballyOn.set(true);
+        }
+        if (!testId) {
+            this.globallyRunning?.dispose(true);
+            this.globallyRunning = cts;
+        }
+        else {
+            this.running.mutate(TestId.fromString(testId).path, c => {
+                c?.dispose(true);
+                return cts;
+            });
+        }
+        this.lastRun.store(( new Set(( profile.map(p => p.profileId)))));
+        this.testService.startContinuousRun({
+            continuous: true,
+            targets: ( profile.map(p => ({
+                testIds: [testId ?? p.controllerId],
+                controllerId: p.controllerId,
+                profileGroup: p.group,
+                profileId: p.profileId
+            }))),
+        }, cts.token);
+        this.changeEmitter.fire(testId);
+    }
+    stop(testId) {
+        if (!testId) {
+            this.globallyRunning?.dispose(true);
+            this.globallyRunning = undefined;
+        }
+        else {
+            this.running.delete(TestId.fromString(testId).path)?.dispose(true);
+        }
+        if (testId === undefined) {
+            this.isGloballyOn.set(false);
+        }
+        this.changeEmitter.fire(testId);
+    }
+};
+TestingContinuousRunService = ( __decorate([
+    ( __param(0, ITestService)),
+    ( __param(1, IStorageService)),
+    ( __param(2, IContextKeyService))
+], TestingContinuousRunService));
+export { ITestingContinuousRunService, TestingContinuousRunService };

package/vscode/src/vs/workbench/contrib/testing/common/testingDecorations.js

@@ -0,0 +1,29 @@
+import { binarySearch } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+class TestDecorations {
+    constructor() {
+        this.value = [];
+    }
+    push(value) {
+        const searchIndex = binarySearch(this.value, value, (a, b) => a.line - b.line);
+        this.value.splice(searchIndex < 0 ? ~searchIndex : searchIndex, 0, value);
+    }
+    *lines() {
+        if (!this.value.length) {
+            return;
+        }
+        let startIndex = 0;
+        let startLine = this.value[0].line;
+        for (let i = 1; i < this.value.length; i++) {
+            const v = this.value[i];
+            if (v.line !== startLine) {
+                yield [startLine, this.value.slice(startIndex, i)];
+                startLine = v.line;
+                startIndex = i;
+            }
+        }
+        yield [startLine, this.value.slice(startIndex)];
+    }
+}
+const ITestingDecorationsService = ( createDecorator('testingDecorationService'));
+export { ITestingDecorationsService, TestDecorations };

package/vscode/src/vs/workbench/contrib/testing/common/testingPeekOpener.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const ITestingPeekOpener = ( createDecorator('testingPeekOpener'));
+export { ITestingPeekOpener };

package/vscode/src/vs/workbench/contrib/testing/common/testingStates.js

@@ -0,0 +1,47 @@
+const statePriority = {
+    [2 ]: 6,
+    [6 ]: 5,
+    [4 ]: 4,
+    [1 ]: 3,
+    [3 ]: 2,
+    [0 ]: 0,
+    [5 ]: 1,
+};
+const isFailedState = (s) => s === 6  || s === 4 ;
+const isStateWithResult = (s) => s === 6  || s === 4  || s === 3 ;
+Object.entries(statePriority).reduce((acc, [stateStr, priority]) => {
+    const state = Number(stateStr);
+    acc[state] = { statusNode: true, state, priority };
+    return acc;
+}, {});
+const cmpPriority = (a, b) => statePriority[b] - statePriority[a];
+const maxPriority = (...states) => {
+    switch (states.length) {
+        case 0:
+            return 0 ;
+        case 1:
+            return states[0];
+        case 2:
+            return statePriority[states[0]] > statePriority[states[1]] ? states[0] : states[1];
+        default: {
+            let max = states[0];
+            for (let i = 1; i < states.length; i++) {
+                if (statePriority[max] < statePriority[states[i]]) {
+                    max = states[i];
+                }
+            }
+            return max;
+        }
+    }
+};
+const statesInOrder = ( ( Object.keys(statePriority)).map(s => Number(s))).sort(cmpPriority);
+const terminalStatePriorities = {
+    [3 ]: 0,
+    [5 ]: 1,
+    [4 ]: 2,
+    [6 ]: 3,
+};
+const makeEmptyCounts = () => {
+    return ( new Uint32Array(statesInOrder.length));
+};
+export { cmpPriority, isFailedState, isStateWithResult, makeEmptyCounts, maxPriority, statePriority, statesInOrder, terminalStatePriorities };

package/vscode/src/vs/workbench/services/suggest/browser/media/suggest.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".workbench-suggest-widget{display:flex;flex-direction:column;left:0;position:absolute;top:0;width:430px;z-index:40}.workbench-suggest-widget.message{align-items:center;flex-direction:row}.monaco-workbench .workbench-suggest-details,.workbench-suggest-widget{background-color:var(--vscode-editorSuggestWidget-background);border-color:var(--vscode-editorSuggestWidget-border);border-style:solid;border-width:1px;flex:0 1 auto;width:100%}.monaco-workbench.hc-black .workbench-suggest-details,.monaco-workbench.hc-black .workbench-suggest-widget,.monaco-workbench.hc-light .workbench-suggest-details,.monaco-workbench.hc-light .workbench-suggest-widget{border-width:2px}.monaco-workbench .workbench-suggest-widget.with-status-bar .suggest-status-bar{display:flex}.monaco-workbench .workbench-suggest-widget .suggest-status-bar .left{padding-right:8px}.monaco-workbench .workbench-suggest-widget.with-status-bar .suggest-status-bar .action-label{color:var(--vscode-editorSuggestWidgetStatus-foreground)}.monaco-workbench .workbench-suggest-widget.with-status-bar .suggest-status-bar .action-item:not(:last-of-type) .action-label{margin-right:0}.monaco-workbench .workbench-suggest-widget.with-status-bar .suggest-status-bar .action-item:not(:last-of-type) .action-label:after{content:\", \";margin-right:.3em}.monaco-workbench .workbench-suggest-widget.with-status-bar .monaco-list .monaco-list-row.focused.string-label>.contents>.main>.right>.readMore,.monaco-workbench .workbench-suggest-widget.with-status-bar .monaco-list .monaco-list-row>.contents>.main>.right>.readMore{display:none}.workbench-suggest-widget .monaco-list .monaco-list-row{background-position:2px 2px;background-repeat:no-repeat;-mox-box-sizing:border-box;box-sizing:border-box;cursor:pointer;display:flex;padding-right:10px;touch-action:none;white-space:nowrap}.workbench-suggest-widget .monaco-list .monaco-list-row.focused{color:var(--vscode-editorSuggestWidget-selectedForeground)}.workbench-suggest-widget .monaco-list .monaco-list-row.focused .codicon{color:var(--vscode-editorSuggestWidget-selectedIconForeground)}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents{flex:1;height:100%;overflow:hidden;padding-left:2px}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main{display:flex;justify-content:space-between;overflow:hidden;text-overflow:ellipsis;white-space:pre}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.left,.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right{display:flex}.workbench-suggest-widget .monaco-list .monaco-list-row:not(.focused)>.contents>.main .monaco-icon-label{color:var(--vscode-editorSuggestWidget-foreground)}.workbench-suggest-widget:not(.frozen) .monaco-highlighted-label .highlight{font-weight:700}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main .monaco-highlighted-label .highlight{color:var(--vscode-editorSuggestWidget-highlightForeground)}.workbench-suggest-widget .monaco-list .monaco-list-row.focused>.contents>.main .monaco-highlighted-label .highlight{color:var(--vscode-editorSuggestWidget-focusHighlightForeground)}.workbench-suggest-widget .monaco-list .monaco-list-row .monaco-icon-label.deprecated{opacity:.66;text-decoration:unset}.workbench-suggest-widget .monaco-list .monaco-list-row .monaco-icon-label.deprecated>.monaco-icon-label-container>.monaco-icon-name-container{text-decoration:line-through}.workbench-suggest-widget .monaco-list .monaco-list-row .monaco-icon-label:before{height:100%}.workbench-suggest-widget .monaco-list .monaco-list-row .icon{background-position:50%;background-repeat:no-repeat;background-size:80%;display:block;height:16px;margin-left:2px;width:16px}.workbench-suggest-widget .monaco-list .monaco-list-row .icon.hide{display:none}.workbench-suggest-widget .monaco-list .monaco-list-row .suggest-icon{align-items:center;display:flex;margin-right:4px}.workbench-suggest-widget.no-icons .monaco-list .monaco-list-row .icon,.workbench-suggest-widget.no-icons .monaco-list .monaco-list-row .suggest-icon:before{display:none}.workbench-suggest-widget .monaco-list .monaco-list-row .icon.customcolor .colorspan{border:.1em solid #000;display:inline-block;height:.7em;margin:0 0 0 .3em;width:.7em}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right>.details-label{opacity:.7}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.left>.signature-label{opacity:.6;overflow:hidden;text-overflow:ellipsis}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.left>.qualifier-label{align-self:center;font-size:85%;line-height:normal;margin-left:12px;opacity:.4;overflow:hidden;text-overflow:ellipsis}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right>.details-label{font-size:85%;margin-left:1.1em;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right>.details-label>.monaco-tokenized-source{display:inline}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right>.details-label{display:none}.workbench-suggest-widget .monaco-list .monaco-list-row:not(.string-label)>.contents>.main>.right>.details-label,.workbench-suggest-widget.docs-side .monaco-list .monaco-list-row.focused:not(.string-label)>.contents>.main>.right>.details-label,.workbench-suggest-widget:not(.shows-details) .monaco-list .monaco-list-row.focused>.contents>.main>.right>.details-label{display:inline}.workbench-suggest-widget:not(.docs-side) .monaco-list .monaco-list-row.focused:hover>.contents>.main>.right.can-expand-details>.details-label{width:calc(100% - 26px)}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.left{flex-grow:1;flex-shrink:1;overflow:hidden}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.left>.monaco-icon-label{flex-shrink:0}.workbench-suggest-widget .monaco-list .monaco-list-row:not(.string-label)>.contents>.main>.left>.monaco-icon-label{max-width:100%}.workbench-suggest-widget .monaco-list .monaco-list-row.string-label>.contents>.main>.left>.monaco-icon-label{flex-shrink:1}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right{flex-shrink:4;max-width:70%;overflow:hidden}.workbench-suggest-widget .monaco-list .monaco-list-row>.contents>.main>.right>.readMore{display:inline-block;height:18px;position:absolute;right:10px;visibility:hidden;width:18px}";
+n(css,{});
+export { css, css as default };

package/vscode/src/vs/workbench/services/suggest/browser/simpleCompletionItem.js

@@ -0,0 +1,10 @@
+import { FuzzyScore } from 'monaco-editor/esm/vs/base/common/filters.js';
+class SimpleCompletionItem {
+    constructor(completion) {
+        this.completion = completion;
+        this.score = FuzzyScore.Default;
+        this.distance = 0;
+        this.labelLow = this.completion.label.toLowerCase();
+    }
+}
+export { SimpleCompletionItem };

package/vscode/src/vs/workbench/services/suggest/browser/simpleCompletionModel.js

@@ -0,0 +1,98 @@
+import { quickSelect } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { FuzzyScoreOptions, FuzzyScore, fuzzyScore, fuzzyScoreGracefulAggressive } from 'monaco-editor/esm/vs/base/common/filters.js';
+class LineContext {
+    constructor(leadingLineContent, characterCountDelta) {
+        this.leadingLineContent = leadingLineContent;
+        this.characterCountDelta = characterCountDelta;
+    }
+}
+class SimpleCompletionModel {
+    constructor(_items, _lineContext, replacementIndex, replacementLength) {
+        this._items = _items;
+        this._lineContext = _lineContext;
+        this.replacementIndex = replacementIndex;
+        this.replacementLength = replacementLength;
+        this._refilterKind = 1 ;
+        this._fuzzyScoreOptions = FuzzyScoreOptions.default;
+        this._options = {};
+    }
+    get items() {
+        this._ensureCachedState();
+        return this._filteredItems;
+    }
+    get stats() {
+        this._ensureCachedState();
+        return this._stats;
+    }
+    get lineContext() {
+        return this._lineContext;
+    }
+    set lineContext(value) {
+        if (this._lineContext.leadingLineContent !== value.leadingLineContent
+            || this._lineContext.characterCountDelta !== value.characterCountDelta) {
+            this._refilterKind = this._lineContext.characterCountDelta < value.characterCountDelta && this._filteredItems ? 2  : 1 ;
+            this._lineContext = value;
+        }
+    }
+    _ensureCachedState() {
+        if (this._refilterKind !== 0 ) {
+            this._createCachedState();
+        }
+    }
+    _createCachedState() {
+        const labelLengths = [];
+        const { leadingLineContent, characterCountDelta } = this._lineContext;
+        let word = '';
+        let wordLow = '';
+        const source = this._refilterKind === 1  ? this._items : this._filteredItems;
+        const target = [];
+        const scoreFn = (!this._options.filterGraceful || source.length > 2000) ? fuzzyScore : fuzzyScoreGracefulAggressive;
+        for (let i = 0; i < source.length; i++) {
+            const item = source[i];
+            const overwriteBefore = this.replacementLength;
+            const wordLen = overwriteBefore + characterCountDelta;
+            if (word.length !== wordLen) {
+                word = wordLen === 0 ? '' : leadingLineContent.slice(-wordLen);
+                wordLow = word.toLowerCase();
+            }
+            item.word = word;
+            if (wordLen === 0) {
+                item.score = FuzzyScore.Default;
+            }
+            else {
+                let wordPos = 0;
+                while (wordPos < overwriteBefore) {
+                    const ch = word.charCodeAt(wordPos);
+                    if (ch === 32  || ch === 9 ) {
+                        wordPos += 1;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                if (wordPos >= wordLen) {
+                    item.score = FuzzyScore.Default;
+                }
+                else {
+                    const match = scoreFn(word, wordLow, wordPos, item.completion.label, item.labelLow, 0, this._fuzzyScoreOptions);
+                    if (!match) {
+                        continue;
+                    }
+                    item.score = match;
+                }
+            }
+            item.idx = i;
+            item.distance = 1;
+            target.push(item);
+            labelLengths.push(item.completion.label.length);
+        }
+        this._filteredItems = target;
+        this._refilterKind = 0 ;
+        this._stats = {
+            pLabelLen: labelLengths.length ?
+                quickSelect(labelLengths.length - .85, labelLengths, (a, b) => a - b)
+                : 0
+        };
+    }
+}
+export { LineContext, SimpleCompletionModel };