@codingame/monaco-vscode-api 1.79.0 → 1.79.1

package/dist/vscode/vs/workbench/contrib/tasks/browser/tasksQuickAccess.js

@@ -0,0 +1,108 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { PickerQuickAccessProvider, TriggerAction } from 'monaco-editor/esm/vs/platform/quickinput/browser/pickerQuickAccess.js';
+import { matchesFuzzy } from 'monaco-editor/esm/vs/base/common/filters.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.js';
+import { ITaskService } from '../common/taskService.js';
+import { ContributedTask, CustomTask, ConfiguringTask } from '../common/tasks.js';
+import { TaskQuickPick } from './taskQuickPick.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { isString } from 'monaco-editor/esm/vs/base/common/types.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { IDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+let TasksQuickAccessProvider = class TasksQuickAccessProvider extends PickerQuickAccessProvider {
+    constructor(extensionService, _taskService, _configurationService, _quickInputService, _notificationService, _dialogService, _themeService, _storageService) {
+        super(TasksQuickAccessProvider.PREFIX, {
+            noResultsPick: {
+                label: ( localize('noTaskResults', "No matching tasks"))
+            }
+        });
+        this._taskService = _taskService;
+        this._configurationService = _configurationService;
+        this._quickInputService = _quickInputService;
+        this._notificationService = _notificationService;
+        this._dialogService = _dialogService;
+        this._themeService = _themeService;
+        this._storageService = _storageService;
+    }
+    async _getPicks(filter, disposables, token) {
+        if (token.isCancellationRequested) {
+            return [];
+        }
+        const taskQuickPick = ( new TaskQuickPick(
+            this._taskService,
+            this._configurationService,
+            this._quickInputService,
+            this._notificationService,
+            this._themeService,
+            this._dialogService,
+            this._storageService
+        ));
+        const topLevelPicks = await taskQuickPick.getTopLevelEntries();
+        const taskPicks = [];
+        for (const entry of topLevelPicks.entries) {
+            const highlights = matchesFuzzy(filter, entry.label);
+            if (!highlights) {
+                continue;
+            }
+            if (entry.type === 'separator') {
+                taskPicks.push(entry);
+            }
+            const task = entry.task;
+            const quickAccessEntry = entry;
+            quickAccessEntry.highlights = { label: highlights };
+            quickAccessEntry.trigger = (index) => {
+                if ((index === 1) && (quickAccessEntry.buttons?.length === 2)) {
+                    const key = (task && !isString(task)) ? task.getRecentlyUsedKey() : undefined;
+                    if (key) {
+                        this._taskService.removeRecentlyUsedTask(key);
+                    }
+                    return TriggerAction.REFRESH_PICKER;
+                }
+                else {
+                    if (ContributedTask.is(task)) {
+                        this._taskService.customize(task, undefined, true);
+                    }
+                    else if (CustomTask.is(task)) {
+                        this._taskService.openConfig(task);
+                    }
+                    return TriggerAction.CLOSE_PICKER;
+                }
+            };
+            quickAccessEntry.accept = async () => {
+                if (isString(task)) {
+                    const showResult = await taskQuickPick.show(( localize('TaskService.pickRunTask', 'Select the task to run')), undefined, task);
+                    if (showResult) {
+                        this._taskService.run(showResult, { attachProblemMatcher: true });
+                    }
+                }
+                else {
+                    this._taskService.run(await this._toTask(task), { attachProblemMatcher: true });
+                }
+            };
+            taskPicks.push(quickAccessEntry);
+        }
+        return taskPicks;
+    }
+    async _toTask(task) {
+        if (!ConfiguringTask.is(task)) {
+            return task;
+        }
+        return this._taskService.tryResolveTask(task);
+    }
+};
+TasksQuickAccessProvider.PREFIX = 'task ';
+TasksQuickAccessProvider = ( __decorate([
+    ( __param(0, IExtensionService)),
+    ( __param(1, ITaskService)),
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IQuickInputService)),
+    ( __param(4, INotificationService)),
+    ( __param(5, IDialogService)),
+    ( __param(6, IThemeService)),
+    ( __param(7, IStorageService))
+], TasksQuickAccessProvider));
+export { TasksQuickAccessProvider };

