@codingame/monaco-vscode-api 1.85.5 → 2.0.0-rework-ci.1

package/vscode/src/vs/platform/quickinput/browser/quickInputService.js

@@ -0,0 +1,178 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { CancellationToken } from '../../../base/common/cancellation.js';
+import { Emitter } from '../../../base/common/event.js';
+import { RawContextKey, IContextKeyService } from '../../contextkey/common/contextkey.js';
+import { IInstantiationService } from '../../instantiation/common/instantiation.js';
+import { ILayoutService } from '../../layout/browser/layoutService.js';
+import { WorkbenchList } from '../../list/browser/listService.js';
+import { IOpenerService } from '../../opener/common/opener.js';
+import { QuickAccessController } from './quickAccess.js';
+import { defaultInputBoxStyles, defaultToggleStyles, defaultCountBadgeStyles, defaultButtonStyles, defaultProgressBarStyles, defaultKeybindingLabelStyles, getListStyles } from '../../theme/browser/defaultStyles.js';
+import { asCssVariable, quickInputBackground, quickInputForeground, quickInputTitleBackground, widgetBorder, widgetShadow, quickInputListFocusBackground, quickInputListFocusForeground, quickInputListFocusIconForeground, activeContrastBorder, pickerGroupBorder, pickerGroupForeground } from '../../theme/common/colorRegistry.js';
+import { Themable, IThemeService } from '../../theme/common/themeService.js';
+import { QuickInputController } from './quickInputController.js';
+let QuickInputService = class QuickInputService extends Themable {
+    get backButton() { return this.controller.backButton; }
+    get controller() {
+        if (!this._controller) {
+            this._controller = this._register(this.createController());
+        }
+        return this._controller;
+    }
+    get hasController() { return !!this._controller; }
+    get quickAccess() {
+        if (!this._quickAccess) {
+            this._quickAccess = this._register(this.instantiationService.createInstance(QuickAccessController));
+        }
+        return this._quickAccess;
+    }
+    constructor(instantiationService, contextKeyService, themeService, layoutService) {
+        super(themeService);
+        this.instantiationService = instantiationService;
+        this.contextKeyService = contextKeyService;
+        this.layoutService = layoutService;
+        this._onShow = this._register(( new Emitter()));
+        this.onShow = this._onShow.event;
+        this._onHide = this._register(( new Emitter()));
+        this.onHide = this._onHide.event;
+        this.contexts = ( new Map());
+    }
+    createController(host = this.layoutService, options) {
+        const defaultOptions = {
+            idPrefix: 'quickInput_',
+            container: host.activeContainer,
+            ignoreFocusOut: () => false,
+            backKeybindingLabel: () => undefined,
+            setContextKey: (id) => this.setContextKey(id),
+            linkOpenerDelegate: (content) => {
+                this.instantiationService.invokeFunction(accessor => {
+                    const openerService = accessor.get(IOpenerService);
+                    openerService.open(content, { allowCommands: true, fromUserGesture: true });
+                });
+            },
+            returnFocus: () => host.focus(),
+            createList: (user, container, delegate, renderers, options) => this.instantiationService.createInstance(WorkbenchList, user, container, delegate, renderers, options),
+            styles: this.computeStyles()
+        };
+        const controller = this._register(( new QuickInputController({
+            ...defaultOptions,
+            ...options
+        }, this.themeService, this.layoutService)));
+        controller.layout(host.activeContainerDimension, host.activeContainerOffset.quickPickTop);
+        this._register(host.onDidLayoutActiveContainer(dimension => controller.layout(dimension, host.activeContainerOffset.quickPickTop)));
+        this._register(host.onDidChangeActiveContainer(() => {
+            if (controller.isVisible()) {
+                return;
+            }
+            controller.layout(host.activeContainerDimension, host.activeContainerOffset.quickPickTop);
+        }));
+        this._register(controller.onShow(() => {
+            this.resetContextKeys();
+            this._onShow.fire();
+        }));
+        this._register(controller.onHide(() => {
+            this.resetContextKeys();
+            this._onHide.fire();
+        }));
+        return controller;
+    }
+    setContextKey(id) {
+        let key;
+        if (id) {
+            key = this.contexts.get(id);
+            if (!key) {
+                key = ( new RawContextKey(id, false))
+                    .bindTo(this.contextKeyService);
+                this.contexts.set(id, key);
+            }
+        }
+        if (key && key.get()) {
+            return;
+        }
+        this.resetContextKeys();
+        key?.set(true);
+    }
+    resetContextKeys() {
+        this.contexts.forEach(context => {
+            if (context.get()) {
+                context.reset();
+            }
+        });
+    }
+    pick(picks, options = {}, token = CancellationToken.None) {
+        return this.controller.pick(picks, options, token);
+    }
+    input(options = {}, token = CancellationToken.None) {
+        return this.controller.input(options, token);
+    }
+    createQuickPick() {
+        return this.controller.createQuickPick();
+    }
+    createInputBox() {
+        return this.controller.createInputBox();
+    }
+    createQuickWidget() {
+        return this.controller.createQuickWidget();
+    }
+    focus() {
+        this.controller.focus();
+    }
+    toggle() {
+        this.controller.toggle();
+    }
+    navigate(next, quickNavigate) {
+        this.controller.navigate(next, quickNavigate);
+    }
+    accept(keyMods) {
+        return this.controller.accept(keyMods);
+    }
+    back() {
+        return this.controller.back();
+    }
+    cancel() {
+        return this.controller.cancel();
+    }
+    updateStyles() {
+        if (this.hasController) {
+            this.controller.applyStyles(this.computeStyles());
+        }
+    }
+    computeStyles() {
+        return {
+            widget: {
+                quickInputBackground: asCssVariable(quickInputBackground),
+                quickInputForeground: asCssVariable(quickInputForeground),
+                quickInputTitleBackground: asCssVariable(quickInputTitleBackground),
+                widgetBorder: asCssVariable(widgetBorder),
+                widgetShadow: asCssVariable(widgetShadow),
+            },
+            inputBox: defaultInputBoxStyles,
+            toggle: defaultToggleStyles,
+            countBadge: defaultCountBadgeStyles,
+            button: defaultButtonStyles,
+            progressBar: defaultProgressBarStyles,
+            keybindingLabel: defaultKeybindingLabelStyles,
+            list: getListStyles({
+                listBackground: quickInputBackground,
+                listFocusBackground: quickInputListFocusBackground,
+                listFocusForeground: quickInputListFocusForeground,
+                listInactiveFocusForeground: quickInputListFocusForeground,
+                listInactiveSelectionIconForeground: quickInputListFocusIconForeground,
+                listInactiveFocusBackground: quickInputListFocusBackground,
+                listFocusOutline: activeContrastBorder,
+                listInactiveFocusOutline: activeContrastBorder,
+            }),
+            pickerGroup: {
+                pickerGroupBorder: asCssVariable(pickerGroupBorder),
+                pickerGroupForeground: asCssVariable(pickerGroupForeground),
+            }
+        };
+    }
+};
+QuickInputService = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IContextKeyService)),
+    ( __param(2, IThemeService)),
+    ( __param(3, ILayoutService))
+], QuickInputService));
+export { QuickInputService };

