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

package/dist/vscode/vs/base/browser/ui/tree/treeDefaults.js

@@ -1,14 +0,0 @@
-import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-class CollapseAllAction extends Action {
-    constructor(viewer, enabled) {
-        super('vs.tree.collapse', ( nls.localize('collapse all', "Collapse All")), 'collapse-all', enabled);
-        this.viewer = viewer;
-    }
-    async run() {
-        this.viewer.collapseAll();
-        this.viewer.setSelection([]);
-        this.viewer.setFocus([]);
-    }
-}
-export { CollapseAllAction };

package/dist/vscode/vs/editor/common/services/treeViewsDnd.js

@@ -1,17 +0,0 @@
-class TreeViewsDnDService {
-    constructor() {
-        this._dragOperations = ( new Map());
-    }
-    removeDragOperationTransfer(uuid) {
-        if ((uuid && ( this._dragOperations.has(uuid)))) {
-            const operation = this._dragOperations.get(uuid);
-            this._dragOperations.delete(uuid);
-            return operation;
-        }
-        return undefined;
-    }
-    addDragOperationTransfer(uuid, transferPromise) {
-        this._dragOperations.set(uuid, transferPromise);
-    }
-}
-export { TreeViewsDnDService };

package/dist/vscode/vs/editor/common/services/treeViewsDndService.js

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

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

@@ -1,7 +0,0 @@
-function isFolderBackupInfo(curr) {
-    return curr && curr.hasOwnProperty('folderUri');
-}
-function isWorkspaceBackupInfo(curr) {
-    return curr && curr.hasOwnProperty('workspace');
-}
-export { isFolderBackupInfo, isWorkspaceBackupInfo };

package/dist/vscode/vs/platform/configuration/common/configurationRegistry.js

@@ -1,10 +0,0 @@
-var ConfigurationScope;
-( (function(ConfigurationScope) {
-    ConfigurationScope[ConfigurationScope["APPLICATION"] = 1] = "APPLICATION";
-    ConfigurationScope[ConfigurationScope["MACHINE"] = 2] = "MACHINE";
-    ConfigurationScope[ConfigurationScope["WINDOW"] = 3] = "WINDOW";
-    ConfigurationScope[ConfigurationScope["RESOURCE"] = 4] = "RESOURCE";
-    ConfigurationScope[ConfigurationScope["LANGUAGE_OVERRIDABLE"] = 5] = "LANGUAGE_OVERRIDABLE";
-    ConfigurationScope[ConfigurationScope["MACHINE_OVERRIDABLE"] = 6] = "MACHINE_OVERRIDABLE";
-})(ConfigurationScope || (ConfigurationScope = {})));
-export { ConfigurationScope };

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

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

package/dist/vscode/vs/platform/extensionManagement/common/extensionStorage.js

