@codingame/monaco-vscode-api 1.78.4 → 1.78.5-next.0

package/dist/{languageService.js → vscode/vs/workbench/services/language/common/languageService.js}

@@ -1,169 +1,14 @@
-import { FILES_ASSOCIATIONS_CONFIG, __decorate, __param, IExtensionService } from './polyfill.js';
-import { ExtensionsRegistry } from './extensionsRegistry.js';
-import { parse } from 'monaco-editor/esm/vs/base/common/glob.js';
-import { posix, basename } from 'monaco-editor/esm/vs/base/common/path.js';
-import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-import { joinPath, DataUri } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { Mimes } from 'monaco-editor/esm/vs/base/common/mime.js';
-import { PLAINTEXT_LANGUAGE_ID } from 'monaco-editor/esm/vs/editor/common/languages/modesRegistry.js';
-import { startsWithUTF8BOM } from 'monaco-editor/esm/vs/base/common/strings.js';
-import { LanguageService } from 'monaco-editor/esm/vs/editor/common/services/languageService.js';
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { clearConfiguredLanguageAssociations, registerConfiguredLanguageAssociation } from 'monaco-editor/esm/vs/editor/common/services/languagesAssociations.js';
+import { joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { LanguageService } from 'monaco-editor/esm/vs/editor/common/services/languageService.js';
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
+import { FILES_ASSOCIATIONS_CONFIG } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IExtensionService } from '../../extensions/common/extensions.js';
+import { ExtensionsRegistry } from '../../extensions/common/extensionsRegistry.js';
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-let registeredAssociations = [];
-let nonUserRegisteredAssociations = [];
-let userRegisteredAssociations = [];
-function registerConfiguredLanguageAssociation(association) {
-    _registerLanguageAssociation(association, true, false);
-}
-function _registerLanguageAssociation(association, userConfigured, warnOnOverwrite) {
-    const associationItem = toLanguageAssociationItem(association, userConfigured);
-    registeredAssociations.push(associationItem);
-    if (!associationItem.userConfigured) {
-        nonUserRegisteredAssociations.push(associationItem);
-    }
-    else {
-        userRegisteredAssociations.push(associationItem);
-    }
-    if (warnOnOverwrite && !associationItem.userConfigured) {
-        registeredAssociations.forEach(a => {
-            if (a.mime === associationItem.mime || a.userConfigured) {
-                return;
-            }
-            if (associationItem.extension && a.extension === associationItem.extension) {
-                console.warn(`Overwriting extension <<${associationItem.extension}>> to now point to mime <<${associationItem.mime}>>`);
-            }
-            if (associationItem.filename && a.filename === associationItem.filename) {
-                console.warn(`Overwriting filename <<${associationItem.filename}>> to now point to mime <<${associationItem.mime}>>`);
-            }
-            if (associationItem.filepattern && a.filepattern === associationItem.filepattern) {
-                console.warn(`Overwriting filepattern <<${associationItem.filepattern}>> to now point to mime <<${associationItem.mime}>>`);
-            }
-            if (associationItem.firstline && a.firstline === associationItem.firstline) {
-                console.warn(`Overwriting firstline <<${associationItem.firstline}>> to now point to mime <<${associationItem.mime}>>`);
-            }
-        });
-    }
-}
-function toLanguageAssociationItem(association, userConfigured) {
-    return {
-        id: association.id,
-        mime: association.mime,
-        filename: association.filename,
-        extension: association.extension,
-        filepattern: association.filepattern,
-        firstline: association.firstline,
-        userConfigured: userConfigured,
-        filenameLowercase: association.filename ? association.filename.toLowerCase() : undefined,
-        extensionLowercase: association.extension ? association.extension.toLowerCase() : undefined,
-        filepatternLowercase: association.filepattern ? parse(association.filepattern.toLowerCase()) : undefined,
-        filepatternOnPath: association.filepattern ? association.filepattern.indexOf(posix.sep) >= 0 : false
-    };
-}
-function clearConfiguredLanguageAssociations() {
-    registeredAssociations = registeredAssociations.filter(a => !a.userConfigured);
-    userRegisteredAssociations = [];
-}
-function getMimeTypes(resource, firstLine) {
-    return ( getAssociations(resource, firstLine).map(item => item.mime));
-}
-function getAssociations(resource, firstLine) {
-    let path;
-    if (resource) {
-        switch (resource.scheme) {
-            case Schemas.file:
-                path = resource.fsPath;
-                break;
-            case Schemas.data: {
-                const metadata = DataUri.parseMetaData(resource);
-                path = metadata.get(DataUri.META_DATA_LABEL);
-                break;
-            }
-            case Schemas.vscodeNotebookCell:
-                path = undefined;
-                break;
-            default:
-                path = resource.path;
-        }
-    }
-    if (!path) {
-        return [{ id: 'unknown', mime: Mimes.unknown }];
-    }
-    path = path.toLowerCase();
-    const filename = basename(path);
-    const configuredLanguage = getAssociationByPath(path, filename, userRegisteredAssociations);
-    if (configuredLanguage) {
-        return [configuredLanguage, { id: PLAINTEXT_LANGUAGE_ID, mime: Mimes.text }];
-    }
-    const registeredLanguage = getAssociationByPath(path, filename, nonUserRegisteredAssociations);
-    if (registeredLanguage) {
-        return [registeredLanguage, { id: PLAINTEXT_LANGUAGE_ID, mime: Mimes.text }];
-    }
-    if (firstLine) {
-        const firstlineLanguage = getAssociationByFirstline(firstLine);
-        if (firstlineLanguage) {
-            return [firstlineLanguage, { id: PLAINTEXT_LANGUAGE_ID, mime: Mimes.text }];
-        }
-    }
-    return [{ id: 'unknown', mime: Mimes.unknown }];
-}
-function getAssociationByPath(path, filename, associations) {
-    let filenameMatch = undefined;
-    let patternMatch = undefined;
-    let extensionMatch = undefined;
-    for (let i = associations.length - 1; i >= 0; i--) {
-        const association = associations[i];
-        if (filename === association.filenameLowercase) {
-            filenameMatch = association;
-            break;
-        }
-        if (association.filepattern) {
-            if (!patternMatch || association.filepattern.length > patternMatch.filepattern.length) {
-                const target = association.filepatternOnPath ? path : filename;
-                if (association.filepatternLowercase?.(target)) {
-                    patternMatch = association;
-                }
-            }
-        }
-        if (association.extension) {
-            if (!extensionMatch || association.extension.length > extensionMatch.extension.length) {
-                if (filename.endsWith(association.extensionLowercase)) {
-                    extensionMatch = association;
-                }
-            }
-        }
-    }
-    if (filenameMatch) {
-        return filenameMatch;
-    }
-    if (patternMatch) {
-        return patternMatch;
-    }
-    if (extensionMatch) {
-        return extensionMatch;
-    }
-    return undefined;
-}
-function getAssociationByFirstline(firstLine) {
-    if (startsWithUTF8BOM(firstLine)) {
-        firstLine = firstLine.substr(1);
-    }
-    if (firstLine.length > 0) {
-        for (let i = registeredAssociations.length - 1; i >= 0; i--) {
-            const association = registeredAssociations[i];
-            if (!association.firstline) {
-                continue;
-            }
-            const matches = firstLine.match(association.firstline);
-            if (matches && matches.length > 0) {
-                return association;
-            }
-        }
-    }
-    return undefined;
-}
 const languagesExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'languages',
     jsonSchema: {
@@ -449,4 +294,4 @@ function isValidLanguageExtensionPoint(value, extension, collector) {
     }
     return true;
 }