package/vscode/src/vs/platform/quickinput/browser/quickInputUtils.js

@@ -0,0 +1,72 @@
+import { createCSSRule, asCSSUrl, reset, $, EventType, isEventLike, EventHelper } from '../../../base/browser/dom.js';
+import { DomEmitter } from '../../../base/browser/event.js';
+import { Event } from '../../../base/common/event.js';
+import { StandardKeyboardEvent } from '../../../base/browser/keyboardEvent.js';
+import { Gesture, EventType as EventType$1 } from '../../../base/browser/touch.js';
+import { renderLabelWithIcons } from '../../../base/browser/ui/iconLabel/iconLabels.js';
+import { IdGenerator } from '../../../base/common/idGenerator.js';
+import { parseLinkedText } from '../../../base/common/linkedText.js';
+import './media/quickInput.css.js';
+import { localizeWithPath } from '../../../nls.js';
+const iconPathToClass = {};
+const iconClassGenerator = ( new IdGenerator('quick-input-button-icon-'));
+function getIconClass(iconPath) {
+    if (!iconPath) {
+        return undefined;
+    }
+    let iconClass;
+    const key = ( iconPath.dark.toString());
+    if (iconPathToClass[key]) {
+        iconClass = iconPathToClass[key];
+    }
+    else {
+        iconClass = iconClassGenerator.nextId();
+        createCSSRule(`.${iconClass}, .hc-light .${iconClass}`, `background-image: ${asCSSUrl(iconPath.light || iconPath.dark)}`);
+        createCSSRule(`.vs-dark .${iconClass}, .hc-black .${iconClass}`, `background-image: ${asCSSUrl(iconPath.dark)}`);
+        iconPathToClass[key] = iconClass;
+    }
+    return iconClass;
+}
+function renderQuickInputDescription(description, container, actionHandler) {
+    reset(container);
+    const parsed = parseLinkedText(description);
+    let tabIndex = 0;
+    for (const node of parsed.nodes) {
+        if (typeof node === 'string') {
+            container.append(...renderLabelWithIcons(node));
+        }
+        else {
+            let title = node.title;
+            if (!title && node.href.startsWith('command:')) {
+                title = ( localizeWithPath(
+                    'vs/platform/quickinput/browser/quickInputUtils',
+                    'executeCommand',
+                    "Click to execute command '{0}'",
+                    node.href.substring('command:'.length)
+                ));
+            }
+            else if (!title) {
+                title = node.href;
+            }
+            const anchor = $('a', { href: node.href, title, tabIndex: tabIndex++ }, node.label);
+            anchor.style.textDecoration = 'underline';
+            const handleOpen = (e) => {
+                if (isEventLike(e)) {
+                    EventHelper.stop(e, true);
+                }
+                actionHandler.callback(node.href);
+            };
+            const onClick = actionHandler.disposables.add(( new DomEmitter(anchor, EventType.CLICK))).event;
+            const onKeydown = actionHandler.disposables.add(( new DomEmitter(anchor, EventType.KEY_DOWN))).event;
+            const onSpaceOrEnter = Event.chain(onKeydown, $ => $.filter(e => {
+                const event = ( new StandardKeyboardEvent(e));
+                return event.equals(10 ) || event.equals(3 );
+            }));
+            actionHandler.disposables.add(Gesture.addTarget(anchor));
+            const onTap = actionHandler.disposables.add(( new DomEmitter(anchor, EventType$1.Tap))).event;
+            Event.any(onClick, onTap, onSpaceOrEnter)(handleOpen, null, actionHandler.disposables);
+            container.appendChild(anchor);
+        }
+    }
+}
+export { getIconClass, renderQuickInputDescription };

