@codingame/monaco-vscode-api 1.82.4-next.1 → 1.82.5-next.0

package/vscode/src/vs/workbench/services/languageDetection/browser/languageDetectionWorkerServiceImpl.js

@@ -1,259 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { LanguageDetectionStatsId } from '../common/languageDetectionWorkerService.js';
-import { FileAccess, Schemas, nodeModulesPath, nodeModulesAsarPath } from 'monaco-editor/esm/vs/base/common/network.js';
-import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
-import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
-import { SimpleWorkerClient } from 'monaco-editor/esm/vs/base/common/worker/simpleWorker.js';
-import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
-import { EditorWorkerClient, EditorWorkerHost } from 'monaco-editor/esm/vs/editor/browser/services/editorWorkerService.js';
-import { ILanguageConfigurationService } from 'monaco-editor/esm/vs/editor/common/languages/languageConfigurationRegistry.js';
-import { IDiagnosticsService } from '../../../../platform/diagnostics/common/diagnostics.js';
-import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
-import { IEditorService } from '../../editor/common/editorService.js';
-import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { LRUCache } from 'monaco-editor/esm/vs/base/common/map.js';
-import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-var LanguageDetectionService_1;
-const TOP_LANG_COUNTS = 12;
-const regexpModuleLocation = `${nodeModulesPath}/vscode-regexp-languagedetection`;
-const regexpModuleLocationAsar = `${nodeModulesAsarPath}/vscode-regexp-languagedetection`;
-const moduleLocation = `${nodeModulesPath}/@vscode/vscode-languagedetection`;
-const moduleLocationAsar = `${nodeModulesAsarPath}/@vscode/vscode-languagedetection`;
-let LanguageDetectionService = class LanguageDetectionService extends Disposable {
-    static { LanguageDetectionService_1 = this; }
-    static { this.enablementSettingKey = 'workbench.editor.languageDetection'; }
-    static { this.historyBasedEnablementConfig = 'workbench.editor.historyBasedLanguageDetection'; }
-    static { this.preferHistoryConfig = 'workbench.editor.preferHistoryBasedLanguageDetection'; }
-    static { this.workspaceOpenedLanguagesStorageKey = 'workbench.editor.languageDetectionOpenedLanguages.workspace'; }
-    static { this.globalOpenedLanguagesStorageKey = 'workbench.editor.languageDetectionOpenedLanguages.global'; }
-    constructor(_environmentService, languageService, _configurationService, _diagnosticsService, _workspaceContextService, modelService, _editorService, telemetryService, storageService, _logService, languageConfigurationService) {
-        super();
-        this._environmentService = _environmentService;
-        this._configurationService = _configurationService;
-        this._diagnosticsService = _diagnosticsService;
-        this._workspaceContextService = _workspaceContextService;
-        this._editorService = _editorService;
-        this._logService = _logService;
-        this.hasResolvedWorkspaceLanguageIds = false;
-        this.workspaceLanguageIds = ( new Set());
-        this.sessionOpenedLanguageIds = ( new Set());
-        this.historicalGlobalOpenedLanguageIds = ( new LRUCache(TOP_LANG_COUNTS));
-        this.historicalWorkspaceOpenedLanguageIds = ( new LRUCache(TOP_LANG_COUNTS));
-        this.dirtyBiases = true;
-        this.langBiases = {};
-        this._languageDetectionWorkerClient = ( new LanguageDetectionWorkerClient(
-            modelService,
-            languageService,
-            telemetryService,
-            this._environmentService.isBuilt && !isWeb
-                ? ( ( FileAccess.asBrowserUri(`${moduleLocationAsar}/dist/lib/index.js`)).toString(true))
-                : ( ( FileAccess.asBrowserUri(`${moduleLocation}/dist/lib/index.js`)).toString(true)),
-            this._environmentService.isBuilt && !isWeb
-                ? ( ( FileAccess.asBrowserUri(`${moduleLocationAsar}/model/model.json`)).toString(true))
-                : ( ( FileAccess.asBrowserUri(`${moduleLocation}/model/model.json`)).toString(true)),
-            this._environmentService.isBuilt && !isWeb
-                ? ( ( FileAccess.asBrowserUri(`${moduleLocationAsar}/model/group1-shard1of1.bin`)).toString(true))
-                : ( ( FileAccess.asBrowserUri(`${moduleLocation}/model/group1-shard1of1.bin`)).toString(true)),
-            this._environmentService.isBuilt && !isWeb
-                ? ( ( FileAccess.asBrowserUri(`${regexpModuleLocationAsar}/dist/index.js`)).toString(true))
-                : ( ( FileAccess.asBrowserUri(`${regexpModuleLocation}/dist/index.js`)).toString(true)),
-            languageConfigurationService
-        ));
-        this.initEditorOpenedListeners(storageService);
-    }
-    async resolveWorkspaceLanguageIds() {
-        if (this.hasResolvedWorkspaceLanguageIds) {
-            return;
-        }
-        this.hasResolvedWorkspaceLanguageIds = true;
-        const fileExtensions = await this._diagnosticsService.getWorkspaceFileExtensions(this._workspaceContextService.getWorkspace());
-        let count = 0;
-        for (const ext of fileExtensions.extensions) {
-            const langId = this._languageDetectionWorkerClient.getLanguageId(ext);
-            if (langId && count < TOP_LANG_COUNTS) {
-                this.workspaceLanguageIds.add(langId);
-                count++;
-                if (count > TOP_LANG_COUNTS) {
-                    break;
-                }
-            }
-        }
-        this.dirtyBiases = true;
-    }
-    isEnabledForLanguage(languageId) {
-        return !!languageId && this._configurationService.getValue(LanguageDetectionService_1.enablementSettingKey, { overrideIdentifier: languageId });
-    }
-    getLanguageBiases() {
-        if (!this.dirtyBiases) {
-            return this.langBiases;
-        }
-        const biases = {};
-        this.sessionOpenedLanguageIds.forEach(lang => biases[lang] = (biases[lang] ?? 0) + 7);
-        this.workspaceLanguageIds.forEach(lang => biases[lang] = (biases[lang] ?? 0) + 5);
-        [...( this.historicalWorkspaceOpenedLanguageIds.keys())].forEach(lang => biases[lang] = (biases[lang] ?? 0) + 3);
-        [...( this.historicalGlobalOpenedLanguageIds.keys())].forEach(lang => biases[lang] = (biases[lang] ?? 0) + 1);
-        this._logService.trace('Session Languages:', JSON.stringify([...this.sessionOpenedLanguageIds]));
-        this._logService.trace('Workspace Languages:', JSON.stringify([...this.workspaceLanguageIds]));
-        this._logService.trace('Historical Workspace Opened Languages:', JSON.stringify([...( this.historicalWorkspaceOpenedLanguageIds.keys())]));
-        this._logService.trace('Historical Globally Opened Languages:', JSON.stringify([...( this.historicalGlobalOpenedLanguageIds.keys())]));
-        this._logService.trace('Computed Language Detection Biases:', JSON.stringify(biases));
-        this.dirtyBiases = false;
-        this.langBiases = biases;
-        return biases;
-    }
-    async detectLanguage(resource, supportedLangs) {
-        const useHistory = this._configurationService.getValue(LanguageDetectionService_1.historyBasedEnablementConfig);
-        const preferHistory = this._configurationService.getValue(LanguageDetectionService_1.preferHistoryConfig);
-        if (useHistory) {
-            await this.resolveWorkspaceLanguageIds();
-        }
-        const biases = useHistory ? this.getLanguageBiases() : undefined;
-        return this._languageDetectionWorkerClient.detectLanguage(resource, biases, preferHistory, supportedLangs);
-    }
-    initEditorOpenedListeners(storageService) {
-        try {
-            const globalLangHistoryData = JSON.parse(storageService.get(LanguageDetectionService_1.globalOpenedLanguagesStorageKey, 0 , '[]'));
-            this.historicalGlobalOpenedLanguageIds.fromJSON(globalLangHistoryData);
-        }
-        catch (e) {
-            console.error(e);
-        }
-        try {
-            const workspaceLangHistoryData = JSON.parse(storageService.get(LanguageDetectionService_1.workspaceOpenedLanguagesStorageKey, 1 , '[]'));
-            this.historicalWorkspaceOpenedLanguageIds.fromJSON(workspaceLangHistoryData);
-        }
-        catch (e) {
-            console.error(e);
-        }
-        this._register(this._editorService.onDidActiveEditorChange(() => {
-            const activeLanguage = this._editorService.activeTextEditorLanguageId;
-            if (activeLanguage && this._editorService.activeEditor?.resource?.scheme !== Schemas.untitled) {
-                this.sessionOpenedLanguageIds.add(activeLanguage);
-                this.historicalGlobalOpenedLanguageIds.set(activeLanguage, true);
-                this.historicalWorkspaceOpenedLanguageIds.set(activeLanguage, true);
-                storageService.store(LanguageDetectionService_1.globalOpenedLanguagesStorageKey, JSON.stringify(this.historicalGlobalOpenedLanguageIds.toJSON()), 0 , 1 );
-                storageService.store(LanguageDetectionService_1.workspaceOpenedLanguagesStorageKey, JSON.stringify(this.historicalWorkspaceOpenedLanguageIds.toJSON()), 1 , 1 );
-                this.dirtyBiases = true;
-            }
-        }));
-    }
-};
-LanguageDetectionService = LanguageDetectionService_1 = ( __decorate([
-    ( __param(0, IWorkbenchEnvironmentService)),
-    ( __param(1, ILanguageService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, IDiagnosticsService)),
-    ( __param(4, IWorkspaceContextService)),
-    ( __param(5, IModelService)),
-    ( __param(6, IEditorService)),
-    ( __param(7, ITelemetryService)),
-    ( __param(8, IStorageService)),
-    ( __param(9, ILogService)),
-    ( __param(10, ILanguageConfigurationService))
-], LanguageDetectionService));
-class LanguageDetectionWorkerClient extends EditorWorkerClient {
-    constructor(modelService, _languageService, _telemetryService, _indexJsUri, _modelJsonUri, _weightsUri, _regexpModelUri, languageConfigurationService) {
-        super(modelService, true, 'languageDetectionWorkerService', languageConfigurationService);
-        this._languageService = _languageService;
-        this._telemetryService = _telemetryService;
-        this._indexJsUri = _indexJsUri;
-        this._modelJsonUri = _modelJsonUri;
-        this._weightsUri = _weightsUri;
-        this._regexpModelUri = _regexpModelUri;
-    }
-    _getOrCreateLanguageDetectionWorker() {
-        if (this.workerPromise) {
-            return this.workerPromise;
-        }
-        this.workerPromise = ( new Promise((resolve, reject) => {
-            resolve(this._register(( new SimpleWorkerClient(
-                this._workerFactory,
-                'vs/workbench/services/languageDetection/browser/languageDetectionSimpleWorker',
-                ( new EditorWorkerHost(this))
-            ))));
-        }));
-        return this.workerPromise;
-    }
-    _guessLanguageIdByUri(uri) {
-        const guess = this._languageService.guessLanguageIdByFilepathOrFirstLine(uri);
-        if (guess && guess !== 'unknown') {
-            return guess;
-        }
-        return undefined;
-    }
-    async _getProxy() {
-        return (await this._getOrCreateLanguageDetectionWorker()).getProxyObject();
-    }
-    async fhr(method, args) {
-        switch (method) {
-            case 'getIndexJsUri':
-                return this.getIndexJsUri();
-            case 'getModelJsonUri':
-                return this.getModelJsonUri();
-            case 'getWeightsUri':
-                return this.getWeightsUri();
-            case 'getRegexpModelUri':
-                return this.getRegexpModelUri();
-            case 'getLanguageId':
-                return this.getLanguageId(args[0]);
-            case 'sendTelemetryEvent':
-                return this.sendTelemetryEvent(args[0], args[1], args[2]);
-            default:
-                return super.fhr(method, args);
-        }
-    }
-    async getIndexJsUri() {
-        return this._indexJsUri;
-    }
-    getLanguageId(languageIdOrExt) {
-        if (!languageIdOrExt) {
-            return undefined;
-        }
-        if (this._languageService.isRegisteredLanguageId(languageIdOrExt)) {
-            return languageIdOrExt;
-        }
-        const guessed = this._guessLanguageIdByUri(URI.file(`file.${languageIdOrExt}`));
-        if (!guessed || guessed === 'unknown') {
-            return undefined;
-        }
-        return guessed;
-    }
-    async getModelJsonUri() {
-        return this._modelJsonUri;
-    }
-    async getWeightsUri() {
-        return this._weightsUri;
-    }
-    async getRegexpModelUri() {
-        return this._regexpModelUri;
-    }
-    async sendTelemetryEvent(languages, confidences, timeSpent) {
-        this._telemetryService.publicLog2(LanguageDetectionStatsId, {
-            languages: languages.join(','),
-            confidences: confidences.join(','),
-            timeSpent
-        });
-    }
-    async detectLanguage(resource, langBiases, preferHistory, supportedLangs) {
-        const startTime = Date.now();
-        const quickGuess = this._guessLanguageIdByUri(resource);
-        if (quickGuess) {
-            return quickGuess;
-        }
-        await this._withSyncedResources([resource]);
-        const modelId = await (await this._getProxy()).detectLanguage(( resource.toString()), langBiases, preferHistory, supportedLangs);
-        const languageId = this.getLanguageId(modelId);
-        const LanguageDetectionStatsId = 'automaticlanguagedetection.perf';
-        this._telemetryService.publicLog2(LanguageDetectionStatsId, {
-            timeSpent: Date.now() - startTime,
-            detection: languageId || 'unknown',
-        });
-        return languageId;
-    }
-}
-export { LanguageDetectionService, LanguageDetectionWorkerClient };

