@codingame/monaco-vscode-user-data-sync-service-override 1.85.2

package/external/rollup-plugin-styles/dist/runtime/inject-css.js

@@ -0,0 +1,3 @@
+var e=[],t=[];function n(n,r){if(n&&"undefined"!=typeof document){var a,s=!0===r.prepend?"prepend":"append",d=!0===r.singleTag,i="string"==typeof r.container?document.querySelector(r.container):document.getElementsByTagName("head")[0];if(d){var u=e.indexOf(i);-1===u&&(u=e.push(i)-1,t[u]={}),a=t[u]&&t[u][s]?t[u][s]:t[u][s]=c();}else a=c();65279===n.charCodeAt(0)&&(n=n.substring(1)),a.styleSheet?a.styleSheet.cssText+=n:a.appendChild(document.createTextNode(n));}function c(){var e=document.createElement("style");if(e.setAttribute("type","text/css"),r.attributes)for(var t=( Object.keys(r.attributes)),n=0;n<t.length;n++)e.setAttribute(t[n],r.attributes[t[n]]);var a="prepend"===s?"afterbegin":"beforeend";return i.insertAdjacentElement(a,e),e}}
+
+export { n as default };

package/external/tslib/tslib.es6.js

@@ -0,0 +1,11 @@
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+export { __decorate, __param };

package/index.d.ts

@@ -0,0 +1 @@
+export { default } from './userDataSync.js';

package/index.js

@@ -0,0 +1 @@
+export { default } from './userDataSync.js';

package/override/vs/platform/dialogs/common/dialogs.js

@@ -0,0 +1,8 @@
+var ConfirmResult;
+( (function(ConfirmResult) {
+    ConfirmResult[ConfirmResult["SAVE"] = 0] = "SAVE";
+    ConfirmResult[ConfirmResult["DONT_SAVE"] = 1] = "DONT_SAVE";
+    ConfirmResult[ConfirmResult["CANCEL"] = 2] = "CANCEL";
+})(ConfirmResult || (ConfirmResult = {})));
+
+export { ConfirmResult };

package/override/vs/platform/userDataSync/common/extensionsSync.js

@@ -0,0 +1,4 @@
+class ExtensionsSynchroniser {}
+class AbstractExtensionsInitializer {}
+
+export { AbstractExtensionsInitializer, ExtensionsSynchroniser };

package/override/vs/platform/userDataSync/common/globalStateSync.js

@@ -0,0 +1,5 @@
+class GlobalStateSynchroniser {}
+class UserDataSyncStoreTypeSynchronizer {}
+class GlobalStateInitializer {}
+
+export { GlobalStateInitializer, GlobalStateSynchroniser, UserDataSyncStoreTypeSynchronizer };

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@codingame/monaco-vscode-user-data-sync-service-override",
+  "version": "1.85.2",
+  "keywords": [],
+  "author": {
+    "name": "CodinGame",
+    "url": "http://www.codingame.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/CodinGame/monaco-vscode-api.git"
+  },
+  "type": "module",
+  "private": false,
+  "description": "VSCode public API plugged on the monaco editor - user-data-sync service-override",
+  "main": "index.js",
+  "module": "index.js",
+  "types": "index.d.ts",
+  "dependencies": {
+    "vscode": "npm:@codingame/monaco-vscode-api@1.85.2",
+    "monaco-editor": "0.45.0"
+  }
+}

package/userDataSync.d.ts

@@ -0,0 +1,5 @@
+import { IEditorOverrideServices } from 'vscode/vscode/vs/editor/standalone/browser/standaloneServices';
+
+declare function getServiceOverride(): IEditorOverrideServices;
+
+export { getServiceOverride as default };

package/userDataSync.js