package/vscode/src/vs/platform/quickinput/browser/quickPickPin.js

@@ -1,6 +1,6 @@
-import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
-import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
-import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { Codicon } from '../../../base/common/codicons.js';
+import { localizeWithPath } from '../../../nls.js';
+import { ThemeIcon } from '../../../base/common/themables.js';
 const pinButtonClass = ThemeIcon.asClassName(Codicon.pin);
 const pinnedButtonClass = ThemeIcon.asClassName(Codicon.pinned);
 const buttonClasses = [pinButtonClass, pinnedButtonClass];

package/vscode/src/vs/platform/quickinput/common/quickAccess.js

@@ -0,0 +1,51 @@
+import { coalesce } from '../../../base/common/arrays.js';
+import { toDisposable } from '../../../base/common/lifecycle.js';
+import { Registry } from '../../registry/common/platform.js';
+var DefaultQuickAccessFilterValue;
+( (function(DefaultQuickAccessFilterValue) {
+    DefaultQuickAccessFilterValue[DefaultQuickAccessFilterValue["PRESERVE"] = 0] = "PRESERVE";
+    DefaultQuickAccessFilterValue[DefaultQuickAccessFilterValue["LAST"] = 1] = "LAST";
+})(DefaultQuickAccessFilterValue || (DefaultQuickAccessFilterValue = {})));
+const Extensions = {
+    Quickaccess: 'workbench.contributions.quickaccess'
+};
+class QuickAccessRegistry {
+    constructor() {
+        this.providers = [];
+        this.defaultProvider = undefined;
+    }
+    registerQuickAccessProvider(provider) {
+        if (provider.prefix.length === 0) {
+            this.defaultProvider = provider;
+        }
+        else {
+            this.providers.push(provider);
+        }
+        this.providers.sort((providerA, providerB) => providerB.prefix.length - providerA.prefix.length);
+        return toDisposable(() => {
+            this.providers.splice(this.providers.indexOf(provider), 1);
+            if (this.defaultProvider === provider) {
+                this.defaultProvider = undefined;
+            }
+        });
+    }
+    getQuickAccessProviders() {
+        return coalesce([this.defaultProvider, ...this.providers]);
+    }
+    getQuickAccessProvider(prefix) {
+        const result = prefix ? (this.providers.find(provider => prefix.startsWith(provider.prefix)) || undefined) : undefined;
+        return result || this.defaultProvider;
+    }
+    clear() {
+        const providers = [...this.providers];
+        const defaultProvider = this.defaultProvider;
+        this.providers = [];
+        this.defaultProvider = undefined;
+        return () => {
+            this.providers = providers;
+            this.defaultProvider = defaultProvider;
+        };
+    }
+}
+Registry.add(Extensions.Quickaccess, ( new QuickAccessRegistry()));
+export { DefaultQuickAccessFilterValue, Extensions, QuickAccessRegistry };

