@codingame/monaco-vscode-api 1.83.15-next.0 → 1.83.16

package/vscode/src/vs/workbench/services/extensions/browser/extensionUrlHandler.js

@@ -1,15 +1,34 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { combinedDisposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { IExtensionManagementService, IExtensionGalleryService } from '../../../../platform/extensionManagement/common/extensionManagement.js';
+import { IWorkbenchExtensionEnablementService } from '../../extensionManagement/common/extensionManagement.js';
+import { areSameExtensions } from '../../../../platform/extensionManagement/common/extensionManagementUtil.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
 import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
 import { IURLService } from '../../../../platform/url/common/url.js';
+import { IHostService } from '../../host/browser/host.js';
+import { toExtensionDescription, IExtensionService } from '../common/extensions.js';
+import { ExtensionIdentifier } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
 import { Extensions } from '../../../common/contributions.js';
 import { registerAction2, Action2, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
 import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { IProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
 import { IsWebContext } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkeys.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
 var ExtensionUrlBootstrapHandler_1;
+const FIVE_MINUTES = 5 * 60 * 1000;
+const THIRTY_SECONDS = 30 * 1000;
+const URL_TO_HANDLE = 'extensionUrlHandler.urlToHandle';
+const USER_TRUSTED_EXTENSIONS_CONFIGURATION_KEY = 'extensions.confirmedUriHandlerExtensionIds';
 const USER_TRUSTED_EXTENSIONS_STORAGE_KEY = 'extensionUrlHandler.confirmedExtensions';
 function isExtensionId(value) {
     return /^[a-z0-9][a-z0-9\-]*\.[a-z0-9][a-z0-9\-]*$/i.test(value);
@@ -38,6 +57,293 @@ class UserTrustedExtensionIdStorage {
     }
 }
 const IExtensionUrlHandler = ( createDecorator('extensionUrlHandler'));
+let ExtensionUrlHandler = class ExtensionUrlHandler {
+    constructor(urlService, extensionService, dialogService, notificationService, extensionManagementService, extensionEnablementService, hostService, galleryService, storageService, configurationService, progressService, telemetryService, productService) {
+        this.extensionService = extensionService;
+        this.dialogService = dialogService;
+        this.notificationService = notificationService;
+        this.extensionManagementService = extensionManagementService;
+        this.extensionEnablementService = extensionEnablementService;
+        this.hostService = hostService;
+        this.galleryService = galleryService;
+        this.storageService = storageService;
+        this.configurationService = configurationService;
+        this.progressService = progressService;
+        this.telemetryService = telemetryService;
+        this.productService = productService;
+        this.extensionHandlers = ( new Map());
+        this.uriBuffer = ( new Map());
+        this.userTrustedExtensionsStorage = ( new UserTrustedExtensionIdStorage(storageService));
+        const interval = setInterval(() => this.garbageCollect(), THIRTY_SECONDS);
+        const urlToHandleValue = this.storageService.get(URL_TO_HANDLE, 1 );
+        if (urlToHandleValue) {
+            this.storageService.remove(URL_TO_HANDLE, 1 );
+            this.handleURL(URI.revive(JSON.parse(urlToHandleValue)), { trusted: true });
+        }
+        this.disposable = combinedDisposable(urlService.registerHandler(this), toDisposable(() => clearInterval(interval)));
+        const cache = ExtensionUrlBootstrapHandler.cache;
+        setTimeout(() => cache.forEach(([uri, option]) => this.handleURL(uri, option)));
+    }
+    async handleURL(uri, options) {
+        if (!isExtensionId(uri.authority)) {
+            return false;
+        }
+        const extensionId = uri.authority;
+        this.telemetryService.publicLog2('uri_invoked/start', { extensionId });
+        const initialHandler = this.extensionHandlers.get(ExtensionIdentifier.toKey(extensionId));
+        let extensionDisplayName;
+        if (!initialHandler) {
+            const extension = await this.extensionService.getExtension(extensionId);
+            if (!extension) {
+                await this.handleUnhandledURL(uri, { id: extensionId }, options);
+                return true;
+            }
+            else {
+                extensionDisplayName = extension.displayName ?? '';
+            }
+        }
+        else {
+            extensionDisplayName = initialHandler.extensionDisplayName;
+        }
+        const trusted = options?.trusted
+            || this.productService.trustedExtensionProtocolHandlers?.includes(extensionId)
+            || this.didUserTrustExtension(ExtensionIdentifier.toKey(extensionId));
+        if (!trusted) {
+            let uriString = ( uri.toString(false));
+            if (uriString.length > 40) {
+                uriString = `${uriString.substring(0, 30)}...${uriString.substring(uriString.length - 5)}`;
+            }
+            const result = await this.dialogService.confirm({
+                message: ( localizeWithPath(
+                    'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                    'confirmUrl',
+                    "Allow '{0}' extension to open this URI?",
+                    extensionDisplayName
+                )),
+                checkbox: {
+                    label: ( localizeWithPath(
+                        'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                        'rememberConfirmUrl',
+                        "Don't ask again for this extension."
+                    )),
+                },
+                detail: uriString,
+                primaryButton: ( localizeWithPath(
+                    'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                    { key: 'open', comment: ['&& denotes a mnemonic'] },
+                    "&&Open"
+                ))
+            });
+            if (!result.confirmed) {
+                this.telemetryService.publicLog2('uri_invoked/cancel', { extensionId });
+                return true;
+            }
+            if (result.checkboxChecked) {
+                this.userTrustedExtensionsStorage.add(ExtensionIdentifier.toKey(extensionId));
+            }
+        }
+        const handler = this.extensionHandlers.get(ExtensionIdentifier.toKey(extensionId));
+        if (handler) {
+            if (!initialHandler) {
+                return await this.handleURLByExtension(extensionId, handler, uri, options);
+            }
+            return false;
+        }
+        const timestamp = ( new Date()).getTime();
+        let uris = this.uriBuffer.get(ExtensionIdentifier.toKey(extensionId));
+        if (!uris) {
+            uris = [];
+            this.uriBuffer.set(ExtensionIdentifier.toKey(extensionId), uris);
+        }
+        uris.push({ timestamp, uri });
+        await this.extensionService.activateByEvent(`onUri:${ExtensionIdentifier.toKey(extensionId)}`, 1 );
+        return true;
+    }
+    registerExtensionHandler(extensionId, handler) {
+        this.extensionHandlers.set(ExtensionIdentifier.toKey(extensionId), handler);
+        const uris = this.uriBuffer.get(ExtensionIdentifier.toKey(extensionId)) || [];
+        for (const { uri } of uris) {
+            this.handleURLByExtension(extensionId, handler, uri);
+        }
+        this.uriBuffer.delete(ExtensionIdentifier.toKey(extensionId));
+    }
+    unregisterExtensionHandler(extensionId) {
+        this.extensionHandlers.delete(ExtensionIdentifier.toKey(extensionId));
+    }
+    async handleURLByExtension(extensionId, handler, uri, options) {
+        this.telemetryService.publicLog2('uri_invoked/end', { extensionId: ExtensionIdentifier.toKey(extensionId) });
+        return await handler.handleURL(uri, options);
+    }
+    async handleUnhandledURL(uri, extensionIdentifier, options) {
+        const installedExtensions = await this.extensionManagementService.getInstalled();
+        let extension = installedExtensions.find(e => areSameExtensions(e.identifier, extensionIdentifier));
+        if (!extension) {
+            let galleryExtension;
+            try {
+                galleryExtension = (await this.galleryService.getExtensions([extensionIdentifier], CancellationToken.None))[0] ?? undefined;
+            }
+            catch (err) {
+                return;
+            }
+            if (!galleryExtension) {
+                return;
+            }
+            this.telemetryService.publicLog2('uri_invoked/install_extension/start', { extensionId: extensionIdentifier.id });
+            const result = await this.dialogService.confirm({
+                message: ( localizeWithPath(
+                    'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                    'installAndHandle',
+                    "Would you like to install '{0}' extension from '{1}' to open this URI?",
+                    galleryExtension.displayName,
+                    galleryExtension.publisherDisplayName
+                )),
+                detail: `${( localizeWithPath(
+                    'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                    'installDetail',
+                    "'{0}' extension wants to open a URI:",
+                    galleryExtension.displayName
+                ))}\n\n${( uri.toString())}`,
+                primaryButton: ( localizeWithPath(
+                    'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                    { key: 'install and open', comment: ['&& denotes a mnemonic'] },
+                    "&&Install and Open"
+                ))
+            });
+            if (!result.confirmed) {
+                this.telemetryService.publicLog2('uri_invoked/install_extension/cancel', { extensionId: extensionIdentifier.id });
+                return;
+            }
+            this.telemetryService.publicLog2('uri_invoked/install_extension/accept', { extensionId: extensionIdentifier.id });
+            try {
+                extension = await this.progressService.withProgress({
+                    location: 15 ,
+                    title: ( localizeWithPath(
+                        'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                        'Installing',
+                        "Installing Extension '{0}'...",
+                        galleryExtension.displayName || galleryExtension.name
+                    ))
+                }, () => this.extensionManagementService.installFromGallery(galleryExtension));
+            }
+            catch (error) {
+                this.notificationService.error(error);
+                return;
+            }
+        }
+        if (!this.extensionEnablementService.isEnabled(extension)) {
+            this.telemetryService.publicLog2('uri_invoked/enable_extension/start', { extensionId: extensionIdentifier.id });
+            const result = await this.dialogService.confirm({
+                message: ( localizeWithPath(
+                    'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                    'enableAndHandle',
+                    "Extension '{0}' is disabled. Would you like to enable the extension and open the URL?",
+                    extension.manifest.displayName || extension.manifest.name
+                )),
+                detail: `${extension.manifest.displayName || extension.manifest.name} (${extensionIdentifier.id}) wants to open a URL:\n\n${( uri.toString())}`,
+                primaryButton: ( localizeWithPath(
+                    'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                    { key: 'enableAndReload', comment: ['&& denotes a mnemonic'] },
+                    "&&Enable and Open"
+                ))
+            });
+            if (!result.confirmed) {
+                this.telemetryService.publicLog2('uri_invoked/enable_extension/cancel', { extensionId: extensionIdentifier.id });
+                return;
+            }
+            this.telemetryService.publicLog2('uri_invoked/enable_extension/accept', { extensionId: extensionIdentifier.id });
+            await this.extensionEnablementService.setEnablement([extension], 8 );
+        }
+        if (this.extensionService.canAddExtension(toExtensionDescription(extension))) {
+            await this.waitUntilExtensionIsAdded(extensionIdentifier);
+            await this.handleURL(uri, { ...options, trusted: true });
+        }
+        else {
+            this.telemetryService.publicLog2('uri_invoked/activate_extension/start', { extensionId: extensionIdentifier.id });
+            const result = await this.dialogService.confirm({
+                message: ( localizeWithPath(
+                    'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                    'reloadAndHandle',
+                    "Extension '{0}' is not loaded. Would you like to reload the window to load the extension and open the URL?",
+                    extension.manifest.displayName || extension.manifest.name
+                )),
+                detail: `${extension.manifest.displayName || extension.manifest.name} (${extensionIdentifier.id}) wants to open a URL:\n\n${( uri.toString())}`,
+                primaryButton: ( localizeWithPath(
+                    'vs/workbench/services/extensions/browser/extensionUrlHandler',
+                    { key: 'reloadAndOpen', comment: ['&& denotes a mnemonic'] },
+                    "&&Reload Window and Open"
+                ))
+            });
+            if (!result.confirmed) {
+                this.telemetryService.publicLog2('uri_invoked/activate_extension/cancel', { extensionId: extensionIdentifier.id });
+                return;
+            }
+            this.telemetryService.publicLog2('uri_invoked/activate_extension/accept', { extensionId: extensionIdentifier.id });
+            this.storageService.store(URL_TO_HANDLE, JSON.stringify(uri.toJSON()), 1 , 1 );
+            await this.hostService.reload();
+        }
+    }
+    async waitUntilExtensionIsAdded(extensionId) {
+        if (!(await this.extensionService.getExtension(extensionId.id))) {
+            await ( new Promise((c, e) => {
+                const disposable = this.extensionService.onDidChangeExtensions(async () => {
+                    try {
+                        if (await this.extensionService.getExtension(extensionId.id)) {
+                            disposable.dispose();
+                            c();
+                        }
+                    }
+                    catch (error) {
+                        e(error);
+                    }
+                });
+            }));
+        }
+    }
+    garbageCollect() {
+        const now = ( new Date()).getTime();
+        const uriBuffer = ( new Map());
+        this.uriBuffer.forEach((uris, extensionId) => {
+            uris = uris.filter(({ timestamp }) => now - timestamp < FIVE_MINUTES);
+            if (uris.length > 0) {
+                uriBuffer.set(extensionId, uris);
+            }
+        });
+        this.uriBuffer = uriBuffer;
+    }
+    didUserTrustExtension(id) {
+        if (( this.userTrustedExtensionsStorage.has(id))) {
+            return true;
+        }
+        return this.getConfirmedTrustedExtensionIdsFromConfiguration().indexOf(id) > -1;
+    }
+    getConfirmedTrustedExtensionIdsFromConfiguration() {
+        const trustedExtensionIds = this.configurationService.getValue(USER_TRUSTED_EXTENSIONS_CONFIGURATION_KEY);
+        if (!Array.isArray(trustedExtensionIds)) {
+            return [];
+        }
+        return trustedExtensionIds;
+    }
+    dispose() {
+        this.disposable.dispose();
+        this.extensionHandlers.clear();
+        this.uriBuffer.clear();
+    }
+};
+ExtensionUrlHandler = ( __decorate([
+    ( __param(0, IURLService)),
+    ( __param(1, IExtensionService)),
+    ( __param(2, IDialogService)),
+    ( __param(3, INotificationService)),
+    ( __param(4, IExtensionManagementService)),
+    ( __param(5, IWorkbenchExtensionEnablementService)),
+    ( __param(6, IHostService)),
+    ( __param(7, IExtensionGalleryService)),
+    ( __param(8, IStorageService)),
+    ( __param(9, IConfigurationService)),
+    ( __param(10, IProgressService)),
+    ( __param(11, ITelemetryService)),
+    ( __param(12, IProductService))
+], ExtensionUrlHandler));
 let ExtensionUrlBootstrapHandler = class ExtensionUrlBootstrapHandler {
     static { ExtensionUrlBootstrapHandler_1 = this; }
     static { this._cache = []; }
@@ -104,4 +410,4 @@ class ManageAuthorizedExtensionURIsAction extends Action2 {
     }
 }
 registerAction2(ManageAuthorizedExtensionURIsAction);
-export { IExtensionUrlHandler };
+export { ExtensionUrlHandler, IExtensionUrlHandler };

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 };