@codingame/monaco-vscode-views-service-override 2.1.4 → 2.2.0-next.2

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

@@ -1,6 +0,0 @@
-import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
-
-var css = ".monaco-workbench .progress-badge>.badge-content:before{background-color:currentColor;background-repeat:no-repeat;bottom:0;content:\"\";height:14px;left:0;margin:auto;mask:url(\"data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNCIgaGVpZ2h0PSIxNCIgdmlld0JveD0iMiAyIDE0IDE0Ij48cGF0aCBmaWxsPSIjZmZmIiBkPSJNOSAxNmMtMy44NiAwLTctMy4xNC03LTdzMy4xNC03IDctN2MzLjg1OSAwIDcgMy4xNDEgNyA3cy0zLjE0MSA3LTcgN3pNOSAzLjRDNS45MTIgMy40IDMuNCA1LjkxMyAzLjQgOXMyLjUxMiA1LjYgNS42IDUuNiA1LjYtMi41MTIgNS42LTUuNlMxMi4wODggMy40IDkgMy40em0zLjg2IDcuMUw5LjcgOC42MDRWNC44SDguM3Y0LjU5NmwzLjg0IDIuMzA1LjcyLTEuMjAxeiIvPjwvc3ZnPg==\") no-repeat;-webkit-mask:url(\"data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNCIgaGVpZ2h0PSIxNCIgdmlld0JveD0iMiAyIDE0IDE0Ij48cGF0aCBmaWxsPSIjZmZmIiBkPSJNOSAxNmMtMy44NiAwLTctMy4xNC03LTdzMy4xNC03IDctN2MzLjg1OSAwIDcgMy4xNDEgNyA3cy0zLjE0MSA3LTcgN3pNOSAzLjRDNS45MTIgMy40IDMuNCA1LjkxMyAzLjQgOXMyLjUxMiA1LjYgNS42IDUuNiA1LjYtMi41MTIgNS42LTUuNlMxMi4wODggMy40IDkgMy40em0zLjg2IDcuMUw5LjcgOC42MDRWNC44SDguM3Y0LjU5NmwzLjg0IDIuMzA1LjcyLTEuMjAxeiIvPjwvc3ZnPg==\") no-repeat;position:absolute;right:0;top:0;width:14px}";
-n(css,{});
-
-export { css, css as default };

package/vscode/src/vs/workbench/services/progress/browser/progressService.js