@@ -1,174 +0,0 @@
-import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
-import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { adoptToGalleryExtensionId, areSameExtensions, getExtensionId } from './extensionManagementUtil.js';
-import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
-import { distinct } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { isString } from 'monaco-editor/esm/vs/base/common/types.js';
-const IExtensionStorageService = ( createDecorator('IExtensionStorageService'));
-const EXTENSION_KEYS_ID_VERSION_REGEX = /^extensionKeys\/([^.]+\..+)@(\d+\.\d+\.\d+(-.*)?)$/;
-let ExtensionStorageService = class ExtensionStorageService extends Disposable {
-    static toKey(extension) {
-        return `extensionKeys/${adoptToGalleryExtensionId(extension.id)}@${extension.version}`;
-    }
-    static fromKey(key) {
-        const matches = EXTENSION_KEYS_ID_VERSION_REGEX.exec(key);
-        if (matches && matches[1]) {
-            return { id: matches[1], version: matches[2] };
-        }
-        return undefined;
-    }
-    static async removeOutdatedExtensionVersions(extensionManagementService, storageService) {
-        const extensions = await extensionManagementService.getInstalled();
-        const extensionVersionsToRemove = [];
-        for (const [id, versions] of ExtensionStorageService.readAllExtensionsWithKeysForSync(storageService)) {
-            const extensionVersion = extensions.find(e => areSameExtensions(e.identifier, { id }))?.manifest.version;
-            for (const version of versions) {
-                if (extensionVersion !== version) {
-                    extensionVersionsToRemove.push(ExtensionStorageService.toKey({ id, version }));
-                }
-            }
-        }
-        for (const key of extensionVersionsToRemove) {
-            storageService.remove(key, 0 );
-        }
-    }
-    static readAllExtensionsWithKeysForSync(storageService) {
-        const extensionsWithKeysForSync = ( new Map());
-        const keys = ( storageService.keys(0 , 1 ));
-        for (const key of keys) {
-            const extensionIdWithVersion = ExtensionStorageService.fromKey(key);
-            if (extensionIdWithVersion) {
-                let versions = extensionsWithKeysForSync.get(extensionIdWithVersion.id.toLowerCase());
-                if (!versions) {
-                    extensionsWithKeysForSync.set(extensionIdWithVersion.id.toLowerCase(), versions = []);
-                }
-                versions.push(extensionIdWithVersion.version);
-            }
-        }
-        return extensionsWithKeysForSync;
-    }
-    constructor(storageService, productService, logService) {
-        super();
-        this.storageService = storageService;
-        this.productService = productService;
-        this.logService = logService;
-        this._onDidChangeExtensionStorageToSync = this._register(( new Emitter()));
-        this.onDidChangeExtensionStorageToSync = this._onDidChangeExtensionStorageToSync.event;
-        this.extensionsWithKeysForSync = ExtensionStorageService.readAllExtensionsWithKeysForSync(storageService);
-        this._register(this.storageService.onDidChangeValue(e => this.onDidChangeStorageValue(e)));
-    }
-    onDidChangeStorageValue(e) {
-        if (e.scope !== 0 ) {
-            return;
-        }
-        if (( this.extensionsWithKeysForSync.has(e.key.toLowerCase()))) {
-            this._onDidChangeExtensionStorageToSync.fire();
-            return;
-        }
-        const extensionIdWithVersion = ExtensionStorageService.fromKey(e.key);
-        if (extensionIdWithVersion) {
-            if (this.storageService.get(e.key, 0 ) === undefined) {
-                this.extensionsWithKeysForSync.delete(extensionIdWithVersion.id.toLowerCase());
-            }
-            else {
-                let versions = this.extensionsWithKeysForSync.get(extensionIdWithVersion.id.toLowerCase());
-                if (!versions) {
-                    this.extensionsWithKeysForSync.set(extensionIdWithVersion.id.toLowerCase(), versions = []);
-                }
-                versions.push(extensionIdWithVersion.version);
-                this._onDidChangeExtensionStorageToSync.fire();
-            }
-            return;
-        }
-    }
-    getExtensionId(extension) {
-        if (isString(extension)) {
-            return extension;
-        }
-        const publisher = extension.manifest ? extension.manifest.publisher : extension.publisher;
-        const name = extension.manifest ? extension.manifest.name : extension.name;
-        return getExtensionId(publisher, name);
-    }
-    getExtensionState(extension, global) {
-        const extensionId = this.getExtensionId(extension);
-        const jsonValue = this.getExtensionStateRaw(extension, global);
-        if (jsonValue) {
-            try {
-                return JSON.parse(jsonValue);
-            }
-            catch (error) {
-                this.logService.error(`[mainThreadStorage] unexpected error parsing storage contents (extensionId: ${extensionId}, global: ${global}): ${error}`);
-            }
-        }
-        return undefined;
-    }
-    getExtensionStateRaw(extension, global) {
-        const extensionId = this.getExtensionId(extension);
-        const rawState = this.storageService.get(extensionId, global ? 0  : 1 );
-        if (rawState && rawState?.length > ExtensionStorageService.LARGE_STATE_WARNING_THRESHOLD) {
-            this.logService.warn(`[mainThreadStorage] large extension state detected (extensionId: ${extensionId}, global: ${global}): ${rawState.length / 1024}kb. Consider to use 'storageUri' or 'globalStorageUri' to store this data on disk instead.`);
-        }
-        return rawState;
-    }
-    setExtensionState(extension, state, global) {
-        const extensionId = this.getExtensionId(extension);
-        if (state === undefined) {
-            this.storageService.remove(extensionId, global ? 0  : 1 );
-        }
-        else {
-            this.storageService.store(extensionId, JSON.stringify(state), global ? 0  : 1 , 1 );
-        }
-    }
-    setKeysForSync(extensionIdWithVersion, keys) {
-        this.storageService.store(ExtensionStorageService.toKey(extensionIdWithVersion), JSON.stringify(keys), 0 , 1 );
-    }
-    getKeysForSync(extensionIdWithVersion) {
-        const extensionKeysForSyncFromProduct = this.productService.extensionSyncedKeys?.[extensionIdWithVersion.id.toLowerCase()];
-        const extensionKeysForSyncFromStorageValue = this.storageService.get(ExtensionStorageService.toKey(extensionIdWithVersion), 0 );
-        const extensionKeysForSyncFromStorage = extensionKeysForSyncFromStorageValue ? JSON.parse(extensionKeysForSyncFromStorageValue) : undefined;
-        return extensionKeysForSyncFromStorage && extensionKeysForSyncFromProduct
-            ? distinct([...extensionKeysForSyncFromStorage, ...extensionKeysForSyncFromProduct])
-            : (extensionKeysForSyncFromStorage || extensionKeysForSyncFromProduct);
-    }
-    addToMigrationList(from, to) {
-        if (from !== to) {
-            const migrationList = this.migrationList.filter(entry => !entry.includes(from) && !entry.includes(to));
-            migrationList.push([from, to]);
-            this.migrationList = migrationList;
-        }
-    }
-    getSourceExtensionToMigrate(toExtensionId) {
-        const entry = this.migrationList.find(([, to]) => toExtensionId === to);
-        return entry ? entry[0] : undefined;
-    }
-    get migrationList() {
-        const value = this.storageService.get('extensionStorage.migrationList', -1 , '[]');
-        try {
-            const migrationList = JSON.parse(value);
-            if (Array.isArray(migrationList)) {
-                return migrationList;
-            }
-        }
-        catch (error) {  }
-        return [];
-    }
-    set migrationList(migrationList) {
-        if (migrationList.length) {
-            this.storageService.store('extensionStorage.migrationList', JSON.stringify(migrationList), -1 , 1 );
-        }
-        else {
-            this.storageService.remove('extensionStorage.migrationList', -1 );
-        }
-    }
-};
-ExtensionStorageService.LARGE_STATE_WARNING_THRESHOLD = 512 * 1024;
-ExtensionStorageService = ( __decorate([
-    ( __param(0, IStorageService)),
-    ( __param(1, IProductService)),
-    ( __param(2, ILogService))
-], ExtensionStorageService));
-export { ExtensionStorageService, IExtensionStorageService };

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