package/vscode/src/vs/platform/quickinput/common/quickInput.js

@@ -0,0 +1,42 @@
+import { createDecorator } from '../../instantiation/common/instantiation.js';
+import { Schemas } from '../../../base/common/network.js';
+const NO_KEY_MODS = { ctrlCmd: false, alt: false };
+var QuickInputHideReason;
+( (function(QuickInputHideReason) {
+    QuickInputHideReason[QuickInputHideReason["Blur"] = 1] = "Blur";
+    QuickInputHideReason[QuickInputHideReason["Gesture"] = 2] = "Gesture";
+    QuickInputHideReason[QuickInputHideReason["Other"] = 3] = "Other";
+})(QuickInputHideReason || (QuickInputHideReason = {})));
+var ItemActivation;
+( (function(ItemActivation) {
+    ItemActivation[ItemActivation["NONE"] = 0] = "NONE";
+    ItemActivation[ItemActivation["FIRST"] = 1] = "FIRST";
+    ItemActivation[ItemActivation["SECOND"] = 2] = "SECOND";
+    ItemActivation[ItemActivation["LAST"] = 3] = "LAST";
+})(ItemActivation || (ItemActivation = {})));
+class QuickPickItemScorerAccessor {
+    constructor(options) {
+        this.options = options;
+    }
+    getItemLabel(entry) {
+        return entry.label;
+    }
+    getItemDescription(entry) {
+        if (this.options?.skipDescription) {
+            return undefined;
+        }
+        return entry.description;
+    }
+    getItemPath(entry) {
+        if (this.options?.skipPath) {
+            return undefined;
+        }
+        if (entry.resource?.scheme === Schemas.file) {
+            return entry.resource.fsPath;
+        }
+        return entry.resource?.path;
+    }
+}
+const quickPickItemScorerAccessor = ( new QuickPickItemScorerAccessor());
+const IQuickInputService = ( createDecorator('quickInputService'));
+export { IQuickInputService, ItemActivation, NO_KEY_MODS, QuickInputHideReason, QuickPickItemScorerAccessor, quickPickItemScorerAccessor };