package/vscode/src/vs/workbench/services/lifecycle/browser/lifecycleService.js

@@ -1,121 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { AbstractLifecycleService } from '../common/lifecycleService.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { addDisposableListener, EventType } from 'monaco-editor/esm/vs/base/browser/dom.js';
-import { WillSaveStateReason, IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
-let BrowserLifecycleService = class BrowserLifecycleService extends AbstractLifecycleService {
-    constructor(logService, storageService) {
-        super(logService, storageService);
-        this.beforeUnloadListener = undefined;
-        this.unloadListener = undefined;
-        this.ignoreBeforeUnload = false;
-        this.didUnload = false;
-        this.registerListeners();
-    }
-    registerListeners() {
-        this.beforeUnloadListener = addDisposableListener(window, EventType.BEFORE_UNLOAD, (e) => this.onBeforeUnload(e));
-        this.unloadListener = addDisposableListener(window, EventType.PAGE_HIDE, () => this.onUnload());
-    }
-    onBeforeUnload(event) {
-        if (this.ignoreBeforeUnload) {
-            this.logService.info('[lifecycle] onBeforeUnload triggered but ignored once');
-            this.ignoreBeforeUnload = false;
-        }
-        else {
-            this.logService.info('[lifecycle] onBeforeUnload triggered and handled with veto support');
-            this.doShutdown(() => this.vetoBeforeUnload(event));
-        }
-    }
-    vetoBeforeUnload(event) {
-        event.preventDefault();
-        event.returnValue = ( localize(
-            'lifecycleVeto',
-            "Changes that you made may not be saved. Please check press 'Cancel' and try again."
-        ));
-    }
-    withExpectedShutdown(reason, callback) {
-        if (typeof reason === 'number') {
-            this.shutdownReason = reason;
-            return this.storageService.flush(WillSaveStateReason.SHUTDOWN);
-        }
-        else {
-            this.ignoreBeforeUnload = true;
-            try {
-                callback?.();
-            }
-            finally {
-                this.ignoreBeforeUnload = false;
-            }
-        }
-    }
-    async shutdown() {
-        this.logService.info('[lifecycle] shutdown triggered');
-        this.beforeUnloadListener?.dispose();
-        this.unloadListener?.dispose();
-        await this.storageService.flush(WillSaveStateReason.SHUTDOWN);
-        this.doShutdown();
-    }
-    doShutdown(vetoShutdown) {
-        const logService = this.logService;
-        this.storageService.flush(WillSaveStateReason.SHUTDOWN);
-        let veto = false;
-        function handleVeto(vetoResult, id) {
-            if (typeof vetoShutdown !== 'function') {
-                return;
-            }
-            if (vetoResult instanceof Promise) {
-                logService.error(`[lifecycle] Long running operations before shutdown are unsupported in the web (id: ${id})`);
-                veto = true;
-            }
-            if (vetoResult === true) {
-                logService.info(`[lifecycle]: Unload was prevented (id: ${id})`);
-                veto = true;
-            }
-        }
-        this._onBeforeShutdown.fire({
-            reason: 2 ,
-            veto(value, id) {
-                handleVeto(value, id);
-            },
-            finalVeto(valueFn, id) {
-                handleVeto(valueFn(), id);
-            }
-        });
-        if (veto && typeof vetoShutdown === 'function') {
-            return vetoShutdown();
-        }
-        return this.onUnload();
-    }
-    onUnload() {
-        if (this.didUnload) {
-            return;
-        }
-        this.didUnload = true;
-        this._register(addDisposableListener(window, EventType.PAGE_SHOW, (e) => this.onLoadAfterUnload(e)));
-        const logService = this.logService;
-        this._onWillShutdown.fire({
-            reason: 2 ,
-            joiners: () => [],
-            token: CancellationToken.None,
-            join(promise, joiner) {
-                logService.error(`[lifecycle] Long running operations during shutdown are unsupported in the web (id: ${joiner.id})`);
-            },
-            force: () => { },
-        });
-        this._onDidShutdown.fire();
-    }
-    onLoadAfterUnload(event) {
-        const wasRestoredFromCache = event.persisted;
-        if (!wasRestoredFromCache) {
-            return;
-        }
-        this.withExpectedShutdown({ disableShutdownHandling: true }, () => window.location.reload());
-    }
-};
-BrowserLifecycleService = ( __decorate([
-    ( __param(0, ILogService)),
-    ( __param(1, IStorageService))
-], BrowserLifecycleService));
-export { BrowserLifecycleService };

package/vscode/src/vs/workbench/services/localization/common/locale.js

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

package/vscode/src/vs/workbench/services/notification/common/notificationService.js

@@ -1,188 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { Severity, NoOpNotification, NeverShowAgainScope, NotificationsFilter } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
-import { NotificationsModel, ChoiceAction } from '../../../common/notifications.js';
-import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
-import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-var NotificationService_1;
-let NotificationService = class NotificationService extends Disposable {
-    static { NotificationService_1 = this; }
-    constructor(storageService) {
-        super();
-        this.storageService = storageService;
-        this.model = this._register(( new NotificationsModel()));
-        this._onDidAddNotification = this._register(( new Emitter()));
-        this.onDidAddNotification = this._onDidAddNotification.event;
-        this._onDidRemoveNotification = this._register(( new Emitter()));
-        this.onDidRemoveNotification = this._onDidRemoveNotification.event;
-        this._onDidChangeDoNotDisturbMode = this._register(( new Emitter()));
-        this.onDidChangeDoNotDisturbMode = this._onDidChangeDoNotDisturbMode.event;
-        this._doNotDisturbMode = this.storageService.getBoolean(NotificationService_1.DND_SETTINGS_KEY, -1 , false);
-        this.updateDoNotDisturbFilters();
-        this.registerListeners();
-    }
-    registerListeners() {
-        this._register(this.model.onDidChangeNotification(e => {
-            switch (e.kind) {
-                case 0 :
-                case 3 : {
-                    const notification = {
-                        message: e.item.message.original,
-                        severity: e.item.severity,
-                        source: typeof e.item.sourceId === 'string' && typeof e.item.source === 'string' ? { id: e.item.sourceId, label: e.item.source } : e.item.source,
-                        priority: e.item.priority
-                    };
-                    if (e.kind === 0 ) {
-                        this._onDidAddNotification.fire(notification);
-                    }
-                    if (e.kind === 3 ) {
-                        this._onDidRemoveNotification.fire(notification);
-                    }
-                    break;
-                }
-            }
-        }));
-    }
-    static { this.DND_SETTINGS_KEY = 'notifications.doNotDisturbMode'; }
-    get doNotDisturbMode() {
-        return this._doNotDisturbMode;
-    }
-    set doNotDisturbMode(enabled) {
-        if (this._doNotDisturbMode === enabled) {
-            return;
-        }
-        this.storageService.store(NotificationService_1.DND_SETTINGS_KEY, enabled, -1 , 1 );
-        this._doNotDisturbMode = enabled;
-        this.updateDoNotDisturbFilters();
-        this._onDidChangeDoNotDisturbMode.fire();
-    }
-    updateDoNotDisturbFilters() {
-        let filter;
-        if (this._doNotDisturbMode) {
-            filter = NotificationsFilter.ERROR;
-        }
-        else {
-            filter = NotificationsFilter.OFF;
-        }
-        this.model.setFilter(filter);
-    }
-    info(message) {
-        if (Array.isArray(message)) {
-            message.forEach(m => this.info(m));
-            return;
-        }
-        this.model.addNotification({ severity: Severity.Info, message });
-    }
-    warn(message) {
-        if (Array.isArray(message)) {
-            message.forEach(m => this.warn(m));
-            return;
-        }
-        this.model.addNotification({ severity: Severity.Warning, message });
-    }
-    error(message) {
-        if (Array.isArray(message)) {
-            message.forEach(m => this.error(m));
-            return;
-        }
-        this.model.addNotification({ severity: Severity.Error, message });
-    }
-    notify(notification) {
-        const toDispose = ( new DisposableStore());
-        if (notification.neverShowAgain) {
-            const scope = this.toStorageScope(notification.neverShowAgain);
-            const id = notification.neverShowAgain.id;
-            if (this.storageService.getBoolean(id, scope)) {
-                return ( new NoOpNotification());
-            }
-            const neverShowAgainAction = toDispose.add(( new Action('workbench.notification.neverShowAgain', ( localize('neverShowAgain', "Don't Show Again")), undefined, true, async () => {
-                handle.close();
-                this.storageService.store(id, true, scope, 0 );
-            })));
-            const actions = {
-                primary: notification.actions?.primary || [],
-                secondary: notification.actions?.secondary || []
-            };
-            if (!notification.neverShowAgain.isSecondary) {
-                actions.primary = [neverShowAgainAction, ...actions.primary];
-            }
-            else {
-                actions.secondary = [...actions.secondary, neverShowAgainAction];
-            }
-            notification.actions = actions;
-        }
-        const handle = this.model.addNotification(notification);
-        Event.once(handle.onDidClose)(() => toDispose.dispose());
-        return handle;
-    }
-    toStorageScope(options) {
-        switch (options.scope) {
-            case NeverShowAgainScope.APPLICATION:
-                return -1 ;
-            case NeverShowAgainScope.PROFILE:
-                return 0 ;
-            case NeverShowAgainScope.WORKSPACE:
-                return 1 ;
-            default:
-                return -1 ;
-        }
-    }
-    prompt(severity, message, choices, options) {
-        const toDispose = ( new DisposableStore());
-        if (options?.neverShowAgain) {
-            const scope = this.toStorageScope(options.neverShowAgain);
-            const id = options.neverShowAgain.id;
-            if (this.storageService.getBoolean(id, scope)) {
-                return ( new NoOpNotification());
-            }
-            const neverShowAgainChoice = {
-                label: ( localize('neverShowAgain', "Don't Show Again")),
-                run: () => this.storageService.store(id, true, scope, 0 ),
-                isSecondary: options.neverShowAgain.isSecondary
-            };
-            if (!options.neverShowAgain.isSecondary) {
-                choices = [neverShowAgainChoice, ...choices];
-            }
-            else {
-                choices = [...choices, neverShowAgainChoice];
-            }
-        }
-        let choiceClicked = false;
-        const primaryActions = [];
-        const secondaryActions = [];
-        choices.forEach((choice, index) => {
-            const action = ( new ChoiceAction(`workbench.dialog.choice.${index}`, choice));
-            if (!choice.isSecondary) {
-                primaryActions.push(action);
-            }
-            else {
-                secondaryActions.push(action);
-            }
-            toDispose.add(action.onDidRun(() => {
-                choiceClicked = true;
-                if (!choice.keepOpen) {
-                    handle.close();
-                }
-            }));
-            toDispose.add(action);
-        });
-        const actions = { primary: primaryActions, secondary: secondaryActions };
-        const handle = this.notify({ severity, message, actions, sticky: options?.sticky, priority: options?.priority });
-        Event.once(handle.onDidClose)(() => {
-            toDispose.dispose();
-            if (options && typeof options.onCancel === 'function' && !choiceClicked) {
-                options.onCancel();
-            }
-        });
-        return handle;
-    }
-    status(message, options) {
-        return this.model.showStatusMessage(message, options);
-    }
-};
-NotificationService = NotificationService_1 = ( __decorate([
-    ( __param(0, IStorageService))
-], NotificationService));
-export { NotificationService };

package/vscode/src/vs/workbench/services/outline/browser/outlineService.js

@@ -1,35 +0,0 @@
-import { toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { LinkedList } from 'monaco-editor/esm/vs/base/common/linkedList.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-class OutlineService {
-    constructor() {
-        this._factories = ( new LinkedList());
-        this._onDidChange = ( new Emitter());
-        this.onDidChange = this._onDidChange.event;
-    }
-    canCreateOutline(pane) {
-        for (const factory of this._factories) {
-            if (factory.matches(pane)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    async createOutline(pane, target, token) {
-        for (const factory of this._factories) {
-            if (factory.matches(pane)) {
-                return await factory.createOutline(pane, target, token);
-            }
-        }
-        return undefined;
-    }
-    registerOutlineCreator(creator) {
-        const rm = this._factories.push(creator);
-        this._onDidChange.fire();
-        return toDisposable(() => {
-            rm();
-            this._onDidChange.fire();
-        });
-    }
-}
-export { OutlineService };

package/vscode/src/vs/workbench/services/preferences/browser/keybindingsEditorInput.js

@@ -1,37 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { OS } from 'monaco-editor/esm/vs/base/common/platform.js';
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { EditorInput } from '../../../common/editor/editorInput.js';
-import { KeybindingsEditorModel } from './keybindingsEditorModel.js';
-var KeybindingsEditorInput_1;
-let KeybindingsEditorInput = class KeybindingsEditorInput extends EditorInput {
-    static { KeybindingsEditorInput_1 = this; }
-    static { this.ID = 'workbench.input.keybindings'; }
-    constructor(instantiationService) {
-        super();
-        this.searchOptions = null;
-        this.resource = undefined;
-        this.keybindingsModel = instantiationService.createInstance(KeybindingsEditorModel, OS);
-    }
-    get typeId() {
-        return KeybindingsEditorInput_1.ID;
-    }
-    getName() {
-        return ( nls.localize('keybindingsInputName', "Keyboard Shortcuts"));
-    }
-    async resolve() {
-        return this.keybindingsModel;
-    }
-    matches(otherInput) {
-        return otherInput instanceof KeybindingsEditorInput_1;
-    }
-    dispose() {
-        this.keybindingsModel.dispose();
-        super.dispose();
-    }
-};
-KeybindingsEditorInput = KeybindingsEditorInput_1 = ( __decorate([
-    ( __param(0, IInstantiationService))
-], KeybindingsEditorInput));
-export { KeybindingsEditorInput };