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

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

@@ -0,0 +1,332 @@
+import { RunOnceScheduler, runWhenIdle, Promises } from 'monaco-editor/esm/vs/base/common/async.js';
+import { PauseableEmitter, Emitter } 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';
+const IS_NEW_KEY = '__$__isNewStorageMarker';
+const TARGET_KEY = '__$__targetStorageMarker';
+var WillSaveStateReason;
+( (function(WillSaveStateReason) {
+    WillSaveStateReason[WillSaveStateReason["NONE"] = 0] = "NONE";
+    WillSaveStateReason[WillSaveStateReason["SHUTDOWN"] = 1] = "SHUTDOWN";
+})(WillSaveStateReason || (WillSaveStateReason = {})));
+var StorageScope;
+( (function(StorageScope) {
+    StorageScope[StorageScope["APPLICATION"] = -1] = "APPLICATION";
+    StorageScope[StorageScope["PROFILE"] = 0] = "PROFILE";
+    StorageScope[StorageScope["WORKSPACE"] = 1] = "WORKSPACE";
+})(StorageScope || (StorageScope = {})));
+var StorageTarget;
+( (function(StorageTarget) {
+    StorageTarget[StorageTarget["USER"] = 0] = "USER";
+    StorageTarget[StorageTarget["MACHINE"] = 1] = "MACHINE";
+})(StorageTarget || (StorageTarget = {})));
+function loadKeyTargets(storage) {
+    const keysRaw = storage.get(TARGET_KEY);
+    if (keysRaw) {
+        try {
+            return JSON.parse(keysRaw);
+        }
+        catch (error) {
+        }
+    }
+    return Object.create(null);
+}
+class AbstractStorageService extends Disposable {
+    constructor(options = { flushInterval: AbstractStorageService.DEFAULT_FLUSH_INTERVAL }) {
+        super();
+        this.options = options;
+        this._onDidChangeValue = this._register(( new PauseableEmitter()));
+        this.onDidChangeValue = this._onDidChangeValue.event;
+        this._onDidChangeTarget = this._register(( new PauseableEmitter()));
+        this.onDidChangeTarget = this._onDidChangeTarget.event;
+        this._onWillSaveState = this._register(( new Emitter()));
+        this.onWillSaveState = this._onWillSaveState.event;
+        this.flushWhenIdleScheduler = this._register(( new RunOnceScheduler(() => this.doFlushWhenIdle(), this.options.flushInterval)));
+        this.runFlushWhenIdle = this._register(( new MutableDisposable()));
+        this._workspaceKeyTargets = undefined;
+        this._profileKeyTargets = undefined;
+        this._applicationKeyTargets = undefined;
+    }
+    doFlushWhenIdle() {
+        this.runFlushWhenIdle.value = runWhenIdle(() => {
+            if (this.shouldFlushWhenIdle()) {
+                this.flush();
+            }
+            this.flushWhenIdleScheduler.schedule();
+        });
+    }
+    shouldFlushWhenIdle() {
+        return true;
+    }
+    stopFlushWhenIdle() {
+        dispose([this.runFlushWhenIdle, this.flushWhenIdleScheduler]);
+    }
+    initialize() {
+        if (!this.initializationPromise) {
+            this.initializationPromise = (async () => {
+                mark('code/willInitStorage');
+                try {
+                    await this.doInitialize();
+                }
+                finally {
+                    mark('code/didInitStorage');
+                }
+                this.flushWhenIdleScheduler.schedule();
+            })();
+        }
+        return this.initializationPromise;
+    }
+    emitDidChangeValue(scope, key) {
+        if (key === TARGET_KEY) {
+            switch (scope) {
+                case -1 :
+                    this._applicationKeyTargets = undefined;
+                    break;
+                case 0 :
+                    this._profileKeyTargets = undefined;
+                    break;
+                case 1 :
+                    this._workspaceKeyTargets = undefined;
+                    break;
+            }
+            this._onDidChangeTarget.fire({ scope });
+        }
+        else {
+            this._onDidChangeValue.fire({ scope, key, target: this.getKeyTargets(scope)[key] });
+        }
+    }
+    emitWillSaveState(reason) {
+        this._onWillSaveState.fire({ reason });
+    }
+    get(key, scope, fallbackValue) {
+        return this.getStorage(scope)?.get(key, fallbackValue);
+    }
+    getBoolean(key, scope, fallbackValue) {
+        return this.getStorage(scope)?.getBoolean(key, fallbackValue);
+    }
+    getNumber(key, scope, fallbackValue) {
+        return this.getStorage(scope)?.getNumber(key, fallbackValue);
+    }
+    store(key, value, scope, target) {
+        if (isUndefinedOrNull(value)) {
+            this.remove(key, scope);
+            return;
+        }
+        this.withPausedEmitters(() => {
+            this.updateKeyTarget(key, scope, target);
+            this.getStorage(scope)?.set(key, value);
+        });
+    }
+    remove(key, scope) {
+        this.withPausedEmitters(() => {
+            this.updateKeyTarget(key, scope, undefined);
+            this.getStorage(scope)?.delete(key);
+        });
+    }
+    withPausedEmitters(fn) {
+        this._onDidChangeValue.pause();
+        this._onDidChangeTarget.pause();
+        try {
+            fn();
+        }
+        finally {
+            this._onDidChangeValue.resume();
+            this._onDidChangeTarget.resume();
+        }
+    }
+    keys(scope, target) {
+        const keys = [];
+        const keyTargets = this.getKeyTargets(scope);
+        for (const key of ( Object.keys(keyTargets))) {
+            const keyTarget = keyTargets[key];
+            if (keyTarget === target) {
+                keys.push(key);
+            }
+        }
+        return keys;
+    }
+    updateKeyTarget(key, scope, target) {
+        const keyTargets = this.getKeyTargets(scope);
+        if (typeof target === 'number') {
+            if (keyTargets[key] !== target) {
+                keyTargets[key] = target;
+                this.getStorage(scope)?.set(TARGET_KEY, JSON.stringify(keyTargets));
+            }
+        }
+        else {
+            if (typeof keyTargets[key] === 'number') {
+                delete keyTargets[key];
+                this.getStorage(scope)?.set(TARGET_KEY, JSON.stringify(keyTargets));
+            }
+        }
+    }
+    get workspaceKeyTargets() {
+        if (!this._workspaceKeyTargets) {
+            this._workspaceKeyTargets = this.loadKeyTargets(1 );
+        }
+        return this._workspaceKeyTargets;
+    }
+    get profileKeyTargets() {
+        if (!this._profileKeyTargets) {
+            this._profileKeyTargets = this.loadKeyTargets(0 );
+        }
+        return this._profileKeyTargets;
+    }
+    get applicationKeyTargets() {
+        if (!this._applicationKeyTargets) {
+            this._applicationKeyTargets = this.loadKeyTargets(-1 );
+        }
+        return this._applicationKeyTargets;
+    }
+    getKeyTargets(scope) {
+        switch (scope) {
+            case -1 :
+                return this.applicationKeyTargets;
+            case 0 :
+                return this.profileKeyTargets;
+            default:
+                return this.workspaceKeyTargets;
+        }
+    }
+    loadKeyTargets(scope) {
+        const storage = this.getStorage(scope);
+        return storage ? loadKeyTargets(storage) : Object.create(null);
+    }
+    isNew(scope) {
+        return this.getBoolean(IS_NEW_KEY, scope) === true;
+    }
+    async flush(reason = WillSaveStateReason.NONE) {
+        this._onWillSaveState.fire({ reason });
+        const applicationStorage = this.getStorage(-1 );
+        const profileStorage = this.getStorage(0 );
+        const workspaceStorage = this.getStorage(1 );
+        switch (reason) {
+            case WillSaveStateReason.NONE:
+                await Promises.settled([
+                    applicationStorage?.whenFlushed() ?? Promise.resolve(),
+                    profileStorage?.whenFlushed() ?? Promise.resolve(),
+                    workspaceStorage?.whenFlushed() ?? Promise.resolve()
+                ]);
+                break;
+            case WillSaveStateReason.SHUTDOWN:
+                await Promises.settled([
+                    applicationStorage?.flush(0) ?? Promise.resolve(),
+                    profileStorage?.flush(0) ?? Promise.resolve(),
+                    workspaceStorage?.flush(0) ?? Promise.resolve()
+                ]);
+                break;
+        }
+    }
+    async log() {
+        const applicationItems = this.getStorage(-1 )?.items ?? ( new Map());
+        const profileItems = this.getStorage(0 )?.items ?? ( new Map());
+        const workspaceItems = this.getStorage(1 )?.items ?? ( new Map());
+        return logStorage(applicationItems, profileItems, workspaceItems, this.getLogDetails(-1 ) ?? '', this.getLogDetails(0 ) ?? '', this.getLogDetails(1 ) ?? '');
+    }
+    async switch(to, preserveData) {
+        this.emitWillSaveState(WillSaveStateReason.NONE);
+        if (isUserDataProfile(to)) {
+            return this.switchToProfile(to, preserveData);
+        }
+        return this.switchToWorkspace(to, preserveData);
+    }
+    canSwitchProfile(from, to) {
+        if (from.id === to.id) {
+            return false;
+        }
+        if (isProfileUsingDefaultStorage(to) && isProfileUsingDefaultStorage(from)) {
+            return false;
+        }
+        return true;
+    }
+    switchData(oldStorage, newStorage, scope, preserveData) {
+        this.withPausedEmitters(() => {
+            if (preserveData) {
+                for (const [key, value] of oldStorage) {
+                    newStorage.set(key, value);
+                }
+            }
+            else {
+                const handledkeys = ( new Set());
+                for (const [key, oldValue] of oldStorage) {
+                    handledkeys.add(key);
+                    const newValue = newStorage.get(key);
+                    if (newValue !== oldValue) {
+                        this.emitDidChangeValue(scope, key);
+                    }
+                }
+                for (const [key] of newStorage.items) {
+                    if (!( handledkeys.has(key))) {
+                        this.emitDidChangeValue(scope, key);
+                    }
+                }
+            }
+        });
+    }
+}
+AbstractStorageService.DEFAULT_FLUSH_INTERVAL = 60 * 1000;
+function isProfileUsingDefaultStorage(profile) {
+    return profile.isDefault || !!profile.useDefaultFlags?.uiState;
+}
+async function logStorage(application, profile, workspace, applicationPath, profilePath, workspacePath) {
+    const safeParse = (value) => {
+        try {
+            return JSON.parse(value);
+        }
+        catch (error) {
+            return value;
+        }
+    };
+    const applicationItems = ( new Map());
+    const applicationItemsParsed = ( new Map());
+    application.forEach((value, key) => {
+        applicationItems.set(key, value);
+        applicationItemsParsed.set(key, safeParse(value));
+    });
+    const profileItems = ( new Map());
+    const profileItemsParsed = ( new Map());
+    profile.forEach((value, key) => {
+        profileItems.set(key, value);
+        profileItemsParsed.set(key, safeParse(value));
+    });
+    const workspaceItems = ( new Map());
+    const workspaceItemsParsed = ( new Map());
+    workspace.forEach((value, key) => {
+        workspaceItems.set(key, value);
+        workspaceItemsParsed.set(key, safeParse(value));
+    });
+    if (applicationPath !== profilePath) {
+        console.group(`Storage: Application (path: ${applicationPath})`);
+    }
+    else {
+        console.group(`Storage: Application & Profile (path: ${applicationPath}, default profile)`);
+    }
+    const applicationValues = [];
+    applicationItems.forEach((value, key) => {
+        applicationValues.push({ key, value });
+    });
+    console.table(applicationValues);
+    console.groupEnd();
+    console.log(applicationItemsParsed);
+    if (applicationPath !== profilePath) {
+        console.group(`Storage: Profile (path: ${profilePath}, profile specific)`);
+        const profileValues = [];
+        profileItems.forEach((value, key) => {
+            profileValues.push({ key, value });
+        });
+        console.table(profileValues);
+        console.groupEnd();
+        console.log(profileItemsParsed);
+    }
+    console.group(`Storage: Workspace (path: ${workspacePath})`);
+    const workspaceValues = [];
+    workspaceItems.forEach((value, key) => {
+        workspaceValues.push({ key, value });
+    });
+    console.table(workspaceValues);
+    console.groupEnd();
+    console.log(workspaceItemsParsed);
+}
+export { AbstractStorageService, IS_NEW_KEY, StorageScope, StorageTarget, TARGET_KEY, WillSaveStateReason, isProfileUsingDefaultStorage, loadKeyTargets, logStorage };