package/dist/vscode/vs/workbench/contrib/tasks/common/tasks.js

@@ -0,0 +1,351 @@
+import * as types from 'monaco-editor/esm/vs/base/common/types.js';
+import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
+const USER_TASKS_GROUP_KEY = 'settings';
+const CUSTOMIZED_TASK_TYPE = '$customized';
+var RuntimeType;
+( ((function(RuntimeType) {
+    RuntimeType[RuntimeType["Shell"] = 1] = "Shell";
+    RuntimeType[RuntimeType["Process"] = 2] = "Process";
+    RuntimeType[RuntimeType["CustomExecution"] = 3] = "CustomExecution";
+})(RuntimeType || (RuntimeType = {}))));
+( ((function(RuntimeType) {
+    function fromString(value) {
+        switch (value.toLowerCase()) {
+            case 'shell':
+                return RuntimeType.Shell;
+            case 'process':
+                return RuntimeType.Process;
+            case 'customExecution':
+                return RuntimeType.CustomExecution;
+            default:
+                return RuntimeType.Process;
+        }
+    }
+    RuntimeType.fromString = fromString;
+    function toString(value) {
+        switch (value) {
+            case RuntimeType.Shell: return 'shell';
+            case RuntimeType.Process: return 'process';
+            case RuntimeType.CustomExecution: return 'customExecution';
+            default: return 'process';
+        }
+    }
+    RuntimeType.toString = toString;
+})(RuntimeType || (RuntimeType = {}))));
+var TaskSourceKind;
+( ((function(TaskSourceKind) {
+    TaskSourceKind.Workspace = 'workspace';
+    TaskSourceKind.Extension = 'extension';
+    TaskSourceKind.InMemory = 'inMemory';
+    TaskSourceKind.WorkspaceFile = 'workspaceFile';
+    TaskSourceKind.User = 'user';
+    function toConfigurationTarget(kind) {
+        switch (kind) {
+            case TaskSourceKind.User: return 2 ;
+            case TaskSourceKind.WorkspaceFile: return 5 ;
+            default: return 6 ;
+        }
+    }
+    TaskSourceKind.toConfigurationTarget = toConfigurationTarget;
+})(TaskSourceKind || (TaskSourceKind = {}))));
+class CommonTask {
+    constructor(id, label, type, runOptions, configurationProperties, source) {
+        this._label = '';
+        this._id = id;
+        if (label) {
+            this._label = label;
+        }
+        if (type) {
+            this.type = type;
+        }
+        this.runOptions = runOptions;
+        this.configurationProperties = configurationProperties;
+        this._source = source;
+    }
+    getDefinition(useSource) {
+        return undefined;
+    }
+    getMapKey() {
+        return this._id;
+    }
+    getRecentlyUsedKey() {
+        return undefined;
+    }
+    getCommonTaskId() {
+        const key = { folder: this.getFolderId(), id: this._id };
+        return JSON.stringify(key);
+    }
+    clone() {
+        return this.fromObject(Object.assign({}, this));
+    }
+    getWorkspaceFolder() {
+        return undefined;
+    }
+    getWorkspaceFileName() {
+        return undefined;
+    }
+    getTelemetryKind() {
+        return 'unknown';
+    }
+    matches(key, compareId = false) {
+        if (key === undefined) {
+            return false;
+        }
+        if (types.isString(key)) {
+            return key === this._label || key === this.configurationProperties.identifier || (compareId && key === this._id);
+        }
+        const identifier = this.getDefinition(true);
+        return identifier !== undefined && identifier._key === key._key;
+    }
+    getQualifiedLabel() {
+        const workspaceFolder = this.getWorkspaceFolder();
+        if (workspaceFolder) {
+            return `${this._label} (${workspaceFolder.name})`;
+        }
+        else {
+            return this._label;
+        }
+    }
+    getTaskExecution() {
+        const result = {
+            id: this._id,
+            task: this
+        };
+        return result;
+    }
+    addTaskLoadMessages(messages) {
+        if (this._taskLoadMessages === undefined) {
+            this._taskLoadMessages = [];
+        }
+        if (messages) {
+            this._taskLoadMessages = this._taskLoadMessages.concat(messages);
+        }
+    }
+    get taskLoadMessages() {
+        return this._taskLoadMessages;
+    }
+}
+class CustomTask extends CommonTask {
+    constructor(id, source, label, type, command, hasDefinedMatchers, runOptions, configurationProperties) {
+        super(id, label, undefined, runOptions, configurationProperties, source);
+        this.command = {};
+        this._source = source;
+        this.hasDefinedMatchers = hasDefinedMatchers;
+        if (command) {
+            this.command = command;
+        }
+    }
+    clone() {
+        return (
+             (new CustomTask(
+                this._id,
+                this._source,
+                this._label,
+                this.type,
+                this.command,
+                this.hasDefinedMatchers,
+                this.runOptions,
+                this.configurationProperties
+            ))
+        );
+    }
+    customizes() {
+        if (this._source && this._source.customizes) {
+            return this._source.customizes;
+        }
+        return undefined;
+    }
+    getDefinition(useSource = false) {
+        if (useSource && this._source.customizes !== undefined) {
+            return this._source.customizes;
+        }
+        else {
+            let type;
+            const commandRuntime = this.command ? this.command.runtime : undefined;
+            switch (commandRuntime) {
+                case RuntimeType.Shell:
+                    type = 'shell';
+                    break;
+                case RuntimeType.Process:
+                    type = 'process';
+                    break;
+                case RuntimeType.CustomExecution:
+                    type = 'customExecution';
+                    break;
+                case undefined:
+                    type = '$composite';
+                    break;
+                default:
+                    throw new Error('Unexpected task runtime');
+            }
+            const result = {
+                type,
+                _key: this._id,
+                id: this._id
+            };
+            return result;
+        }
+    }
+    static is(value) {
+        return value instanceof CustomTask;
+    }
+    getMapKey() {
+        const workspaceFolder = this._source.config.workspaceFolder;
+        return workspaceFolder ? `${( ( workspaceFolder.uri.toString()))}|${this._id}|${this.instance}` : `${this._id}|${this.instance}`;
+    }
+    getFolderId() {
+        return this._source.kind === TaskSourceKind.User ? USER_TASKS_GROUP_KEY : this._source.config.workspaceFolder?.uri.toString();
+    }
+    getCommonTaskId() {
+        return this._source.customizes ? super.getCommonTaskId() : (this.getRecentlyUsedKey() ?? super.getCommonTaskId());
+    }
+    getRecentlyUsedKey() {
+        const workspaceFolder = this.getFolderId();
+        if (!workspaceFolder) {
+            return undefined;
+        }
+        let id = this.configurationProperties.identifier;
+        if (this._source.kind !== TaskSourceKind.Workspace) {
+            id += this._source.kind;
+        }
+        const key = { type: CUSTOMIZED_TASK_TYPE, folder: workspaceFolder, id };
+        return JSON.stringify(key);
+    }
+    getWorkspaceFolder() {
+        return this._source.config.workspaceFolder;
+    }
+    getWorkspaceFileName() {
+        return (this._source.config.workspace && this._source.config.workspace.configuration) ? resources.basename(this._source.config.workspace.configuration) : undefined;
+    }
+    getTelemetryKind() {
+        if (this._source.customizes) {
+            return 'workspace>extension';
+        }
+        else {
+            return 'workspace';
+        }
+    }
+    fromObject(object) {
+        return (
+             (new CustomTask(
+                object._id,
+                object._source,
+                object._label,
+                object.type,
+                object.command,
+                object.hasDefinedMatchers,
+                object.runOptions,
+                object.configurationProperties
+            ))
+        );
+    }
+}
+class ConfiguringTask extends CommonTask {
+    constructor(id, source, label, type, configures, runOptions, configurationProperties) {
+        super(id, label, type, runOptions, configurationProperties, source);
+        this._source = source;
+        this.configures = configures;
+    }
+    static is(value) {
+        return value instanceof ConfiguringTask;
+    }
+    fromObject(object) {
+        return object;
+    }
+    getDefinition() {
+        return this.configures;
+    }
+    getWorkspaceFileName() {
+        return (this._source.config.workspace && this._source.config.workspace.configuration) ? resources.basename(this._source.config.workspace.configuration) : undefined;
+    }
+    getWorkspaceFolder() {
+        return this._source.config.workspaceFolder;
+    }
+    getFolderId() {
+        return this._source.kind === TaskSourceKind.User ? USER_TASKS_GROUP_KEY : this._source.config.workspaceFolder?.uri.toString();
+    }
+    getRecentlyUsedKey() {
+        const workspaceFolder = this.getFolderId();
+        if (!workspaceFolder) {
+            return undefined;
+        }
+        let id = this.configurationProperties.identifier;
+        if (this._source.kind !== TaskSourceKind.Workspace) {
+            id += this._source.kind;
+        }
+        const key = { type: CUSTOMIZED_TASK_TYPE, folder: workspaceFolder, id };
+        return JSON.stringify(key);
+    }
+}
+class ContributedTask extends CommonTask {
+    constructor(id, source, label, type, defines, command, hasDefinedMatchers, runOptions, configurationProperties) {
+        super(id, label, type, runOptions, configurationProperties, source);
+        this.defines = defines;
+        this.hasDefinedMatchers = hasDefinedMatchers;
+        this.command = command;
+        this.icon = configurationProperties.icon;
+        this.hide = configurationProperties.hide;
+    }
+    clone() {
+        return (
+             (new ContributedTask(
+                this._id,
+                this._source,
+                this._label,
+                this.type,
+                this.defines,
+                this.command,
+                this.hasDefinedMatchers,
+                this.runOptions,
+                this.configurationProperties
+            ))
+        );
+    }
+    getDefinition() {
+        return this.defines;
+    }
+    static is(value) {
+        return value instanceof ContributedTask;
+    }
+    getMapKey() {
+        const workspaceFolder = this._source.workspaceFolder;
+        return workspaceFolder
+            ? `${( ( this._source.scope.toString()))}|${( ( workspaceFolder.uri.toString()))}|${this._id}|${this.instance}`
+            : `${( ( this._source.scope.toString()))}|${this._id}|${this.instance}`;
+    }
+    getFolderId() {
+        if (this._source.scope === 3  && this._source.workspaceFolder) {
+            return (
+                 (this._source.workspaceFolder.uri.toString())
+            );
+        }
+        return undefined;
+    }
+    getRecentlyUsedKey() {
+        const key = { type: 'contributed', scope: this._source.scope, id: this._id };
+        key.folder = this.getFolderId();
+        return JSON.stringify(key);
+    }
+    getWorkspaceFolder() {
+        return this._source.workspaceFolder;
+    }
+    getTelemetryKind() {
+        return 'extension';
+    }
+    fromObject(object) {
+        return (
+             (new ContributedTask(
+                object._id,
+                object._source,
+                object._label,
+                object.type,
+                object.defines,
+                object.command,
+                object.hasDefinedMatchers,
+                object.runOptions,
+                object.configurationProperties
+            ))
+        );
+    }
+}
+export { CUSTOMIZED_TASK_TYPE, CommonTask, ConfiguringTask, ContributedTask, CustomTask, RuntimeType, TaskSourceKind, USER_TASKS_GROUP_KEY };

