@codingame/monaco-vscode-language-detection-worker-service-override 4.0.0 → 4.1.0

package/languageDetectionWorker.js

@@ -1,8 +1,8 @@
 import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
-import { LanguageDetectionService } from './vscode/src/vs/workbench/services/languageDetection/browser/languageDetectionWorkerServiceImpl.js';
+import { LanguageDetectionService } from 'vscode/vscode/vs/workbench/services/languageDetection/browser/languageDetectionWorkerServiceImpl';
 import { ILanguageDetectionService } from 'vscode/vscode/vs/workbench/services/languageDetection/common/languageDetectionWorkerService';
 import { registerAssets } from 'vscode/assets';
-import './vscode/src/vs/workbench/contrib/languageDetection/browser/languageDetection.contribution.js';
+import 'vscode/vscode/vs/workbench/contrib/languageDetection/browser/languageDetection.contribution';
 
 registerAssets({
     'vs/../../node_modules/@vscode/vscode-languagedetection/model/model.json': new URL('@vscode/vscode-languagedetection/model/model.json', import.meta.url).href,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-language-detection-worker-service-override",
-  "version": "4.0.0",
+  "version": "4.1.0",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,7 +18,7 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@4.0.0",
+    "vscode": "npm:@codingame/monaco-vscode-api@4.1.0",
     "@vscode/vscode-languagedetection": "1.0.21"
   },
   "exports": {

package/external/tslib/tslib.es6.js

@@ -1,11 +0,0 @@
-function __decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function __param(paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-}
-
-export { __decorate, __param };

package/vscode/src/vs/workbench/contrib/languageDetection/browser/languageDetection.contribution.js

@@ -1,157 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
-import { getCodeEditor } from 'vscode/vscode/vs/editor/browser/editorBrowser';
-import { localizeWithPath, localize2WithPath } from 'vscode/vscode/vs/nls';
-import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
-import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
-import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
-import { IStatusbarService } from 'vscode/vscode/vs/workbench/services/statusbar/browser/statusbar';
-import { ILanguageDetectionService, LanguageDetectionLanguageEventSource } from 'vscode/vscode/vs/workbench/services/languageDetection/common/languageDetectionWorkerService';
-import { ThrottledDelayer } from 'vscode/vscode/vs/base/common/async';
-import { ILanguageService } from 'vscode/vscode/vs/editor/common/languages/language';
-import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
-import { registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
-import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification';
-import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { NOTEBOOK_EDITOR_EDITABLE } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys';
-import { EditorContextKeys } from 'vscode/vscode/vs/editor/common/editorContextKeys';
-import { Schemas } from 'vscode/vscode/vs/base/common/network';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-
-var LanguageDetectionStatusContribution_1;
-const detectLanguageCommandId = 'editor.detectLanguage';
-let LanguageDetectionStatusContribution = class LanguageDetectionStatusContribution {
-    static { LanguageDetectionStatusContribution_1 = this; }
-    static { this._id = 'status.languageDetectionStatus'; }
-    constructor(_languageDetectionService, _statusBarService, _configurationService, _editorService, _languageService, _keybindingService) {
-        this._languageDetectionService = _languageDetectionService;
-        this._statusBarService = _statusBarService;
-        this._configurationService = _configurationService;
-        this._editorService = _editorService;
-        this._languageService = _languageService;
-        this._keybindingService = _keybindingService;
-        this._disposables = ( new DisposableStore());
-        this._delayer = ( new ThrottledDelayer(1000));
-        this._renderDisposables = ( new DisposableStore());
-        _editorService.onDidActiveEditorChange(() => this._update(true), this, this._disposables);
-        this._update(false);
-    }
-    dispose() {
-        this._disposables.dispose();
-        this._delayer.dispose();
-        this._combinedEntry?.dispose();
-        this._renderDisposables.dispose();
-    }
-    _update(clear) {
-        if (clear) {
-            this._combinedEntry?.dispose();
-            this._combinedEntry = undefined;
-        }
-        this._delayer.trigger(() => this._doUpdate());
-    }
-    async _doUpdate() {
-        const editor = getCodeEditor(this._editorService.activeTextEditorControl);
-        this._renderDisposables.clear();
-        editor?.onDidChangeModelLanguage(() => this._update(true), this, this._renderDisposables);
-        editor?.onDidChangeModelContent(() => this._update(false), this, this._renderDisposables);
-        const editorModel = editor?.getModel();
-        const editorUri = editorModel?.uri;
-        const existingId = editorModel?.getLanguageId();
-        const enablementConfig = this._configurationService.getValue('workbench.editor.languageDetectionHints');
-        const enabled = typeof enablementConfig === 'object' && enablementConfig?.untitledEditors;
-        const disableLightbulb = !enabled || editorUri?.scheme !== Schemas.untitled || !existingId;
-        if (disableLightbulb || !editorUri) {
-            this._combinedEntry?.dispose();
-            this._combinedEntry = undefined;
-        }
-        else {
-            const lang = await this._languageDetectionService.detectLanguage(editorUri);
-            const skip = { 'jsonc': 'json' };
-            const existing = editorModel.getLanguageId();
-            if (lang && lang !== existing && skip[existing] !== lang) {
-                const detectedName = this._languageService.getLanguageName(lang) || lang;
-                let tooltip = ( localizeWithPath(
-                    'vs/workbench/contrib/languageDetection/browser/languageDetection.contribution',
-                    'status.autoDetectLanguage',
-                    "Accept Detected Language: {0}",
-                    detectedName
-                ));
-                const keybinding = this._keybindingService.lookupKeybinding(detectLanguageCommandId);
-                const label = keybinding?.getLabel();
-                if (label) {
-                    tooltip += ` (${label})`;
-                }
-                const props = {
-                    name: ( localizeWithPath(
-                        'vs/workbench/contrib/languageDetection/browser/languageDetection.contribution',
-                        'langDetection.name',
-                        "Language Detection"
-                    )),
-                    ariaLabel: ( localizeWithPath(
-                        'vs/workbench/contrib/languageDetection/browser/languageDetection.contribution',
-                        'langDetection.aria',
-                        "Change to Detected Language: {0}",
-                        lang
-                    )),
-                    tooltip,
-                    command: detectLanguageCommandId,
-                    text: '$(lightbulb-autofix)',
-                };
-                if (!this._combinedEntry) {
-                    this._combinedEntry = this._statusBarService.addEntry(props, LanguageDetectionStatusContribution_1._id, 1 , { id: 'status.editor.mode', alignment: 1 , compact: true });
-                }
-                else {
-                    this._combinedEntry.update(props);
-                }
-            }
-            else {
-                this._combinedEntry?.dispose();
-                this._combinedEntry = undefined;
-            }
-        }
-    }
-};
-LanguageDetectionStatusContribution = LanguageDetectionStatusContribution_1 = ( __decorate([
-    ( __param(0, ILanguageDetectionService)),
-    ( __param(1, IStatusbarService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, IEditorService)),
-    ( __param(4, ILanguageService)),
-    ( __param(5, IKeybindingService))
-], LanguageDetectionStatusContribution));
-( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(LanguageDetectionStatusContribution, 3 );
-registerAction2(class extends Action2 {
-    constructor() {
-        super({
-            id: detectLanguageCommandId,
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/languageDetection/browser/languageDetection.contribution',
-                'detectlang',
-                "Detect Language from Content"
-            )),
-            f1: true,
-            precondition: ( ContextKeyExpr.and(( NOTEBOOK_EDITOR_EDITABLE.toNegated()), EditorContextKeys.editorTextFocus)),
-            keybinding: { primary: 34  | 512  | 1024 , weight: 200  }
-        });
-    }
-    async run(accessor) {
-        const editorService = accessor.get(IEditorService);
-        const languageDetectionService = accessor.get(ILanguageDetectionService);
-        const editor = getCodeEditor(editorService.activeTextEditorControl);
-        const notificationService = accessor.get(INotificationService);
-        const editorUri = editor?.getModel()?.uri;
-        if (editorUri) {
-            const lang = await languageDetectionService.detectLanguage(editorUri);
-            if (lang) {
-                editor.getModel()?.setLanguage(lang, LanguageDetectionLanguageEventSource);
-            }
-            else {
-                notificationService.warn(( localizeWithPath(
-                    'vs/workbench/contrib/languageDetection/browser/languageDetection.contribution',
-                    'noDetection',
-                    "Unable to detect editor language"
-                )));
-            }
-        }
-    }
-});

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

@@ -1,261 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { LanguageDetectionStatsId } from 'vscode/vscode/vs/workbench/services/languageDetection/common/languageDetectionWorkerService';
-import { FileAccess, Schemas, nodeModulesPath, nodeModulesAsarPath } from 'vscode/vscode/vs/base/common/network';
-import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { ILanguageService } from 'vscode/vscode/vs/editor/common/languages/language';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { isWeb } from 'vscode/vscode/vs/base/common/platform';
-import { IModelService } from 'vscode/vscode/vs/editor/common/services/model';
-import { SimpleWorkerClient } from 'vscode/vscode/vs/base/common/worker/simpleWorker';
-import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
-import { EditorWorkerClient, EditorWorkerHost } from 'vscode/vscode/vs/editor/browser/services/editorWorkerService';
-import { ILanguageConfigurationService } from 'vscode/vscode/vs/editor/common/languages/languageConfigurationRegistry';
-import { IDiagnosticsService } from 'vscode/vscode/vs/platform/diagnostics/common/diagnostics';
-import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
-import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
-import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
-import { LRUCache } from 'vscode/vscode/vs/base/common/map';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-
-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 = this._register(( 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 };