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

package/dist/vscode/vs/workbench/services/decorations/browser/decorationsService.js

@@ -0,0 +1,312 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { DebounceEmitter, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { TernarySearchTree } from 'monaco-editor/esm/vs/base/common/ternarySearchTree.js';
+import { toDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { isThenable } from 'monaco-editor/esm/vs/base/common/async.js';
+import { LinkedList } from 'monaco-editor/esm/vs/base/common/linkedList.js';
+import { createStyleSheet, createCSSRule, asCSSPropertyValue, removeCSSRulesContainingSelector } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { isFalsyOrWhitespace } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { hash } from 'monaco-editor/esm/vs/base/common/hash.js';
+import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.js';
+import { distinct, asArray } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { asCssVariable } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { getIconRegistry } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+class DecorationRule {
+    static keyOf(data) {
+        if (Array.isArray(data)) {
+            return ( data.map(DecorationRule.keyOf)).join(',');
+        }
+        else {
+            const { color, letter } = data;
+            if (ThemeIcon.isThemeIcon(letter)) {
+                return `${color}+${letter.id}`;
+            }
+            else {
+                return `${color}/${letter}`;
+            }
+        }
+    }
+    constructor(themeService, data, key) {
+        this.themeService = themeService;
+        this._refCounter = 0;
+        this.data = data;
+        const suffix = ( hash(key).toString(36));
+        this.itemColorClassName = `${DecorationRule._classNamesPrefix}-itemColor-${suffix}`;
+        this.itemBadgeClassName = `${DecorationRule._classNamesPrefix}-itemBadge-${suffix}`;
+        this.bubbleBadgeClassName = `${DecorationRule._classNamesPrefix}-bubbleBadge-${suffix}`;
+        this.iconBadgeClassName = `${DecorationRule._classNamesPrefix}-iconBadge-${suffix}`;
+    }
+    acquire() {
+        this._refCounter += 1;
+    }
+    release() {
+        return --this._refCounter === 0;
+    }
+    appendCSSRules(element) {
+        if (!Array.isArray(this.data)) {
+            this._appendForOne(this.data, element);
+        }
+        else {
+            this._appendForMany(this.data, element);
+        }
+    }
+    _appendForOne(data, element) {
+        const { color, letter } = data;
+        createCSSRule(`.${this.itemColorClassName}`, `color: ${getColor(color)};`, element);
+        if (ThemeIcon.isThemeIcon(letter)) {
+            this._createIconCSSRule(letter, color, element);
+        }
+        else if (letter) {
+            createCSSRule(`.${this.itemBadgeClassName}::after`, `content: "${letter}"; color: ${getColor(color)};`, element);
+        }
+    }
+    _appendForMany(data, element) {
+        const { color } = data[0];
+        createCSSRule(`.${this.itemColorClassName}`, `color: ${getColor(color)};`, element);
+        const letters = [];
+        let icon;
+        for (const d of data) {
+            if (ThemeIcon.isThemeIcon(d.letter)) {
+                icon = d.letter;
+                break;
+            }
+            else if (d.letter) {
+                letters.push(d.letter);
+            }
+        }
+        if (icon) {
+            this._createIconCSSRule(icon, color, element);
+        }
+        else {
+            if (letters.length) {
+                createCSSRule(`.${this.itemBadgeClassName}::after`, `content: "${letters.join(', ')}"; color: ${getColor(color)};`, element);
+            }
+            createCSSRule(`.${this.bubbleBadgeClassName}::after`, `content: "\uea71"; color: ${getColor(color)}; font-family: codicon; font-size: 14px; margin-right: 14px; opacity: 0.4;`, element);
+        }
+    }
+    _createIconCSSRule(icon, color, element) {
+        const modifier = ThemeIcon.getModifier(icon);
+        if (modifier) {
+            icon = ThemeIcon.modify(icon, undefined);
+        }
+        const iconContribution = getIconRegistry().getIcon(icon.id);
+        if (!iconContribution) {
+            return;
+        }
+        const definition = this.themeService.getProductIconTheme().getIcon(iconContribution);
+        if (!definition) {
+            return;
+        }
+        createCSSRule(`.${this.iconBadgeClassName}::after`, `content: '${definition.fontCharacter}';
+			color: ${icon.color ? getColor(icon.color.id) : getColor(color)};
+			font-family: ${asCSSPropertyValue(definition.font?.id ?? 'codicon')};
+			font-size: 16px;
+			margin-right: 14px;
+			font-weight: normal;
+			${modifier === 'spin' ? 'animation: codicon-spin 1.5s steps(30) infinite' : ''};
+			`, element);
+    }
+    removeCSSRules(element) {
+        removeCSSRulesContainingSelector(this.itemColorClassName, element);
+        removeCSSRulesContainingSelector(this.itemBadgeClassName, element);
+        removeCSSRulesContainingSelector(this.bubbleBadgeClassName, element);
+        removeCSSRulesContainingSelector(this.iconBadgeClassName, element);
+    }
+}
+DecorationRule._classNamesPrefix = 'monaco-decoration';
+class DecorationStyles {
+    constructor(_themeService) {
+        this._themeService = _themeService;
+        this._styleElement = createStyleSheet();
+        this._decorationRules = ( new Map());
+        this._dispoables = ( new DisposableStore());
+    }
+    dispose() {
+        this._dispoables.dispose();
+        this._styleElement.remove();
+    }
+    asDecoration(data, onlyChildren) {
+        data.sort((a, b) => (b.weight || 0) - (a.weight || 0));
+        const key = DecorationRule.keyOf(data);
+        let rule = this._decorationRules.get(key);
+        if (!rule) {
+            rule = ( new DecorationRule(this._themeService, data, key));
+            this._decorationRules.set(key, rule);
+            rule.appendCSSRules(this._styleElement);
+        }
+        rule.acquire();
+        const labelClassName = rule.itemColorClassName;
+        let badgeClassName = rule.itemBadgeClassName;
+        const iconClassName = rule.iconBadgeClassName;
+        let tooltip = distinct(( data.filter(d => !isFalsyOrWhitespace(d.tooltip)).map(d => d.tooltip))).join(' • ');
+        const strikethrough = ( data.some(d => d.strikethrough));
+        if (onlyChildren) {
+            badgeClassName = rule.bubbleBadgeClassName;
+            tooltip = ( localize('bubbleTitle', "Contains emphasized items"));
+        }
+        return {
+            labelClassName,
+            badgeClassName,
+            iconClassName,
+            strikethrough,
+            tooltip,
+            dispose: () => {
+                if (rule?.release()) {
+                    this._decorationRules.delete(key);
+                    rule.removeCSSRules(this._styleElement);
+                    rule = undefined;
+                }
+            }
+        };
+    }
+}
+class FileDecorationChangeEvent {
+    constructor(all) {
+        this._data = TernarySearchTree.forUris(_uri => true);
+        this._data.fill(true, asArray(all));
+    }
+    affectsResource(uri) {
+        return this._data.hasElementOrSubtree(uri);
+    }
+}
+class DecorationDataRequest {
+    constructor(source, thenable) {
+        this.source = source;
+        this.thenable = thenable;
+    }
+}
+function getColor(color) {
+    return color ? asCssVariable(color) : 'inherit';
+}
+let DecorationsService = class DecorationsService {
+    constructor(uriIdentityService, themeService) {
+        this._onDidChangeDecorationsDelayed = ( new DebounceEmitter({ merge: all => all.flat() }));
+        this._onDidChangeDecorations = ( new Emitter());
+        this.onDidChangeDecorations = this._onDidChangeDecorations.event;
+        this._provider = ( new LinkedList());
+        this._decorationStyles = ( new DecorationStyles(themeService));
+        this._data = TernarySearchTree.forUris(key => uriIdentityService.extUri.ignorePathCasing(key));
+        this._onDidChangeDecorationsDelayed.event(event => { this._onDidChangeDecorations.fire(( new FileDecorationChangeEvent(event))); });
+    }
+    dispose() {
+        this._onDidChangeDecorations.dispose();
+        this._onDidChangeDecorationsDelayed.dispose();
+    }
+    registerDecorationsProvider(provider) {
+        const rm = this._provider.unshift(provider);
+        this._onDidChangeDecorations.fire({
+            affectsResource() { return true; }
+        });
+        const removeAll = () => {
+            const uris = [];
+            for (const [uri, map] of this._data) {
+                if (map.delete(provider)) {
+                    uris.push(uri);
+                }
+            }
+            if (uris.length > 0) {
+                this._onDidChangeDecorationsDelayed.fire(uris);
+            }
+        };
+        const listener = provider.onDidChange(uris => {
+            if (!uris) {
+                removeAll();
+            }
+            else {
+                for (const uri of uris) {
+                    const map = this._ensureEntry(uri);
+                    this._fetchData(map, uri, provider);
+                }
+            }
+        });
+        return toDisposable(() => {
+            rm();
+            listener.dispose();
+            removeAll();
+        });
+    }
+    _ensureEntry(uri) {
+        let map = this._data.get(uri);
+        if (!map) {
+            map = ( new Map());
+            this._data.set(uri, map);
+        }
+        return map;
+    }
+    getDecoration(uri, includeChildren) {
+        const all = [];
+        let containsChildren = false;
+        const map = this._ensureEntry(uri);
+        for (const provider of this._provider) {
+            let data = map.get(provider);
+            if (data === undefined) {
+                data = this._fetchData(map, uri, provider);
+            }
+            if (data && !(data instanceof DecorationDataRequest)) {
+                all.push(data);
+            }
+        }
+        if (includeChildren) {
+            const iter = this._data.findSuperstr(uri);
+            if (iter) {
+                for (const tuple of iter) {
+                    for (const data of ( tuple[1].values())) {
+                        if (data && !(data instanceof DecorationDataRequest)) {
+                            if (data.bubble) {
+                                all.push(data);
+                                containsChildren = true;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return all.length === 0
+            ? undefined
+            : this._decorationStyles.asDecoration(all, containsChildren);
+    }
+    _fetchData(map, uri, provider) {
+        const pendingRequest = map.get(provider);
+        if (pendingRequest instanceof DecorationDataRequest) {
+            pendingRequest.source.cancel();
+            map.delete(provider);
+        }
+        const source = ( new CancellationTokenSource());
+        const dataOrThenable = provider.provideDecorations(uri, source.token);
+        if (!isThenable(dataOrThenable)) {
+            return this._keepItem(map, provider, uri, dataOrThenable);
+        }
+        else {
+            const request = ( new DecorationDataRequest(source, Promise.resolve(dataOrThenable).then(data => {
+                if (map.get(provider) === request) {
+                    this._keepItem(map, provider, uri, data);
+                }
+            }).catch(err => {
+                if (!isCancellationError(err) && map.get(provider) === request) {
+                    map.delete(provider);
+                }
+            })));
+            map.set(provider, request);
+            return null;
+        }
+    }
+    _keepItem(map, provider, uri, data) {
+        const deco = data ? data : null;
+        const old = map.get(provider);
+        map.set(provider, deco);
+        if (deco || old) {
+            this._onDidChangeDecorationsDelayed.fire(uri);
+        }
+        return deco;
+    }
+};
+DecorationsService = ( __decorate([
+    ( __param(0, IUriIdentityService)),
+    ( __param(1, IThemeService))
+], DecorationsService));
+export { DecorationsService };

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

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

package/dist/vscode/vs/workbench/services/dialogs/common/dialogService.js

@@ -0,0 +1,65 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { DialogsModel } from '../../../common/dialogs.js';
+import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+let DialogService = class DialogService extends Disposable {
+    constructor(environmentService, logService) {
+        super();
+        this.environmentService = environmentService;
+        this.logService = logService;
+        this.model = this._register(( new DialogsModel()));
+        this.onWillShowDialog = this.model.onWillShowDialog;
+        this.onDidShowDialog = this.model.onDidShowDialog;
+    }
+    skipDialogs() {
+        if (this.environmentService.isExtensionDevelopment && this.environmentService.extensionTestsLocationURI) {
+            return true;
+        }
+        return !!this.environmentService.enableSmokeTestDriver;
+    }
+    async confirm(confirmation) {
+        if (this.skipDialogs()) {
+            this.logService.trace('DialogService: refused to show confirmation dialog in tests.');
+            return { confirmed: true };
+        }
+        const handle = this.model.show({ confirmArgs: { confirmation } });
+        return await handle.result;
+    }
+    async prompt(prompt) {
+        if (this.skipDialogs()) {
+            throw new Error(`DialogService: refused to show dialog in tests. Contents: ${prompt.message}`);
+        }
+        const handle = this.model.show({ promptArgs: { prompt } });
+        return await handle.result;
+    }
+    async input(input) {
+        if (this.skipDialogs()) {
+            throw new Error('DialogService: refused to show input dialog in tests.');
+        }
+        const handle = this.model.show({ inputArgs: { input } });
+        return await handle.result;
+    }
+    async info(message, detail) {
+        await this.prompt({ type: Severity.Info, message, detail });
+    }
+    async warn(message, detail) {
+        await this.prompt({ type: Severity.Warning, message, detail });
+    }
+    async error(message, detail) {
+        await this.prompt({ type: Severity.Error, message, detail });
+    }
+    async about() {
+        if (this.skipDialogs()) {
+            throw new Error('DialogService: refused to show about dialog in tests.');
+        }
+        const handle = this.model.show({});
+        await handle.result;
+    }
+};
+DialogService = ( __decorate([
+    ( __param(0, IWorkbenchEnvironmentService)),
+    ( __param(1, ILogService))
+], DialogService));
+export { DialogService };

package/dist/vscode/vs/workbench/services/editor/browser/codeEditorService.js

@@ -0,0 +1,80 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { isCodeEditor, isDiffEditor, isCompositeEditor, getCodeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
+import { AbstractCodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/abstractCodeEditorService.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { SIDE_GROUP, ACTIVE_GROUP, IEditorService } from '../common/editorService.js';
+import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { applyTextEditorOptions } from '../../../common/editor/editorOptions.js';
+let CodeEditorService = class CodeEditorService extends AbstractCodeEditorService {
+    constructor(editorService, themeService, configurationService) {
+        super(themeService);
+        this.editorService = editorService;
+        this.configurationService = configurationService;
+        this.registerCodeEditorOpenHandler(this.doOpenCodeEditor.bind(this));
+        this.registerCodeEditorOpenHandler(this.doOpenCodeEditorFromDiff.bind(this));
+    }
+    getActiveCodeEditor() {
+        const activeTextEditorControl = this.editorService.activeTextEditorControl;
+        if (isCodeEditor(activeTextEditorControl)) {
+            return activeTextEditorControl;
+        }
+        if (isDiffEditor(activeTextEditorControl)) {
+            return activeTextEditorControl.getModifiedEditor();
+        }
+        const activeControl = this.editorService.activeEditorPane?.getControl();
+        if (isCompositeEditor(activeControl) && isCodeEditor(activeControl.activeCodeEditor)) {
+            return activeControl.activeCodeEditor;
+        }
+        return null;
+    }
+    async doOpenCodeEditorFromDiff(input, source, sideBySide) {
+        const activeTextEditorControl = this.editorService.activeTextEditorControl;
+        if (!sideBySide &&
+            isDiffEditor(activeTextEditorControl) &&
+            input.options &&
+            input.resource &&
+            source === activeTextEditorControl.getModifiedEditor() &&
+            activeTextEditorControl.getModel() &&
+            isEqual(input.resource, activeTextEditorControl.getModel()?.modified.uri)
+        ) {
+            const targetEditor = activeTextEditorControl.getModifiedEditor();
+            applyTextEditorOptions(input.options, targetEditor, 0 );
+            return targetEditor;
+        }
+        return null;
+    }
+    async doOpenCodeEditor(input, source, sideBySide) {
+        const enablePreviewFromCodeNavigation = this.configurationService.getValue().workbench?.editor?.enablePreviewFromCodeNavigation;
+        if (!enablePreviewFromCodeNavigation &&
+            source &&
+            !input.options?.pinned &&
+            !sideBySide &&
+            !isEqual(source.getModel()?.uri, input.resource)
+        ) {
+            for (const visiblePane of this.editorService.visibleEditorPanes) {
+                if (getCodeEditor(visiblePane.getControl()) === source) {
+                    visiblePane.group.pinEditor();
+                    break;
+                }
+            }
+        }
+        const control = await this.editorService.openEditor(input, sideBySide ? SIDE_GROUP : ACTIVE_GROUP);
+        if (control) {
+            const widget = control.getControl();
+            if (isCodeEditor(widget)) {
+                return widget;
+            }
+            if (isCompositeEditor(widget) && isCodeEditor(widget.activeCodeEditor)) {
+                return widget.activeCodeEditor;
+            }
+        }
+        return null;
+    }
+};
+CodeEditorService = ( __decorate([
+    ( __param(0, IEditorService)),
+    ( __param(1, IThemeService)),
+    ( __param(2, IConfigurationService))
+], CodeEditorService));
+export { CodeEditorService };

package/dist/{textEditor.js → vscode/vs/workbench/services/editor/common/editorGroupColumn.js}

@@ -1,15 +1,5 @@
-import { ACTIVE_GROUP, SIDE_GROUP, preferredSideBySideGroupDirection } from './missing-services.js';
-var EditorActivation;
-( (function(EditorActivation) {
-    EditorActivation[EditorActivation["ACTIVATE"] = 1] = "ACTIVATE";
-    EditorActivation[EditorActivation["RESTORE"] = 2] = "RESTORE";
-    EditorActivation[EditorActivation["PRESERVE"] = 3] = "PRESERVE";
-})(EditorActivation || (EditorActivation = {})));
-var EditorResolution;
-( (function(EditorResolution) {
-    EditorResolution[EditorResolution["PICK"] = 0] = "PICK";
-    EditorResolution[EditorResolution["EXCLUSIVE_ONLY"] = 1] = "EXCLUSIVE_ONLY";
-})(EditorResolution || (EditorResolution = {})));
+import { preferredSideBySideGroupDirection } from './editorGroupsService.js';
+import { ACTIVE_GROUP, SIDE_GROUP } from './editorService.js';
 function columnToEditorGroup(editorGroupService, configurationService, column = ACTIVE_GROUP) {
     if (column === ACTIVE_GROUP || column === SIDE_GROUP) {
         return column;
@@ -30,5 +20,4 @@ function editorGroupToColumn(editorGroupService, editorGroup) {
     const group = (typeof editorGroup === 'number') ? editorGroupService.getGroup(editorGroup) : editorGroup;
     return editorGroupService.getGroups(2 ).indexOf(group ?? editorGroupService.activeGroup);
 }
-class AbstractTextEditor {}
-export { AbstractTextEditor, EditorActivation, EditorResolution, columnToEditorGroup, editorGroupToColumn };
+export { columnToEditorGroup, editorGroupToColumn };

package/dist/vscode/vs/workbench/services/editor/common/editorGroupsService.js

@@ -0,0 +1,14 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IEditorGroupsService = ( createDecorator('editorGroupsService'));
+function isEditorGroup(obj) {
+    const group = obj;
+    return !!group && typeof group.id === 'number' && Array.isArray(group.editors);
+}
+function preferredSideBySideGroupDirection(configurationService) {
+    const openSideBySideDirection = configurationService.getValue('workbench.editor.openSideBySideDirection');
+    if (openSideBySideDirection === 'down') {
+        return 1 ;
+    }
+    return 3 ;
+}
+export { IEditorGroupsService, isEditorGroup, preferredSideBySideGroupDirection };

package/dist/vscode/vs/workbench/services/editor/common/editorResolverService.js

@@ -0,0 +1,31 @@
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { workbenchConfigurationNodeBase } from '../../../common/configuration.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+const IEditorResolverService = ( createDecorator('editorResolverService'));
+const configurationRegistry = ( Registry.as(Extensions.Configuration));
+const editorAssociationsConfigurationNode = {
+    ...workbenchConfigurationNodeBase,
+    properties: {
+        'workbench.editorAssociations': {
+            type: 'object',
+            markdownDescription: ( localize(
+                'editor.editorAssociations',
+                "Configure glob patterns to editors (for example `\"*.hex\": \"hexEditor.hexedit\"`). These have precedence over the default behavior."
+            )),
+            additionalProperties: {
+                type: 'string'
+            }
+        }
+    }
+};
+configurationRegistry.registerConfiguration(editorAssociationsConfigurationNode);
+var RegisteredEditorPriority;
+( (function(RegisteredEditorPriority) {
+    RegisteredEditorPriority["builtin"] = "builtin";
+    RegisteredEditorPriority["option"] = "option";
+    RegisteredEditorPriority["exclusive"] = "exclusive";
+    RegisteredEditorPriority["default"] = "default";
+})(RegisteredEditorPriority || (RegisteredEditorPriority = {})));
+export { IEditorResolverService, RegisteredEditorPriority };

package/dist/vscode/vs/workbench/services/editor/common/editorService.js

@@ -0,0 +1,10 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { isEditorGroup } from './editorGroupsService.js';
+const IEditorService = ( createDecorator('editorService'));
+const ACTIVE_GROUP = -1;
+const SIDE_GROUP = -2;
+function isPreferredGroup(obj) {
+    const candidate = obj;
+    return typeof obj === 'number' || isEditorGroup(candidate);
+}
+export { ACTIVE_GROUP, IEditorService, SIDE_GROUP, isPreferredGroup };

package/dist/vscode/vs/workbench/services/environment/browser/environmentService.js

@@ -0,0 +1,4 @@
+import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
+import { refineServiceDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IBrowserWorkbenchEnvironmentService = refineServiceDecorator(IEnvironmentService);
+export { IBrowserWorkbenchEnvironmentService };

package/dist/vscode/vs/workbench/services/environment/common/environmentService.js

@@ -0,0 +1,4 @@
+import { refineServiceDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
+const IWorkbenchEnvironmentService = refineServiceDecorator(IEnvironmentService);
+export { IWorkbenchEnvironmentService };

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

@@ -0,0 +1,6 @@
+import { refineServiceDecorator, createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IExtensionManagementService } from '../../../../platform/extensionManagement/common/extensionManagement.js';
+const IProfileAwareExtensionManagementService = refineServiceDecorator(IExtensionManagementService);
+refineServiceDecorator(IProfileAwareExtensionManagementService);
+const IWorkbenchExtensionEnablementService = ( createDecorator('extensionEnablementService'));
+export { IProfileAwareExtensionManagementService, IWorkbenchExtensionEnablementService };

package/dist/vscode/vs/workbench/services/extensions/common/extHostCustomers.js

@@ -0,0 +1,40 @@
+function extHostNamedCustomer(id) {
+    return function (ctor) {
+        ExtHostCustomersRegistryImpl.INSTANCE.registerNamedCustomer(id, ctor);
+    };
+}
+function extHostCustomer(ctor) {
+    ExtHostCustomersRegistryImpl.INSTANCE.registerCustomer(ctor);
+}
+var ExtHostCustomersRegistry;
+( (function(ExtHostCustomersRegistry) {
+    function getNamedCustomers() {
+        return ExtHostCustomersRegistryImpl.INSTANCE.getNamedCustomers();
+    }
+    ExtHostCustomersRegistry.getNamedCustomers = getNamedCustomers;
+    function getCustomers() {
+        return ExtHostCustomersRegistryImpl.INSTANCE.getCustomers();
+    }
+    ExtHostCustomersRegistry.getCustomers = getCustomers;
+})(ExtHostCustomersRegistry || (ExtHostCustomersRegistry = {})));
+class ExtHostCustomersRegistryImpl {
+    constructor() {
+        this._namedCustomers = [];
+        this._customers = [];
+    }
+    registerNamedCustomer(id, ctor) {
+        const entry = [id, ctor];
+        this._namedCustomers.push(entry);
+    }
+    getNamedCustomers() {
+        return this._namedCustomers;
+    }
+    registerCustomer(ctor) {
+        this._customers.push(ctor);
+    }
+    getCustomers() {
+        return this._customers;
+    }
+}
+ExtHostCustomersRegistryImpl.INSTANCE = ( new ExtHostCustomersRegistryImpl());
+export { ExtHostCustomersRegistry, extHostCustomer, extHostNamedCustomer };