package/dist/vscode/vs/workbench/contrib/terminal/browser/terminal.js

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

package/dist/vscode/vs/workbench/contrib/terminal/browser/terminalIcon.js

@@ -0,0 +1,44 @@
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { ansiColorMap } from '../common/terminalColorRegistry.js';
+function getColorClass(terminalOrColorKey) {
+    let color = undefined;
+    if (typeof terminalOrColorKey === 'string') {
+        color = terminalOrColorKey;
+    }
+    else if (terminalOrColorKey.color) {
+        color = terminalOrColorKey.color.replace(/\./g, '_');
+    }
+    else if (ThemeIcon.isThemeIcon(terminalOrColorKey.icon) && terminalOrColorKey.icon.color) {
+        color = terminalOrColorKey.icon.color.id.replace(/\./g, '_');
+    }
+    if (color) {
+        return `terminal-icon-${color.replace(/\./g, '_')}`;
+    }
+    return undefined;
+}
+function getStandardColors(colorTheme) {
+    const standardColors = [];
+    for (const colorKey in ansiColorMap) {
+        const color = colorTheme.getColor(colorKey);
+        if (color && !colorKey.toLowerCase().includes('bright')) {
+            standardColors.push(colorKey);
+        }
+    }
+    return standardColors;
+}
+function getColorStyleElement(colorTheme) {
+    const standardColors = getStandardColors(colorTheme);
+    const styleElement = document.createElement('style');
+    let css = '';
+    for (const colorKey of standardColors) {
+        const colorClass = getColorClass(colorKey);
+        const color = colorTheme.getColor(colorKey);
+        if (color) {
+            css += (`.monaco-workbench .${colorClass} .codicon:first-child:not(.codicon-split-horizontal):not(.codicon-trashcan):not(.file-icon)` +
+                `{ color: ${color} !important; }`);
+        }
+    }
+    styleElement.textContent = css;
+    return styleElement;
+}
+export { getColorClass, getColorStyleElement, getStandardColors };