@@ -1,28 +0,0 @@
-var FileType;
-( (function(FileType) {
-    FileType[FileType["Unknown"] = 0] = "Unknown";
-    FileType[FileType["File"] = 1] = "File";
-    FileType[FileType["Directory"] = 2] = "Directory";
-    FileType[FileType["SymbolicLink"] = 64] = "SymbolicLink";
-})(FileType || (FileType = {})));
-var FileSystemProviderCapabilities;
-( (function(FileSystemProviderCapabilities) {
-    FileSystemProviderCapabilities[FileSystemProviderCapabilities["None"] = 0] = "None";
-    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileReadWrite"] = 2] = "FileReadWrite";
-    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileOpenReadWriteClose"] = 4] = "FileOpenReadWriteClose";
-    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileReadStream"] = 16] = "FileReadStream";
-    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileFolderCopy"] = 8] = "FileFolderCopy";
-    FileSystemProviderCapabilities[FileSystemProviderCapabilities["PathCaseSensitive"] = 1024] = "PathCaseSensitive";
-    FileSystemProviderCapabilities[FileSystemProviderCapabilities["Readonly"] = 2048] = "Readonly";
-    FileSystemProviderCapabilities[FileSystemProviderCapabilities["Trash"] = 4096] = "Trash";
-    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileWriteUnlock"] = 8192] = "FileWriteUnlock";
-    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileAtomicRead"] = 16384] = "FileAtomicRead";
-    FileSystemProviderCapabilities[FileSystemProviderCapabilities["FileClone"] = 32768] = "FileClone";
-})(FileSystemProviderCapabilities || (FileSystemProviderCapabilities = {})));
-var FileChangeType;
-( (function(FileChangeType) {
-    FileChangeType[FileChangeType["UPDATED"] = 0] = "UPDATED";
-    FileChangeType[FileChangeType["ADDED"] = 1] = "ADDED";
-    FileChangeType[FileChangeType["DELETED"] = 2] = "DELETED";
-})(FileChangeType || (FileChangeType = {})));
-export { FileChangeType, FileSystemProviderCapabilities, FileType };

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

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

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

@@ -1,332 +0,0 @@
-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/update/common/update.js

@@ -1,3 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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/workbench/api/browser/mainThreadLocalization.js

@@ -1,33 +0,0 @@
-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 };