@@ -0,0 +1,106 @@
+import { __decorate, __param } from './external/tslib/tslib.es6.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { IUserDataAutoSyncService, IUserDataSyncStoreManagementService, IUserDataSyncStoreService, IUserDataSyncEnablementService, IUserDataSyncService, IUserDataSyncLogService, IUserDataSyncResourceProviderService, IUserDataSyncLocalStoreService, IUserDataSyncUtilService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSync';
+import { IUserDataSyncAccountService, UserDataSyncAccountService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSyncAccount';
+import { IUserDataSyncMachinesService, UserDataSyncMachinesService } from 'vscode/vscode/vs/platform/userDataSync/common/userDataSyncMachines';
+import { UserDataSyncStoreManagementService, UserDataSyncStoreService } from './vscode/src/vs/platform/userDataSync/common/userDataSyncStoreService.js';
+import { UserDataAutoSyncService } from './vscode/src/vs/platform/userDataSync/common/userDataAutoSyncService.js';
+import { WebUserDataSyncEnablementService } from './vscode/src/vs/workbench/services/userDataSync/browser/webUserDataSyncEnablementService.js';
+import { UserDataSyncService } from './vscode/src/vs/platform/userDataSync/common/userDataSyncService.js';
+import { UserDataSyncLogService } from './vscode/src/vs/platform/userDataSync/common/userDataSyncLog.js';
+import { BrowserUserDataProfilesService } from './vscode/src/vs/platform/userDataProfile/browser/userDataProfile.js';
+import { IUserDataProfilesService } from 'monaco-editor/esm/vs/platform/userDataProfile/common/userDataProfile.js';
+import { UserDataSyncResourceProviderService } from './vscode/src/vs/platform/userDataSync/common/userDataSyncResourceProvider.js';
+import { UserDataSyncLocalStoreService } from './vscode/src/vs/platform/userDataSync/common/userDataSyncLocalStoreService.js';
+import { UserDataSyncWorkbenchService } from './vscode/src/vs/workbench/services/userDataSync/browser/userDataSyncWorkbenchService.js';
+import { IUserDataSyncWorkbenchService } from 'vscode/vscode/vs/workbench/services/userDataSync/common/userDataSync';
+import './vscode/src/vs/workbench/contrib/userDataSync/browser/userDataSync.contribution.js';
+import { IUserDataInitializationService, UserDataInitializationService } from 'vscode/vscode/vs/workbench/services/userData/browser/userDataInit';
+import { UserDataSyncInitializer } from './vscode/src/vs/workbench/services/userDataSync/browser/userDataSyncInit.js';
+import { UserDataProfileInitializer } from './vscode/src/vs/workbench/services/userDataProfile/browser/userDataProfileInit.js';
+import { IBrowserWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/browser/environmentService';
+import { ISecretStorageService } from 'vscode/vscode/vs/platform/secrets/common/secrets';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+import { IRequestService } from 'vscode/vscode/vs/platform/request/common/request';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { IUserDataProfileImportExportService, IUserDataProfileManagementService, IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
+import { mark } from 'monaco-editor/esm/vs/base/common/performance.js';
+import { timeout } from 'monaco-editor/esm/vs/base/common/async.js';
+import { IWorkbenchConfigurationService } from 'vscode/vscode/vs/workbench/services/configuration/common/configuration';
+import { UserDataSyncUtilService } from './vscode/src/vs/workbench/services/userDataSync/common/userDataSyncUtil.js';
+import { UserDataProfileImportExportService } from './vscode/src/vs/workbench/services/userDataProfile/browser/userDataProfileImportExportService.js';
+import { UserDataProfileManagementService } from './vscode/src/vs/workbench/services/userDataProfile/browser/userDataProfileManagement.js';
+import { registerServiceInitializePostParticipant } from 'vscode/lifecycle';
+
+function isWorkspaceService(configurationService) {
+    return 'reloadLocalUserConfiguration' in configurationService;
+}
+async function initializeUserData(userDataInitializationService, configurationService) {
+    if (await userDataInitializationService.requiresInitialization()) {
+        mark('code/willInitRequiredUserData');
+        await userDataInitializationService.initializeRequiredResources();
+        if (isWorkspaceService(configurationService)) {
+            await configurationService.reloadLocalUserConfiguration();
+        }
+        mark('code/didInitRequiredUserData');
+    }
+}
+registerServiceInitializePostParticipant(async (accessor) => {
+    try {
+        await Promise.race([
+            timeout(5000),
+            initializeUserData(accessor.get(IUserDataInitializationService), accessor.get(IWorkbenchConfigurationService))
+        ]);
+    }
+    catch (error) {
+        accessor.get(ILogService).error(error);
+    }
+});
+let InjectedUserDataInitializationService = class InjectedUserDataInitializationService extends UserDataInitializationService {
+    constructor(environmentService, secretStorageService, userDataSyncStoreManagementService, fileService, userDataProfilesService, storageService, productService, requestService, logService, uriIdentityService, userDataProfileService) {
+        const userDataInitializers = [];
+        userDataInitializers.push(new UserDataSyncInitializer(environmentService, secretStorageService, userDataSyncStoreManagementService, fileService, userDataProfilesService, storageService, productService, requestService, logService, uriIdentityService));
+        if (environmentService.options?.profile != null) {
+            userDataInitializers.push(new UserDataProfileInitializer(environmentService, fileService, userDataProfileService, storageService, logService, uriIdentityService, requestService));
+        }
+        super(userDataInitializers);
+    }
+};
+InjectedUserDataInitializationService = __decorate([
+    ( __param(0, IBrowserWorkbenchEnvironmentService)),
+    ( __param(1, ISecretStorageService)),
+    ( __param(2, IUserDataSyncStoreManagementService)),
+    ( __param(3, IFileService)),
+    ( __param(4, IUserDataProfilesService)),
+    ( __param(5, IStorageService)),
+    ( __param(6, IProductService)),
+    ( __param(7, IRequestService)),
+    ( __param(8, ILogService)),
+    ( __param(9, IUriIdentityService)),
+    ( __param(10, IUserDataProfileService))
+], InjectedUserDataInitializationService);
+function getServiceOverride() {
+    return {
+        [( IUserDataAutoSyncService.toString())]: new SyncDescriptor(UserDataAutoSyncService, [], true),
+        [( IUserDataSyncStoreManagementService.toString())]: new SyncDescriptor(UserDataSyncStoreManagementService, [], true),
+        [( IUserDataSyncStoreService.toString())]: new SyncDescriptor(UserDataSyncStoreService, [], true),
+        [( IUserDataSyncEnablementService.toString())]: new SyncDescriptor(WebUserDataSyncEnablementService, [], true),
+        [( IUserDataSyncService.toString())]: new SyncDescriptor(UserDataSyncService, [], true),
+        [( IUserDataSyncLogService.toString())]: new SyncDescriptor(UserDataSyncLogService, [], true),
+        [( IUserDataSyncAccountService.toString())]: new SyncDescriptor(UserDataSyncAccountService, [], true),
+        [( IUserDataSyncMachinesService.toString())]: new SyncDescriptor(UserDataSyncMachinesService, [], true),
+        [( IUserDataProfilesService.toString())]: new SyncDescriptor(BrowserUserDataProfilesService, [], true),
+        [( IUserDataSyncResourceProviderService.toString())]: new SyncDescriptor(UserDataSyncResourceProviderService, [], true),
+        [( IUserDataSyncLocalStoreService.toString())]: new SyncDescriptor(UserDataSyncLocalStoreService, [], true),
+        [( IUserDataSyncWorkbenchService.toString())]: new SyncDescriptor(UserDataSyncWorkbenchService, [], true),
+        [( IUserDataInitializationService.toString())]: new SyncDescriptor(InjectedUserDataInitializationService, [], true),
+        [( IUserDataSyncUtilService.toString())]: new SyncDescriptor(UserDataSyncUtilService, [], true),
+        [( IUserDataProfileImportExportService.toString())]: new SyncDescriptor(UserDataProfileImportExportService, [], true),
+        [( IUserDataProfileManagementService.toString())]: new SyncDescriptor(UserDataProfileManagementService, [], true)
+    };
+}
+
+export { getServiceOverride as default };

package/vscode/src/vs/base/browser/ui/icons/iconSelectBox.css.js

@@ -0,0 +1,6 @@
+import n from '../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+
+var css = ".icon-select-box>.icon-select-box-container{height:100%}.icon-select-box .icon-select-icons-container{height:100%;outline:0!important}.icon-select-box .icon-select-icons-container>.icon-container{align-items:center;border-radius:5px;cursor:pointer;display:inline-flex;font-size:20px;justify-content:center}.icon-select-box .icon-select-icons-container>.icon-container.focused{background-color:var(--vscode-quickInputList-focusBackground);color:var(--vscode-quickInputList-focusForeground)}.icon-select-box .icon-select-icons-container>.icon-container:hover:not(.focused){background-color:var(--vscode-toolbar-hoverBackground);color:var(--vscode-list-hoverForeground)}.icon-select-box .icon-select-id-container .icon-select-id-label{height:24px;opacity:.8;padding:10px}.icon-select-box .icon-select-id-container .icon-select-id-label .highlight{color:var(--vscode-list-highlightForeground);font-weight:700}";
+n(css,{});
+
+export { css, css as default };

package/vscode/src/vs/base/browser/ui/icons/iconSelectBox.js

@@ -0,0 +1,248 @@
+import './iconSelectBox.css.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { alert } from 'monaco-editor/esm/vs/base/browser/ui/aria/aria.js';
+import { InputBox } from 'monaco-editor/esm/vs/base/browser/ui/inputbox/inputBox.js';
+import { DomScrollableElement } from 'monaco-editor/esm/vs/base/browser/ui/scrollbar/scrollableElement.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, DisposableStore, MutableDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { HighlightedLabel } from 'monaco-editor/esm/vs/base/browser/ui/highlightedlabel/highlightedLabel.js';
+
+class IconSelectBox extends Disposable {
+    static { this.InstanceCount = 0; }
+    constructor(options) {
+        super();
+        this.options = options;
+        this.domId = `icon_select_box_id_${++IconSelectBox.InstanceCount}`;
+        this._onDidSelect = this._register(( new Emitter()));
+        this.onDidSelect = this._onDidSelect.event;
+        this.renderedIcons = [];
+        this.focusedItemIndex = 0;
+        this.numberOfElementsPerRow = 1;
+        this.iconContainerWidth = 36;
+        this.iconContainerHeight = 36;
+        this.domNode = dom.$('.icon-select-box');
+        this._register(this.create());
+    }
+    create() {
+        const disposables = ( new DisposableStore());
+        const iconSelectBoxContainer = dom.append(this.domNode, dom.$('.icon-select-box-container'));
+        iconSelectBoxContainer.style.margin = '10px 15px';
+        const iconSelectInputContainer = dom.append(iconSelectBoxContainer, dom.$('.icon-select-input-container'));
+        iconSelectInputContainer.style.paddingBottom = '10px';
+        this.inputBox = disposables.add(( new InputBox(iconSelectInputContainer, undefined, {
+            placeholder: ( localizeWithPath(
+                'vs/base/browser/ui/icons/iconSelectBox',
+                'iconSelect.placeholder',
+                "Search icons"
+            )),
+            inputBoxStyles: this.options.inputBoxStyles,
+        })));
+        const iconsContainer = this.iconsContainer = dom.$('.icon-select-icons-container', { id: `${this.domId}_icons` });
+        iconsContainer.role = 'listbox';
+        iconsContainer.tabIndex = 0;
+        this.scrollableElement = disposables.add(( new DomScrollableElement(iconsContainer, {
+            useShadows: false,
+            horizontal: 2 ,
+        })));
+        dom.append(iconSelectBoxContainer, this.scrollableElement.getDomNode());
+        if (this.options.showIconInfo) {
+            this.iconIdElement = ( new HighlightedLabel(
+                dom.append(dom.append(iconSelectBoxContainer, dom.$('.icon-select-id-container')), dom.$('.icon-select-id-label'))
+            ));
+        }
+        const iconsDisposables = disposables.add(( new MutableDisposable()));
+        iconsDisposables.value = this.renderIcons(this.options.icons, [], iconsContainer);
+        this.scrollableElement.scanDomNode();
+        disposables.add(this.inputBox.onDidChange(value => {
+            const icons = [], matches = [];
+            for (const icon of this.options.icons) {
+                const match = this.matchesContiguous(value, icon.id);
+                if (match) {
+                    icons.push(icon);
+                    matches.push(match);
+                }
+            }
+            if (icons.length) {
+                iconsDisposables.value = this.renderIcons(icons, matches, iconsContainer);
+                this.scrollableElement?.scanDomNode();
+            }
+        }));
+        this.inputBox.inputElement.role = 'combobox';
+        this.inputBox.inputElement.ariaHasPopup = 'menu';
+        this.inputBox.inputElement.ariaAutoComplete = 'list';
+        this.inputBox.inputElement.ariaExpanded = 'true';
+        this.inputBox.inputElement.setAttribute('aria-controls', iconsContainer.id);
+        return disposables;
+    }
+    renderIcons(icons, matches, container) {
+        const disposables = ( new DisposableStore());
+        dom.clearNode(container);
+        const focusedIcon = this.renderedIcons[this.focusedItemIndex]?.icon;
+        let focusedIconIndex = 0;
+        const renderedIcons = [];
+        if (icons.length) {
+            for (let index = 0; index < icons.length; index++) {
+                const icon = icons[index];
+                const iconContainer = dom.append(container, dom.$('.icon-container', { id: `${this.domId}_icons_${index}` }));
+                iconContainer.style.width = `${this.iconContainerWidth}px`;
+                iconContainer.style.height = `${this.iconContainerHeight}px`;
+                iconContainer.title = icon.id;
+                iconContainer.role = 'button';
+                iconContainer.setAttribute('aria-setsize', `${icons.length}`);
+                iconContainer.setAttribute('aria-posinset', `${index + 1}`);
+                dom.append(iconContainer, dom.$(ThemeIcon.asCSSSelector(icon)));
+                renderedIcons.push({ icon, element: iconContainer, highlightMatches: matches[index] });
+                disposables.add(dom.addDisposableListener(iconContainer, dom.EventType.CLICK, (e) => {
+                    e.stopPropagation();
+                    this.setSelection(index);
+                }));
+                if (icon === focusedIcon) {
+                    focusedIconIndex = index;
+                }
+            }
+        }
+        else {
+            const noResults = ( localizeWithPath(
+                'vs/base/browser/ui/icons/iconSelectBox',
+                'iconSelect.noResults',
+                "No results"
+            ));
+            dom.append(container, dom.$('.icon-no-results', undefined, noResults));
+            alert(noResults);
+        }
+        this.renderedIcons.splice(0, this.renderedIcons.length, ...renderedIcons);
+        this.focusIcon(focusedIconIndex);
+        return disposables;
+    }
+    focusIcon(index) {
+        const existing = this.renderedIcons[this.focusedItemIndex];
+        if (existing) {
+            existing.element.classList.remove('focused');
+        }
+        this.focusedItemIndex = index;
+        const renderedItem = this.renderedIcons[index];
+        if (renderedItem) {
+            renderedItem.element.classList.add('focused');
+        }
+        if (this.inputBox) {
+            if (renderedItem) {
+                this.inputBox.inputElement.setAttribute('aria-activedescendant', renderedItem.element.id);
+            }
+            else {
+                this.inputBox.inputElement.removeAttribute('aria-activedescendant');
+            }
+        }
+        if (this.iconIdElement) {
+            if (renderedItem) {
+                this.iconIdElement.set(renderedItem.icon.id, renderedItem.highlightMatches);
+            }
+            else {
+                this.iconIdElement.set('');
+            }
+        }
+        this.reveal(index);
+    }
+    reveal(index) {
+        if (!this.scrollableElement) {
+            return;
+        }
+        if (index < 0 || index >= this.renderedIcons.length) {
+            return;
+        }
+        const element = this.renderedIcons[index].element;
+        if (!element) {
+            return;
+        }
+        const { height } = this.scrollableElement.getScrollDimensions();
+        const { scrollTop } = this.scrollableElement.getScrollPosition();
+        if (element.offsetTop + this.iconContainerHeight > scrollTop + height) {
+            this.scrollableElement.setScrollPosition({ scrollTop: element.offsetTop + this.iconContainerHeight - height });
+        }
+        else if (element.offsetTop < scrollTop) {
+            this.scrollableElement.setScrollPosition({ scrollTop: element.offsetTop });
+        }
+    }
+    matchesContiguous(word, wordToMatchAgainst) {
+        const matchIndex = wordToMatchAgainst.toLowerCase().indexOf(word.toLowerCase());
+        if (matchIndex !== -1) {
+            return [{ start: matchIndex, end: matchIndex + word.length }];
+        }
+        return null;
+    }
+    layout(dimension) {
+        this.domNode.style.width = `${dimension.width}px`;
+        this.domNode.style.height = `${dimension.height}px`;
+        const iconsContainerWidth = dimension.width - 30;
+        this.numberOfElementsPerRow = Math.floor(iconsContainerWidth / this.iconContainerWidth);
+        if (this.numberOfElementsPerRow === 0) {
+            throw new Error('Insufficient width');
+        }
+        const extraSpace = iconsContainerWidth % this.iconContainerWidth;
+        const iconElementMargin = Math.floor(extraSpace / this.numberOfElementsPerRow);
+        for (const { element } of this.renderedIcons) {
+            element.style.marginRight = `${iconElementMargin}px`;
+        }
+        const containerPadding = extraSpace % this.numberOfElementsPerRow;
+        if (this.iconsContainer) {
+            this.iconsContainer.style.paddingLeft = `${Math.floor(containerPadding / 2)}px`;
+            this.iconsContainer.style.paddingRight = `${Math.ceil(containerPadding / 2)}px`;
+        }
+        if (this.scrollableElement) {
+            this.scrollableElement.getDomNode().style.height = `${this.iconIdElement ? dimension.height - 80 : dimension.height - 40}px`;
+            this.scrollableElement.scanDomNode();
+        }
+    }
+    getFocus() {
+        return [this.focusedItemIndex];
+    }
+    setSelection(index) {
+        if (index < 0 || index >= this.renderedIcons.length) {
+            throw new Error(`Invalid index ${index}`);
+        }
+        this.focusIcon(index);
+        this._onDidSelect.fire(this.renderedIcons[index].icon);
+    }
+    clearInput() {
+        if (this.inputBox) {
+            this.inputBox.value = '';
+        }
+    }
+    focus() {
+        this.inputBox?.focus();
+        this.focusIcon(0);
+    }
+    focusNext() {
+        this.focusIcon((this.focusedItemIndex + 1) % this.renderedIcons.length);
+    }
+    focusPrevious() {
+        this.focusIcon((this.focusedItemIndex - 1 + this.renderedIcons.length) % this.renderedIcons.length);
+    }
+    focusNextRow() {
+        let nextRowIndex = this.focusedItemIndex + this.numberOfElementsPerRow;
+        if (nextRowIndex >= this.renderedIcons.length) {
+            nextRowIndex = (nextRowIndex + 1) % this.numberOfElementsPerRow;
+            nextRowIndex = nextRowIndex >= this.renderedIcons.length ? 0 : nextRowIndex;
+        }
+        this.focusIcon(nextRowIndex);
+    }
+    focusPreviousRow() {
+        let previousRowIndex = this.focusedItemIndex - this.numberOfElementsPerRow;
+        if (previousRowIndex < 0) {
+            const numberOfRows = Math.floor(this.renderedIcons.length / this.numberOfElementsPerRow);
+            previousRowIndex = this.focusedItemIndex + (this.numberOfElementsPerRow * numberOfRows) - 1;
+            previousRowIndex = previousRowIndex < 0
+                ? this.renderedIcons.length - 1
+                : previousRowIndex >= this.renderedIcons.length
+                    ? previousRowIndex - this.numberOfElementsPerRow
+                    : previousRowIndex;
+        }
+        this.focusIcon(previousRowIndex);
+    }
+    getFocusedIcon() {
+        return this.renderedIcons[this.focusedItemIndex].icon;
+    }
+}
+
+export { IconSelectBox };

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

@@ -0,0 +1,95 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { BroadcastDataChannel } from 'vscode/vscode/vs/base/browser/broadcast';
+import { revive } from 'monaco-editor/esm/vs/base/common/marshalling.js';
+import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { UserDataProfilesService, reviveProfile } from 'monaco-editor/esm/vs/platform/userDataProfile/common/userDataProfile.js';
+
+let BrowserUserDataProfilesService = class BrowserUserDataProfilesService extends UserDataProfilesService {
+    constructor(environmentService, fileService, uriIdentityService, logService) {
+        super(environmentService, fileService, uriIdentityService, logService);
+        this.changesBroadcastChannel = this._register(( new BroadcastDataChannel(`${UserDataProfilesService.PROFILES_KEY}.changes`)));
+        this._register(this.changesBroadcastChannel.onDidReceiveData(changes => {
+            try {
+                this._profilesObject = undefined;
+                const added = ( changes.added.map(p => reviveProfile(p, this.profilesHome.scheme)));
+                const removed = ( changes.removed.map(p => reviveProfile(p, this.profilesHome.scheme)));
+                const updated = ( changes.updated.map(p => reviveProfile(p, this.profilesHome.scheme)));
+                this.updateTransientProfiles(added.filter(a => a.isTransient), removed.filter(a => a.isTransient), updated.filter(a => a.isTransient));
+                this._onDidChangeProfiles.fire({
+                    added,
+                    removed,
+                    updated,
+                    all: this.profiles
+                });
+            }
+            catch (error) {  }
+        }));
+    }
+    updateTransientProfiles(added, removed, updated) {
+        if (added.length) {
+            this.transientProfilesObject.profiles.push(...added);
+        }
+        if (removed.length || updated.length) {
+            const allTransientProfiles = this.transientProfilesObject.profiles;
+            this.transientProfilesObject.profiles = [];
+            for (const profile of allTransientProfiles) {
+                if (( removed.some(p => profile.id === p.id))) {
+                    continue;
+                }
+                this.transientProfilesObject.profiles.push(updated.find(p => profile.id === p.id) ?? profile);
+            }
+        }
+    }
+    getStoredProfiles() {
+        try {
+            const value = localStorage.getItem(UserDataProfilesService.PROFILES_KEY);
+            if (value) {
+                return revive(JSON.parse(value));
+            }
+        }
+        catch (error) {
+            this.logService.error(error);
+        }
+        return [];
+    }
+    triggerProfilesChanges(added, removed, updated) {
+        super.triggerProfilesChanges(added, removed, updated);
+        this.changesBroadcastChannel.postData({ added, removed, updated });
+    }
+    saveStoredProfiles(storedProfiles) {
+        localStorage.setItem(UserDataProfilesService.PROFILES_KEY, JSON.stringify(storedProfiles));
+    }
+    getStoredProfileAssociations() {
+        const migrateKey = 'profileAssociationsMigration';
+        try {
+            const value = localStorage.getItem(UserDataProfilesService.PROFILE_ASSOCIATIONS_KEY);
+            if (value) {
+                let associations = JSON.parse(value);
+                if (!localStorage.getItem(migrateKey)) {
+                    associations = this.migrateStoredProfileAssociations(associations);
+                    this.saveStoredProfileAssociations(associations);
+                    localStorage.setItem(migrateKey, 'true');
+                }
+                return associations;
+            }
+        }
+        catch (error) {
+            this.logService.error(error);
+        }
+        return {};
+    }
+    saveStoredProfileAssociations(storedProfileAssociations) {
+        localStorage.setItem(UserDataProfilesService.PROFILE_ASSOCIATIONS_KEY, JSON.stringify(storedProfileAssociations));
+    }
+};
+BrowserUserDataProfilesService = ( __decorate([
+    ( __param(0, IEnvironmentService)),
+    ( __param(1, IFileService)),
+    ( __param(2, IUriIdentityService)),
+    ( __param(3, ILogService))
+], BrowserUserDataProfilesService));
+
+export { BrowserUserDataProfilesService };

package/vscode/src/vs/platform/userDataProfile/common/userDataProfileStorageService.js

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