package/dist/vscode/vs/platform/telemetry/common/telemetryUtils.js

@@ -45,7 +45,7 @@ function cleanRemoteAuthority(remoteAuthority) {
         return 'none';
     }
     const remoteName = getRemoteName(remoteAuthority);
-    return telemetryAllowedAuthorities.has(remoteName) ? remoteName : 'other';
+    return ( telemetryAllowedAuthorities.has(remoteName)) ? remoteName : 'other';
 }
 function anonymizeFilePaths(stack, cleanupPatterns) {
     if (!stack || (!stack.includes('/') && !stack.includes('\\'))) {

package/dist/vscode/vs/platform/tunnel/common/tunnel.js

@@ -1,3 +1,31 @@
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 const ITunnelService = ( createDecorator('tunnelService'));
-export { ITunnelService };
+var TunnelProtocol;
+( (function(TunnelProtocol) {
+    TunnelProtocol["Http"] = "http";
+    TunnelProtocol["Https"] = "https";
+})(TunnelProtocol || (TunnelProtocol = {})));
+var TunnelPrivacyId;
+( (function(TunnelPrivacyId) {
+    TunnelPrivacyId["ConstantPrivate"] = "constantPrivate";
+    TunnelPrivacyId["Private"] = "private";
+    TunnelPrivacyId["Public"] = "public";
+})(TunnelPrivacyId || (TunnelPrivacyId = {})));
+var ProvidedOnAutoForward;
+( (function(ProvidedOnAutoForward) {
+    ProvidedOnAutoForward[ProvidedOnAutoForward["Notify"] = 1] = "Notify";
+    ProvidedOnAutoForward[ProvidedOnAutoForward["OpenBrowser"] = 2] = "OpenBrowser";
+    ProvidedOnAutoForward[ProvidedOnAutoForward["OpenPreview"] = 3] = "OpenPreview";
+    ProvidedOnAutoForward[ProvidedOnAutoForward["Silent"] = 4] = "Silent";
+    ProvidedOnAutoForward[ProvidedOnAutoForward["Ignore"] = 5] = "Ignore";
+    ProvidedOnAutoForward[ProvidedOnAutoForward["OpenBrowserOnce"] = 6] = "OpenBrowserOnce";
+})(ProvidedOnAutoForward || (ProvidedOnAutoForward = {})));
+const LOCALHOST_ADDRESSES = ['localhost', '127.0.0.1', '0:0:0:0:0:0:0:1', '::1'];
+function isLocalhost(host) {
+    return LOCALHOST_ADDRESSES.indexOf(host) >= 0;
+}
+const ALL_INTERFACES_ADDRESSES = ['0.0.0.0', '0:0:0:0:0:0:0:0', '::'];
+function isAllInterfaces(host) {
+    return ALL_INTERFACES_ADDRESSES.indexOf(host) >= 0;
+}
+export { ALL_INTERFACES_ADDRESSES, ITunnelService, LOCALHOST_ADDRESSES, ProvidedOnAutoForward, TunnelPrivacyId, TunnelProtocol, isAllInterfaces, isLocalhost };

package/dist/vscode/vs/platform/update/common/update.js

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

package/dist/vscode/vs/platform/window/common/window.js

@@ -0,0 +1,33 @@
+import { isMacintosh, isNative, isWeb, isLinux } from 'monaco-editor/esm/vs/base/common/platform.js';
+function getMenuBarVisibility(configurationService) {
+    const titleBarStyle = getTitleBarStyle(configurationService);
+    const menuBarVisibility = configurationService.getValue('window.menuBarVisibility');
+    if (menuBarVisibility === 'default' || (titleBarStyle === 'native' && menuBarVisibility === 'compact') || (isMacintosh && isNative)) {
+        return 'classic';
+    }
+    else {
+        return menuBarVisibility;
+    }
+}
+function getTitleBarStyle(configurationService) {
+    if (isWeb) {
+        return 'custom';
+    }
+    const configuration = configurationService.getValue('window');
+    if (configuration) {
+        const useNativeTabs = isMacintosh && configuration.nativeTabs === true;
+        if (useNativeTabs) {
+            return 'native';
+        }
+        const useSimpleFullScreen = isMacintosh && configuration.nativeFullScreen === false;
+        if (useSimpleFullScreen) {
+            return 'native';
+        }
+        const style = configuration.titleBarStyle;
+        if (style === 'native' || style === 'custom') {
+            return style;
+        }
+    }
+    return isLinux ? 'native' : 'custom';
+}
+export { getMenuBarVisibility, getTitleBarStyle };

package/dist/vscode/vs/platform/workspaces/common/workspaces.js

@@ -93,7 +93,7 @@ function toWorkspaceFolders(configuredFolders, workspaceConfigFile, extUri) {
         }
         if (uri) {
             const comparisonKey = extUri.getComparisonKey(uri);
-            if (!seen.has(comparisonKey)) {
+            if (!( (seen.has(comparisonKey)))) {
                 seen.add(comparisonKey);
                 const name = configuredFolder.name || extUri.basenameOrAuthority(uri);
                 result.push(( (new WorkspaceFolder({ uri, name, index: result.length }, configuredFolder))));

package/dist/vscode/vs/workbench/api/browser/mainThreadDebugService.js

@@ -254,7 +254,7 @@ let MainThreadDebugService = class MainThreadDebugService {
     getSessionDto(session) {
         if (session) {
             const sessionID = session.getId();
-            if (this._sessions.has(sessionID)) {
+            if (( this._sessions.has(sessionID))) {
                 return sessionID;
             }
             else {

package/dist/vscode/vs/workbench/api/browser/mainThreadDiagnostics.js

@@ -25,7 +25,7 @@ let MainThreadDiagnostics = class MainThreadDiagnostics {
                 data.push([resource, []]);
             }
             else {
-                const forgeinMarkerData = allMarkerData.filter(marker => !this._activeOwners.has(marker.owner));
+                const forgeinMarkerData = allMarkerData.filter(marker => !( this._activeOwners.has(marker.owner)));
                 if (forgeinMarkerData.length > 0) {
                     data.push([resource, forgeinMarkerData]);
                 }

package/dist/vscode/vs/workbench/api/browser/mainThreadDocuments.js

@@ -151,13 +151,13 @@ let MainThreadDocuments = class MainThreadDocuments extends Disposable {
     }
     _onModelModeChanged(event) {
         const { model } = event;
-        if (!this._modelTrackers.has(model.uri)) {
+        if (!( this._modelTrackers.has(model.uri))) {
             return;
         }
         this._proxy.$acceptModelLanguageChanged(model.uri, model.getLanguageId());
     }
     handleModelRemoved(modelUrl) {
-        if (!this._modelTrackers.has(modelUrl)) {
+        if (!( this._modelTrackers.has(modelUrl))) {
             return;
         }
         this._modelTrackers.get(modelUrl).dispose();
@@ -196,7 +196,7 @@ let MainThreadDocuments = class MainThreadDocuments extends Disposable {
         else if (!extUri.isEqual(documentUri, canonicalUri)) {
             throw new Error(`cannot open ${canonicalUri.toString()}. Detail: Actual document opened as ${documentUri.toString()}`);
         }
-        else if (!this._modelTrackers.has(canonicalUri)) {
+        else if (!( this._modelTrackers.has(canonicalUri))) {
             throw new Error(`cannot open ${canonicalUri.toString()}. Detail: Files above 50MB cannot be synchronized with extensions.`);
         }
         else {
@@ -226,7 +226,7 @@ let MainThreadDocuments = class MainThreadDocuments extends Disposable {
             initialValue
         });
         const resource = model.resource;
-        if (!this._modelTrackers.has(resource)) {
+        if (!( this._modelTrackers.has(resource))) {
             throw new Error(`expected URI ${resource.toString()} to have come to LIFE`);
         }
         this._proxy.$acceptDirtyStateChanged(resource, true);

package/dist/vscode/vs/workbench/api/browser/mainThreadDocumentsAndEditors.js

@@ -121,7 +121,7 @@ let MainThreadDocumentAndEditorStateComputer = class MainThreadDocumentAndEditor
     }
     _onDidRemoveEditor(e) {
         const id = e.getId();
-        if (this._toDisposeOnEditorRemove.has(id)) {
+        if (( (this._toDisposeOnEditorRemove.has(id)))) {
             this._toDisposeOnEditorRemove.deleteAndDispose(id);
             this._updateState();
         }

package/dist/vscode/vs/workbench/api/browser/mainThreadFileSystem.js

@@ -185,7 +185,7 @@ let MainThreadFileSystem = MainThreadFileSystem_1 = class MainThreadFileSystem {
         this._watches.set(session, subscription);
     }
     $unwatch(session) {
-        if (this._watches.has(session)) {
+        if (( (this._watches.has(session)))) {
             this._logService.trace(`MainThreadFileSystem#$unwatch(): request to stop watching (session: ${session})`);
             this._watches.deleteAndDispose(session);
         }

package/dist/vscode/vs/workbench/api/browser/mainThreadLocalization.js

@@ -0,0 +1,33 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { MainContext } from '../common/extHost.protocol.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ILanguagePackService } from '../../../platform/languagePacks/common/languagePacks.js';
+let MainThreadLocalization = class MainThreadLocalization extends Disposable {
+    constructor(extHostContext, fileService, languagePackService) {
+        super();
+        this.fileService = fileService;
+        this.languagePackService = languagePackService;
+    }
+    async $fetchBuiltInBundleUri(id, language) {
+        try {
+            const uri = await this.languagePackService.getBuiltInExtensionTranslationsUri(id, language);
+            return uri;
+        }
+        catch (e) {
+            return undefined;
+        }
+    }
+    async $fetchBundleContents(uriComponents) {
+        const contents = await this.fileService.readFile(URI.revive(uriComponents));
+        return ( contents.value.toString());
+    }
+};
+MainThreadLocalization = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadLocalization),
+    ( __param(1, IFileService)),
+    ( __param(2, ILanguagePackService))
+], MainThreadLocalization);
+export { MainThreadLocalization };

package/dist/vscode/vs/workbench/api/browser/mainThreadQuickOpen.js

@@ -147,7 +147,7 @@ let MainThreadQuickOpen = class MainThreadQuickOpen {
             }
             else if (param === 'activeItems' || param === 'selectedItems') {
                 input[param] = ( params[param]
-                    .filter((handle) => handlesToItems.has(handle))
+                    .filter((handle) => ( handlesToItems.has(handle)))
                     .map((handle) => handlesToItems.get(handle)));
             }
             else if (param === 'buttons') {

package/dist/vscode/vs/workbench/api/browser/mainThreadStorage.js

@@ -0,0 +1,69 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { isWeb } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { IExtensionStorageService } from '../../../platform/extensionManagement/common/extensionStorage.js';
+import { migrateExtensionStorage } from '../../services/extensions/common/extensionStorageMigration.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+let MainThreadStorage = class MainThreadStorage {
+    constructor(extHostContext, _extensionStorageService, _storageService, _instantiationService, _logService) {
+        this._extensionStorageService = _extensionStorageService;
+        this._storageService = _storageService;
+        this._instantiationService = _instantiationService;
+        this._logService = _logService;
+        this._sharedStorageKeysToWatch = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostStorage));
+        this._storageListener = this._storageService.onDidChangeValue(e => {
+            const shared = e.scope === 0 ;
+            if (shared && ( this._sharedStorageKeysToWatch.has(e.key))) {
+                const rawState = this._extensionStorageService.getExtensionStateRaw(e.key, shared);
+                if (typeof rawState === 'string') {
+                    this._proxy.$acceptValue(shared, e.key, rawState);
+                }
+            }
+        });
+    }
+    dispose() {
+        this._storageListener.dispose();
+    }
+    async $initializeExtensionStorage(shared, extensionId) {
+        await this.checkAndMigrateExtensionStorage(extensionId, shared);
+        if (shared) {
+            this._sharedStorageKeysToWatch.set(extensionId, true);
+        }
+        return this._extensionStorageService.getExtensionStateRaw(extensionId, shared);
+    }
+    async $setValue(shared, key, value) {
+        this._extensionStorageService.setExtensionState(key, value, shared);
+    }
+    $registerExtensionStorageKeysToSync(extension, keys) {
+        this._extensionStorageService.setKeysForSync(extension, keys);
+    }
+    async checkAndMigrateExtensionStorage(extensionId, shared) {
+        try {
+            let sourceExtensionId = this._extensionStorageService.getSourceExtensionToMigrate(extensionId);
+            if (!sourceExtensionId && isWeb && extensionId !== extensionId.toLowerCase()) {
+                sourceExtensionId = extensionId.toLowerCase();
+            }
+            if (sourceExtensionId) {
+                if (isWeb && sourceExtensionId !== sourceExtensionId.toLowerCase() && this._extensionStorageService.getExtensionState(sourceExtensionId.toLowerCase(), shared) && !this._extensionStorageService.getExtensionState(sourceExtensionId, shared)) {
+                    sourceExtensionId = sourceExtensionId.toLowerCase();
+                }
+                await migrateExtensionStorage(sourceExtensionId, extensionId, shared, this._instantiationService);
+            }
+        }
+        catch (error) {
+            this._logService.error(error);
+        }
+    }
+};
+MainThreadStorage = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadStorage),
+    ( __param(1, IExtensionStorageService)),
+    ( __param(2, IStorageService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, ILogService))
+], MainThreadStorage);
+export { MainThreadStorage };