package/vscode/src/vs/platform/registry/common/platform.js

@@ -0,0 +1,21 @@
+import { ok } from '../../../base/common/assert.js';
+import { isString, isObject } from '../../../base/common/types.js';
+class RegistryImpl {
+    constructor() {
+        this.data = ( new Map());
+    }
+    add(id, data) {
+        ok(isString(id));
+        ok(isObject(data));
+        ok(!( this.data.has(id)), 'There is already an extension with this id');
+        this.data.set(id, data);
+    }
+    knows(id) {
+        return ( this.data.has(id));
+    }
+    as(id) {
+        return this.data.get(id) || null;
+    }
+}
+const Registry = ( new RegistryImpl());
+export { Registry };

package/vscode/src/vs/platform/remote/common/remoteAgentConnection.js

@@ -1,15 +1,15 @@
-import { createCancelablePromise } from 'monaco-editor/esm/vs/base/common/async.js';
-import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
-import { CancellationTokenSource, CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
-import { isCancellationError, onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Disposable, toDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import * as performance from 'monaco-editor/esm/vs/base/common/performance.js';
-import { StopWatch } from 'monaco-editor/esm/vs/base/common/stopwatch.js';
-import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
+import { createCancelablePromise } from '../../../base/common/async.js';
+import { VSBuffer } from '../../../base/common/buffer.js';
+import { CancellationTokenSource, CancellationToken } from '../../../base/common/cancellation.js';
+import { isCancellationError, onUnexpectedError } from '../../../base/common/errors.js';
+import { Emitter } from '../../../base/common/event.js';
+import { Disposable, toDisposable, DisposableStore } from '../../../base/common/lifecycle.js';
+import { mark } from '../../../base/common/performance.js';
+import { StopWatch } from '../../../base/common/stopwatch.js';
+import { generateUuid } from '../../../base/common/uuid.js';
 import { Client, PersistentProtocol } from '../../../base/parts/ipc/common/ipc.net.js';
 import { RemoteAuthorityResolverError } from './remoteAuthorityResolver.js';
-import { getRemoteServerRootPath } from 'monaco-editor/esm/vs/platform/remote/common/remoteHosts.js';
+import { getRemoteServerRootPath } from './remoteHosts.js';
 const RECONNECT_TIMEOUT = 30 * 1000 ;
 function connectionTypeToString(connectionType) {
     switch (connectionType) {
@@ -110,20 +110,20 @@ function createSocket(logService, remoteSocketFactoryService, connectTo, path, q
     const result = ( new PromiseWithTimeout(timeoutCancellationToken));
     const sw = StopWatch.create(false);
     logService.info(`Creating a socket (${debugLabel})...`);
-    performance.mark(`code/willCreateSocket/${debugConnectionType}`);
+    mark(`code/willCreateSocket/${debugConnectionType}`);
     remoteSocketFactoryService.connect(connectTo, path, query, debugLabel).then((socket) => {
         if (result.didTimeout) {
-            performance.mark(`code/didCreateSocketError/${debugConnectionType}`);
+            mark(`code/didCreateSocketError/${debugConnectionType}`);
             logService.info(`Creating a socket (${debugLabel}) finished after ${sw.elapsed()} ms, but this is too late and has timed out already.`);
             socket?.dispose();
         }
         else {
-            performance.mark(`code/didCreateSocketOK/${debugConnectionType}`);
+            mark(`code/didCreateSocketOK/${debugConnectionType}`);
             logService.info(`Creating a socket (${debugLabel}) was successful after ${sw.elapsed()} ms.`);
             result.resolve(socket);
         }
     }, (err) => {
-        performance.mark(`code/didCreateSocketError/${debugConnectionType}`);
+        mark(`code/didCreateSocketError/${debugConnectionType}`);
         logService.info(`Creating a socket (${debugLabel}) returned an error after ${sw.elapsed()} ms.`);
         logService.error(err);
         result.reject(err);

package/vscode/src/vs/platform/remote/common/remoteAuthorityResolver.js

@@ -1,5 +1,5 @@
-import { ErrorNoTelemetry } from 'monaco-editor/esm/vs/base/common/errors.js';
-import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ErrorNoTelemetry } from '../../../base/common/errors.js';
+import { createDecorator } from '../../instantiation/common/instantiation.js';
 const IRemoteAuthorityResolverService = ( createDecorator('remoteAuthorityResolverService'));
 class ManagedRemoteConnection {
     constructor(id) {

package/vscode/src/vs/platform/remote/common/remoteExtensionsScanner.js

@@ -1,4 +1,4 @@
-import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { createDecorator } from '../../instantiation/common/instantiation.js';
 const IRemoteExtensionsScannerService = ( createDecorator('IRemoteExtensionsScannerService'));
 const RemoteExtensionsScannerChannelName = 'remoteExtensionsScanner';
 export { IRemoteExtensionsScannerService, RemoteExtensionsScannerChannelName };

package/vscode/src/vs/platform/remote/common/remoteHosts.js

@@ -0,0 +1,40 @@
+import { Schemas } from '../../../base/common/network.js';
+function getRemoteAuthority(uri) {
+    return uri.scheme === Schemas.vscodeRemote ? uri.authority : undefined;
+}
+function getRemoteName(authority) {
+    if (!authority) {
+        return undefined;
+    }
+    const pos = authority.indexOf('+');
+    if (pos < 0) {
+        return authority;
+    }
+    return authority.substr(0, pos);
+}
+function getRemoteServerRootPath(product) {
+    return `/${product.quality ?? 'oss'}-${product.commit ?? 'dev'}`;
+}
+function parseAuthorityWithOptionalPort(authority, defaultPort) {
+    let { host, port } = parseAuthority(authority);
+    if (typeof port === 'undefined') {
+        port = defaultPort;
+    }
+    return { host, port };
+}
+function parseAuthority(authority) {
+    const m1 = authority.match(/^(\[[0-9a-z:]+\]):(\d+)$/);
+    if (m1) {
+        return { host: m1[1], port: parseInt(m1[2], 10) };
+    }
+    const m2 = authority.match(/^(\[[0-9a-z:]+\])$/);
+    if (m2) {
+        return { host: m2[1], port: undefined };
+    }
+    const m3 = authority.match(/(.*):(\d+)$/);
+    if (m3) {
+        return { host: m3[1], port: parseInt(m3[2], 10) };
+    }
+    return { host: authority, port: undefined };
+}
+export { getRemoteAuthority, getRemoteName, getRemoteServerRootPath, parseAuthorityWithOptionalPort };

package/vscode/src/vs/platform/remote/common/remoteSocketFactoryService.js

@@ -1,5 +1,5 @@
-import { toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { toDisposable } from '../../../base/common/lifecycle.js';
+import { createDecorator } from '../../instantiation/common/instantiation.js';
 const IRemoteSocketFactoryService = ( createDecorator('remoteSocketFactoryService'));
 class RemoteSocketFactoryService {
     constructor() {

package/vscode/src/vs/platform/request/common/request.js

@@ -1,9 +1,9 @@
-import { streamToBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
-import { getErrorMessage } from 'monaco-editor/esm/vs/base/common/errors.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
-import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { CONTEXT_LOG_LEVEL, LogLevelToString, LogLevel } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { streamToBuffer } from '../../../base/common/buffer.js';
+import { getErrorMessage } from '../../../base/common/errors.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { localizeWithPath } from '../../../nls.js';
+import { createDecorator } from '../../instantiation/common/instantiation.js';
+import { CONTEXT_LOG_LEVEL, LogLevelToString, LogLevel } from '../../log/common/log.js';
 const IRequestService = ( createDecorator('requestService'));
 class LoggableHeaders {
     constructor(original) {

package/vscode/src/vs/platform/secrets/common/secrets.js

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

package/vscode/src/vs/platform/severityIcon/browser/media/severityIcon.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".extension-editor .codicon.codicon-error,.extensions-viewlet>.extensions .codicon.codicon-error,.markers-panel .marker-icon .codicon.codicon-error,.markers-panel .marker-icon.error,.monaco-editor .zone-widget .codicon.codicon-error,.preferences-editor .codicon.codicon-error,.text-search-provider-messages .providerMessage .codicon.codicon-error{color:var(--vscode-problemsErrorIcon-foreground)}.extension-editor .codicon.codicon-warning,.extensions-viewlet>.extensions .codicon.codicon-warning,.markers-panel .marker-icon .codicon.codicon-warning,.markers-panel .marker-icon.warning,.monaco-editor .zone-widget .codicon.codicon-warning,.preferences-editor .codicon.codicon-warning,.text-search-provider-messages .providerMessage .codicon.codicon-warning{color:var(--vscode-problemsWarningIcon-foreground)}.extension-editor .codicon.codicon-info,.extensions-viewlet>.extensions .codicon.codicon-info,.markers-panel .marker-icon .codicon.codicon-info,.markers-panel .marker-icon.info,.monaco-editor .zone-widget .codicon.codicon-info,.preferences-editor .codicon.codicon-info,.text-search-provider-messages .providerMessage .codicon.codicon-info{color:var(--vscode-problemsInfoIcon-foreground)}";
+n(css,{});
+export { css, css as default };

package/vscode/src/vs/platform/severityIcon/browser/severityIcon.js

@@ -0,0 +1,23 @@
+import './media/severityIcon.css.js';
+import { Codicon } from '../../../base/common/codicons.js';
+import { ThemeIcon } from '../../../base/common/themables.js';
+import Severity from '../../../base/common/severity.js';
+var SeverityIcon;
+( (function(SeverityIcon) {
+    function className(severity) {
+        switch (severity) {
+            case Severity.Ignore:
+                return 'severity-ignore ' + ThemeIcon.asClassName(Codicon.info);
+            case Severity.Info:
+                return ThemeIcon.asClassName(Codicon.info);
+            case Severity.Warning:
+                return ThemeIcon.asClassName(Codicon.warning);
+            case Severity.Error:
+                return ThemeIcon.asClassName(Codicon.error);
+            default:
+                return '';
+        }
+    }
+    SeverityIcon.className = className;
+})(SeverityIcon || (SeverityIcon = {})));
+export { SeverityIcon };

package/vscode/src/vs/platform/sign/common/sign.js

@@ -1,4 +1,4 @@
-import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { createDecorator } from '../../instantiation/common/instantiation.js';
 const SIGN_SERVICE_ID = 'signService';
 const ISignService = ( createDecorator(SIGN_SERVICE_ID));
 export { ISignService, SIGN_SERVICE_ID };

package/vscode/src/vs/platform/storage/common/storage.js

@@ -1,11 +1,14 @@
-import { RunOnceScheduler, runWhenGlobalIdle, Promises } from 'monaco-editor/esm/vs/base/common/async.js';
-import { PauseableEmitter, Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Disposable, MutableDisposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { mark } from 'monaco-editor/esm/vs/base/common/performance.js';
-import { isUndefinedOrNull } from 'monaco-editor/esm/vs/base/common/types.js';
-import { isUserDataProfile } from 'monaco-editor/esm/vs/platform/userDataProfile/common/userDataProfile.js';
+import { RunOnceScheduler, runWhenGlobalIdle, Promises } from '../../../base/common/async.js';
+import { PauseableEmitter, Emitter, Event } from '../../../base/common/event.js';
+import { Disposable, MutableDisposable, dispose } from '../../../base/common/lifecycle.js';
+import { mark } from '../../../base/common/performance.js';
+import { isUndefinedOrNull } from '../../../base/common/types.js';
+import { Storage, InMemoryStorageDatabase, StorageHint } from '../../../base/parts/storage/common/storage.js';
+import { createDecorator } from '../../instantiation/common/instantiation.js';
+import { isUserDataProfile } from '../../userDataProfile/common/userDataProfile.js';
 const IS_NEW_KEY = '__$__isNewStorageMarker';
 const TARGET_KEY = '__$__targetStorageMarker';
+const IStorageService = ( createDecorator('storageService'));
 var WillSaveStateReason;
 ( (function(WillSaveStateReason) {
     WillSaveStateReason[WillSaveStateReason["NONE"] = 0] = "NONE";
@@ -280,6 +283,48 @@ class AbstractStorageService extends Disposable {
 function isProfileUsingDefaultStorage(profile) {
     return profile.isDefault || !!profile.useDefaultFlags?.globalState;
 }
+class InMemoryStorageService extends AbstractStorageService {
+    constructor() {
+        super();
+        this.applicationStorage = this._register(( new Storage(( new InMemoryStorageDatabase()), { hint: StorageHint.STORAGE_IN_MEMORY })));
+        this.profileStorage = this._register(( new Storage(( new InMemoryStorageDatabase()), { hint: StorageHint.STORAGE_IN_MEMORY })));
+        this.workspaceStorage = this._register(( new Storage(( new InMemoryStorageDatabase()), { hint: StorageHint.STORAGE_IN_MEMORY })));
+        this._register(this.workspaceStorage.onDidChangeStorage(e => this.emitDidChangeValue(1 , e)));
+        this._register(this.profileStorage.onDidChangeStorage(e => this.emitDidChangeValue(0 , e)));
+        this._register(this.applicationStorage.onDidChangeStorage(e => this.emitDidChangeValue(-1 , e)));
+    }
+    getStorage(scope) {
+        switch (scope) {
+            case -1 :
+                return this.applicationStorage;
+            case 0 :
+                return this.profileStorage;
+            default:
+                return this.workspaceStorage;
+        }
+    }
+    getLogDetails(scope) {
+        switch (scope) {
+            case -1 :
+                return 'inMemory (application)';
+            case 0 :
+                return 'inMemory (profile)';
+            default:
+                return 'inMemory (workspace)';
+        }
+    }
+    async doInitialize() { }
+    async switchToProfile() {
+    }
+    async switchToWorkspace() {
+    }
+    shouldFlushWhenIdle() {
+        return false;
+    }
+    hasScope(scope) {
+        return false;
+    }
+}
 async function logStorage(application, profile, workspace, applicationPath, profilePath, workspacePath) {
     const safeParse = (value) => {
         try {
@@ -339,4 +384,4 @@ async function logStorage(application, profile, workspace, applicationPath, prof
     console.groupEnd();
     console.log(workspaceItemsParsed);
 }
-export { AbstractStorageService, IS_NEW_KEY, StorageScope, StorageTarget, TARGET_KEY, WillSaveStateReason, isProfileUsingDefaultStorage, loadKeyTargets, logStorage };
+export { AbstractStorageService, IS_NEW_KEY, IStorageService, InMemoryStorageService, StorageScope, StorageTarget, TARGET_KEY, WillSaveStateReason, isProfileUsingDefaultStorage, loadKeyTargets, logStorage };

package/vscode/src/vs/platform/telemetry/common/telemetry.js

@@ -0,0 +1,8 @@
+import { createDecorator } from '../../instantiation/common/instantiation.js';
+const ITelemetryService = ( createDecorator('telemetryService'));
+const ICustomEndpointTelemetryService = ( createDecorator('customEndpointTelemetryService'));
+const firstSessionDateStorageKey = 'telemetry.firstSessionDate';
+const TELEMETRY_SETTING_ID = 'telemetry.telemetryLevel';
+const TELEMETRY_CRASH_REPORTER_SETTING_ID = 'telemetry.enableCrashReporter';
+const TELEMETRY_OLD_SETTING_ID = 'telemetry.enableTelemetry';
+export { ICustomEndpointTelemetryService, ITelemetryService, TELEMETRY_CRASH_REPORTER_SETTING_ID, TELEMETRY_OLD_SETTING_ID, TELEMETRY_SETTING_ID, firstSessionDateStorageKey };