@codingame/monaco-vscode-api 1.85.0 → 1.85.2

package/vscode/src/vs/workbench/services/host/browser/browserHostService.js

@@ -1,408 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
-import { IEditorService } from '../../editor/common/editorService.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { isFolderToOpen, isWorkspaceToOpen, isFileToOpen } from '../../../../platform/window/common/window.js';
-import { pathsToEditors, isResourceEditorInput } from '../../../common/editor.js';
-import { whenEditorClosed } from '../../../browser/editor.js';
-import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
-import { ModifierKeyEmitter, onDidRegisterWindow, trackFocus, getActiveDocument, getWindowId, disposableWindowInterval } from 'monaco-editor/esm/vs/base/browser/dom.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { IBrowserWorkbenchEnvironmentService } from '../../environment/browser/environmentService.js';
-import { memoize } from 'monaco-editor/esm/vs/base/common/decorators.js';
-import { parseLineAndColumnAware } from 'monaco-editor/esm/vs/base/common/extpath.js';
-import { IWorkspaceEditingService } from '../../workspaces/common/workspaceEditing.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { ILifecycleService } from '../../lifecycle/common/lifecycle.js';
-import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { getWorkspaceIdentifier } from '../../workspaces/browser/workspaces.js';
-import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
-import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
-import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { DomEmitter } from 'monaco-editor/esm/vs/base/browser/event.js';
-import { isUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
-import { isTemporaryWorkspace, IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
-import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-import { IUserDataProfileService } from '../../userDataProfile/common/userDataProfile.js';
-import { coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { mainWindow, isAuxiliaryWindow } from 'monaco-editor/esm/vs/base/browser/window.js';
-import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
-var HostShutdownReason;
-( (function(HostShutdownReason) {
-    HostShutdownReason[HostShutdownReason["Unknown"] = 1] = "Unknown";
-    HostShutdownReason[HostShutdownReason["Keyboard"] = 2] = "Keyboard";
-    HostShutdownReason[HostShutdownReason["Api"] = 3] = "Api";
-})(HostShutdownReason || (HostShutdownReason = {})));
-let BrowserHostService = class BrowserHostService extends Disposable {
-    constructor(layoutService, configurationService, fileService, labelService, environmentService, instantiationService, lifecycleService, logService, dialogService, contextService, userDataProfileService) {
-        super();
-        this.layoutService = layoutService;
-        this.configurationService = configurationService;
-        this.fileService = fileService;
-        this.labelService = labelService;
-        this.environmentService = environmentService;
-        this.instantiationService = instantiationService;
-        this.lifecycleService = lifecycleService;
-        this.logService = logService;
-        this.dialogService = dialogService;
-        this.contextService = contextService;
-        this.userDataProfileService = userDataProfileService;
-        this.shutdownReason = HostShutdownReason.Unknown;
-        if (environmentService.options?.workspaceProvider) {
-            this.workspaceProvider = environmentService.options.workspaceProvider;
-        }
-        else {
-            this.workspaceProvider = new class {
-                constructor() {
-                    this.workspace = undefined;
-                    this.trusted = undefined;
-                }
-                async open() { return true; }
-            };
-        }
-        this.registerListeners();
-    }
-    registerListeners() {
-        this._register(this.lifecycleService.onBeforeShutdown(e => this.onBeforeShutdown(e)));
-        this._register(ModifierKeyEmitter.getInstance().event(() => this.updateShutdownReasonFromEvent()));
-    }
-    onBeforeShutdown(e) {
-        switch (this.shutdownReason) {
-            case HostShutdownReason.Unknown:
-            case HostShutdownReason.Keyboard: {
-                const confirmBeforeClose = this.configurationService.getValue('window.confirmBeforeClose');
-                if (confirmBeforeClose === 'always' || (confirmBeforeClose === 'keyboardOnly' && this.shutdownReason === HostShutdownReason.Keyboard)) {
-                    e.veto(true, 'veto.confirmBeforeClose');
-                }
-                break;
-            }
-        }
-        this.shutdownReason = HostShutdownReason.Unknown;
-    }
-    updateShutdownReasonFromEvent() {
-        if (this.shutdownReason === HostShutdownReason.Api) {
-            return;
-        }
-        if (ModifierKeyEmitter.getInstance().isModifierPressed) {
-            this.shutdownReason = HostShutdownReason.Keyboard;
-        }
-        else {
-            this.shutdownReason = HostShutdownReason.Unknown;
-        }
-    }
-    get onDidChangeFocus() {
-        const emitter = this._register(( new Emitter()));
-        this._register(Event.runAndSubscribe(onDidRegisterWindow, ({ window, disposables }) => {
-            const focusTracker = disposables.add(trackFocus(window));
-            const visibilityTracker = disposables.add(( new DomEmitter(window.document, 'visibilitychange')));
-            Event.any(( Event.map(focusTracker.onDidFocus, () => this.hasFocus, disposables)), ( Event.map(focusTracker.onDidBlur, () => this.hasFocus, disposables)), ( Event.map(visibilityTracker.event, () => this.hasFocus, disposables)), ( Event.map(this.onDidChangeActiveWindow, () => this.hasFocus, disposables)))(focus => emitter.fire(focus));
-        }, { window: mainWindow, disposables: this._store }));
-        return Event.latch(emitter.event, undefined, this._store);
-    }
-    get hasFocus() {
-        return getActiveDocument().hasFocus();
-    }
-    async hadLastFocus() {
-        return true;
-    }
-    async focus(targetWindow) {
-        targetWindow.focus();
-    }
-    get onDidChangeActiveWindow() {
-        const emitter = this._register(( new Emitter()));
-        this._register(Event.runAndSubscribe(onDidRegisterWindow, ({ window, disposables }) => {
-            const windowId = getWindowId(window);
-            const focusTracker = disposables.add(trackFocus(window));
-            disposables.add(focusTracker.onDidFocus(() => emitter.fire(windowId)));
-            if (isAuxiliaryWindow(window)) {
-                disposables.add(disposableWindowInterval(window, () => {
-                    const hasFocus = window.document.hasFocus();
-                    if (hasFocus) {
-                        emitter.fire(windowId);
-                    }
-                    return hasFocus;
-                }, 100, 20));
-            }
-        }, { window: mainWindow, disposables: this._store }));
-        return Event.latch(emitter.event, undefined, this._store);
-    }
-    openWindow(arg1, arg2) {
-        if (Array.isArray(arg1)) {
-            return this.doOpenWindow(arg1, arg2);
-        }
-        return this.doOpenEmptyWindow(arg1);
-    }
-    async doOpenWindow(toOpen, options) {
-        const payload = this.preservePayload(false );
-        const fileOpenables = [];
-        const foldersToAdd = [];
-        for (const openable of toOpen) {
-            openable.label = openable.label || this.getRecentLabel(openable);
-            if (isFolderToOpen(openable)) {
-                if (options?.addMode) {
-                    foldersToAdd.push(({ uri: openable.folderUri }));
-                }
-                else {
-                    this.doOpen({ folderUri: openable.folderUri }, { reuse: this.shouldReuse(options, false ), payload });
-                }
-            }
-            else if (isWorkspaceToOpen(openable)) {
-                this.doOpen({ workspaceUri: openable.workspaceUri }, { reuse: this.shouldReuse(options, false ), payload });
-            }
-            else if (isFileToOpen(openable)) {
-                fileOpenables.push(openable);
-            }
-        }
-        if (foldersToAdd.length > 0) {
-            this.withServices(accessor => {
-                const workspaceEditingService = accessor.get(IWorkspaceEditingService);
-                workspaceEditingService.addFolders(foldersToAdd);
-            });
-        }
-        if (fileOpenables.length > 0) {
-            this.withServices(async (accessor) => {
-                const editorService = accessor.get(IEditorService);
-                if (options?.mergeMode && fileOpenables.length === 4) {
-                    const editors = coalesce(await pathsToEditors(fileOpenables, this.fileService, this.logService));
-                    if (editors.length !== 4 || !isResourceEditorInput(editors[0]) || !isResourceEditorInput(editors[1]) || !isResourceEditorInput(editors[2]) || !isResourceEditorInput(editors[3])) {
-                        return;
-                    }
-                    if (this.shouldReuse(options, true )) {
-                        editorService.openEditor({
-                            input1: { resource: editors[0].resource },
-                            input2: { resource: editors[1].resource },
-                            base: { resource: editors[2].resource },
-                            result: { resource: editors[3].resource },
-                            options: { pinned: true }
-                        });
-                    }
-                    else {
-                        const environment = ( new Map());
-                        environment.set('mergeFile1', ( editors[0].resource.toString()));
-                        environment.set('mergeFile2', ( editors[1].resource.toString()));
-                        environment.set('mergeFileBase', ( editors[2].resource.toString()));
-                        environment.set('mergeFileResult', ( editors[3].resource.toString()));
-                        this.doOpen(undefined, { payload: Array.from(environment.entries()) });
-                    }
-                }
-                if (options?.diffMode && fileOpenables.length === 2) {
-                    const editors = coalesce(await pathsToEditors(fileOpenables, this.fileService, this.logService));
-                    if (editors.length !== 2 || !isResourceEditorInput(editors[0]) || !isResourceEditorInput(editors[1])) {
-                        return;
-                    }
-                    if (this.shouldReuse(options, true )) {
-                        editorService.openEditor({
-                            original: { resource: editors[0].resource },
-                            modified: { resource: editors[1].resource },
-                            options: { pinned: true }
-                        });
-                    }
-                    else {
-                        const environment = ( new Map());
-                        environment.set('diffFileSecondary', ( editors[0].resource.toString()));
-                        environment.set('diffFilePrimary', ( editors[1].resource.toString()));
-                        this.doOpen(undefined, { payload: Array.from(environment.entries()) });
-                    }
-                }
-                else {
-                    for (const openable of fileOpenables) {
-                        if (this.shouldReuse(options, true )) {
-                            let openables = [];
-                            if (options?.gotoLineMode) {
-                                const pathColumnAware = parseLineAndColumnAware(openable.fileUri.path);
-                                openables = [{
-                                        fileUri: openable.fileUri.with({ path: pathColumnAware.path }),
-                                        options: {
-                                            selection: !isUndefined(pathColumnAware.line) ? { startLineNumber: pathColumnAware.line, startColumn: pathColumnAware.column || 1 } : undefined
-                                        }
-                                    }];
-                            }
-                            else {
-                                openables = [openable];
-                            }
-                            editorService.openEditors(coalesce(await pathsToEditors(openables, this.fileService, this.logService)), undefined, { validateTrust: true });
-                        }
-                        else {
-                            const environment = ( new Map());
-                            environment.set('openFile', ( openable.fileUri.toString()));
-                            if (options?.gotoLineMode) {
-                                environment.set('gotoLineMode', 'true');
-                            }
-                            this.doOpen(undefined, { payload: Array.from(environment.entries()) });
-                        }
-                    }
-                }
-                const waitMarkerFileURI = options?.waitMarkerFileURI;
-                if (waitMarkerFileURI) {
-                    (async () => {
-                        await this.instantiationService.invokeFunction(accessor => whenEditorClosed(accessor, ( fileOpenables.map(fileOpenable => fileOpenable.fileUri))));
-                        await this.fileService.del(waitMarkerFileURI);
-                    })();
-                }
-            });
-        }
-    }
-    withServices(fn) {
-        this.instantiationService.invokeFunction(accessor => fn(accessor));
-    }
-    preservePayload(isEmptyWindow) {
-        const newPayload = ( new Array());
-        if (!isEmptyWindow && this.environmentService.extensionDevelopmentLocationURI) {
-            newPayload.push(['extensionDevelopmentPath', ( this.environmentService.extensionDevelopmentLocationURI.toString())]);
-            if (this.environmentService.debugExtensionHost.debugId) {
-                newPayload.push(['debugId', this.environmentService.debugExtensionHost.debugId]);
-            }
-            if (this.environmentService.debugExtensionHost.port) {
-                newPayload.push(['inspect-brk-extensions', String(this.environmentService.debugExtensionHost.port)]);
-            }
-        }
-        if (!this.userDataProfileService.currentProfile.isDefault) {
-            newPayload.push(['lastActiveProfile', this.userDataProfileService.currentProfile.id]);
-        }
-        return newPayload.length ? newPayload : undefined;
-    }
-    getRecentLabel(openable) {
-        if (isFolderToOpen(openable)) {
-            return this.labelService.getWorkspaceLabel(openable.folderUri, { verbose: 2  });
-        }
-        if (isWorkspaceToOpen(openable)) {
-            return this.labelService.getWorkspaceLabel(getWorkspaceIdentifier(openable.workspaceUri), { verbose: 2  });
-        }
-        return this.labelService.getUriLabel(openable.fileUri);
-    }
-    shouldReuse(options = Object.create(null), isFile) {
-        if (options.waitMarkerFileURI) {
-            return true;
-        }
-        const windowConfig = this.configurationService.getValue('window');
-        const openInNewWindowConfig = isFile ? ((windowConfig?.openFilesInNewWindow || 'off') ) : ((windowConfig?.openFoldersInNewWindow || 'default') );
-        let openInNewWindow = (options.preferNewWindow || !!options.forceNewWindow) && !options.forceReuseWindow;
-        if (!options.forceNewWindow && !options.forceReuseWindow && (openInNewWindowConfig === 'on' || openInNewWindowConfig === 'off')) {
-            openInNewWindow = (openInNewWindowConfig === 'on');
-        }
-        return !openInNewWindow;
-    }
-    async doOpenEmptyWindow(options) {
-        return this.doOpen(undefined, {
-            reuse: options?.forceReuseWindow,
-            payload: this.preservePayload(true )
-        });
-    }
-    async doOpen(workspace, options) {
-        if (workspace && isFolderToOpen(workspace) && workspace.folderUri.scheme === Schemas.file && isTemporaryWorkspace(this.contextService.getWorkspace())) {
-            this.withServices(async (accessor) => {
-                const workspaceEditingService = accessor.get(IWorkspaceEditingService);
-                await workspaceEditingService.updateFolders(0, this.contextService.getWorkspace().folders.length, [{ uri: workspace.folderUri }]);
-            });
-            return;
-        }
-        if (options?.reuse) {
-            await this.handleExpectedShutdown(4 );
-        }
-        const opened = await this.workspaceProvider.open(workspace, options);
-        if (!opened) {
-            const { confirmed } = await this.dialogService.confirm({
-                type: Severity.Warning,
-                message: ( localizeWithPath(
-                    'vs/workbench/services/host/browser/browserHostService',
-                    'unableToOpenExternal',
-                    "The browser interrupted the opening of a new tab or window. Press 'Open' to open it anyway."
-                )),
-                primaryButton: ( localizeWithPath(
-                    'vs/workbench/services/host/browser/browserHostService',
-                    { key: 'open', comment: ['&& denotes a mnemonic'] },
-                    "&&Open"
-                ))
-            });
-            if (confirmed) {
-                await this.workspaceProvider.open(workspace, options);
-            }
-        }
-    }
-    async toggleFullScreen(targetWindow) {
-        const target = this.layoutService.getContainer(targetWindow);
-        if (targetWindow.document.fullscreen !== undefined) {
-            if (!targetWindow.document.fullscreen) {
-                try {
-                    return await target.requestFullscreen();
-                }
-                catch (error) {
-                    this.logService.warn('toggleFullScreen(): requestFullscreen failed');
-                }
-            }
-            else {
-                try {
-                    return await targetWindow.document.exitFullscreen();
-                }
-                catch (error) {
-                    this.logService.warn('toggleFullScreen(): exitFullscreen failed');
-                }
-            }
-        }
-        if (targetWindow.document.webkitIsFullScreen !== undefined) {
-            try {
-                if (!targetWindow.document.webkitIsFullScreen) {
-                    target.webkitRequestFullscreen();
-                }
-                else {
-                    targetWindow.document.webkitExitFullscreen();
-                }
-            }
-            catch {
-                this.logService.warn('toggleFullScreen(): requestFullscreen/exitFullscreen failed');
-            }
-        }
-    }
-    async moveTop(targetWindow) {
-    }
-    async getCursorScreenPoint() {
-        return undefined;
-    }
-    async restart() {
-        this.reload();
-    }
-    async reload() {
-        await this.handleExpectedShutdown(3 );
-        mainWindow.location.reload();
-    }
-    async close() {
-        await this.handleExpectedShutdown(1 );
-        mainWindow.close();
-    }
-    async withExpectedShutdown(expectedShutdownTask) {
-        const previousShutdownReason = this.shutdownReason;
-        try {
-            this.shutdownReason = HostShutdownReason.Api;
-            return await expectedShutdownTask();
-        }
-        finally {
-            this.shutdownReason = previousShutdownReason;
-        }
-    }
-    async handleExpectedShutdown(reason) {
-        this.shutdownReason = HostShutdownReason.Api;
-        return this.lifecycleService.withExpectedShutdown(reason);
-    }
-};
-BrowserHostService.__decorator = ( __decorate([
-    memoize
-], BrowserHostService.prototype, "onDidChangeFocus", null));
-BrowserHostService.__decorator = ( __decorate([
-    memoize
-], BrowserHostService.prototype, "onDidChangeActiveWindow", null));
-BrowserHostService = ( __decorate([
-    ( __param(0, ILayoutService)),
-    ( __param(1, IConfigurationService)),
-    ( __param(2, IFileService)),
-    ( __param(3, ILabelService)),
-    ( __param(4, IBrowserWorkbenchEnvironmentService)),
-    ( __param(5, IInstantiationService)),
-    ( __param(6, ILifecycleService)),
-    ( __param(7, ILogService)),
-    ( __param(8, IDialogService)),
-    ( __param(9, IWorkspaceContextService)),
-    ( __param(10, IUserDataProfileService))
-], BrowserHostService));
-export { BrowserHostService };

package/vscode/src/vs/workbench/services/request/browser/requestService.js

@@ -1,48 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { ILoggerService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { RequestChannelClient } from '../../../../platform/request/common/requestIpc.js';
-import { IRemoteAgentService } from '../../remote/common/remoteAgentService.js';
-import { RequestService } from '../../../../platform/request/browser/requestService.js';
-import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
-let BrowserRequestService = class BrowserRequestService extends RequestService {
-    constructor(remoteAgentService, configurationService, loggerService) {
-        super(configurationService, loggerService);
-        this.remoteAgentService = remoteAgentService;
-    }
-    async request(options, token) {
-        try {
-            const context = await super.request(options, token);
-            const connection = this.remoteAgentService.getConnection();
-            if (connection && context.res.statusCode === 405) {
-                return this._makeRemoteRequest(connection, options, token);
-            }
-            return context;
-        }
-        catch (error) {
-            const connection = this.remoteAgentService.getConnection();
-            if (connection) {
-                return this._makeRemoteRequest(connection, options, token);
-            }
-            throw error;
-        }
-    }
-    _makeRemoteRequest(connection, options, token) {
-        return connection.withChannel('request', channel => ( new RequestChannelClient(channel)).request(options, token));
-    }
-};
-BrowserRequestService = ( __decorate([
-    ( __param(0, IRemoteAgentService)),
-    ( __param(1, IConfigurationService)),
-    ( __param(2, ILoggerService))
-], BrowserRequestService));
-CommandsRegistry.registerCommand('_workbench.fetchJSON', async function (accessor, url, method) {
-    const result = await fetch(url, { method, headers: { Accept: 'application/json' } });
-    if (result.ok) {
-        return result.json();
-    }
-    else {
-        throw new Error(result.statusText);
-    }
-});
-export { BrowserRequestService };

package/vscode/src/vs/workbench/services/textfile/browser/browserTextFileService.js

@@ -1,56 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { AbstractTextFileService } from './textFileService.js';
-import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.js';
-import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
-import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
-import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
-import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
-import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { IElevatedFileService } from '../../files/common/elevatedFileService.js';
-import { IFilesConfigurationService } from '../../filesConfiguration/common/filesConfigurationService.js';
-import { ILifecycleService } from '../../lifecycle/common/lifecycle.js';
-import { IPathService } from '../../path/common/pathService.js';
-import { IUntitledTextEditorService } from '../../untitled/common/untitledTextEditorService.js';
-import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
-import { IWorkingCopyFileService } from '../../workingCopy/common/workingCopyFileService.js';
-import { IDecorationsService } from '../../decorations/common/decorations.js';
-import { IDialogService, IFileDialogService } from '../../../../platform/dialogs/common/dialogs.js';
-let BrowserTextFileService = class BrowserTextFileService extends AbstractTextFileService {
-    constructor(fileService, untitledTextEditorService, lifecycleService, instantiationService, modelService, environmentService, dialogService, fileDialogService, textResourceConfigurationService, filesConfigurationService, codeEditorService, pathService, workingCopyFileService, uriIdentityService, languageService, elevatedFileService, logService, decorationsService) {
-        super(fileService, untitledTextEditorService, lifecycleService, instantiationService, modelService, environmentService, dialogService, fileDialogService, textResourceConfigurationService, filesConfigurationService, codeEditorService, pathService, workingCopyFileService, uriIdentityService, languageService, logService, elevatedFileService, decorationsService);
-        this.registerListeners();
-    }
-    registerListeners() {
-        this._register(this.lifecycleService.onBeforeShutdown(event => event.veto(this.onBeforeShutdown(), 'veto.textFiles')));
-    }
-    onBeforeShutdown() {
-        if (( this.files.models.some(model => model.hasState(2 )))) {
-            return true;
-        }
-        return false;
-    }
-};
-BrowserTextFileService = ( __decorate([
-    ( __param(0, IFileService)),
-    ( __param(1, IUntitledTextEditorService)),
-    ( __param(2, ILifecycleService)),
-    ( __param(3, IInstantiationService)),
-    ( __param(4, IModelService)),
-    ( __param(5, IWorkbenchEnvironmentService)),
-    ( __param(6, IDialogService)),
-    ( __param(7, IFileDialogService)),
-    ( __param(8, ITextResourceConfigurationService)),
-    ( __param(9, IFilesConfigurationService)),
-    ( __param(10, ICodeEditorService)),
-    ( __param(11, IPathService)),
-    ( __param(12, IWorkingCopyFileService)),
-    ( __param(13, IUriIdentityService)),
-    ( __param(14, ILanguageService)),
-    ( __param(15, IElevatedFileService)),
-    ( __param(16, ILogService)),
-    ( __param(17, IDecorationsService))
-], BrowserTextFileService));
-export { BrowserTextFileService };