@codingame/monaco-vscode-api 1.78.8 → 1.79.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

@@ -4,6 +4,7 @@ import { TELEMETRY_SETTING_ID, TELEMETRY_CRASH_REPORTER_SETTING_ID, TELEMETRY_OL
 class TelemetryTrustedValue {
     constructor(value) {
         this.value = value;
+        this.isTrustedTelemetryValue = true;
     }
 }
 class NullEndpointTelemetryService {
@@ -101,7 +102,7 @@ function removePropertiesWithPossibleUserInfo(property) {
 }
 function cleanData(data, cleanUpPatterns) {
     return cloneAndChange(data, value => {
-        if (value instanceof TelemetryTrustedValue) {
+        if (value instanceof TelemetryTrustedValue || Object.hasOwnProperty.call(value, 'isTrustedTelemetryValue')) {
             return value.value;
         }
         if (typeof value === 'string') {

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/workbench/api/browser/mainThreadBulkEdits.js

@@ -1,4 +1,5 @@
 import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { decodeBase64 } from 'monaco-editor/esm/vs/base/common/buffer.js';
 import { revive } from 'monaco-editor/esm/vs/base/common/marshalling.js';
 import { IBulkEditService, ResourceTextEdit, ResourceFileEdit } from 'monaco-editor/esm/vs/editor/browser/services/bulkEditService.js';
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
@@ -27,7 +28,7 @@ MainThreadBulkEdits = __decorate([
     ( __param(2, ILogService)),
     ( __param(3, IUriIdentityService))
 ], MainThreadBulkEdits);
-function reviveWorkspaceEditDto(data, uriIdentityService) {
+function reviveWorkspaceEditDto(data, uriIdentityService, resolveDataTransferFile) {
     if (!data || !data.edits) {
         return data;
     }
@@ -37,6 +38,22 @@ function reviveWorkspaceEditDto(data, uriIdentityService) {
             edit.resource = uriIdentityService.asCanonicalUri(edit.resource);
         }
         if (ResourceFileEdit.is(edit)) {
+            if (edit.options) {
+                const inContents = edit.options?.contents;
+                if (inContents) {
+                    if (inContents.type === 'base64') {
+                        edit.options.contents = Promise.resolve(decodeBase64(inContents.value));
+                    }
+                    else {
+                        if (resolveDataTransferFile) {
+                            edit.options.contents = resolveDataTransferFile(inContents.id);
+                        }
+                        else {
+                            throw new Error('Could not revive data transfer file');
+                        }
+                    }
+                }
+            }
             edit.newResource = edit.newResource && uriIdentityService.asCanonicalUri(edit.newResource);
             edit.oldResource = edit.oldResource && uriIdentityService.asCanonicalUri(edit.oldResource);
         }

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

@@ -34,6 +34,27 @@ let MainThreadDebugService = class MainThreadDebugService {
         this._debugConfigurationProviders = ( new Map());
         this._debugAdapterDescriptorFactories = ( new Map());
         this._sessions = ( new Set());
+        this._toDispose.add(this.debugService.getViewModel().onDidFocusThread(({ thread, explicit, session }) => {
+            if (session) {
+                const dto = {
+                    kind: 'thread',
+                    threadId: thread?.threadId,
+                    sessionId: session.getId(),
+                };
+                this._proxy.$acceptStackFrameFocus(dto);
+            }
+        }));
+        this._toDispose.add(this.debugService.getViewModel().onDidFocusStackFrame(({ stackFrame, explicit, session }) => {
+            if (session) {
+                const dto = {
+                    kind: 'stackFrame',
+                    threadId: stackFrame?.thread.threadId,
+                    frameId: stackFrame?.frameId,
+                    sessionId: session.getId(),
+                };
+                this._proxy.$acceptStackFrameFocus(dto);
+            }
+        }));
     }
     dispose() {
         this._toDispose.dispose();

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

@@ -50,7 +50,7 @@ let MainThreadExtensionService = class MainThreadExtensionService {
         error.message = data.message;
         error.stack = data.stack;
         this._internalExtensionService._onExtensionRuntimeError(extensionId, error);
-        console.error(`[${extensionId}]${error.message}`);
+        console.error(`[${extensionId.value}]${error.message}`);
         console.error(error.stack);
     }
     async $onExtensionActivationError(extensionId, data, missingExtensionDependency) {

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

@@ -452,9 +452,9 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
             provideInlineCompletions: async (model, position, context, token) => {
                 return this._proxy.$provideInlineCompletions(handle, model.uri, position, context, token);
             },
-            handleItemDidShow: async (completions, item) => {
+            handleItemDidShow: async (completions, item, updatedInsertText) => {
                 if (supportsHandleEvents) {
-                    await this._proxy.$handleInlineCompletionDidShow(handle, completions.pid, item.idx);
+                    await this._proxy.$handleInlineCompletionDidShow(handle, completions.pid, item.idx, updatedInsertText);
                 }
             },
             handlePartialAccept: async (completions, item, acceptedCharacters) => {
@@ -742,8 +742,8 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
             }
         }));
     }
-    $registerDocumentOnDropEditProvider(handle, selector) {
-        const provider = ( new MainThreadDocumentOnDropEditProvider(handle, this._proxy, this._uriIdentService));
+    $registerDocumentOnDropEditProvider(handle, selector, extensionId, metadata) {
+        const provider = ( new MainThreadDocumentOnDropEditProvider(handle, extensionId, metadata, this._proxy, this._uriIdentService));
         this._documentOnDropEditProviders.set(handle, provider);
         this._registrations.set(handle, combinedDisposable(this._languageFeaturesService.documentOnDropEditProvider.register(selector, provider), toDisposable(() => this._documentOnDropEditProviders.delete(handle))));
     }
@@ -797,7 +797,7 @@ let MainThreadPasteEditProvider = class MainThreadPasteEditProvider {
             }
             return {
                 insertText: result.insertText,
-                additionalEdit: result.additionalEdit ? reviveWorkspaceEditDto(result.additionalEdit, this._uriIdentService) : undefined,
+                additionalEdit: result.additionalEdit ? reviveWorkspaceEditDto(result.additionalEdit, this._uriIdentService, dataId => this.resolveFileData(request.id, dataId)) : undefined,
             };
         }
         finally {
@@ -805,18 +805,20 @@ let MainThreadPasteEditProvider = class MainThreadPasteEditProvider {
         }
     }
     resolveFileData(requestId, dataId) {
-        return this.dataTransfers.resolveDropFileData(requestId, dataId);
+        return this.dataTransfers.resolveFileData(requestId, dataId);
     }
 };
 MainThreadPasteEditProvider = ( __decorate([
     ( __param(4, IUriIdentityService))
 ], MainThreadPasteEditProvider));
 let MainThreadDocumentOnDropEditProvider = class MainThreadDocumentOnDropEditProvider {
-    constructor(handle, _proxy, _uriIdentService) {
+    constructor(handle, extensionId, metadata, _proxy, _uriIdentService) {
         this.handle = handle;
         this._proxy = _proxy;
         this._uriIdentService = _uriIdentService;
         this.dataTransfers = ( new DataTransferCache());
+        this.id = extensionId.value + (metadata ? '.' + metadata.id : '');
+        this.dropMimeTypes = metadata?.dropMimeTypes ?? ['*/*'];
     }
     async provideDocumentOnDropEdits(model, position, dataTransfer, token) {
         const request = this.dataTransfers.add(dataTransfer);
@@ -827,8 +829,9 @@ let MainThreadDocumentOnDropEditProvider = class MainThreadDocumentOnDropEditPro
                 return undefined;
             }
             return {
+                label: edit.label,
                 insertText: edit.insertText,
-                additionalEdit: reviveWorkspaceEditDto(edit.additionalEdit, this._uriIdentService),
+                additionalEdit: reviveWorkspaceEditDto(edit.additionalEdit, this._uriIdentService, dataId => this.resolveDocumentOnDropFileData(request.id, dataId)),
             };
         }
         finally {
@@ -836,11 +839,11 @@ let MainThreadDocumentOnDropEditProvider = class MainThreadDocumentOnDropEditPro
         }
     }
     resolveDocumentOnDropFileData(requestId, dataId) {
-        return this.dataTransfers.resolveDropFileData(requestId, dataId);
+        return this.dataTransfers.resolveFileData(requestId, dataId);
     }
 };
 MainThreadDocumentOnDropEditProvider = ( __decorate([
-    ( __param(2, IUriIdentityService))
+    ( __param(4, IUriIdentityService))
 ], MainThreadDocumentOnDropEditProvider));
 class MainThreadDocumentSemanticTokensProvider {
     constructor(_proxy, _handle, _legend, onDidChange) {

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 };