@codingame/monaco-vscode-view-common-service-override 4.5.0-improve-code-splitting.1

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

@@ -0,0 +1,6 @@
+import n from 'vscode/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

@@ -0,0 +1,527 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import './media/progressService.css.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { Disposable, toDisposable, DisposableStore, dispose } from 'vscode/vscode/vs/base/common/lifecycle';
+import { Progress } from 'vscode/vscode/vs/platform/progress/common/progress';
+import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IStatusbarService } from 'vscode/vscode/vs/workbench/services/statusbar/browser/statusbar.service';
+import { timeout, DeferredPromise, RunOnceScheduler } from 'vscode/vscode/vs/base/common/async';
+import { ProgressBadge } from 'vscode/vscode/vs/workbench/services/activity/common/activity';
+import { IActivityService } from 'vscode/vscode/vs/workbench/services/activity/common/activity.service';
+import { NotificationPriority, NotificationsFilter, isNotificationSource } from 'vscode/vscode/vs/platform/notification/common/notification';
+import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification.service';
+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.service';
+import { Dialog } from 'vscode/vscode/vs/base/browser/ui/dialog/dialog';
+import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding.service';
+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.service';
+import { IViewsService } from 'vscode/vscode/vs/workbench/services/views/common/viewsService.service';
+import { IPaneCompositePartService } from 'vscode/vscode/vs/workbench/services/panecomposite/browser/panecomposite.service';
+import { stripIcons } from 'vscode/vscode/vs/base/common/iconLabels';
+import { defaultButtonStyles, defaultCheckboxStyles, defaultInputBoxStyles, defaultDialogStyles } from 'vscode/vscode/vs/platform/theme/browser/defaultStyles';
+import Severity$1 from 'vscode/vscode/vs/base/common/severity';
+
+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$1.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

@@ -0,0 +1,102 @@
+import { __decorate, __param } from 'vscode/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.service';
+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.service';
+import { IFilesConfigurationService } from 'vscode/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService.service';
+import { IPathService } from 'vscode/vscode/vs/workbench/services/path/common/pathService.service';
+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.service';
+import { IUntitledTextEditorService } from 'vscode/vscode/vs/workbench/services/untitled/common/untitledTextEditorService.service';
+
+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.canSerialize(editorInput)) {
+            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 {
+    static { this.ID = 'workbench.contrib.untitledTextEditorWorkingCopyEditorHandler'; }
+    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 };