package/dist/vscode/vs/workbench/contrib/terminal/common/terminalColorRegistry.js

@@ -164,4 +164,150 @@ registerColor('terminal.tab.activeBorder', {
     'terminal.tab.activeBorder',
     'Border on the side of the terminal tab in the panel. This defaults to tab.activeBorder.'
 )));
-export { TERMINAL_SELECTION_BACKGROUND_COLOR, ansiColorIdentifiers };
+const ansiColorMap = {
+    'terminal.ansiBlack': {
+        index: 0,
+        defaults: {
+            light: '#000000',
+            dark: '#000000',
+            hcDark: '#000000',
+            hcLight: '#292929'
+        }
+    },
+    'terminal.ansiRed': {
+        index: 1,
+        defaults: {
+            light: '#cd3131',
+            dark: '#cd3131',
+            hcDark: '#cd0000',
+            hcLight: '#cd3131'
+        }
+    },
+    'terminal.ansiGreen': {
+        index: 2,
+        defaults: {
+            light: '#00BC00',
+            dark: '#0DBC79',
+            hcDark: '#00cd00',
+            hcLight: '#00bc00'
+        }
+    },
+    'terminal.ansiYellow': {
+        index: 3,
+        defaults: {
+            light: '#949800',
+            dark: '#e5e510',
+            hcDark: '#cdcd00',
+            hcLight: '#949800'
+        }
+    },
+    'terminal.ansiBlue': {
+        index: 4,
+        defaults: {
+            light: '#0451a5',
+            dark: '#2472c8',
+            hcDark: '#0000ee',
+            hcLight: '#0451a5'
+        }
+    },
+    'terminal.ansiMagenta': {
+        index: 5,
+        defaults: {
+            light: '#bc05bc',
+            dark: '#bc3fbc',
+            hcDark: '#cd00cd',
+            hcLight: '#bc05bc'
+        }
+    },
+    'terminal.ansiCyan': {
+        index: 6,
+        defaults: {
+            light: '#0598bc',
+            dark: '#11a8cd',
+            hcDark: '#00cdcd',
+            hcLight: '#0598bc'
+        }
+    },
+    'terminal.ansiWhite': {
+        index: 7,
+        defaults: {
+            light: '#555555',
+            dark: '#e5e5e5',
+            hcDark: '#e5e5e5',
+            hcLight: '#555555'
+        }
+    },
+    'terminal.ansiBrightBlack': {
+        index: 8,
+        defaults: {
+            light: '#666666',
+            dark: '#666666',
+            hcDark: '#7f7f7f',
+            hcLight: '#666666'
+        }
+    },
+    'terminal.ansiBrightRed': {
+        index: 9,
+        defaults: {
+            light: '#cd3131',
+            dark: '#f14c4c',
+            hcDark: '#ff0000',
+            hcLight: '#cd3131'
+        }
+    },
+    'terminal.ansiBrightGreen': {
+        index: 10,
+        defaults: {
+            light: '#14CE14',
+            dark: '#23d18b',
+            hcDark: '#00ff00',
+            hcLight: '#00bc00'
+        }
+    },
+    'terminal.ansiBrightYellow': {
+        index: 11,
+        defaults: {
+            light: '#b5ba00',
+            dark: '#f5f543',
+            hcDark: '#ffff00',
+            hcLight: '#b5ba00'
+        }
+    },
+    'terminal.ansiBrightBlue': {
+        index: 12,
+        defaults: {
+            light: '#0451a5',
+            dark: '#3b8eea',
+            hcDark: '#5c5cff',
+            hcLight: '#0451a5'
+        }
+    },
+    'terminal.ansiBrightMagenta': {
+        index: 13,
+        defaults: {
+            light: '#bc05bc',
+            dark: '#d670d6',
+            hcDark: '#ff00ff',
+            hcLight: '#bc05bc'
+        }
+    },
+    'terminal.ansiBrightCyan': {
+        index: 14,
+        defaults: {
+            light: '#0598bc',
+            dark: '#29b8db',
+            hcDark: '#00ffff',
+            hcLight: '#0598bc'
+        }
+    },
+    'terminal.ansiBrightWhite': {
+        index: 15,
+        defaults: {
+            light: '#a5a5a5',
+            dark: '#e5e5e5',
+            hcDark: '#ffffff',
+            hcLight: '#a5a5a5'
+        }
+    }
+};
+export { TERMINAL_SELECTION_BACKGROUND_COLOR, ansiColorIdentifiers, ansiColorMap };