-export { WorkbenchLanguageService, getMimeTypes, languagesExtPoint };
+export { WorkbenchLanguageService, languagesExtPoint };

package/dist/vscode/vs/workbench/services/languageDetection/common/languageDetectionWorkerService.js

@@ -0,0 +1,5 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const ILanguageDetectionService = ( createDecorator('ILanguageDetectionService'));
+const LanguageDetectionLanguageEventSource = 'languageDetection';
+const AutomaticLanguageDetectionLikelyWrongId = 'automaticlanguagedetection.likelywrong';
+export { AutomaticLanguageDetectionLikelyWrongId, ILanguageDetectionService, LanguageDetectionLanguageEventSource };

package/dist/vscode/vs/workbench/services/languageStatus/common/languageStatusService.js

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

package/dist/vscode/vs/workbench/services/layout/browser/layoutService.js

@@ -0,0 +1,12 @@
+import { refineServiceDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
+const IWorkbenchLayoutService = refineServiceDecorator(ILayoutService);
+function positionToString(position) {
+    switch (position) {
+        case 0 : return 'left';
+        case 1 : return 'right';
+        case 2 : return 'bottom';
+        default: return 'bottom';
+    }
+}
+export { IWorkbenchLayoutService, positionToString };

package/dist/vscode/vs/workbench/services/lifecycle/common/lifecycle.js

@@ -0,0 +1,11 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const ILifecycleService = ( createDecorator('lifecycleService'));
+function LifecyclePhaseToString(phase) {
+    switch (phase) {
+        case 1 : return 'Starting';
+        case 2 : return 'Ready';
+        case 3 : return 'Restored';
+        case 4 : return 'Eventually';
+    }
+}
+export { ILifecycleService, LifecyclePhaseToString };

package/dist/vscode/vs/workbench/services/lifecycle/common/lifecycleService.js

@@ -0,0 +1,85 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Barrier } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { LifecyclePhaseToString } from './lifecycle.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { mark } from '../../../../base/common/performance.js';
+import { WillSaveStateReason, IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+let AbstractLifecycleService = class AbstractLifecycleService extends Disposable {
+    get startupKind() { return this._startupKind; }
+    get phase() { return this._phase; }
+    constructor(logService, storageService) {
+        super();
+        this.logService = logService;
+        this.storageService = storageService;
+        this._onBeforeShutdown = this._register(( new Emitter()));
+        this.onBeforeShutdown = this._onBeforeShutdown.event;
+        this._onWillShutdown = this._register(( new Emitter()));
+        this.onWillShutdown = this._onWillShutdown.event;
+        this._onDidShutdown = this._register(( new Emitter()));
+        this.onDidShutdown = this._onDidShutdown.event;
+        this._onBeforeShutdownError = this._register(( new Emitter()));
+        this.onBeforeShutdownError = this._onBeforeShutdownError.event;
+        this._onShutdownVeto = this._register(( new Emitter()));
+        this.onShutdownVeto = this._onShutdownVeto.event;
+        this._phase = 1 ;
+        this.phaseWhen = ( new Map());
+        this._startupKind = this.resolveStartupKind();
+        this.storageService.onWillSaveState(e => {
+            if (e.reason === WillSaveStateReason.SHUTDOWN) {
+                this.storageService.store(AbstractLifecycleService.LAST_SHUTDOWN_REASON_KEY, this.shutdownReason, 1 , 1 );
+            }
+        });
+    }
+    resolveStartupKind() {
+        const lastShutdownReason = this.storageService.getNumber(AbstractLifecycleService.LAST_SHUTDOWN_REASON_KEY, 1 );
+        this.storageService.remove(AbstractLifecycleService.LAST_SHUTDOWN_REASON_KEY, 1 );
+        let startupKind;
+        switch (lastShutdownReason) {
+            case 3 :
+                startupKind = 3 ;
+                break;
+            case 4 :
+                startupKind = 4 ;
+                break;
+            default:
+                startupKind = 1 ;
+        }
+        this.logService.trace(`[lifecycle] starting up (startup kind: ${startupKind})`);
+        return startupKind;
+    }
+    set phase(value) {
+        if (value < this.phase) {
+            throw new Error('Lifecycle cannot go backwards');
+        }
+        if (this._phase === value) {
+            return;
+        }
+        this.logService.trace(`lifecycle: phase changed (value: ${value})`);
+        this._phase = value;
+        mark(`code/LifecyclePhase/${LifecyclePhaseToString(value)}`);
+        const barrier = this.phaseWhen.get(this._phase);
+        if (barrier) {
+            barrier.open();
+            this.phaseWhen.delete(this._phase);
+        }
+    }
+    async when(phase) {
+        if (phase <= this._phase) {
+            return;
+        }
+        let barrier = this.phaseWhen.get(phase);
+        if (!barrier) {
+            barrier = ( new Barrier());
+            this.phaseWhen.set(phase, barrier);
+        }
+        await barrier.wait();
+    }
+};
+AbstractLifecycleService.LAST_SHUTDOWN_REASON_KEY = 'lifecyle.lastShutdownReason';
+AbstractLifecycleService = ( __decorate([
+    ( __param(0, ILogService)),
+    ( __param(1, IStorageService))
+], AbstractLifecycleService));
+export { AbstractLifecycleService };

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

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

package/dist/vscode/vs/workbench/services/output/common/output.js

@@ -0,0 +1,51 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const OUTPUT_MIME = 'text/x-code-output';
+const OUTPUT_SCHEME = 'output';
+const OUTPUT_MODE_ID = 'Log';
+const LOG_MIME = 'text/x-code-log-output';
+const LOG_MODE_ID = 'log';
+const OUTPUT_VIEW_ID = 'workbench.panel.output';
+const CONTEXT_ACTIVE_LOG_OUTPUT = ( new RawContextKey('activeLogOutput', false));
+const IOutputService = ( createDecorator('outputService'));
+var OutputChannelUpdateMode;
+( (function(OutputChannelUpdateMode) {
+    OutputChannelUpdateMode[OutputChannelUpdateMode["Append"] = 1] = "Append";
+    OutputChannelUpdateMode[OutputChannelUpdateMode["Replace"] = 2] = "Replace";
+    OutputChannelUpdateMode[OutputChannelUpdateMode["Clear"] = 3] = "Clear";
+})(OutputChannelUpdateMode || (OutputChannelUpdateMode = {})));
+const Extensions = {
+    OutputChannels: 'workbench.contributions.outputChannels'
+};
+class OutputChannelRegistry {
+    constructor() {
+        this.channels = ( new Map());
+        this._onDidRegisterChannel = ( new Emitter());
+        this.onDidRegisterChannel = this._onDidRegisterChannel.event;
+        this._onDidRemoveChannel = ( new Emitter());
+        this.onDidRemoveChannel = this._onDidRemoveChannel.event;
+    }
+    registerChannel(descriptor) {
+        if (!this.channels.has(descriptor.id)) {
+            this.channels.set(descriptor.id, descriptor);
+            this._onDidRegisterChannel.fire(descriptor.id);
+        }
+    }
+    getChannels() {
+        const result = [];
+        this.channels.forEach(value => result.push(value));
+        return result;
+    }
+    getChannel(id) {
+        return this.channels.get(id);
+    }
+    removeChannel(id) {
+        this.channels.delete(id);
+        this._onDidRemoveChannel.fire(id);
+    }
+}
+Registry.add(Extensions.OutputChannels, ( new OutputChannelRegistry()));
+const ACTIVE_OUTPUT_CHANNEL_CONTEXT = ( new RawContextKey('activeOutputChannel', ''));
+export { ACTIVE_OUTPUT_CHANNEL_CONTEXT, CONTEXT_ACTIVE_LOG_OUTPUT, Extensions, IOutputService, LOG_MIME, LOG_MODE_ID, OUTPUT_MIME, OUTPUT_MODE_ID, OUTPUT_SCHEME, OUTPUT_VIEW_ID, OutputChannelUpdateMode };

package/dist/vscode/vs/workbench/services/panecomposite/browser/panecomposite.js

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

package/dist/vscode/vs/workbench/services/path/browser/pathService.js

@@ -0,0 +1,34 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { IRemoteAgentService } from '../../remote/common/remoteAgentService.js';
+import { AbstractPathService } from '../common/pathService.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { firstOrDefault } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { dirname } from 'monaco-editor/esm/vs/base/common/resources.js';
+let BrowserPathService = class BrowserPathService extends AbstractPathService {
+    constructor(remoteAgentService, environmentService, contextService) {
+        super(guessLocalUserHome(environmentService, contextService), remoteAgentService, environmentService, contextService);
+    }
+};
+BrowserPathService = ( __decorate([
+    ( __param(0, IRemoteAgentService)),
+    ( __param(1, IWorkbenchEnvironmentService)),
+    ( __param(2, IWorkspaceContextService))
+], BrowserPathService));
+function guessLocalUserHome(environmentService, contextService) {
+    const workspace = contextService.getWorkspace();
+    const firstFolder = firstOrDefault(workspace.folders);
+    if (firstFolder) {
+        return firstFolder.uri;
+    }
+    if (workspace.configuration) {
+        return dirname(workspace.configuration);
+    }
+    return ( URI.from({
+        scheme: AbstractPathService.findDefaultUriScheme(environmentService, contextService),
+        authority: environmentService.remoteAuthority,
+        path: '/'
+    }));
+}
+export { BrowserPathService };