@@ -1,523 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import './media/progressService.css.js';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { Disposable, dispose, DisposableStore, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { Progress } from 'vscode/vscode/vs/platform/progress/common/progress';
-import { IStatusbarService } from 'vscode/vscode/vs/workbench/services/statusbar/browser/statusbar';
-import { timeout, RunOnceScheduler, DeferredPromise } from 'vscode/vscode/vs/base/common/async';
-import { ProgressBadge, IActivityService } from 'vscode/vscode/vs/workbench/services/activity/common/activity';
-import { NotificationPriority, NotificationsFilter, isNotificationSource, INotificationService, Severity } from 'vscode/vscode/vs/platform/notification/common/notification';
-import { Action } from 'vscode/vscode/vs/base/common/actions';
-import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
-import { ILayoutService } from 'vscode/vscode/vs/platform/layout/browser/layoutService';
-import { Dialog } from 'vscode/vscode/vs/base/browser/ui/dialog/dialog';
-import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
-import { EventHelper } from 'vscode/vscode/vs/base/browser/dom';
-import { parseLinkedText } from 'vscode/vscode/vs/base/common/linkedText';
-import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
-import { IViewsService } from 'vscode/vscode/vs/workbench/services/views/common/viewsService';
-import { IPaneCompositePartService } from 'vscode/vscode/vs/workbench/services/panecomposite/browser/panecomposite';
-import { stripIcons } from 'vscode/vscode/vs/base/common/iconLabels';
-import { defaultButtonStyles, defaultCheckboxStyles, defaultInputBoxStyles, defaultDialogStyles } from 'vscode/vscode/vs/platform/theme/browser/defaultStyles';
-
-let ProgressService = class ProgressService extends Disposable {
-    constructor(activityService, paneCompositeService, viewDescriptorService, viewsService, notificationService, statusbarService, layoutService, keybindingService) {
-        super();
-        this.activityService = activityService;
-        this.paneCompositeService = paneCompositeService;
-        this.viewDescriptorService = viewDescriptorService;
-        this.viewsService = viewsService;
-        this.notificationService = notificationService;
-        this.statusbarService = statusbarService;
-        this.layoutService = layoutService;
-        this.keybindingService = keybindingService;
-        this.windowProgressStack = [];
-        this.windowProgressStatusEntry = undefined;
-    }
-    async withProgress(options, task, onDidCancel) {
-        const { location } = options;
-        const handleStringLocation = (location) => {
-            const viewContainer = this.viewDescriptorService.getViewContainerById(location);
-            if (viewContainer) {
-                const viewContainerLocation = this.viewDescriptorService.getViewContainerLocation(viewContainer);
-                if (viewContainerLocation !== null) {
-                    return this.withPaneCompositeProgress(location, viewContainerLocation, task, { ...options, location });
-                }
-            }
-            if (this.viewDescriptorService.getViewDescriptorById(location) !== null) {
-                return this.withViewProgress(location, task, { ...options, location });
-            }
-            throw new Error(`Bad progress location: ${location}`);
-        };
-        if (typeof location === 'string') {
-            return handleStringLocation(location);
-        }
-        switch (location) {
-            case 15 : {
-                let priority = options.priority;
-                if (priority !== NotificationPriority.URGENT) {
-                    if (this.notificationService.getFilter() === NotificationsFilter.ERROR) {
-                        priority = NotificationPriority.SILENT;
-                    }
-                    else if (isNotificationSource(options.source) && this.notificationService.getFilter(options.source) === NotificationsFilter.ERROR) {
-                        priority = NotificationPriority.SILENT;
-                    }
-                }
-                return this.withNotificationProgress({ ...options, location, priority }, task, onDidCancel);
-            }
-            case 10 : {
-                const type = options.type;
-                if (options.command) {
-                    return this.withWindowProgress({ ...options, location, type }, task);
-                }
-                return this.withNotificationProgress({ delay: 150 , ...options, priority: NotificationPriority.SILENT, location: 15 , type }, task, onDidCancel);
-            }
-            case 1 :
-                return this.withPaneCompositeProgress('workbench.view.explorer', 0 , task, { ...options, location });
-            case 3 :
-                return handleStringLocation('workbench.scm');
-            case 5 :
-                return this.withPaneCompositeProgress('workbench.view.extensions', 0 , task, { ...options, location });
-            case 20 :
-                return this.withDialogProgress(options, task, onDidCancel);
-            default:
-                throw new Error(`Bad progress location: ${location}`);
-        }
-    }
-    withWindowProgress(options, callback) {
-        const task = [options, ( new Progress(() => this.updateWindowProgress()))];
-        const promise = callback(task[1]);
-        let delayHandle = setTimeout(() => {
-            delayHandle = undefined;
-            this.windowProgressStack.unshift(task);
-            this.updateWindowProgress();
-            Promise.all([
-                timeout(150),
-                promise
-            ]).finally(() => {
-                const idx = this.windowProgressStack.indexOf(task);
-                this.windowProgressStack.splice(idx, 1);
-                this.updateWindowProgress();
-            });
-        }, 150);
-        return promise.finally(() => clearTimeout(delayHandle));
-    }
-    updateWindowProgress(idx = 0) {
-        if (idx < this.windowProgressStack.length) {
-            const [options, progress] = this.windowProgressStack[idx];
-            const progressTitle = options.title;
-            const progressMessage = progress.value && progress.value.message;
-            const progressCommand = options.command;
-            let text;
-            let title;
-            const source = options.source && typeof options.source !== 'string' ? options.source.label : options.source;
-            if (progressTitle && progressMessage) {
-                text = ( localizeWithPath(
-                    'vs/workbench/services/progress/browser/progressService',
-                    'progress.text2',
-                    "{0}: {1}",
-                    progressTitle,
-                    progressMessage
-                ));
-                title = source ? ( localizeWithPath(
-                    'vs/workbench/services/progress/browser/progressService',
-                    'progress.title3',
-                    "[{0}] {1}: {2}",
-                    source,
-                    progressTitle,
-                    progressMessage
-                )) : text;
-            }
-            else if (progressTitle) {
-                text = progressTitle;
-                title = source ? ( localizeWithPath(
-                    'vs/workbench/services/progress/browser/progressService',
-                    'progress.title2',
-                    "[{0}]: {1}",
-                    source,
-                    progressTitle
-                )) : text;
-            }
-            else if (progressMessage) {
-                text = progressMessage;
-                title = source ? ( localizeWithPath(
-                    'vs/workbench/services/progress/browser/progressService',
-                    'progress.title2',
-                    "[{0}]: {1}",
-                    source,
-                    progressMessage
-                )) : text;
-            }
-            else {
-                this.updateWindowProgress(idx + 1);
-                return;
-            }
-            const statusEntryProperties = {
-                name: ( localizeWithPath(
-                    'vs/workbench/services/progress/browser/progressService',
-                    'status.progress',
-                    "Progress Message"
-                )),
-                text,
-                showProgress: options.type || true,
-                ariaLabel: text,
-                tooltip: title,
-                command: progressCommand
-            };
-            if (this.windowProgressStatusEntry) {
-                this.windowProgressStatusEntry.update(statusEntryProperties);
-            }
-            else {
-                this.windowProgressStatusEntry = this.statusbarService.addEntry(statusEntryProperties, 'status.progress', 0 );
-            }
-        }
-        else {
-            this.windowProgressStatusEntry?.dispose();
-            this.windowProgressStatusEntry = undefined;
-        }
-    }
-    withNotificationProgress(options, callback, onDidCancel) {
-        const progressStateModel = new (class extends Disposable {
-            get step() { return this._step; }
-            get done() { return this._done; }
-            constructor() {
-                super();
-                this._onDidReport = this._register(( new Emitter()));
-                this.onDidReport = this._onDidReport.event;
-                this._onWillDispose = this._register(( new Emitter()));
-                this.onWillDispose = this._onWillDispose.event;
-                this._step = undefined;
-                this._done = false;
-                this.promise = callback(this);
-                this.promise.finally(() => {
-                    this.dispose();
-                });
-            }
-            report(step) {
-                this._step = step;
-                this._onDidReport.fire(step);
-            }
-            cancel(choice) {
-                onDidCancel?.(choice);
-                this.dispose();
-            }
-            dispose() {
-                this._done = true;
-                this._onWillDispose.fire();
-                super.dispose();
-            }
-        });
-        const createWindowProgress = () => {
-            const promise = ( new DeferredPromise());
-            this.withWindowProgress({
-                location: 10 ,
-                title: options.title ? ( parseLinkedText(options.title).toString()) : undefined,
-                command: 'notifications.showList',
-                type: options.type
-            }, progress => {
-                function reportProgress(step) {
-                    if (step.message) {
-                        progress.report({
-                            message: ( parseLinkedText(step.message).toString())
-                        });
-                    }
-                }
-                if (progressStateModel.step) {
-                    reportProgress(progressStateModel.step);
-                }
-                const onDidReportListener = progressStateModel.onDidReport(step => reportProgress(step));
-                promise.p.finally(() => onDidReportListener.dispose());
-                Event.once(progressStateModel.onWillDispose)(() => promise.complete());
-                return promise.p;
-            });
-            return toDisposable(() => promise.complete());
-        };
-        const createNotification = (message, priority, increment) => {
-            const notificationDisposables = ( new DisposableStore());
-            const primaryActions = options.primaryActions ? Array.from(options.primaryActions) : [];
-            const secondaryActions = options.secondaryActions ? Array.from(options.secondaryActions) : [];
-            if (options.buttons) {
-                options.buttons.forEach((button, index) => {
-                    const buttonAction = new (class extends Action {
-                        constructor() {
-                            super(`progress.button.${button}`, button, undefined, true);
-                        }
-                        async run() {
-                            progressStateModel.cancel(index);
-                        }
-                    });
-                    notificationDisposables.add(buttonAction);
-                    primaryActions.push(buttonAction);
-                });
-            }
-            if (options.cancellable) {
-                const cancelAction = new (class extends Action {
-                    constructor() {
-                        super('progress.cancel', ( localizeWithPath(
-                            'vs/workbench/services/progress/browser/progressService',
-                            'cancel',
-                            "Cancel"
-                        )), undefined, true);
-                    }
-                    async run() {
-                        progressStateModel.cancel();
-                    }
-                });
-                notificationDisposables.add(cancelAction);
-                primaryActions.push(cancelAction);
-            }
-            const notification = this.notificationService.notify({
-                severity: Severity.Info,
-                message: stripIcons(message),
-                source: options.source,
-                actions: { primary: primaryActions, secondary: secondaryActions },
-                progress: typeof increment === 'number' && increment >= 0 ? { total: 100, worked: increment } : { infinite: true },
-                priority
-            });
-            let windowProgressDisposable = undefined;
-            const onVisibilityChange = (visible) => {
-                dispose(windowProgressDisposable);
-                if (!visible && !progressStateModel.done) {
-                    windowProgressDisposable = createWindowProgress();
-                }
-            };
-            notificationDisposables.add(notification.onDidChangeVisibility(onVisibilityChange));
-            if (priority === NotificationPriority.SILENT) {
-                onVisibilityChange(false);
-            }
-            Event.once(notification.onDidClose)(() => notificationDisposables.dispose());
-            return notification;
-        };
-        const updateProgress = (notification, increment) => {
-            if (typeof increment === 'number' && increment >= 0) {
-                notification.progress.total(100);
-                notification.progress.worked(increment);
-            }
-            else {
-                notification.progress.infinite();
-            }
-        };
-        let notificationHandle;
-        let notificationTimeout;
-        let titleAndMessage;
-        const updateNotification = (step) => {
-            if (step?.message && options.title) {
-                titleAndMessage = `${options.title}: ${step.message}`;
-            }
-            else {
-                titleAndMessage = options.title || step?.message;
-            }
-            if (!notificationHandle && titleAndMessage) {
-                if (typeof options.delay === 'number' && options.delay > 0) {
-                    if (typeof notificationTimeout !== 'number') {
-                        notificationTimeout = setTimeout(() => notificationHandle = createNotification(titleAndMessage, options.priority, step?.increment), options.delay);
-                    }
-                }
-                else {
-                    notificationHandle = createNotification(titleAndMessage, options.priority, step?.increment);
-                }
-            }
-            if (notificationHandle) {
-                if (titleAndMessage) {
-                    notificationHandle.updateMessage(titleAndMessage);
-                }
-                if (typeof step?.increment === 'number') {
-                    updateProgress(notificationHandle, step.increment);
-                }
-            }
-        };
-        updateNotification(progressStateModel.step);
-        const listener = progressStateModel.onDidReport(step => updateNotification(step));
-        Event.once(progressStateModel.onWillDispose)(() => listener.dispose());
-        (async () => {
-            try {
-                if (typeof options.delay === 'number' && options.delay > 0) {
-                    await progressStateModel.promise;
-                }
-                else {
-                    await Promise.all([timeout(800), progressStateModel.promise]);
-                }
-            }
-            finally {
-                clearTimeout(notificationTimeout);
-                notificationHandle?.close();
-            }
-        })();
-        return progressStateModel.promise;
-    }
-    withPaneCompositeProgress(paneCompositeId, viewContainerLocation, task, options) {
-        const progressIndicator = this.paneCompositeService.getProgressIndicator(paneCompositeId, viewContainerLocation);
-        const promise = progressIndicator ? this.withCompositeProgress(progressIndicator, task, options) : task({ report: () => { } });
-        if (viewContainerLocation === 0 ) {
-            this.showOnActivityBar(paneCompositeId, options, promise);
-        }
-        return promise;
-    }
-    withViewProgress(viewId, task, options) {
-        const progressIndicator = this.viewsService.getViewProgressIndicator(viewId);
-        const promise = progressIndicator ? this.withCompositeProgress(progressIndicator, task, options) : task({ report: () => { } });
-        const location = this.viewDescriptorService.getViewLocationById(viewId);
-        if (location !== 0 ) {
-            return promise;
-        }
-        const viewletId = this.viewDescriptorService.getViewContainerByViewId(viewId)?.id;
-        if (viewletId === undefined) {
-            return promise;
-        }
-        this.showOnActivityBar(viewletId, options, promise);
-        return promise;
-    }
-    showOnActivityBar(viewletId, options, promise) {
-        let activityProgress;
-        let delayHandle = setTimeout(() => {
-            delayHandle = undefined;
-            const handle = this.activityService.showViewContainerActivity(viewletId, { badge: ( new ProgressBadge(() => '')), priority: 100 });
-            const startTimeVisible = Date.now();
-            const minTimeVisible = 300;
-            activityProgress = {
-                dispose() {
-                    const d = Date.now() - startTimeVisible;
-                    if (d < minTimeVisible) {
-                        setTimeout(() => handle.dispose(), minTimeVisible - d);
-                    }
-                    else {
-                        handle.dispose();
-                    }
-                }
-            };
-        }, options.delay || 300);
-        promise.finally(() => {
-            clearTimeout(delayHandle);
-            dispose(activityProgress);
-        });
-    }
-    withCompositeProgress(progressIndicator, task, options) {
-        let discreteProgressRunner = undefined;
-        function updateProgress(stepOrTotal) {
-            let total = undefined;
-            let increment = undefined;
-            if (typeof stepOrTotal !== 'undefined') {
-                if (typeof stepOrTotal === 'number') {
-                    total = stepOrTotal;
-                }
-                else if (typeof stepOrTotal.increment === 'number') {
-                    total = stepOrTotal.total ?? 100;
-                    increment = stepOrTotal.increment;
-                }
-            }
-            if (typeof total === 'number') {
-                if (!discreteProgressRunner) {
-                    discreteProgressRunner = progressIndicator.show(total, options.delay);
-                    promise.catch(() => undefined ).finally(() => discreteProgressRunner?.done());
-                }
-                if (typeof increment === 'number') {
-                    discreteProgressRunner.worked(increment);
-                }
-            }
-            else {
-                discreteProgressRunner?.done();
-                progressIndicator.showWhile(promise, options.delay);
-            }
-            return discreteProgressRunner;
-        }
-        const promise = task({
-            report: progress => {
-                updateProgress(progress);
-            }
-        });
-        updateProgress(options.total);
-        return promise;
-    }
-    withDialogProgress(options, task, onDidCancel) {
-        const disposables = ( new DisposableStore());
-        const allowableCommands = [
-            'workbench.action.quit',
-            'workbench.action.reloadWindow',
-            'copy',
-            'cut',
-            'editor.action.clipboardCopyAction',
-            'editor.action.clipboardCutAction'
-        ];
-        let dialog;
-        const createDialog = (message) => {
-            const buttons = options.buttons || [];
-            if (!options.sticky) {
-                buttons.push(options.cancellable ? ( localizeWithPath(
-                    'vs/workbench/services/progress/browser/progressService',
-                    'cancel',
-                    "Cancel"
-                )) : ( localizeWithPath(
-                    'vs/workbench/services/progress/browser/progressService',
-                    'dismiss',
-                    "Dismiss"
-                )));
-            }
-            dialog = ( new Dialog(this.layoutService.activeContainer, message, buttons, {
-                type: 'pending',
-                detail: options.detail,
-                cancelId: buttons.length - 1,
-                disableCloseAction: options.sticky,
-                disableDefaultAction: options.sticky,
-                keyEventProcessor: (event) => {
-                    const resolved = this.keybindingService.softDispatch(event, this.layoutService.activeContainer);
-                    if (resolved.kind === 2  && resolved.commandId) {
-                        if (!allowableCommands.includes(resolved.commandId)) {
-                            EventHelper.stop(event, true);
-                        }
-                    }
-                },
-                buttonStyles: defaultButtonStyles,
-                checkboxStyles: defaultCheckboxStyles,
-                inputBoxStyles: defaultInputBoxStyles,
-                dialogStyles: defaultDialogStyles
-            }));
-            disposables.add(dialog);
-            dialog.show().then(dialogResult => {
-                onDidCancel?.(dialogResult.button);
-                dispose(dialog);
-            });
-            return dialog;
-        };
-        let delay = options.delay ?? 0;
-        let latestMessage = undefined;
-        const scheduler = disposables.add(( new RunOnceScheduler(() => {
-            delay = 0;
-            if (latestMessage && !dialog) {
-                dialog = createDialog(latestMessage);
-            }
-            else if (latestMessage) {
-                dialog.updateMessage(latestMessage);
-            }
-        }, 0)));
-        const updateDialog = function (message) {
-            latestMessage = message;
-            if (!scheduler.isScheduled()) {
-                scheduler.schedule(delay);
-            }
-        };
-        const promise = task({
-            report: progress => {
-                updateDialog(progress.message);
-            }
-        });
-        promise.finally(() => {
-            dispose(disposables);
-        });
-        if (options.title) {
-            updateDialog(options.title);
-        }
-        return promise;
-    }
-};
-ProgressService = ( __decorate([
-    ( __param(0, IActivityService)),
-    ( __param(1, IPaneCompositePartService)),
-    ( __param(2, IViewDescriptorService)),
-    ( __param(3, IViewsService)),
-    ( __param(4, INotificationService)),
-    ( __param(5, IStatusbarService)),
-    ( __param(6, ILayoutService)),
-    ( __param(7, IKeybindingService))
-], ProgressService));
-
-export { ProgressService };

package/vscode/src/vs/workbench/services/untitled/common/untitledTextEditorHandler.js

@@ -1,101 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Schemas } from 'vscode/vscode/vs/base/common/network';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { ITextEditorService } from 'vscode/vscode/vs/workbench/services/textfile/common/textEditorService';
-import { toLocalResource, isEqual } from 'vscode/vscode/vs/base/common/resources';
-import { PLAINTEXT_LANGUAGE_ID } from 'vscode/vscode/vs/editor/common/languages/modesRegistry';
-import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
-import { IFilesConfigurationService } from 'vscode/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService';
-import { IPathService } from 'vscode/vscode/vs/workbench/services/path/common/pathService';
-import { UntitledTextEditorInput } from 'vscode/vscode/vs/workbench/services/untitled/common/untitledTextEditorInput';
-import { NO_TYPE_ID } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopy';
-import { IWorkingCopyEditorService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyEditorService';
-import { IUntitledTextEditorService } from 'vscode/vscode/vs/workbench/services/untitled/common/untitledTextEditorService';
-
-let UntitledTextEditorInputSerializer = class UntitledTextEditorInputSerializer {
-    constructor(filesConfigurationService, environmentService, pathService) {
-        this.filesConfigurationService = filesConfigurationService;
-        this.environmentService = environmentService;
-        this.pathService = pathService;
-    }
-    canSerialize(editorInput) {
-        return this.filesConfigurationService.isHotExitEnabled && !editorInput.isDisposed();
-    }
-    serialize(editorInput) {
-        if (!this.filesConfigurationService.isHotExitEnabled || editorInput.isDisposed()) {
-            return undefined;
-        }
-        const untitledTextEditorInput = editorInput;
-        let resource = untitledTextEditorInput.resource;
-        if (untitledTextEditorInput.hasAssociatedFilePath) {
-            resource = toLocalResource(resource, this.environmentService.remoteAuthority, this.pathService.defaultUriScheme);
-        }
-        let languageId;
-        const languageIdCandidate = untitledTextEditorInput.getLanguageId();
-        if (languageIdCandidate !== PLAINTEXT_LANGUAGE_ID) {
-            languageId = languageIdCandidate;
-        }
-        else if (untitledTextEditorInput.hasLanguageSetExplicitly) {
-            languageId = languageIdCandidate;
-        }
-        const serialized = {
-            resourceJSON: resource.toJSON(),
-            modeId: languageId,
-            encoding: untitledTextEditorInput.getEncoding()
-        };
-        return JSON.stringify(serialized);
-    }
-    deserialize(instantiationService, serializedEditorInput) {
-        return instantiationService.invokeFunction(accessor => {
-            const deserialized = JSON.parse(serializedEditorInput);
-            const resource = URI.revive(deserialized.resourceJSON);
-            const languageId = deserialized.modeId;
-            const encoding = deserialized.encoding;
-            return accessor.get(ITextEditorService).createTextEditor({ resource, languageId, encoding, forceUntitled: true });
-        });
-    }
-};
-UntitledTextEditorInputSerializer = ( __decorate([
-    ( __param(0, IFilesConfigurationService)),
-    ( __param(1, IWorkbenchEnvironmentService)),
-    ( __param(2, IPathService))
-], UntitledTextEditorInputSerializer));
-let UntitledTextEditorWorkingCopyEditorHandler = class UntitledTextEditorWorkingCopyEditorHandler extends Disposable {
-    constructor(workingCopyEditorService, environmentService, pathService, textEditorService, untitledTextEditorService) {
-        super();
-        this.environmentService = environmentService;
-        this.pathService = pathService;
-        this.textEditorService = textEditorService;
-        this.untitledTextEditorService = untitledTextEditorService;
-        this._register(workingCopyEditorService.registerHandler(this));
-    }
-    handles(workingCopy) {
-        return workingCopy.resource.scheme === Schemas.untitled && workingCopy.typeId === NO_TYPE_ID;
-    }
-    isOpen(workingCopy, editor) {
-        if (!this.handles(workingCopy)) {
-            return false;
-        }
-        return editor instanceof UntitledTextEditorInput && isEqual(workingCopy.resource, editor.resource);
-    }
-    createEditor(workingCopy) {
-        let editorInputResource;
-        if (this.untitledTextEditorService.isUntitledWithAssociatedResource(workingCopy.resource)) {
-            editorInputResource = toLocalResource(workingCopy.resource, this.environmentService.remoteAuthority, this.pathService.defaultUriScheme);
-        }
-        else {
-            editorInputResource = workingCopy.resource;
-        }
-        return this.textEditorService.createTextEditor({ resource: editorInputResource, forceUntitled: true });
-    }
-};
-UntitledTextEditorWorkingCopyEditorHandler = ( __decorate([
-    ( __param(0, IWorkingCopyEditorService)),
-    ( __param(1, IWorkbenchEnvironmentService)),
-    ( __param(2, IPathService)),
-    ( __param(3, ITextEditorService)),
-    ( __param(4, IUntitledTextEditorService))
-], UntitledTextEditorWorkingCopyEditorHandler));
-
-export { UntitledTextEditorInputSerializer, UntitledTextEditorWorkingCopyEditorHandler };