package/dist/vscode/vs/workbench/contrib/typeHierarchy/browser/media/typeHierarchy.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../node_modules/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-workbench .type-hierarchy .message,.monaco-workbench .type-hierarchy .results{display:none}.monaco-workbench .type-hierarchy[data-state=data] .results{display:inherit;height:100%}.monaco-workbench .type-hierarchy[data-state=message] .message{align-items:center;display:flex;height:100%;justify-content:center}.monaco-workbench .type-hierarchy .editor,.monaco-workbench .type-hierarchy .tree{height:100%}.monaco-editor .type-hierarchy .tree{background-color:var(--vscode-peekViewResult-background);color:var(--vscode-peekViewResult-fileForeground)}.monaco-editor .type-hierarchy .tree .monaco-list:focus .monaco-list-rows>.monaco-list-row.selected:not(.highlighted){background-color:var(--vscode-peekViewResult-selectionBackground);color:var(--vscode-peekViewResult-selectionForeground)!important}.monaco-workbench .type-hierarchy .tree .typehierarchy-element{align-items:center;display:flex;flex:1;flex-flow:row nowrap}.monaco-workbench .type-hierarchy .tree .typehierarchy-element .monaco-icon-label{padding-left:4px}.monaco-editor .type-hierarchy .type-decoration{background-color:var(--vscode-peekViewEditor-matchHighlightBackground);border:2px solid var(--vscode-peekViewEditor-matchHighlightBorder);box-sizing:border-box}.monaco-editor .type-hierarchy .editor .monaco-editor .inputarea.ime-input,.monaco-editor .type-hierarchy .editor .monaco-editor .monaco-editor-background{background-color:var(--vscode-peekViewEditor-background)}.monaco-editor .type-hierarchy .editor .monaco-editor .margin{background-color:var(--vscode-peekViewEditorGutter-background)}";
+n(css,{});
+export { css, css as default };

package/dist/vscode/vs/workbench/contrib/typeHierarchy/browser/typeHierarchyPeek.js

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
-import "../../../../../../assets/typeHierarchy.css";
+import './media/typeHierarchy.css.js';
 import { Dimension } from 'monaco-editor/esm/vs/base/browser/dom.js';
 import { SplitView, Sizing } from 'monaco-editor/esm/vs/base/browser/ui/splitview/splitview.js';
 import { TreeMouseEventTarget } from 'monaco-editor/esm/vs/base/browser/ui/tree/tree.js';

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

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