@codingame/monaco-vscode-api 1.69.24 → 1.76.0-next.1

package/dist/extHost.js

@@ -1,46 +1,49 @@
-import { _ as __decorate, a as __param, E as Emitter, c as __classPrivateFieldSet, d as __classPrivateFieldGet } from './workspace.js';
-import { u as disposed, v as coalesceInPlace, C as ConsoleMainLogger, w as mapArrayOrNot, x as delta$1, y as readonly, N as NotImplementedError, R as ResourceSet } from './polyfill.js';
-import { b as IEditorService, I as IEditorGroupsService, h as IProductService, P as markAsFileSystemProviderError, u as FileSystemProviderErrorCode, A as ACTIVE_GROUP, p as SIDE_GROUP, k as IUriIdentityService, f as IPaneCompositePartService, j as ITextFileService, c as IFileService, l as IWorkbenchEnvironmentService, m as IWorkingCopyFileService, g as IPathService, e as ILanguageStatusService, d as IHostService, S as Services } from './services2.js';
-import { b as isStringArray, w as withUndefinedAsNull } from './types.js';
+import { _ as __decorate, a as __param, E as Emitter$1, c as __classPrivateFieldSet, d as __classPrivateFieldGet } from './contextkey.js';
+import { l as checkProposedApiEnabled, u as unsupported, c as IExtensionService, m as ILoggerService, n as isLogLevel, i as isProposedApiEnabled } from './missing-services.js';
+import { b as IEditorService, I as IEditorGroupsService, h as IProductService, B as FileSystemProviderErrorCode, P as markAsFileSystemProviderError, A as ACTIVE_GROUP, p as SIDE_GROUP, Q as preferredSideBySideGroupDirection, S as Services, k as IUriIdentityService, f as IPaneCompositePartService, j as ITextFileService, c as IFileService, l as IWorkbenchEnvironmentService, m as IWorkingCopyFileService, g as IPathService, e as ILanguageStatusService, d as IHostService } from './services2.js';
+import { z as disposed, h as isStringArray, w as withUndefinedAsNull, A as mapArrayOrNot, B as delta$1, C as readonly, D as NotImplementedError, E as encodeBase64 } from './polyfill.js';
 import { illegalArgument, canceled, transformErrorForSerialization, CancellationError, onUnexpectedError, onUnexpectedExternalError, isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { coalesceInPlace, equals as equals$1, coalesce, isNonEmptyArray, isFalsyOrEmpty, asArray, distinct } from 'monaco-editor/esm/vs/base/common/arrays.js';
 import { URI, uriToFsPath } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { equals as equals$1, coalesce, isNonEmptyArray, isFalsyOrEmpty, asArray, distinct } from 'monaco-editor/esm/vs/base/common/arrays.js';
 import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
-import { isString, isArray, isNumber, validateConstraint, assertIsDefined, isObject, withNullAsUndefined, isUndefinedOrNull, isUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { isNumber, isObject, isString, validateConstraint, assertIsDefined, withNullAsUndefined, isUndefinedOrNull, isUndefined } from 'monaco-editor/esm/vs/base/common/types.js';
 import { compare, equalsIgnoreCase, isFalsyOrWhitespace, nextCharLength, splitLines, regExpFlags, regExpLeadsToEndlessLoop } from 'monaco-editor/esm/vs/base/common/strings.js';
 import { Mimes } from 'monaco-editor/esm/vs/base/common/mime.js';
-import { ResourceMap, TernarySearchTree } from 'monaco-editor/esm/vs/base/common/map.js';
+import { ResourceMap as ResourceMap$1 } from 'monaco-editor/esm/vs/base/common/map.js';
 import { MarkdownString as MarkdownString$2, parseHrefAndDimensions, isMarkdownString } from 'monaco-editor/esm/vs/base/common/htmlContent.js';
 import { marked as marked$1 } from 'monaco-editor/esm/vs/base/common/marked/marked.js';
 import * as monaco from 'monaco-editor/esm/vs/editor/editor.api.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
 import { MarkerSeverity, IMarkerService } from 'monaco-editor/esm/vs/platform/markers/common/markers.js';
 import { revive, parse } from 'monaco-editor/esm/vs/base/common/marshalling.js';
-import { equals, cloneAndChange, deepFreeze, mixin, deepClone } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { equals, mixin, cloneAndChange, deepFreeze, deepClone } from 'monaco-editor/esm/vs/base/common/objects.js';
 import { once } from 'monaco-editor/esm/vs/base/common/functional.js';
-import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
-import { createDecorator, IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { createStringDataTransferItem, VSDataTransfer, UriList } from 'monaco-editor/esm/vs/base/common/dataTransfer.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { Disposable as Disposable$1, DisposableStore, dispose, toDisposable, DisposableMap, combinedDisposable, SafeDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { ILogService, LogLevel } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { StopWatch } from 'monaco-editor/esm/vs/base/common/stopwatch.js';
 import { toErrorMessage } from 'monaco-editor/esm/vs/base/common/errorMessage.js';
-import { ILogService, LogLevel, LogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { Disposable as Disposable$1, DisposableStore, dispose, toDisposable, combinedDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { d as IExtensionService, u as unsupported, m as checkProposedApiEnabled, i as isProposedApiEnabled } from './missing-services.js';
 import { ICommandService, CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
-import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
 import { basename as basename$1, dirname as dirname$1, basenameOrAuthority, relativePath, ExtUri as ExtUri$1, extUri as extUri$1 } from 'monaco-editor/esm/vs/base/common/resources.js';
 import { DebounceEmitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { RunOnceScheduler, disposableTimeout } from 'monaco-editor/esm/vs/base/common/async.js';
 import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
 import { MirrorTextModel } from 'monaco-editor/esm/vs/editor/common/model/mirrorTextModel.js';
 import { ok } from 'monaco-editor/esm/vs/base/common/assert.js';
 import { getWordAtText, ensureValidWordDefinition } from 'monaco-editor/esm/vs/editor/common/core/wordHelper.js';
 import Severity$1 from 'monaco-editor/esm/vs/base/common/severity.js';
-import { ThemeIcon as ThemeIcon$1 } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ThemeIcon as ThemeIcon$1 } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { LinkedList } from 'monaco-editor/esm/vs/base/common/linkedList.js';
 import { B as Barrier, r as raceCancellationError } from './async.js';
 import { INotificationService, Severity } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
 import { IWorkspaceContextService, Workspace, WorkspaceFolder } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { TernarySearchTree } from 'monaco-editor/esm/vs/base/common/ternarySearchTree.js';
 import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { toAction, Action } from 'monaco-editor/esm/vs/base/common/actions.js';
 import { IDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
-import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
 import { IProgressService, Progress } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
 import { EditOperation } from 'monaco-editor/esm/vs/editor/common/core/editOperation.js';
 import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
@@ -58,27 +61,292 @@ import { SnippetParser } from 'monaco-editor/esm/vs/editor/contrib/snippet/brows
 import { SnippetController2 } from 'monaco-editor/esm/vs/editor/contrib/snippet/browser/snippetController2.js';
 import { EditorState } from 'monaco-editor/esm/vs/editor/contrib/editorState/browser/editorState.js';
 import { TextEditorCursorStyle as TextEditorCursorStyle$1 } from 'monaco-editor/esm/vs/editor/common/config/editorOptions.js';
+import { getCodeEditor, isCodeEditor, isDiffEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
 import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import { IConfigurationService, getLanguageTagSettingPlainKey } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
-import { isCodeEditor, isDiffEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
 import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
 import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
 import { IBulkEditService, ResourceTextEdit, ResourceFileEdit, ResourceEdit } from 'monaco-editor/esm/vs/editor/browser/services/bulkEditService.js';
 import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
 import { encodeSemanticTokensDto } from 'monaco-editor/esm/vs/editor/common/services/semanticTokensDto.js';
 import { InlineCompletionTriggerKind as InlineCompletionTriggerKind$1 } from 'monaco-editor/esm/vs/editor/common/languages.js';
-import { StopWatch } from 'monaco-editor/esm/vs/base/common/stopwatch.js';
 import { LanguageFeatureRegistry } from 'monaco-editor/esm/vs/editor/common/languageFeatureRegistry.js';
 import { ILanguageConfigurationService } from 'monaco-editor/esm/vs/editor/common/languages/languageConfigurationRegistry.js';
 import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
-import { createStringDataTransferItem, VSDataTransfer } from 'monaco-editor/esm/vs/base/common/dataTransfer.js';
 import { Configuration, ConfigurationChangeEvent } from 'monaco-editor/esm/vs/platform/configuration/common/configurationModels.js';
 import { Extensions, OVERRIDE_PROPERTY_REGEX as OVERRIDE_PROPERTY_REGEX$1 } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
-import { IConfigurationService, getLanguageTagSettingPlainKey } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
 import { Extensions as Extensions$1 } from 'monaco-editor/esm/vs/platform/jsonschemas/common/jsonContributionRegistry.js';
 import { ExtensionIdentifier } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
 import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
+class EventProfiling {
+    constructor(name) {
+        this.listenerCount = 0;
+        this.invocationCount = 0;
+        this.elapsedOverall = 0;
+        this.durations = [];
+        this.name = `${name}_${EventProfiling._idPool++}`;
+        EventProfiling.all.add(this);
+    }
+    start(listenerCount) {
+        this._stopWatch = ( (new StopWatch(true)));
+        this.listenerCount = listenerCount;
+    }
+    stop() {
+        if (this._stopWatch) {
+            const elapsed = this._stopWatch.elapsed();
+            this.durations.push(elapsed);
+            this.elapsedOverall += elapsed;
+            this.invocationCount += 1;
+            this._stopWatch = undefined;
+        }
+    }
+}
+EventProfiling.all = ( (new Set()));
+EventProfiling._idPool = 0;
+let _globalLeakWarningThreshold = -1;
+class LeakageMonitor {
+    constructor(threshold, name = ( (Math.random().toString(18))).slice(2, 5)) {
+        this.threshold = threshold;
+        this.name = name;
+        this._warnCountdown = 0;
+    }
+    dispose() {
+        this._stacks?.clear();
+    }
+    check(stack, listenerCount) {
+        const threshold = this.threshold;
+        if (threshold <= 0 || listenerCount < threshold) {
+            return undefined;
+        }
+        if (!this._stacks) {
+            this._stacks = ( (new Map()));
+        }
+        const count = (this._stacks.get(stack.value) || 0);
+        this._stacks.set(stack.value, count + 1);
+        this._warnCountdown -= 1;
+        if (this._warnCountdown <= 0) {
+            this._warnCountdown = threshold * 0.5;
+            let topStack;
+            let topCount = 0;
+            for (const [stack, count] of this._stacks) {
+                if (!topStack || topCount < count) {
+                    topStack = stack;
+                    topCount = count;
+                }
+            }
+            console.warn(`[${this.name}] potential listener LEAK detected, having ${listenerCount} listeners already. MOST frequent listener (${topCount}):`);
+            console.warn(topStack);
+        }
+        return () => {
+            const count = (this._stacks.get(stack.value) || 0);
+            this._stacks.set(stack.value, count - 1);
+        };
+    }
+}
+class Stacktrace {
+    static create() {
+        return (
+             (new Stacktrace(( (new Error())).stack ?? ''))
+        );
+    }
+    constructor(value) {
+        this.value = value;
+    }
+    print() {
+        console.warn(this.value.split('\n').slice(2).join('\n'));
+    }
+}
+class Listener {
+    constructor(callback, callbackThis, stack) {
+        this.callback = callback;
+        this.callbackThis = callbackThis;
+        this.stack = stack;
+        this.subscription = ( (new SafeDisposable()));
+    }
+    invoke(e) {
+        this.callback.call(this.callbackThis, e);
+    }
+}
+class Emitter {
+    constructor(options) {
+        this._disposed = false;
+        this._options = options;
+        this._leakageMon = this._options?.leakWarningThreshold ? ( (new LeakageMonitor(this._options?.leakWarningThreshold ?? _globalLeakWarningThreshold))) : undefined;
+        this._perfMon = this._options?._profName ? ( (new EventProfiling(this._options._profName))) : undefined;
+        this._deliveryQueue = this._options?.deliveryQueue;
+    }
+    dispose() {
+        if (!this._disposed) {
+            this._disposed = true;
+            if (this._listeners) {
+                this._listeners.clear();
+            }
+            this._deliveryQueue?.clear(this);
+            this._options?.onDidRemoveLastListener?.();
+            this._leakageMon?.dispose();
+        }
+    }
+    get event() {
+        if (!this._event) {
+            this._event = (callback, thisArgs, disposables) => {
+                if (!this._listeners) {
+                    this._listeners = ( (new LinkedList()));
+                }
+                if (this._leakageMon && this._listeners.size > this._leakageMon.threshold * 3) {
+                    console.warn(`[${this._leakageMon.name}] REFUSES to accept new listeners because it exceeded its threshold by far`);
+                    return Disposable$1.None;
+                }
+                const firstListener = this._listeners.isEmpty();
+                if (firstListener && this._options?.onWillAddFirstListener) {
+                    this._options.onWillAddFirstListener(this);
+                }
+                let removeMonitor;
+                let stack;
+                if (this._leakageMon && this._listeners.size >= Math.ceil(this._leakageMon.threshold * 0.2)) {
+                    stack = Stacktrace.create();
+                    removeMonitor = this._leakageMon.check(stack, this._listeners.size + 1);
+                }
+                const listener = ( (new Listener(callback, thisArgs, stack)));
+                const removeListener = this._listeners.push(listener);
+                if (firstListener && this._options?.onDidAddFirstListener) {
+                    this._options.onDidAddFirstListener(this);
+                }
+                if (this._options?.onDidAddListener) {
+                    this._options.onDidAddListener(this, callback, thisArgs);
+                }
+                const result = listener.subscription.set(() => {
+                    removeMonitor?.();
+                    if (!this._disposed) {
+                        this._options?.onWillRemoveListener?.(this);
+                        removeListener();
+                        if (this._options && this._options.onDidRemoveLastListener) {
+                            const hasListeners = (this._listeners && !this._listeners.isEmpty());
+                            if (!hasListeners) {
+                                this._options.onDidRemoveLastListener(this);
+                            }
+                        }
+                    }
+                });
+                if (disposables instanceof DisposableStore) {
+                    disposables.add(result);
+                }
+                else if (Array.isArray(disposables)) {
+                    disposables.push(result);
+                }
+                return result;
+            };
+        }
+        return this._event;
+    }
+    fire(event) {
+        if (this._listeners) {
+            if (!this._deliveryQueue) {
+                this._deliveryQueue = ( (new PrivateEventDeliveryQueue()));
+            }
+            for (const listener of this._listeners) {
+                this._deliveryQueue.push(this, listener, event);
+            }
+            this._perfMon?.start(this._deliveryQueue.size);
+            this._deliveryQueue.deliver();
+            this._perfMon?.stop();
+        }
+    }
+    hasListeners() {
+        if (!this._listeners) {
+            return false;
+        }
+        return !this._listeners.isEmpty();
+    }
+}
+class EventDeliveryQueue {
+    constructor() {
+        this._queue = ( (new LinkedList()));
+    }
+    get size() {
+        return this._queue.size;
+    }
+    push(emitter, listener, event) {
+        this._queue.push(( (new EventDeliveryQueueElement(emitter, listener, event))));
+    }
+    clear(emitter) {
+        const newQueue = ( (new LinkedList()));
+        for (const element of this._queue) {
+            if (element.emitter !== emitter) {
+                newQueue.push(element);
+            }
+        }
+        this._queue = newQueue;
+    }
+    deliver() {
+        while (this._queue.size > 0) {
+            const element = this._queue.shift();
+            try {
+                element.listener.invoke(element.event);
+            }
+            catch (e) {
+                onUnexpectedError(e);
+            }
+        }
+    }
+}
+class PrivateEventDeliveryQueue extends EventDeliveryQueue {
+    clear(emitter) {
+        this._queue.clear();
+    }
+}
+class EventDeliveryQueueElement {
+    constructor(emitter, listener, event) {
+        this.emitter = emitter;
+        this.listener = listener;
+        this.event = event;
+    }
+}
+class AsyncEmitter extends Emitter {
+    async fireAsync(data, token, promiseJoin) {
+        if (!this._listeners) {
+            return;
+        }
+        if (!this._asyncDeliveryQueue) {
+            this._asyncDeliveryQueue = ( (new LinkedList()));
+        }
+        for (const listener of this._listeners) {
+            this._asyncDeliveryQueue.push([listener, data]);
+        }
+        while (this._asyncDeliveryQueue.size > 0 && !token.isCancellationRequested) {
+            const [listener, data] = this._asyncDeliveryQueue.shift();
+            const thenables = [];
+            const event = {
+                ...data,
+                token,
+                waitUntil: (p) => {
+                    if (Object.isFrozen(thenables)) {
+                        throw new Error('waitUntil can NOT be called asynchronous');
+                    }
+                    if (promiseJoin) {
+                        p = promiseJoin(p, listener.callback);
+                    }
+                    thenables.push(p);
+                }
+            };
+            try {
+                listener.invoke(event);
+            }
+            catch (e) {
+                onUnexpectedError(e);
+                continue;
+            }
+            await Promise.allSettled(thenables).then(values => {
+                for (const value of values) {
+                    if (value.status === 'rejected') {
+                        onUnexpectedError(value.reason);
+                    }
+                }
+            });
+        }
+    }
+}
 const CancellationTokenSource = monaco.CancellationTokenSource;
 function originalFSPath(uri) {
     return uriToFsPath(uri, true);
@@ -289,9 +557,9 @@ const contributionRegistry = ( (Registry.as(Extensions$1.JSONContribution)));
 class ConfigurationRegistry {
     constructor() {
         this.overrideIdentifiers = ( (new Set()));
-        this._onDidSchemaChange = ( (new Emitter()));
+        this._onDidSchemaChange = ( (new Emitter$1()));
         this.onDidSchemaChange = this._onDidSchemaChange.event;
-        this._onDidUpdateConfiguration = ( (new Emitter()));
+        this._onDidUpdateConfiguration = ( (new Emitter$1()));
         this.onDidUpdateConfiguration = this._onDidUpdateConfiguration.event;
         this.configurationDefaultsOverrides = ( (new Map()));
         this.defaultLanguageConfigurationOverridesNode = {
@@ -303,7 +571,13 @@ class ConfigurationRegistry {
             properties: {}
         };
         this.configurationContributors = [this.defaultLanguageConfigurationOverridesNode];
-        this.resourceLanguageSettingsSchema = { properties: {}, patternProperties: {}, additionalProperties: false, errorMessage: 'Unknown editor configuration setting', allowTrailingCommas: true, allowComments: true };
+        this.resourceLanguageSettingsSchema = {
+            properties: {},
+            patternProperties: {},
+            additionalProperties: true,
+            allowTrailingCommas: true,
+            allowComments: true
+        };
         this.configurationProperties = {};
         this.policyConfigurations = ( (new Map()));
         this.excludedConfigurationProperties = {};
@@ -314,31 +588,38 @@ class ConfigurationRegistry {
         this.registerConfigurations([configuration], validate);
     }
     registerConfigurations(configurations, validate = true) {
-        const properties = this.doRegisterConfigurations(configurations, validate);
+        const properties = ( (new Set()));
+        this.doRegisterConfigurations(configurations, validate, properties);
         contributionRegistry.registerSchema(resourceLanguageSettingsSchemaId, this.resourceLanguageSettingsSchema);
         this._onDidSchemaChange.fire();
         this._onDidUpdateConfiguration.fire({ properties });
     }
     deregisterConfigurations(configurations) {
-        const properties = this.doDeregisterConfigurations(configurations);
+        const properties = ( (new Set()));
+        this.doDeregisterConfigurations(configurations, properties);
         contributionRegistry.registerSchema(resourceLanguageSettingsSchemaId, this.resourceLanguageSettingsSchema);
         this._onDidSchemaChange.fire();
         this._onDidUpdateConfiguration.fire({ properties });
     }
     updateConfigurations({ add, remove }) {
-        const properties = [];
-        properties.push(...this.doDeregisterConfigurations(remove));
-        properties.push(...this.doRegisterConfigurations(add, false));
+        const properties = ( (new Set()));
+        this.doDeregisterConfigurations(remove, properties);
+        this.doRegisterConfigurations(add, false, properties);
         contributionRegistry.registerSchema(resourceLanguageSettingsSchemaId, this.resourceLanguageSettingsSchema);
         this._onDidSchemaChange.fire();
-        this._onDidUpdateConfiguration.fire({ properties: distinct(properties) });
+        this._onDidUpdateConfiguration.fire({ properties });
     }
     registerDefaultConfigurations(configurationDefaults) {
-        const properties = [];
+        const properties = ( (new Set()));
+        this.doRegisterDefaultConfigurations(configurationDefaults, properties);
+        this._onDidSchemaChange.fire();
+        this._onDidUpdateConfiguration.fire({ properties, defaultsOverrides: true });
+    }
+    doRegisterDefaultConfigurations(configurationDefaults, bucket) {
         const overrideIdentifiers = [];
         for (const { overrides, source } of configurationDefaults) {
             for (const key in overrides) {
-                properties.push(key);
+                bucket.add(key);
                 if (OVERRIDE_PROPERTY_REGEX.test(key)) {
                     const configurationDefaultOverride = this.configurationDefaultsOverrides.get(key);
                     const valuesSources = configurationDefaultOverride?.valuesSources ?? ( (new Map()));
@@ -377,12 +658,15 @@ class ConfigurationRegistry {
                 }
             }
         }
-        this.registerOverrideIdentifiers(overrideIdentifiers);
+        this.doRegisterOverrideIdentifiers(overrideIdentifiers);
+    }
+    deregisterDefaultConfigurations(defaultConfigurations) {
+        const properties = ( (new Set()));
+        this.doDeregisterDefaultConfigurations(defaultConfigurations, properties);
         this._onDidSchemaChange.fire();
         this._onDidUpdateConfiguration.fire({ properties, defaultsOverrides: true });
     }
-    deregisterDefaultConfigurations(defaultConfigurations) {
-        const properties = [];
+    doDeregisterDefaultConfigurations(defaultConfigurations, bucket) {
         for (const { overrides, source } of defaultConfigurations) {
             for (const key in overrides) {
                 const configurationDefaultsOverride = this.configurationDefaultsOverrides.get(key);
@@ -391,7 +675,7 @@ class ConfigurationRegistry {
                 if (id !== configurationDefaultsOverrideSourceId) {
                     continue;
                 }
-                properties.push(key);
+                bucket.add(key);
                 this.configurationDefaultsOverrides.delete(key);
                 if (OVERRIDE_PROPERTY_REGEX.test(key)) {
                     delete this.configurationProperties[key];
@@ -407,33 +691,52 @@ class ConfigurationRegistry {
             }
         }
         this.updateOverridePropertyPatternKey();
+    }
+    deltaConfiguration(delta) {
+        let defaultsOverrides = false;
+        const properties = ( (new Set()));
+        if (delta.removedDefaults) {
+            this.doDeregisterDefaultConfigurations(delta.removedDefaults, properties);
+            defaultsOverrides = true;
+        }
+        if (delta.addedDefaults) {
+            this.doRegisterDefaultConfigurations(delta.addedDefaults, properties);
+            defaultsOverrides = true;
+        }
+        if (delta.removedConfigurations) {
+            this.doDeregisterConfigurations(delta.removedConfigurations, properties);
+        }
+        if (delta.addedConfigurations) {
+            this.doRegisterConfigurations(delta.addedConfigurations, false, properties);
+        }
         this._onDidSchemaChange.fire();
-        this._onDidUpdateConfiguration.fire({ properties, defaultsOverrides: true });
+        this._onDidUpdateConfiguration.fire({ properties, defaultsOverrides });
     }
     notifyConfigurationSchemaUpdated(...configurations) {
         this._onDidSchemaChange.fire();
     }
     registerOverrideIdentifiers(overrideIdentifiers) {
+        this.doRegisterOverrideIdentifiers(overrideIdentifiers);
+        this._onDidSchemaChange.fire();
+    }
+    doRegisterOverrideIdentifiers(overrideIdentifiers) {
         for (const overrideIdentifier of overrideIdentifiers) {
             this.overrideIdentifiers.add(overrideIdentifier);
         }
         this.updateOverridePropertyPatternKey();
     }
-    doRegisterConfigurations(configurations, validate) {
-        const properties = [];
+    doRegisterConfigurations(configurations, validate, bucket) {
         configurations.forEach(configuration => {
-            properties.push(...this.validateAndRegisterProperties(configuration, validate, configuration.extensionInfo, configuration.restrictedProperties));
+            this.validateAndRegisterProperties(configuration, validate, configuration.extensionInfo, configuration.restrictedProperties, undefined, bucket);
             this.configurationContributors.push(configuration);
             this.registerJSONConfiguration(configuration);
         });
-        return properties;
     }
-    doDeregisterConfigurations(configurations) {
-        const properties = [];
+    doDeregisterConfigurations(configurations, bucket) {
         const deregisterConfiguration = (configuration) => {
             if (configuration.properties) {
                 for (const key in configuration.properties) {
-                    properties.push(key);
+                    bucket.add(key);
                     const property = this.configurationProperties[key];
                     if (property?.policy?.name) {
                         this.policyConfigurations.delete(property.policy.name);
@@ -451,11 +754,9 @@ class ConfigurationRegistry {
                 this.configurationContributors.splice(index, 1);
             }
         }
-        return properties;
     }
-    validateAndRegisterProperties(configuration, validate = true, extensionInfo, restrictedProperties, scope = 3 ) {
+    validateAndRegisterProperties(configuration, validate = true, extensionInfo, restrictedProperties, scope = 3 , bucket) {
         scope = isUndefinedOrNull(configuration.scope) ? scope : configuration.scope;
-        const propertyKeys = [];
         const properties = configuration.properties;
         if (properties) {
             for (const key in properties) {
@@ -488,16 +789,15 @@ class ConfigurationRegistry {
                 if (!properties[key].deprecationMessage && properties[key].markdownDeprecationMessage) {
                     properties[key].deprecationMessage = properties[key].markdownDeprecationMessage;
                 }
-                propertyKeys.push(key);
+                bucket.add(key);
             }
         }
         const subNodes = configuration.allOf;
         if (subNodes) {
             for (const node of subNodes) {
-                propertyKeys.push(...this.validateAndRegisterProperties(node, validate, extensionInfo, restrictedProperties, scope));
+                this.validateAndRegisterProperties(node, validate, extensionInfo, restrictedProperties, scope, bucket);
             }
         }
-        return propertyKeys;
     }
     getConfigurations() {
         return this.configurationContributors;
@@ -577,7 +877,6 @@ class ConfigurationRegistry {
             };
             this.updatePropertyDefaultValue(overrideIdentifierProperty, resourceLanguagePropertiesSchema);
         }
-        this._onDidSchemaChange.fire();
     }
     registerOverridePropertyPatternKey() {
         this._onDidSchemaChange.fire();
@@ -685,19 +984,126 @@ function getScopes() {
     return scopes;
 }
 const Position$2 = monaco.Position;
-const TELEMETRY_SETTING_ID = 'telemetry.telemetryLevel';
-const TELEMETRY_OLD_SETTING_ID = 'telemetry.enableTelemetry';
-const _simplePattern = /^(.+)\/(.+?)(;.+)?$/;
-function normalizeMimeType(mimeType, strict) {
-    const match = _simplePattern.exec(mimeType);
-    if (!match) {
-        return strict
-            ? undefined
-            : mimeType;
+var _a$2, _b;
+class ResourceMapEntry {
+    constructor(uri, value) {
+        this.uri = uri;
+        this.value = value;
     }
-    return `${match[1].toLowerCase()}/${match[2].toLowerCase()}${match[3] ?? ''}`;
 }
-const marked = marked$1.marked;
+class ResourceMap {
+    constructor(mapOrKeyFn, toKey) {
+        this[_a$2] = 'ResourceMap';
+        if (mapOrKeyFn instanceof ResourceMap) {
+            this.map = ( (new Map(mapOrKeyFn.map)));
+            this.toKey = toKey ?? ResourceMap.defaultToKey;
+        }
+        else {
+            this.map = ( (new Map()));
+            this.toKey = mapOrKeyFn ?? ResourceMap.defaultToKey;
+        }
+    }
+    set(resource, value) {
+        this.map.set(this.toKey(resource), ( (new ResourceMapEntry(resource, value))));
+        return this;
+    }
+    get(resource) {
+        return this.map.get(this.toKey(resource))?.value;
+    }
+    has(resource) {
+        return this.map.has(this.toKey(resource));
+    }
+    get size() {
+        return this.map.size;
+    }
+    clear() {
+        this.map.clear();
+    }
+    delete(resource) {
+        return this.map.delete(this.toKey(resource));
+    }
+    forEach(clb, thisArg) {
+        if (typeof thisArg !== 'undefined') {
+            clb = clb.bind(thisArg);
+        }
+        for (const [_, entry] of this.map) {
+            clb(entry.value, entry.uri, this);
+        }
+    }
+    *values() {
+        for (const entry of ( (this.map.values()))) {
+            yield entry.value;
+        }
+    }
+    *keys() {
+        for (const entry of ( (this.map.values()))) {
+            yield entry.uri;
+        }
+    }
+    *entries() {
+        for (const entry of ( (this.map.values()))) {
+            yield [entry.uri, entry.value];
+        }
+    }
+    *[(_a$2 = Symbol.toStringTag, Symbol.iterator)]() {
+        for (const [, entry] of this.map) {
+            yield [entry.uri, entry.value];
+        }
+    }
+}
+ResourceMap.defaultToKey = (resource) => ( (resource.toString()));
+class ResourceSet {
+    constructor(entriesOrKey, toKey) {
+        this[_b] = 'ResourceSet';
+        if (!entriesOrKey || typeof entriesOrKey === 'function') {
+            this._map = ( (new ResourceMap(entriesOrKey)));
+        }
+        else {
+            this._map = ( (new ResourceMap(toKey)));
+            entriesOrKey.forEach(this.add, this);
+        }
+    }
+    get size() {
+        return this._map.size;
+    }
+    add(value) {
+        this._map.set(value, value);
+        return this;
+    }
+    clear() {
+        this._map.clear();
+    }
+    delete(value) {
+        return this._map.delete(value);
+    }
+    forEach(callbackfn, thisArg) {
+        this._map.forEach((_value, key) => callbackfn.call(thisArg, key, key, this));
+    }
+    has(value) {
+        return this._map.has(value);
+    }
+    entries() {
+        return this._map.entries();
+    }
+    keys() {
+        return (
+             (this._map.keys())
+        );
+    }
+    values() {
+        return (
+             (this._map.keys())
+        );
+    }
+    [(_b = Symbol.toStringTag, Symbol.iterator)]() {
+        return (
+             (this.keys())
+        );
+    }
+}
+const TELEMETRY_SETTING_ID = 'telemetry.telemetryLevel';
+const TELEMETRY_CRASH_REPORTER_SETTING_ID = 'telemetry.enableCrashReporter';
+const TELEMETRY_OLD_SETTING_ID = 'telemetry.enableTelemetry';
 function diffSets(before, after) {
     const removed = [];
     const added = [];
@@ -736,20 +1142,173 @@ class Counter {
         return this._next++;
     }
 }
+const _simplePattern = /^(.+)\/(.+?)(;.+)?$/;
+function normalizeMimeType(mimeType, strict) {
+    const match = _simplePattern.exec(mimeType);
+    if (!match) {
+        return strict
+            ? undefined
+            : mimeType;
+    }
+    return `${match[1].toLowerCase()}/${match[2].toLowerCase()}${match[3] ?? ''}`;
+}
+var CellKind;
+( ((function(CellKind) {
+    CellKind[CellKind["Markup"] = 1] = "Markup";
+    CellKind[CellKind["Code"] = 2] = "Code";
+})(CellKind || (CellKind = {}))));
+function isTextStreamMime(mimeType) {
+    return ['application/vnd.code.notebook.stdout', 'application/vnd.code.notebook.stderr'].includes(mimeType);
+}
+const MOVE_CURSOR_1_LINE_COMMAND = `${String.fromCharCode(27)}[A`;
+MOVE_CURSOR_1_LINE_COMMAND.split('').map(c => c.charCodeAt(0));
+function getRemoteAuthority(uri) {
+    return uri.scheme === Schemas.vscodeRemote ? uri.authority : undefined;
+}
+function getRemoteName(authority) {
+    if (!authority) {
+        return undefined;
+    }
+    const pos = authority.indexOf('+');
+    if (pos < 0) {
+        return authority;
+    }
+    return authority.substr(0, pos);
+}
+function getRemoteServerRootPath(product) {
+    return `/${product.quality ?? 'oss'}-${product.commit ?? 'dev'}`;
+}
+class TelemetryTrustedValue {
+    constructor(value) {
+        this.value = value;
+    }
+}
+const extensionTelemetryLogChannelId = 'extensionTelemetryLog';
+function supportsTelemetry(productService, environmentService) {
+    if (!environmentService.isBuilt && !environmentService.disableTelemetry) {
+        return true;
+    }
+    return !(environmentService.disableTelemetry || !productService.enableTelemetry || environmentService.extensionTestsLocationURI);
+}
+function getTelemetryLevel(configurationService) {
+    const newConfig = configurationService.getValue(TELEMETRY_SETTING_ID);
+    const crashReporterConfig = configurationService.getValue(TELEMETRY_CRASH_REPORTER_SETTING_ID);
+    const oldConfig = configurationService.getValue(TELEMETRY_OLD_SETTING_ID);
+    if (oldConfig === false || crashReporterConfig === false) {
+        return 0 ;
+    }
+    switch (newConfig ?? "all" ) {
+        case "all" :
+            return 3 ;
+        case "error" :
+            return 2 ;
+        case "crash" :
+            return 1 ;
+        case "off" :
+            return 0 ;
+    }
+}
+const telemetryAllowedAuthorities = ( (new Set(
+    ['ssh-remote', 'dev-container', 'attached-container', 'wsl', 'tunnel', 'codespaces', 'amlext']
+)));
+function cleanRemoteAuthority(remoteAuthority) {
+    if (!remoteAuthority) {
+        return 'none';
+    }
+    const remoteName = getRemoteName(remoteAuthority);
+    return telemetryAllowedAuthorities.has(remoteName) ? remoteName : 'other';
+}
+function anonymizeFilePaths(stack, cleanupPatterns) {
+    if (!stack || (!stack.includes('/') && !stack.includes('\\'))) {
+        return stack;
+    }
+    let updatedStack = stack;
+    const cleanUpIndexes = [];
+    for (const regexp of cleanupPatterns) {
+        while (true) {
+            const result = regexp.exec(stack);
+            if (!result) {
+                break;
+            }
+            cleanUpIndexes.push([result.index, regexp.lastIndex]);
+        }
+    }
+    const nodeModulesRegex = /^[\\\/]?(node_modules|node_modules\.asar)[\\\/]/;
+    const fileRegex = /(file:\/\/)?([a-zA-Z]:(\\\\|\\|\/)|(\\\\|\\|\/))?([\w-\._]+(\\\\|\\|\/))+[\w-\._]*/g;
+    let lastIndex = 0;
+    updatedStack = '';
+    while (true) {
+        const result = fileRegex.exec(stack);
+        if (!result) {
+            break;
+        }
+        const overlappingRange = cleanUpIndexes.some(([start, end]) => result.index < end && start < fileRegex.lastIndex);
+        if (!nodeModulesRegex.test(result[0]) && !overlappingRange) {
+            updatedStack += stack.substring(lastIndex, result.index) + '<REDACTED: user-file-path>';
+            lastIndex = fileRegex.lastIndex;
+        }
+    }
+    if (lastIndex < stack.length) {
+        updatedStack += stack.substr(lastIndex);
+    }
+    return updatedStack;
+}
+function removePropertiesWithPossibleUserInfo(property) {
+    if (!property) {
+        return property;
+    }
+    const value = property.toLowerCase();
+    const userDataRegexes = [
+        { label: 'Google API Key', regex: /AIza[A-Za-z0-9_\\\-]{35}/ },
+        { label: 'Slack Token', regex: /xox[pbar]\-[A-Za-z0-9]/ },
+        { label: 'Generic Secret', regex: /(key|token|sig|secret|signature|password|passwd|pwd|android:value)[^a-zA-Z0-9]/ },
+        { label: 'Email', regex: /@[a-zA-Z0-9-]+\.[a-zA-Z0-9-]+/ }
+    ];
+    for (const secretRegex of userDataRegexes) {
+        if (secretRegex.regex.test(value)) {
+            return `<REDACTED: ${secretRegex.label}>`;
+        }
+    }
+    return property;
+}
+function cleanData(data, cleanUpPatterns) {
+    return cloneAndChange(data, value => {
+        if (value instanceof TelemetryTrustedValue) {
+            return value.value;
+        }
+        if (typeof value === 'string') {
+            let updatedProperty = value.replaceAll('%20', ' ');
+            updatedProperty = anonymizeFilePaths(updatedProperty, cleanUpPatterns);
+            for (const regexp of cleanUpPatterns) {
+                updatedProperty = updatedProperty.replace(regexp, '');
+            }
+            updatedProperty = removePropertiesWithPossibleUserInfo(updatedProperty);
+            return updatedProperty;
+        }
+        return undefined;
+    });
+}
 var _Disposable_callOnDispose, _MarkdownString_delegate, _DataTransfer_items, _a$1, _NotebookCellOutputItem_encoder;
 var Disposable_1, Position_1, Range_1, Selection_1, TextEdit_1, NotebookEdit_1, SnippetString_1, Location_1, SymbolInformation_1, DocumentSymbol_1, CodeActionKind_1, MarkdownString_1, TaskGroup_1, Task_1, TreeItem_1, FileSystemError_1, TestMessage_1;
 function es5ClassCompat(target) {
-    function _() { return Reflect.construct(target, arguments, this.constructor); }
-    Object.defineProperty(_, 'name', Object.getOwnPropertyDescriptor(target, 'name'));
-    Object.setPrototypeOf(_, target);
-    Object.setPrototypeOf(_.prototype, target.prototype);
-    return _;
+    const interceptFunctions = {
+        apply: function () {
+            const args = arguments.length === 1 ? [] : arguments[1];
+            return Reflect.construct(target, args, arguments[0].constructor);
+        },
+        call: function () {
+            if (arguments.length === 0) {
+                return Reflect.construct(target, []);
+            }
+            else {
+                const [thisArg, ...restArgs] = arguments;
+                return Reflect.construct(target, restArgs, thisArg.constructor);
+            }
+        }
+    };
+    return Object.assign(target, interceptFunctions);
 }
 let Disposable = Disposable_1 = class Disposable {
-    constructor(callOnDispose) {
-        _Disposable_callOnDispose.set(this, void 0);
-        __classPrivateFieldSet(this, _Disposable_callOnDispose, callOnDispose, "f");
-    }
     static from(...inDisposables) {
         let disposables = inDisposables;
         return (
@@ -765,6 +1324,10 @@ let Disposable = Disposable_1 = class Disposable {
             }))
         );
     }
+    constructor(callOnDispose) {
+        _Disposable_callOnDispose.set(this, void 0);
+        __classPrivateFieldSet(this, _Disposable_callOnDispose, callOnDispose, "f");
+    }
     dispose() {
         if (typeof __classPrivateFieldGet(this, _Disposable_callOnDispose, "f") === 'function') {
             __classPrivateFieldGet(this, _Disposable_callOnDispose, "f").call(this);
@@ -777,16 +1340,6 @@ Disposable = Disposable_1 = ( (__decorate([
     es5ClassCompat
 ], Disposable)));
 let Position$1 = Position_1 = class Position {
-    constructor(line, character) {
-        if (line < 0) {
-            throw illegalArgument('line must be non-negative');
-        }
-        if (character < 0) {
-            throw illegalArgument('character must be non-negative');
-        }
-        this._line = line;
-        this._character = character;
-    }
     static Min(...positions) {
         if (positions.length === 0) {
             throw new TypeError();
@@ -843,6 +1396,16 @@ let Position$1 = Position_1 = class Position {
     get character() {
         return this._character;
     }
+    constructor(line, character) {
+        if (line < 0) {
+            throw illegalArgument('line must be non-negative');
+        }
+        if (character < 0) {
+            throw illegalArgument('character must be non-negative');
+        }
+        this._line = line;
+        this._character = character;
+    }
     isBefore(other) {
         if (this._line < other._line) {
             return true;
@@ -941,29 +1504,6 @@ Position$1 = Position_1 = ( (__decorate([
     es5ClassCompat
 ], Position$1)));
 let Range$1 = Range_1 = class Range {
-    constructor(startLineOrStart, startColumnOrEnd, endLine, endColumn) {
-        let start;
-        let end;
-        if (typeof startLineOrStart === 'number' && typeof startColumnOrEnd === 'number' && typeof endLine === 'number' && typeof endColumn === 'number') {
-            start = ( (new Position$1(startLineOrStart, startColumnOrEnd)));
-            end = ( (new Position$1(endLine, endColumn)));
-        }
-        else if (Position$1.isPosition(startLineOrStart) && Position$1.isPosition(startColumnOrEnd)) {
-            start = Position$1.of(startLineOrStart);
-            end = Position$1.of(startColumnOrEnd);
-        }
-        if (!start || !end) {
-            throw new Error('Invalid arguments');
-        }
-        if (start.isBefore(end)) {
-            this._start = start;
-            this._end = end;
-        }
-        else {
-            this._start = end;
-            this._end = start;
-        }
-    }
     static isRange(thing) {
         if (thing instanceof Range_1) {
             return true;
@@ -991,6 +1531,29 @@ let Range$1 = Range_1 = class Range {
     get end() {
         return this._end;
     }
+    constructor(startLineOrStart, startColumnOrEnd, endLine, endColumn) {
+        let start;
+        let end;
+        if (typeof startLineOrStart === 'number' && typeof startColumnOrEnd === 'number' && typeof endLine === 'number' && typeof endColumn === 'number') {
+            start = ( (new Position$1(startLineOrStart, startColumnOrEnd)));
+            end = ( (new Position$1(endLine, endColumn)));
+        }
+        else if (Position$1.isPosition(startLineOrStart) && Position$1.isPosition(startColumnOrEnd)) {
+            start = Position$1.of(startLineOrStart);
+            end = Position$1.of(startColumnOrEnd);
+        }
+        if (!start || !end) {
+            throw new Error('Invalid arguments');
+        }
+        if (start.isBefore(end)) {
+            this._start = start;
+            this._end = end;
+        }
+        else {
+            this._start = end;
+            this._end = start;
+        }
+    }
     contains(positionOrRange) {
         if (Range_1.isRange(positionOrRange)) {
             return this.contains(positionOrRange.start)
@@ -1069,24 +1632,6 @@ Range$1 = Range_1 = ( (__decorate([
     es5ClassCompat
 ], Range$1)));
 let Selection$2 = Selection_1 = class Selection extends Range$1 {
-    constructor(anchorLineOrAnchor, anchorColumnOrActive, activeLine, activeColumn) {
-        let anchor;
-        let active;
-        if (typeof anchorLineOrAnchor === 'number' && typeof anchorColumnOrActive === 'number' && typeof activeLine === 'number' && typeof activeColumn === 'number') {
-            anchor = ( (new Position$1(anchorLineOrAnchor, anchorColumnOrActive)));
-            active = ( (new Position$1(activeLine, activeColumn)));
-        }
-        else if (Position$1.isPosition(anchorLineOrAnchor) && Position$1.isPosition(anchorColumnOrActive)) {
-            anchor = Position$1.of(anchorLineOrAnchor);
-            active = Position$1.of(anchorColumnOrActive);
-        }
-        if (!anchor || !active) {
-            throw new Error('Invalid arguments');
-        }
-        super(anchor, active);
-        this._anchor = anchor;
-        this._active = active;
-    }
     static isSelection(thing) {
         if (thing instanceof Selection_1) {
             return true;
@@ -1105,6 +1650,24 @@ let Selection$2 = Selection_1 = class Selection extends Range$1 {
     get active() {
         return this._active;
     }
+    constructor(anchorLineOrAnchor, anchorColumnOrActive, activeLine, activeColumn) {
+        let anchor;
+        let active;
+        if (typeof anchorLineOrAnchor === 'number' && typeof anchorColumnOrActive === 'number' && typeof activeLine === 'number' && typeof activeColumn === 'number') {
+            anchor = ( (new Position$1(anchorLineOrAnchor, anchorColumnOrActive)));
+            active = ( (new Position$1(activeLine, activeColumn)));
+        }
+        else if (Position$1.isPosition(anchorLineOrAnchor) && Position$1.isPosition(anchorColumnOrActive)) {
+            anchor = Position$1.of(anchorLineOrAnchor);
+            active = Position$1.of(anchorColumnOrActive);
+        }
+        if (!anchor || !active) {
+            throw new Error('Invalid arguments');
+        }
+        super(anchor, active);
+        this._anchor = anchor;
+        this._active = active;
+    }
     get isReversed() {
         return this._anchor === this._end;
     }
@@ -1132,10 +1695,6 @@ var EnvironmentVariableMutatorType;
     EnvironmentVariableMutatorType[EnvironmentVariableMutatorType["Prepend"] = 3] = "Prepend";
 })(EnvironmentVariableMutatorType || (EnvironmentVariableMutatorType = {}))));
 let TextEdit$1 = TextEdit_1 = class TextEdit {
-    constructor(range, newText) {
-        this._range = range;
-        this._newText = newText;
-    }
     static isTextEdit(thing) {
         if (thing instanceof TextEdit_1) {
             return true;
@@ -1192,6 +1751,10 @@ let TextEdit$1 = TextEdit_1 = class TextEdit {
         }
         this._newEol = value;
     }
+    constructor(range, newText) {
+        this._range = range;
+        this._newText = newText;
+    }
     toJSON() {
         return {
             range: this.range,
@@ -1204,10 +1767,6 @@ TextEdit$1 = TextEdit_1 = ( (__decorate([
     es5ClassCompat
 ], TextEdit$1)));
 let NotebookEdit = NotebookEdit_1 = class NotebookEdit {
-    constructor(range, newCells) {
-        this.range = range;
-        this.newCells = newCells;
-    }
     static isNotebookCellEdit(thing) {
         if (thing instanceof NotebookEdit_1) {
             return true;
@@ -1243,10 +1802,38 @@ let NotebookEdit = NotebookEdit_1 = class NotebookEdit {
         edit.newNotebookMetadata = newMetadata;
         return edit;
     }
+    constructor(range, newCells) {
+        this.range = range;
+        this.newCells = newCells;
+    }
 };
 NotebookEdit = NotebookEdit_1 = ( (__decorate([
     es5ClassCompat
 ], NotebookEdit)));
+class SnippetTextEdit {
+    static isSnippetTextEdit(thing) {
+        if (thing instanceof SnippetTextEdit) {
+            return true;
+        }
+        if (!thing) {
+            return false;
+        }
+        return Range$1.isRange(thing.range)
+            && SnippetString.isSnippetString(thing.snippet);
+    }
+    static replace(range, snippet) {
+        return (
+             (new SnippetTextEdit(range, snippet))
+        );
+    }
+    static insert(position, snippet) {
+        return SnippetTextEdit.replace(( (new Range$1(position, position))), snippet);
+    }
+    constructor(range, snippet) {
+        this.range = range;
+        this.snippet = snippet;
+    }
+}
 let WorkspaceEdit$1 = class WorkspaceEdit {
     constructor() {
         this._edits = [];
@@ -1266,40 +1853,18 @@ let WorkspaceEdit$1 = class WorkspaceEdit {
     replaceNotebookMetadata(uri, value, metadata) {
         this._edits.push({ _type: 3 , metadata, uri, edit: { editType: 5 , metadata: value }, notebookMetadata: value });
     }
-    replaceNotebookCells(uri, startOrRange, endOrCells, cellsOrMetadata, metadata) {
-        let start;
-        let end;
-        let cellData = [];
-        let workspaceEditMetadata;
-        if (NotebookRange$1.isNotebookRange(startOrRange) && NotebookCellData$1.isNotebookCellDataArray(endOrCells) && !NotebookCellData$1.isNotebookCellDataArray(cellsOrMetadata)) {
-            start = startOrRange.start;
-            end = startOrRange.end;
-            cellData = endOrCells;
-            workspaceEditMetadata = cellsOrMetadata;
-        }
-        else if (typeof startOrRange === 'number' && typeof endOrCells === 'number' && NotebookCellData$1.isNotebookCellDataArray(cellsOrMetadata)) {
-            start = startOrRange;
-            end = endOrCells;
-            cellData = cellsOrMetadata;
-            workspaceEditMetadata = metadata;
-        }
-        if (start === undefined || end === undefined) {
-            throw new Error('Invalid arguments');
-        }
+    replaceNotebookCells(uri, startOrRange, cellData, metadata) {
+        const start = startOrRange.start;
+        const end = startOrRange.end;
         if (start !== end || cellData.length > 0) {
-            this._edits.push({ _type: 5 , uri, index: start, count: end - start, cells: cellData, metadata: workspaceEditMetadata });
+            this._edits.push({ _type: 5 , uri, index: start, count: end - start, cells: cellData, metadata });
         }
     }
     replaceNotebookCellMetadata(uri, index, cellMetadata, metadata) {
         this._edits.push({ _type: 3 , metadata, uri, edit: { editType: 8 , index, metadata: cellMetadata } });
     }
     replace(uri, range, newText, metadata) {
-        if (typeof newText === 'string') {
-            this._edits.push({ _type: 2 , uri, edit: ( (new TextEdit$1(range, newText))), metadata });
-        }
-        else {
-            this._edits.push({ _type: 6 , uri, range, edit: newText, metadata });
-        }
+        this._edits.push({ _type: 2 , uri, edit: ( (new TextEdit$1(range, newText))), metadata });
     }
     insert(resource, position, newText, metadata) {
         this.replace(resource, ( (new Range$1(position, position))), newText, metadata);
@@ -1314,30 +1879,50 @@ let WorkspaceEdit$1 = class WorkspaceEdit {
         if (!edits) {
             for (let i = 0; i < this._edits.length; i++) {
                 const element = this._edits[i];
-                if (element._type === 2  && ( (element.uri.toString())) === ( (uri.toString()))) {
-                    this._edits[i] = undefined;
+                switch (element._type) {
+                    case 2 :
+                    case 6 :
+                    case 3 :
+                    case 5 :
+                        if (( (element.uri.toString())) === ( (uri.toString()))) {
+                            this._edits[i] = undefined;
+                        }
+                        break;
                 }
             }
             coalesceInPlace(this._edits);
         }
         else {
-            for (const edit of edits) {
-                if (edit) {
-                    if (NotebookEdit.isNotebookCellEdit(edit)) {
-                        if (edit.newCellMetadata) {
-                            this.replaceNotebookCellMetadata(uri, edit.range.start, edit.newCellMetadata);
-                        }
-                        else if (edit.newNotebookMetadata) {
-                            this.replaceNotebookMetadata(uri, edit.newNotebookMetadata);
-                        }
-                        else {
-                            this.replaceNotebookCells(uri, edit.range, edit.newCells);
-                        }
+            for (const editOrTuple of edits) {
+                if (!editOrTuple) {
+                    continue;
+                }
+                let edit;
+                let metadata;
+                if (Array.isArray(editOrTuple)) {
+                    edit = editOrTuple[0];
+                    metadata = editOrTuple[1];
+                }
+                else {
+                    edit = editOrTuple;
+                }
+                if (NotebookEdit.isNotebookCellEdit(edit)) {
+                    if (edit.newCellMetadata) {
+                        this.replaceNotebookCellMetadata(uri, edit.range.start, edit.newCellMetadata, metadata);
+                    }
+                    else if (edit.newNotebookMetadata) {
+                        this.replaceNotebookMetadata(uri, edit.newNotebookMetadata, metadata);
                     }
                     else {
-                        this._edits.push({ _type: 2 , uri, edit });
+                        this.replaceNotebookCells(uri, edit.range, edit.newCells, metadata);
                     }
                 }
+                else if (SnippetTextEdit.isSnippetTextEdit(edit)) {
+                    this._edits.push({ _type: 6 , uri, range: edit.range, edit: edit.snippet, metadata });
+                }
+                else {
+                    this._edits.push({ _type: 2 , uri, edit, metadata });
+                }
             }
         }
     }
@@ -1351,7 +1936,7 @@ let WorkspaceEdit$1 = class WorkspaceEdit {
         return res;
     }
     entries() {
-        const textEdits = ( (new ResourceMap()));
+        const textEdits = ( (new ResourceMap$1()));
         for (const candidate of this._edits) {
             if (candidate._type === 2 ) {
                 let textEdit = textEdits.get(candidate.uri);
@@ -1375,10 +1960,6 @@ WorkspaceEdit$1 = ( (__decorate([
     es5ClassCompat
 ], WorkspaceEdit$1)));
 let SnippetString = SnippetString_1 = class SnippetString {
-    constructor(value) {
-        this._tabstop = 1;
-        this.value = value || '';
-    }
     static isSnippetString(thing) {
         if (thing instanceof SnippetString_1) {
             return true;
@@ -1391,6 +1972,10 @@ let SnippetString = SnippetString_1 = class SnippetString {
     static _escape(value) {
         return value.replace(/\$|}|\\/g, '\\$&');
     }
+    constructor(value) {
+        this._tabstop = 1;
+        this.value = value || '';
+    }
     appendText(string) {
         this.value += SnippetString_1._escape(string);
         return this;
@@ -1464,6 +2049,16 @@ var DiagnosticSeverity$1;
     DiagnosticSeverity[DiagnosticSeverity["Error"] = 0] = "Error";
 })(DiagnosticSeverity$1 || (DiagnosticSeverity$1 = {}))));
 let Location = Location_1 = class Location {
+    static isLocation(thing) {
+        if (thing instanceof Location_1) {
+            return true;
+        }
+        if (!thing) {
+            return false;
+        }
+        return Range$1.isRange(thing.range)
+            && URI.isUri(thing.uri);
+    }
     constructor(uri, rangeOrPosition) {
         this.uri = uri;
         if (!rangeOrPosition) ;
@@ -1477,16 +2072,6 @@ let Location = Location_1 = class Location {
             throw new Error('Illegal argument');
         }
     }
-    static isLocation(thing) {
-        if (thing instanceof Location_1) {
-            return true;
-        }
-        if (!thing) {
-            return false;
-        }
-        return Range$1.isRange(thing.range)
-            && URI.isUri(thing.uri);
-    }
     toJSON() {
         return {
             uri: this.uri,
@@ -1498,10 +2083,6 @@ Location = Location_1 = ( (__decorate([
     es5ClassCompat
 ], Location)));
 let DiagnosticRelatedInformation$1 = class DiagnosticRelatedInformation {
-    constructor(location, message) {
-        this.location = location;
-        this.message = message;
-    }
     static is(thing) {
         if (!thing) {
             return false;
@@ -1511,6 +2092,10 @@ let DiagnosticRelatedInformation$1 = class DiagnosticRelatedInformation {
             && Range$1.isRange(thing.location.range)
             && URI.isUri(thing.location.uri);
     }
+    constructor(location, message) {
+        this.location = location;
+        this.message = message;
+    }
     static isEqual(a, b) {
         if (a === b) {
             return true;
@@ -1639,6 +2224,11 @@ var SymbolTag$1;
     SymbolTag[SymbolTag["Deprecated"] = 1] = "Deprecated";
 })(SymbolTag$1 || (SymbolTag$1 = {}))));
 let SymbolInformation = SymbolInformation_1 = class SymbolInformation {
+    static validate(candidate) {
+        if (!candidate.name) {
+            throw new Error('name must not be falsy');
+        }
+    }
     constructor(name, kind, rangeOrContainer, locationOrUri, containerName) {
         this.name = name;
         this.kind = kind;
@@ -1654,11 +2244,6 @@ let SymbolInformation = SymbolInformation_1 = class SymbolInformation {
         }
         SymbolInformation_1.validate(this);
     }
-    static validate(candidate) {
-        if (!candidate.name) {
-            throw new Error('name must not be falsy');
-        }
-    }
     toJSON() {
         return {
             name: this.name,
@@ -1672,15 +2257,6 @@ SymbolInformation = SymbolInformation_1 = ( (__decorate([
     es5ClassCompat
 ], SymbolInformation)));
 let DocumentSymbol$1 = DocumentSymbol_1 = class DocumentSymbol {
-    constructor(name, detail, kind, range, selectionRange) {
-        this.name = name;
-        this.detail = detail;
-        this.kind = kind;
-        this.range = range;
-        this.selectionRange = selectionRange;
-        this.children = [];
-        DocumentSymbol_1.validate(this);
-    }
     static validate(candidate) {
         if (!candidate.name) {
             throw new Error('name must not be falsy');
@@ -1690,6 +2266,15 @@ let DocumentSymbol$1 = DocumentSymbol_1 = class DocumentSymbol {
         }
         candidate.children?.forEach(DocumentSymbol_1.validate);
     }
+    constructor(name, detail, kind, range, selectionRange) {
+        this.name = name;
+        this.detail = detail;
+        this.kind = kind;
+        this.range = range;
+        this.selectionRange = selectionRange;
+        this.children = [];
+        DocumentSymbol_1.validate(this);
+    }
 };
 DocumentSymbol$1 = DocumentSymbol_1 = ( (__decorate([
     es5ClassCompat
@@ -1733,6 +2318,7 @@ CodeActionKind.QuickFix = CodeActionKind.Empty.append('quickfix');
 CodeActionKind.Refactor = CodeActionKind.Empty.append('refactor');
 CodeActionKind.RefactorExtract = CodeActionKind.Refactor.append('extract');
 CodeActionKind.RefactorInline = CodeActionKind.Refactor.append('inline');
+CodeActionKind.RefactorMove = CodeActionKind.Refactor.append('move');
 CodeActionKind.RefactorRewrite = CodeActionKind.Refactor.append('rewrite');
 CodeActionKind.Source = CodeActionKind.Empty.append('source');
 CodeActionKind.SourceOrganizeImports = CodeActionKind.Source.append('organizeImports');
@@ -1790,16 +2376,16 @@ CodeLens = ( (__decorate([
     es5ClassCompat
 ], CodeLens)));
 let MarkdownString$1 = MarkdownString_1 = class MarkdownString {
-    constructor(value, supportThemeIcons = false) {
-        _MarkdownString_delegate.set(this, void 0);
-        __classPrivateFieldSet(this, _MarkdownString_delegate, ( (new MarkdownString$2(value, { supportThemeIcons }))), "f");
-    }
     static isMarkdownString(thing) {
         if (thing instanceof MarkdownString_1) {
             return true;
         }
         return thing && thing.appendCodeblock && thing.appendMarkdown && thing.appendText && (thing.value !== undefined);
     }
+    constructor(value, supportThemeIcons = false) {
+        _MarkdownString_delegate.set(this, void 0);
+        __classPrivateFieldSet(this, _MarkdownString_delegate, ( (new MarkdownString$2(value, { supportThemeIcons }))), "f");
+    }
     get value() {
         return __classPrivateFieldGet(this, _MarkdownString_delegate, "f").value;
     }
@@ -2114,6 +2700,14 @@ let ColorPresentation$1 = class ColorPresentation {
 ColorPresentation$1 = ( (__decorate([
     es5ClassCompat
 ], ColorPresentation$1)));
+var TerminalExitReason;
+( ((function(TerminalExitReason) {
+    TerminalExitReason[TerminalExitReason["Unknown"] = 0] = "Unknown";
+    TerminalExitReason[TerminalExitReason["Shutdown"] = 1] = "Shutdown";
+    TerminalExitReason[TerminalExitReason["Process"] = 2] = "Process";
+    TerminalExitReason[TerminalExitReason["User"] = 3] = "User";
+    TerminalExitReason[TerminalExitReason["Extension"] = 4] = "Extension";
+})(TerminalExitReason || (TerminalExitReason = {}))));
 class TerminalLink {
     constructor(startIndex, length, tooltip) {
         this.startIndex = startIndex;
@@ -2156,16 +2750,6 @@ var TaskPanelKind;
     TaskPanelKind[TaskPanelKind["New"] = 3] = "New";
 })(TaskPanelKind || (TaskPanelKind = {}))));
 let TaskGroup = TaskGroup_1 = class TaskGroup {
-    constructor(id, label) {
-        this.label = label;
-        if (typeof id !== 'string') {
-            throw illegalArgument('name');
-        }
-        if (typeof label !== 'string') {
-            throw illegalArgument('name');
-        }
-        this._id = id;
-    }
     static from(value) {
         switch (value) {
             case 'clean':
@@ -2180,6 +2764,16 @@ let TaskGroup = TaskGroup_1 = class TaskGroup {
                 return undefined;
         }
     }
+    constructor(id, label) {
+        this.label = label;
+        if (typeof id !== 'string') {
+            throw illegalArgument('name');
+        }
+        if (typeof label !== 'string') {
+            throw illegalArgument('name');
+        }
+        this._id = id;
+    }
     get id() {
         return this._id;
     }
@@ -2572,21 +3166,22 @@ var ProgressLocation$1;
     ProgressLocation[ProgressLocation["Notification"] = 15] = "Notification";
 })(ProgressLocation$1 || (ProgressLocation$1 = {}))));
 let TreeItem = TreeItem_1 = class TreeItem {
-    constructor(arg1, collapsibleState = TreeItemCollapsibleState.None) {
-        this.collapsibleState = collapsibleState;
-        if (URI.isUri(arg1)) {
-            this.resourceUri = arg1;
-        }
-        else {
-            this.label = arg1;
+    static isTreeItem(thing, extension) {
+        const treeItemThing = thing;
+        if (treeItemThing.checkboxState !== undefined) {
+            checkProposedApiEnabled(extension, 'treeItemCheckbox');
+            const checkbox = isNumber(treeItemThing.checkboxState) ? treeItemThing.checkboxState :
+                isObject(treeItemThing.checkboxState) && isNumber(treeItemThing.checkboxState.state) ? treeItemThing.checkboxState.state : undefined;
+            const tooltip = !isNumber(treeItemThing.checkboxState) && isObject(treeItemThing.checkboxState) ? treeItemThing.checkboxState.tooltip : undefined;
+            if (checkbox === undefined || (checkbox !== TreeItemCheckboxState.Checked && checkbox !== TreeItemCheckboxState.Unchecked) || (tooltip !== undefined && !isString(tooltip))) {
+                console.log('INVALID tree item, invalid checkboxState', treeItemThing.checkboxState);
+                return false;
+            }
         }
-    }
-    static isTreeItem(thing) {
         if (thing instanceof TreeItem_1) {
             return true;
         }
-        const treeItemThing = thing;
-        if (treeItemThing.label !== undefined && !isString(treeItemThing.label) && !(treeItemThing.label.label)) {
+        if (treeItemThing.label !== undefined && !isString(treeItemThing.label) && !(treeItemThing.label?.label)) {
             console.log('INVALID tree item, invalid label', treeItemThing.label);
             return false;
         }
@@ -2594,9 +3189,12 @@ let TreeItem = TreeItem_1 = class TreeItem {
             console.log('INVALID tree item, invalid id', treeItemThing.id);
             return false;
         }
-        if ((treeItemThing.iconPath !== undefined) && !isString(treeItemThing.iconPath) && !URI.isUri(treeItemThing.iconPath) && !isString(treeItemThing.iconPath.id)) {
-            console.log('INVALID tree item, invalid iconPath', treeItemThing.iconPath);
-            return false;
+        if ((treeItemThing.iconPath !== undefined) && !isString(treeItemThing.iconPath) && !URI.isUri(treeItemThing.iconPath) && (!treeItemThing.iconPath || !isString(treeItemThing.iconPath.id))) {
+            const asLightAndDarkThing = treeItemThing.iconPath;
+            if (!asLightAndDarkThing || (!isString(asLightAndDarkThing.light) && !URI.isUri(asLightAndDarkThing.light) && !isString(asLightAndDarkThing.dark) && !URI.isUri(asLightAndDarkThing.dark))) {
+                console.log('INVALID tree item, invalid iconPath', treeItemThing.iconPath);
+                return false;
+            }
         }
         if ((treeItemThing.description !== undefined) && !isString(treeItemThing.description) && (typeof treeItemThing.description !== 'boolean')) {
             console.log('INVALID tree item, invalid description', treeItemThing.description);
@@ -2622,12 +3220,21 @@ let TreeItem = TreeItem_1 = class TreeItem {
             console.log('INVALID tree item, invalid contextValue', treeItemThing.contextValue);
             return false;
         }
-        if ((treeItemThing.accessibilityInformation !== undefined) && !treeItemThing.accessibilityInformation.label) {
+        if ((treeItemThing.accessibilityInformation !== undefined) && !treeItemThing.accessibilityInformation?.label) {
             console.log('INVALID tree item, invalid accessibilityInformation', treeItemThing.accessibilityInformation);
             return false;
         }
         return true;
     }
+    constructor(arg1, collapsibleState = TreeItemCollapsibleState.None) {
+        this.collapsibleState = collapsibleState;
+        if (URI.isUri(arg1)) {
+            this.resourceUri = arg1;
+        }
+        else {
+            this.label = arg1;
+        }
+    }
 };
 TreeItem = TreeItem_1 = ( (__decorate([
     es5ClassCompat
@@ -2638,16 +3245,22 @@ var TreeItemCollapsibleState;
     TreeItemCollapsibleState[TreeItemCollapsibleState["Collapsed"] = 1] = "Collapsed";
     TreeItemCollapsibleState[TreeItemCollapsibleState["Expanded"] = 2] = "Expanded";
 })(TreeItemCollapsibleState || (TreeItemCollapsibleState = {}))));
+var TreeItemCheckboxState;
+( ((function(TreeItemCheckboxState) {
+    TreeItemCheckboxState[TreeItemCheckboxState["Unchecked"] = 0] = "Unchecked";
+    TreeItemCheckboxState[TreeItemCheckboxState["Checked"] = 1] = "Checked";
+})(TreeItemCheckboxState || (TreeItemCheckboxState = {}))));
 let DataTransferItem$1 = class DataTransferItem {
-    constructor(value) {
-        this.value = value;
-    }
     async asString() {
         return typeof this.value === 'string' ? this.value : JSON.stringify(this.value);
     }
     asFile() {
         return undefined;
     }
+    constructor(value, id) {
+        this.value = value;
+        this.id = id ?? generateUuid();
+    }
 };
 DataTransferItem$1 = ( (__decorate([
     es5ClassCompat
@@ -2702,6 +3315,13 @@ let ThemeIcon = class ThemeIcon {
         this.id = id;
         this.color = color;
     }
+    static isThemeIcon(thing) {
+        if (typeof thing.id !== 'string') {
+            console.log('INVALID ThemeIcon, invalid id', thing.id);
+            return false;
+        }
+        return true;
+    }
 };
 ThemeIcon = ( (__decorate([
     es5ClassCompat
@@ -2723,6 +3343,20 @@ var ConfigurationTarget;
     ConfigurationTarget[ConfigurationTarget["WorkspaceFolder"] = 3] = "WorkspaceFolder";
 })(ConfigurationTarget || (ConfigurationTarget = {}))));
 let RelativePattern = class RelativePattern {
+    get base() {
+        return this._base;
+    }
+    set base(base) {
+        this._base = base;
+        this._baseUri = URI.file(base);
+    }
+    get baseUri() {
+        return this._baseUri;
+    }
+    set baseUri(baseUri) {
+        this._baseUri = baseUri;
+        this._base = baseUri.fsPath;
+    }
     constructor(base, pattern) {
         if (typeof base !== 'string') {
             if (!base || !URI.isUri(base) && !URI.isUri(base.uri)) {
@@ -2743,20 +3377,6 @@ let RelativePattern = class RelativePattern {
         }
         this.pattern = pattern;
     }
-    get base() {
-        return this._base;
-    }
-    set base(base) {
-        this._base = base;
-        this._baseUri = URI.file(base);
-    }
-    get baseUri() {
-        return this._baseUri;
-    }
-    set baseUri(baseUri) {
-        this._baseUri = baseUri;
-        this._base = baseUri.fsPath;
-    }
     toJSON() {
         return {
             pattern: this.pattern,
@@ -2768,6 +3388,7 @@ let RelativePattern = class RelativePattern {
 RelativePattern = ( (__decorate([
     es5ClassCompat
 ], RelativePattern)));
+const breakpointIds = ( (new WeakMap()));
 let Breakpoint = class Breakpoint {
     constructor(enabled, condition, hitCondition, logMessage) {
         this.enabled = typeof enabled === 'boolean' ? enabled : true;
@@ -2783,7 +3404,7 @@ let Breakpoint = class Breakpoint {
     }
     get id() {
         if (!this._id) {
-            this._id = generateUuid();
+            this._id = breakpointIds.get(this) ?? generateUuid();
         }
         return this._id;
     }
@@ -2861,11 +3482,6 @@ var InlineCompletionTriggerKind;
     InlineCompletionTriggerKind[InlineCompletionTriggerKind["Invoke"] = 0] = "Invoke";
     InlineCompletionTriggerKind[InlineCompletionTriggerKind["Automatic"] = 1] = "Automatic";
 })(InlineCompletionTriggerKind || (InlineCompletionTriggerKind = {}))));
-var InlineCompletionTriggerKindNew;
-( ((function(InlineCompletionTriggerKindNew) {
-    InlineCompletionTriggerKindNew[InlineCompletionTriggerKindNew["Invoke"] = 0] = "Invoke";
-    InlineCompletionTriggerKindNew[InlineCompletionTriggerKindNew["Automatic"] = 1] = "Automatic";
-})(InlineCompletionTriggerKindNew || (InlineCompletionTriggerKindNew = {}))));
 let InlineValueText = class InlineValueText {
     constructor(range, text) {
         this.range = range;
@@ -2910,17 +3526,6 @@ var FileChangeType;
     FileChangeType[FileChangeType["Deleted"] = 3] = "Deleted";
 })(FileChangeType || (FileChangeType = {}))));
 let FileSystemError = FileSystemError_1 = class FileSystemError extends Error {
-    constructor(uriOrMessage, code = FileSystemProviderErrorCode.Unknown, terminator) {
-        super(URI.isUri(uriOrMessage) ? ( (uriOrMessage.toString(true))) : uriOrMessage);
-        this.code = terminator?.name ?? 'Unknown';
-        markAsFileSystemProviderError(this, code);
-        if (typeof Object.setPrototypeOf === 'function') {
-            Object.setPrototypeOf(this, FileSystemError_1.prototype);
-        }
-        if (typeof Error.captureStackTrace === 'function' && typeof terminator === 'function') {
-            Error.captureStackTrace(this, terminator);
-        }
-    }
     static FileExists(messageOrUri) {
         return (
              (new FileSystemError_1(
@@ -2975,6 +3580,15 @@ let FileSystemError = FileSystemError_1 = class FileSystemError extends Error {
             ))
         );
     }
+    constructor(uriOrMessage, code = FileSystemProviderErrorCode.Unknown, terminator) {
+        super(URI.isUri(uriOrMessage) ? ( (uriOrMessage.toString(true))) : uriOrMessage);
+        this.code = terminator?.name ?? 'Unknown';
+        markAsFileSystemProviderError(this, code);
+        Object.setPrototypeOf(this, FileSystemError_1.prototype);
+        if (typeof Error.captureStackTrace === 'function' && typeof terminator === 'function') {
+            Error.captureStackTrace(this, terminator);
+        }
+    }
 };
 FileSystemError = FileSystemError_1 = ( (__decorate([
     es5ClassCompat
@@ -3005,6 +3619,11 @@ var CommentMode;
     CommentMode[CommentMode["Editing"] = 0] = "Editing";
     CommentMode[CommentMode["Preview"] = 1] = "Preview";
 })(CommentMode || (CommentMode = {}))));
+var CommentThreadState;
+( ((function(CommentThreadState) {
+    CommentThreadState[CommentThreadState["Unresolved"] = 0] = "Unresolved";
+    CommentThreadState[CommentThreadState["Resolved"] = 1] = "Resolved";
+})(CommentThreadState || (CommentThreadState = {}))));
 class SemanticTokensLegend {
     constructor(tokenTypes, tokenModifiers = []) {
         this.tokenTypes = tokenTypes;
@@ -3208,13 +3827,8 @@ var ExtensionKind;
     ExtensionKind[ExtensionKind["Workspace"] = 2] = "Workspace";
 })(ExtensionKind || (ExtensionKind = {}))));
 class FileDecoration {
-    constructor(badge, tooltip, color) {
-        this.badge = badge;
-        this.tooltip = tooltip;
-        this.color = color;
-    }
     static validate(d) {
-        if (d.badge) {
+        if (typeof d.badge === 'string') {
             let len = nextCharLength(d.badge, 0);
             if (len < d.badge.length) {
                 len += nextCharLength(d.badge, len);
@@ -3223,29 +3837,23 @@ class FileDecoration {
                 throw new Error(`The 'badge'-property must be undefined or a short character`);
             }
         }
+        else if (d.badge) {
+            if (!ThemeIcon.isThemeIcon(d.badge)) {
+                throw new Error(`The 'badge'-property is not a valid ThemeIcon`);
+            }
+        }
         if (!d.color && !d.badge && !d.tooltip) {
             throw new Error(`The decoration is empty`);
         }
         return true;
     }
+    constructor(badge, tooltip, color) {
+        this.badge = badge;
+        this.tooltip = tooltip;
+        this.color = color;
+    }
 }
 let NotebookRange$1 = class NotebookRange {
-    constructor(start, end) {
-        if (start < 0) {
-            throw illegalArgument('start must be positive');
-        }
-        if (end < 0) {
-            throw illegalArgument('end must be positive');
-        }
-        if (start <= end) {
-            this._start = start;
-            this._end = end;
-        }
-        else {
-            this._start = end;
-            this._end = start;
-        }
-    }
     static isNotebookRange(thing) {
         if (thing instanceof NotebookRange) {
             return true;
@@ -3265,6 +3873,22 @@ let NotebookRange$1 = class NotebookRange {
     get isEmpty() {
         return this._start === this._end;
     }
+    constructor(start, end) {
+        if (start < 0) {
+            throw illegalArgument('start must be positive');
+        }
+        if (end < 0) {
+            throw illegalArgument('end must be positive');
+        }
+        if (start <= end) {
+            this._start = start;
+            this._end = end;
+        }
+        else {
+            this._start = end;
+            this._end = start;
+        }
+    }
     with(change) {
         let start = this._start;
         let end = this._end;
@@ -3283,16 +3907,6 @@ let NotebookRange$1 = class NotebookRange {
     }
 };
 let NotebookCellData$1 = class NotebookCellData {
-    constructor(kind, value, languageId, mime, outputs, metadata, executionSummary) {
-        this.kind = kind;
-        this.value = value;
-        this.languageId = languageId;
-        this.mime = mime;
-        this.outputs = outputs ?? [];
-        this.metadata = metadata;
-        this.executionSummary = executionSummary;
-        NotebookCellData.validate(this);
-    }
     static validate(data) {
         if (typeof data.kind !== 'number') {
             throw new Error('NotebookCellData MUST have \'kind\' property');
@@ -3310,6 +3924,16 @@ let NotebookCellData$1 = class NotebookCellData {
     static isNotebookCellData(value) {
         return true;
     }
+    constructor(kind, value, languageId, mime, outputs, metadata, executionSummary) {
+        this.kind = kind;
+        this.value = value;
+        this.languageId = languageId;
+        this.mime = mime;
+        this.outputs = outputs ?? [];
+        this.metadata = metadata;
+        this.executionSummary = executionSummary;
+        NotebookCellData.validate(this);
+    }
 };
 class NotebookData {
     constructor(cells) {
@@ -3317,15 +3941,6 @@ class NotebookData {
     }
 }
 let NotebookCellOutputItem$1 = class NotebookCellOutputItem {
-    constructor(data, mime) {
-        this.data = data;
-        this.mime = mime;
-        const mimeNormalized = normalizeMimeType(mime, true);
-        if (!mimeNormalized) {
-            throw new Error(`INVALID mime type: ${mime}. Must be in the format "type/subtype[;optionalparameter]"`);
-        }
-        this.mime = mimeNormalized;
-    }
     static isNotebookCellOutputItem(obj) {
         if (obj instanceof NotebookCellOutputItem) {
             return true;
@@ -3365,21 +3980,19 @@ let NotebookCellOutputItem$1 = class NotebookCellOutputItem {
         const rawStr = JSON.stringify(value, undefined, '\t');
         return NotebookCellOutputItem.text(rawStr, mime);
     }
+    constructor(data, mime) {
+        this.data = data;
+        this.mime = mime;
+        const mimeNormalized = normalizeMimeType(mime, true);
+        if (!mimeNormalized) {
+            throw new Error(`INVALID mime type: ${mime}. Must be in the format "type/subtype[;optionalparameter]"`);
+        }
+        this.mime = mimeNormalized;
+    }
 };
 _a$1 = NotebookCellOutputItem$1;
 _NotebookCellOutputItem_encoder = { value: ( (new TextEncoder())) };
 let NotebookCellOutput$1 = class NotebookCellOutput {
-    constructor(items, idOrMetadata, metadata) {
-        this.items = NotebookCellOutput.ensureUniqueMimeTypes(items, true);
-        if (typeof idOrMetadata === 'string') {
-            this.id = idOrMetadata;
-            this.metadata = metadata;
-        }
-        else {
-            this.id = generateUuid();
-            this.metadata = idOrMetadata ?? metadata;
-        }
-    }
     static isNotebookCellOutput(candidate) {
         if (candidate instanceof NotebookCellOutput) {
             return true;
@@ -3387,7 +4000,7 @@ let NotebookCellOutput$1 = class NotebookCellOutput {
         if (!candidate || typeof candidate !== 'object') {
             return false;
         }
-        return typeof candidate.id === 'string' && isArray(candidate.items);
+        return typeof candidate.id === 'string' && Array.isArray(candidate.items);
     }
     static ensureUniqueMimeTypes(items, warn = false) {
         const seen = ( (new Set()));
@@ -3395,7 +4008,7 @@ let NotebookCellOutput$1 = class NotebookCellOutput {
         for (let i = 0; i < items.length; i++) {
             const item = items[i];
             const normalMime = normalizeMimeType(item.mime);
-            if (!seen.has(normalMime)) {
+            if (!seen.has(normalMime) || isTextStreamMime(normalMime)) {
                 seen.add(normalMime);
                 continue;
             }
@@ -3409,6 +4022,17 @@ let NotebookCellOutput$1 = class NotebookCellOutput {
         }
         return items.filter((_item, index) => !removeIdx.has(index));
     }
+    constructor(items, idOrMetadata, metadata) {
+        this.items = NotebookCellOutput.ensureUniqueMimeTypes(items, true);
+        if (typeof idOrMetadata === 'string') {
+            this.id = idOrMetadata;
+            this.metadata = metadata;
+        }
+        else {
+            this.id = generateUuid();
+            this.metadata = idOrMetadata ?? metadata;
+        }
+    }
 };
 var NotebookCellKind$1;
 ( ((function(NotebookCellKind) {
@@ -3474,15 +4098,15 @@ TestRunRequest = ( (__decorate([
     es5ClassCompat
 ], TestRunRequest)));
 let TestMessage = TestMessage_1 = class TestMessage {
-    constructor(message) {
-        this.message = message;
-    }
     static diff(message, expected, actual) {
         const msg = ( (new TestMessage_1(message)));
         msg.expectedOutput = expected;
         msg.actualOutput = actual;
         return msg;
     }
+    constructor(message) {
+        this.message = message;
+    }
 };
 TestMessage = TestMessage_1 = ( (__decorate([
     es5ClassCompat
@@ -3562,23 +4186,7 @@ function cursorStyleToString(cursorStyle) {
         case TextEditorCursorStyle.UnderlineThin: return 'underline-thin';
     }
 }
-var EditorActivation;
-( ((function(EditorActivation) {
-    EditorActivation[EditorActivation["ACTIVATE"] = 1] = "ACTIVATE";
-    EditorActivation[EditorActivation["RESTORE"] = 2] = "RESTORE";
-    EditorActivation[EditorActivation["PRESERVE"] = 3] = "PRESERVE";
-})(EditorActivation || (EditorActivation = {}))));
-var EditorResolution;
-( ((function(EditorResolution) {
-    EditorResolution[EditorResolution["PICK"] = 0] = "PICK";
-    EditorResolution[EditorResolution["DISABLED"] = 1] = "DISABLED";
-    EditorResolution[EditorResolution["EXCLUSIVE_ONLY"] = 2] = "EXCLUSIVE_ONLY";
-})(EditorResolution || (EditorResolution = {}))));
-var CellKind;
-( ((function(CellKind) {
-    CellKind[CellKind["Markup"] = 1] = "Markup";
-    CellKind[CellKind["Code"] = 2] = "Code";
-})(CellKind || (CellKind = {}))));
+const marked = marked$1.marked;
 var Selection$1;
 ( ((function(Selection) {
     function to(selection) {
@@ -4069,7 +4677,7 @@ var TextEdit;
 })(TextEdit || (TextEdit = {}))));
 var WorkspaceEdit;
 ( ((function(WorkspaceEdit) {
-    function from(value, versionInfo, allowSnippetTextEdit) {
+    function from(value, versionInfo) {
         const result = {
             edits: []
         };
@@ -4085,7 +4693,7 @@ var WorkspaceEdit;
                     result.edits.push({
                         oldResource: entry.from,
                         newResource: entry.to,
-                        options: entry.options,
+                        options: { ...entry.options, contentsBase64: entry.options?.contents && encodeBase64(VSBuffer.wrap(entry.options.contents)) },
                         metadata: entry.metadata
                     });
                 }
@@ -4098,10 +4706,6 @@ var WorkspaceEdit;
                     });
                 }
                 else if (entry._type === 6 ) {
-                    if (!allowSnippetTextEdit) {
-                        console.warn(`DROPPING snippet text edit because proposal IS NOT ENABLED`, entry);
-                        continue;
-                    }
                     result.edits.push({
                         resource: entry.uri,
                         textEdit: {
@@ -4554,6 +5158,9 @@ var CompletionItemKind;
 var ParameterInformation;
 ( ((function(ParameterInformation) {
     function from(info) {
+        if (typeof info.label !== 'string' && !Array.isArray(info.label)) {
+            throw new TypeError('Invalid label');
+        }
         return {
             label: info.label,
             documentation: MarkdownString.fromStrict(info.documentation)
@@ -4761,6 +5368,14 @@ var FoldingRange;
         return range;
     }
     FoldingRange.from = from;
+    function to(r) {
+        const range = { start: r.start - 1, end: r.end - 1 };
+        if (r.kind) {
+            range.kind = FoldingRangeKind.to(r.kind);
+        }
+        return range;
+    }
+    FoldingRange.to = to;
 })(FoldingRange || (FoldingRange = {}))));
 var FoldingRangeKind;
 ( ((function(FoldingRangeKind) {
@@ -4778,6 +5393,20 @@ var FoldingRangeKind;
         return undefined;
     }
     FoldingRangeKind.from = from;
+    function to(kind) {
+        if (kind) {
+            switch (kind.value) {
+                case FoldingRangeKind$2.Comment.value:
+                    return FoldingRangeKind$1.Comment;
+                case FoldingRangeKind$2.Imports.value:
+                    return FoldingRangeKind$1.Imports;
+                case FoldingRangeKind$2.Region.value:
+                    return FoldingRangeKind$1.Region;
+            }
+        }
+        return undefined;
+    }
+    FoldingRangeKind.to = to;
 })(FoldingRangeKind || (FoldingRangeKind = {}))));
 var GlobPattern;
 ( ((function(GlobPattern) {
@@ -4987,7 +5616,7 @@ var TypeHierarchyItem;
 })(TypeHierarchyItem || (TypeHierarchyItem = {}))));
 var DataTransferItem;
 ( ((function(DataTransferItem) {
-    function toDataTransferItem(item, resolveFileData) {
+    function to(mime, item, resolveFileData) {
         const file = item.fileData;
         if (file) {
             return new (class extends DataTransferItem$1 {
@@ -4998,19 +5627,58 @@ var DataTransferItem;
                         data: once(() => resolveFileData()),
                     };
                 }
-            })('');
+            })('', item.id);
         }
-        else {
-            return new DataTransferItem$1(item.asString);
+        if (mime === Mimes.uriList && item.uriListData) {
+            return new DataTransferItem$1(reviveUriList(item.uriListData));
+        }
+        return new DataTransferItem$1(item.asString);
+    }
+    DataTransferItem.to = to;
+    async function from(mime, item) {
+        const stringValue = await item.asString();
+        if (mime === Mimes.uriList) {
+            return {
+                id: item.id,
+                asString: stringValue,
+                fileData: undefined,
+                uriListData: serializeUriList(stringValue),
+            };
         }
+        const fileValue = item.asFile();
+        return {
+            id: item.id,
+            asString: stringValue,
+            fileData: fileValue ? { name: fileValue.name, uri: fileValue.uri } : undefined,
+        };
+    }
+    DataTransferItem.from = from;
+    function serializeUriList(stringValue) {
+        return UriList.split(stringValue).map(part => {
+            if (part.startsWith('#')) {
+                return part;
+            }
+            try {
+                return (
+                     (URI.parse(part))
+                );
+            }
+            catch {
+            }
+            return part;
+        });
+    }
+    function reviveUriList(parts) {
+        return UriList.create(parts.map(part => {
+            return typeof part === 'string' ? part : URI.revive(part);
+        }));
     }
-    DataTransferItem.toDataTransferItem = toDataTransferItem;
 })(DataTransferItem || (DataTransferItem = {}))));
 var DataTransfer;
 ( ((function(DataTransfer) {
     function toDataTransfer(value, resolveFileData) {
-        const init = value.items.map(([type, item], index) => {
-            return [type, DataTransferItem.toDataTransferItem(item, () => resolveFileData(index))];
+        const init = value.items.map(([type, item]) => {
+            return [type, DataTransferItem.to(type, item, () => resolveFileData(item.id))];
         });
         return new DataTransfer$1(init);
     }
@@ -5020,12 +5688,7 @@ var DataTransfer;
         const promises = [];
         value.forEach((value, key) => {
             promises.push((async () => {
-                const stringValue = await value.asString();
-                const fileValue = value.asFile();
-                newDTO.items.push([key, {
-                        asString: stringValue,
-                        fileData: fileValue ? { name: fileValue.name, uri: fileValue.uri } : undefined,
-                    }]);
+                newDTO.items.push([key, await DataTransferItem.from(key, value)]);
             })());
         });
         await Promise.all(promises);
@@ -5062,12 +5725,6 @@ var TextEditorRevealType;
     TextEditorRevealType[TextEditorRevealType["InCenterIfOutsideViewport"] = 2] = "InCenterIfOutsideViewport";
     TextEditorRevealType[TextEditorRevealType["AtTop"] = 3] = "AtTop";
 })(TextEditorRevealType || (TextEditorRevealType = {}))));
-function reviveWorkspaceEditDto(data) {
-    if (data && data.edits) {
-        revive(data);
-    }
-    return data;
-}
 const MainContext = {
     MainThreadAuthentication: ( (createProxyIdentifier('MainThreadAuthentication'))),
     MainThreadBulkEdits: ( (createProxyIdentifier('MainThreadBulkEdits'))),
@@ -5095,6 +5752,7 @@ const MainContext = {
     MainThreadMessageService: ( (createProxyIdentifier('MainThreadMessageService'))),
     MainThreadOutputService: ( (createProxyIdentifier('MainThreadOutputService'))),
     MainThreadProgress: ( (createProxyIdentifier('MainThreadProgress'))),
+    MainThreadQuickDiff: ( (createProxyIdentifier('MainThreadQuickDiff'))),
     MainThreadQuickOpen: ( (createProxyIdentifier('MainThreadQuickOpen'))),
     MainThreadStatusBar: ( (createProxyIdentifier('MainThreadStatusBar'))),
     MainThreadSecretState: ( (createProxyIdentifier('MainThreadSecretState'))),
@@ -5107,6 +5765,7 @@ const MainContext = {
     MainThreadCustomEditors: ( (createProxyIdentifier('MainThreadCustomEditors'))),
     MainThreadUrls: ( (createProxyIdentifier('MainThreadUrls'))),
     MainThreadUriOpeners: ( (createProxyIdentifier('MainThreadUriOpeners'))),
+    MainThreadProfileContentHandlers: ( (createProxyIdentifier('MainThreadProfileContentHandlers'))),
     MainThreadWorkspace: ( (createProxyIdentifier('MainThreadWorkspace'))),
     MainThreadFileSystem: ( (createProxyIdentifier('MainThreadFileSystem'))),
     MainThreadExtensionService: ( (createProxyIdentifier('MainThreadExtensionService'))),
@@ -5125,6 +5784,7 @@ const MainContext = {
     MainThreadTunnelService: ( (createProxyIdentifier('MainThreadTunnelService'))),
     MainThreadTimeline: ( (createProxyIdentifier('MainThreadTimeline'))),
     MainThreadTesting: ( (createProxyIdentifier('MainThreadTesting'))),
+    MainThreadLocalization: ( (createProxyIdentifier('MainThreadLocalizationShape')))
 };
 const ExtHostContext = {
     ExtHostCommands: ( (createProxyIdentifier('ExtHostCommands'))),
@@ -5144,6 +5804,7 @@ const ExtHostContext = {
     ExtHostLanguages: ( (createProxyIdentifier('ExtHostLanguages'))),
     ExtHostLanguageFeatures: ( (createProxyIdentifier('ExtHostLanguageFeatures'))),
     ExtHostQuickOpen: ( (createProxyIdentifier('ExtHostQuickOpen'))),
+    ExtHostQuickDiff: ( (createProxyIdentifier('ExtHostQuickDiff'))),
     ExtHostExtensionService: ( (createProxyIdentifier('ExtHostExtensionService'))),
     ExtHostLogLevelServiceShape: ( (createProxyIdentifier('ExtHostLogLevelServiceShape'))),
     ExtHostTerminalService: ( (createProxyIdentifier('ExtHostTerminalService'))),
@@ -5164,6 +5825,7 @@ const ExtHostContext = {
     ExtHostStorage: ( (createProxyIdentifier('ExtHostStorage'))),
     ExtHostUrls: ( (createProxyIdentifier('ExtHostUrls'))),
     ExtHostUriOpeners: ( (createProxyIdentifier('ExtHostUriOpeners'))),
+    ExtHostProfileContentHandlers: ( (createProxyIdentifier('ExtHostProfileContentHandlers'))),
     ExtHostOutputService: ( (createProxyIdentifier('ExtHostOutputService'))),
     ExtHosLabelService: ( (createProxyIdentifier('ExtHostLabelService'))),
     ExtHostNotebook: ( (createProxyIdentifier('ExtHostNotebook'))),
@@ -5178,17 +5840,245 @@ const ExtHostContext = {
     ExtHostTimeline: ( (createProxyIdentifier('ExtHostTimeline'))),
     ExtHostTesting: ( (createProxyIdentifier('ExtHostTesting'))),
     ExtHostTelemetry: ( (createProxyIdentifier('ExtHostTelemetry'))),
+    ExtHostLocalization: ( (createProxyIdentifier('ExtHostLocalization'))),
 };
 const IExtHostRpcService = ( (createDecorator('IExtHostRpcService')));
-var _ExtHostCommands_proxy, _ExtHostCommands_telemetry;
+const IExtHostInitDataService = ( (createDecorator('IExtHostInitDataService')));
+let ExtHostTelemetry = class ExtHostTelemetry extends Disposable$1 {
+    constructor(initData, loggerService) {
+        super();
+        this.initData = initData;
+        this.loggerService = loggerService;
+        this._onDidChangeTelemetryEnabled = this._register(( (new Emitter$1())));
+        this.onDidChangeTelemetryEnabled = this._onDidChangeTelemetryEnabled.event;
+        this._onDidChangeTelemetryConfiguration = this._register(( (new Emitter$1())));
+        this.onDidChangeTelemetryConfiguration = this._onDidChangeTelemetryConfiguration.event;
+        this._productConfig = { usage: true, error: true };
+        this._level = 0 ;
+        this._telemetryIsSupported = false;
+        this._inLoggingOnlyMode = false;
+        this._telemetryLoggers = ( (new Map()));
+        this.extHostTelemetryLogFile = URI.revive(this.initData.environment.extensionTelemetryLogResource);
+        this._inLoggingOnlyMode = this.initData.environment.isExtensionTelemetryLoggingOnly;
+        this._outputLogger = loggerService.createLogger(this.extHostTelemetryLogFile, { id: extensionTelemetryLogChannelId, name: ( (localize(
+            'extensionTelemetryLog',
+            "Extension Telemetry{0}",
+            this._inLoggingOnlyMode ? ' (Not Sent)' : ''
+        ))), hidden: true });
+        this._register(loggerService.onDidChangeLogLevel(arg => {
+            if (isLogLevel(arg)) {
+                this.updateLoggerVisibility();
+            }
+        }));
+        this._outputLogger.info('Below are logs for extension telemetry events sent to the telemetry output channel API once the log level is set to trace.');
+        this._outputLogger.info('===========================================================');
+    }
+    updateLoggerVisibility() {
+        this.loggerService.setVisibility(this.extHostTelemetryLogFile, this._telemetryIsSupported && this.loggerService.getLogLevel() === LogLevel.Trace);
+    }
+    getTelemetryConfiguration() {
+        return this._level === 3 ;
+    }
+    getTelemetryDetails() {
+        return {
+            isCrashEnabled: this._level >= 1 ,
+            isErrorsEnabled: this._productConfig.error ? this._level >= 2  : false,
+            isUsageEnabled: this._productConfig.usage ? this._level >= 3  : false
+        };
+    }
+    instantiateLogger(extension, sender, options) {
+        const telemetryDetails = this.getTelemetryDetails();
+        const logger = ( (new ExtHostTelemetryLogger(
+            sender,
+            options,
+            extension,
+            this._outputLogger,
+            this._inLoggingOnlyMode,
+            this.getBuiltInCommonProperties(extension),
+            { isUsageEnabled: telemetryDetails.isUsageEnabled, isErrorsEnabled: telemetryDetails.isErrorsEnabled }
+        )));
+        this._telemetryLoggers.set(extension.identifier.value, logger);
+        return logger.apiTelemetryLogger;
+    }
+    $initializeTelemetryLevel(level, supportsTelemetry, productConfig) {
+        this._level = level;
+        this._telemetryIsSupported = supportsTelemetry;
+        this._productConfig = productConfig ?? { usage: true, error: true };
+        this.updateLoggerVisibility();
+    }
+    getBuiltInCommonProperties(extension) {
+        const commonProperties = {};
+        commonProperties['common.extname'] = `${extension.publisher}.${extension.name}`;
+        commonProperties['common.extversion'] = extension.version;
+        commonProperties['common.vscodemachineid'] = this.initData.telemetryInfo.machineId;
+        commonProperties['common.vscodesessionid'] = this.initData.telemetryInfo.sessionId;
+        commonProperties['common.vscodeversion'] = this.initData.version;
+        commonProperties['common.isnewappinstall'] = isNewAppInstall(this.initData.telemetryInfo.firstSessionDate);
+        commonProperties['common.product'] = this.initData.environment.appHost;
+        switch (this.initData.uiKind) {
+            case UIKind.Web:
+                commonProperties['common.uikind'] = 'web';
+                break;
+            case UIKind.Desktop:
+                commonProperties['common.uikind'] = 'desktop';
+                break;
+            default:
+                commonProperties['common.uikind'] = 'unknown';
+        }
+        commonProperties['common.remotename'] = getRemoteName(cleanRemoteAuthority(this.initData.remote.authority));
+        return commonProperties;
+    }
+    $onDidChangeTelemetryLevel(level) {
+        this._oldTelemetryEnablement = this.getTelemetryConfiguration();
+        this._level = level;
+        const telemetryDetails = this.getTelemetryDetails();
+        this._telemetryLoggers.forEach(logger => {
+            logger.updateTelemetryEnablements(telemetryDetails.isUsageEnabled, telemetryDetails.isErrorsEnabled);
+        });
+        if (this._oldTelemetryEnablement !== this.getTelemetryConfiguration()) {
+            this._onDidChangeTelemetryEnabled.fire(this.getTelemetryConfiguration());
+        }
+        this._onDidChangeTelemetryConfiguration.fire(this.getTelemetryDetails());
+        this.updateLoggerVisibility();
+    }
+    onExtensionError(extension, error) {
+        const logger = this._telemetryLoggers.get(extension.value);
+        if (!logger || logger.ignoreUnhandledExtHostErrors) {
+            return false;
+        }
+        logger.logError(error);
+        return true;
+    }
+};
+ExtHostTelemetry = ( (__decorate([
+    ( (__param(0, IExtHostInitDataService))),
+    ( (__param(1, ILoggerService)))
+], ExtHostTelemetry)));
+class ExtHostTelemetryLogger {
+    static validateSender(sender) {
+        if (typeof sender !== 'object') {
+            throw new TypeError('TelemetrySender argument is invalid');
+        }
+        if (typeof sender.sendEventData !== 'function') {
+            throw new TypeError('TelemetrySender.sendEventData must be a function');
+        }
+        if (typeof sender.sendErrorData !== 'function') {
+            throw new TypeError('TelemetrySender.sendErrorData must be a function');
+        }
+        if (typeof sender.flush !== 'undefined' && typeof sender.flush !== 'function') {
+            throw new TypeError('TelemetrySender.flush must be a function or undefined');
+        }
+    }
+    constructor(sender, options, _extension, _logger, _inLoggingOnlyMode, _commonProperties, telemetryEnablements) {
+        this._extension = _extension;
+        this._logger = _logger;
+        this._inLoggingOnlyMode = _inLoggingOnlyMode;
+        this._commonProperties = _commonProperties;
+        this._onDidChangeEnableStates = ( (new Emitter$1()));
+        this.ignoreUnhandledExtHostErrors = options?.ignoreUnhandledErrors ?? false;
+        this._ignoreBuiltinCommonProperties = options?.ignoreBuiltInCommonProperties ?? false;
+        this._additionalCommonProperties = options?.additionalCommonProperties;
+        this._sender = sender;
+        this._telemetryEnablements = { isUsageEnabled: telemetryEnablements.isUsageEnabled, isErrorsEnabled: telemetryEnablements.isErrorsEnabled };
+    }
+    updateTelemetryEnablements(isUsageEnabled, isErrorsEnabled) {
+        if (this._apiObject) {
+            this._telemetryEnablements = { isUsageEnabled, isErrorsEnabled };
+            this._onDidChangeEnableStates.fire(this._apiObject);
+        }
+    }
+    mixInCommonPropsAndCleanData(data) {
+        let updatedData = data.properties ?? data;
+        updatedData = cleanData(updatedData, []);
+        if (this._additionalCommonProperties) {
+            updatedData = mixin(updatedData, this._additionalCommonProperties);
+        }
+        if (!this._ignoreBuiltinCommonProperties) {
+            updatedData = mixin(updatedData, this._commonProperties);
+        }
+        if (data.properties) {
+            data.properties = updatedData;
+        }
+        else {
+            data = updatedData;
+        }
+        return data;
+    }
+    logEvent(eventName, data) {
+        if (!this._sender) {
+            return;
+        }
+        if (this._extension.publisher === 'vscode') {
+            eventName = this._extension.name + '/' + eventName;
+        }
+        else {
+            eventName = this._extension.identifier.value + '/' + eventName;
+        }
+        data = this.mixInCommonPropsAndCleanData(data || {});
+        if (!this._inLoggingOnlyMode) {
+            this._sender?.sendEventData(eventName, data);
+        }
+        this._logger.trace(eventName, data);
+    }
+    logUsage(eventName, data) {
+        if (!this._telemetryEnablements.isUsageEnabled) {
+            return;
+        }
+        this.logEvent(eventName, data);
+    }
+    logError(eventNameOrException, data) {
+        if (!this._telemetryEnablements.isErrorsEnabled || !this._sender) {
+            return;
+        }
+        if (typeof eventNameOrException === 'string') {
+            this.logEvent(eventNameOrException, data);
+        }
+        else {
+            this._sender.sendErrorData(eventNameOrException, data);
+        }
+    }
+    get apiTelemetryLogger() {
+        if (!this._apiObject) {
+            const that = this;
+            const obj = {
+                logUsage: that.logUsage.bind(that),
+                get isUsageEnabled() {
+                    return that._telemetryEnablements.isUsageEnabled;
+                },
+                get isErrorsEnabled() {
+                    return that._telemetryEnablements.isErrorsEnabled;
+                },
+                logError: that.logError.bind(that),
+                dispose: that.dispose.bind(that),
+                onDidChangeEnableStates: that._onDidChangeEnableStates.event.bind(that)
+            };
+            this._apiObject = ( (Object.freeze(obj)));
+        }
+        return this._apiObject;
+    }
+    dispose() {
+        if (this._sender?.flush) {
+            Promise.resolve(this._sender.flush()).then(this._sender = undefined);
+            this._apiObject = undefined;
+        }
+    }
+}
+function isNewAppInstall(firstSessionDate) {
+    const installAge = Date.now() - ( (new Date(firstSessionDate))).getTime();
+    return isNaN(installAge) ? false : installAge < 1000 * 60 * 60 * 24;
+}
+const IExtHostTelemetry = ( (createDecorator('IExtHostTelemetry')));
+var _ExtHostCommands_proxy, _ExtHostCommands_telemetry, _ExtHostCommands_extHostTelemetry;
 let ExtHostCommands = class ExtHostCommands {
-    constructor(extHostRpc, logService) {
+    constructor(extHostRpc, logService, extHostTelemetry) {
         _ExtHostCommands_proxy.set(this, void 0);
         this._commands = ( (new Map()));
         this._apiCommands = ( (new Map()));
         _ExtHostCommands_telemetry.set(this, void 0);
+        _ExtHostCommands_extHostTelemetry.set(this, void 0);
         __classPrivateFieldSet(this, _ExtHostCommands_proxy, extHostRpc.getProxy(MainContext.MainThreadCommands), "f");
         this._logService = logService;
+        __classPrivateFieldSet(this, _ExtHostCommands_extHostTelemetry, extHostTelemetry, "f");
         __classPrivateFieldSet(this, _ExtHostCommands_telemetry, extHostRpc.getProxy(MainContext.MainThreadTelemetry), "f");
         this.converter = ( (new CommandsConverter(this, id => {
             const candidate = this._apiCommands.get(id);
@@ -5327,7 +6217,6 @@ let ExtHostCommands = class ExtHostCommands {
         if (!command) {
             throw new Error('Unknown command');
         }
-        this._reportTelemetry(command, id);
         const { callback, thisArg, description } = command;
         if (description) {
             for (let i = 0; i < description.args.length; i++) {
@@ -5339,6 +6228,7 @@ let ExtHostCommands = class ExtHostCommands {
                 }
             }
         }
+        const stopWatch = StopWatch.create();
         try {
             return await callback.apply(thisArg, args);
         }
@@ -5353,6 +6243,10 @@ let ExtHostCommands = class ExtHostCommands {
             if (!annotateError) {
                 throw err;
             }
+            if (command.extension?.identifier) {
+                const reported = __classPrivateFieldGet(this, _ExtHostCommands_extHostTelemetry, "f").onExtensionError(command.extension.identifier, err);
+                this._logService.trace('forwarded error to extension?', reported, command.extension?.identifier);
+            }
             throw new (class CommandError extends Error {
                 constructor() {
                     super(toErrorMessage(err));
@@ -5361,23 +6255,28 @@ let ExtHostCommands = class ExtHostCommands {
                 }
             });
         }
+        finally {
+            this._reportTelemetry(command, id, stopWatch.elapsed());
+        }
     }
-    _reportTelemetry(command, id) {
-        if (!command.extension || command.extension.isBuiltin) {
+    _reportTelemetry(command, id, duration) {
+        if (!command.extension) {
             return;
         }
         __classPrivateFieldGet(this, _ExtHostCommands_telemetry, "f").$publicLog2('Extension:ActionExecuted', {
             extensionId: command.extension.identifier.value,
-            id: id,
+            id: ( (new TelemetryTrustedValue(id))),
+            duration: duration,
         });
     }
     $executeContributedCommand(id, ...args) {
         this._logService.trace('ExtHostCommands#$executeContributedCommand', id);
-        if (!this._commands.has(id)) {
+        const cmdHandler = this._commands.get(id);
+        if (!cmdHandler) {
             return Promise.reject(( (new Error(`Contributed command '${id}' does not exist.`))));
         }
         else {
-            args = args.map(arg => this._argumentProcessors.reduce((r, p) => p.processArgument(r), arg));
+            args = args.map(arg => this._argumentProcessors.reduce((r, p) => p.processArgument(r, cmdHandler.extension?.identifier), arg));
             return this._executeContributedCommand(id, args, true);
         }
     }
@@ -5401,17 +6300,20 @@ let ExtHostCommands = class ExtHostCommands {
         return Promise.resolve(result);
     }
 };
-_ExtHostCommands_proxy = ( (new WeakMap())), _ExtHostCommands_telemetry = ( (new WeakMap()));
+_ExtHostCommands_proxy = ( (new WeakMap()));
+_ExtHostCommands_telemetry = ( (new WeakMap()));
+_ExtHostCommands_extHostTelemetry = ( (new WeakMap()));
 ExtHostCommands = ( (__decorate([
     ( (__param(0, IExtHostRpcService))),
-    ( (__param(1, ILogService)))
+    ( (__param(1, ILogService))),
+    ( (__param(2, IExtHostTelemetry)))
 ], ExtHostCommands)));
 class CommandsConverter {
     constructor(_commands, _lookupApiCommand, _logService) {
         this._commands = _commands;
         this._lookupApiCommand = _lookupApiCommand;
         this._logService = _logService;
-        this.delegatingCommandId = `_vscode_delegate_cmd_${( ( Date.now().toString(36)))}`;
+        this.delegatingCommandId = `__vsc${( ( Date.now().toString(36)))}`;
         this._cache = ( (new Map()));
         this._cachIdPool = 0;
         this._commands.registerCommand(true, this.delegatingCommandId, this._executeConvertedCommand, this);
@@ -5435,7 +6337,7 @@ class CommandsConverter {
             result.arguments = apiCommand.args.map((arg, i) => arg.convert(command.arguments && command.arguments[i]));
         }
         else if (isNonEmptyArray(command.arguments)) {
-            const id = ++this._cachIdPool;
+            const id = `${command.command}/${++this._cachIdPool}`;
             this._cache.set(id, command);
             disposables.add(toDisposable(() => {
                 this._cache.delete(id);
@@ -5449,7 +6351,7 @@ class CommandsConverter {
         return result;
     }
     fromInternal(command) {
-        if (typeof command.$ident === 'number') {
+        if (typeof command.$ident === 'string') {
             return this._cache.get(command.$ident);
         }
         else {
@@ -5467,7 +6369,7 @@ class CommandsConverter {
         const actualCmd = this.getActualCommand(...args);
         this._logService.trace('CommandsConverter#EXECUTE', args[0], actualCmd ? actualCmd.command : 'MISSING');
         if (!actualCmd) {
-            return Promise.reject('actual command NOT FOUND');
+            return Promise.reject(`Actual command not found, wanted to execute ${args[0]}`);
         }
         return this._commands.executeCommand(actualCmd.command, ...(actualCmd.arguments || []));
     }
@@ -5511,7 +6413,7 @@ let MainThreadCommands = class MainThreadCommands {
     constructor(extHostContext, _commandService, _extensionService) {
         this._commandService = _commandService;
         this._extensionService = _extensionService;
-        this._commandRegistrations = ( (new Map()));
+        this._commandRegistrations = ( (new DisposableMap()));
         this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostCommands);
         this._generateCommandsDocumentationRegistration = ( (CommandsRegistry.registerCommand(
             '_generateCommandsDocumentation',
@@ -5519,8 +6421,7 @@ let MainThreadCommands = class MainThreadCommands {
         )));
     }
     dispose() {
-        dispose(( (this._commandRegistrations.values())));
-        this._commandRegistrations.clear();
+        this._commandRegistrations.dispose();
         this._generateCommandsDocumentationRegistration.dispose();
     }
     async _generateCommandsDocumentation() {
@@ -5545,11 +6446,7 @@ let MainThreadCommands = class MainThreadCommands {
         }))));
     }
     $unregisterCommand(id) {
-        const command = this._commandRegistrations.get(id);
-        if (command) {
-            command.dispose();
-            this._commandRegistrations.delete(id);
-        }
+        this._commandRegistrations.deleteAndDispose(id);
     }
     $fireCommandActivationEvent(id) {
         const activationEvent = `onCommand:${id}`;
@@ -5659,15 +6556,16 @@ class ExtHostFileSystemInfo {
 const IExtHostFileSystemInfo = ( (createDecorator('IExtHostFileSystemInfo')));
 var _DiagnosticCollection_proxy, _DiagnosticCollection_onDidChangeDiagnostics, _DiagnosticCollection_data;
 class DiagnosticCollection {
-    constructor(_name, _owner, _maxDiagnosticsPerFile, extUri, proxy, onDidChangeDiagnostics) {
+    constructor(_name, _owner, _maxDiagnosticsPerFile, _modelVersionIdProvider, extUri, proxy, onDidChangeDiagnostics) {
         this._name = _name;
         this._owner = _owner;
         this._maxDiagnosticsPerFile = _maxDiagnosticsPerFile;
+        this._modelVersionIdProvider = _modelVersionIdProvider;
         _DiagnosticCollection_proxy.set(this, void 0);
         _DiagnosticCollection_onDidChangeDiagnostics.set(this, void 0);
         _DiagnosticCollection_data.set(this, void 0);
         this._isDisposed = false;
-        __classPrivateFieldSet(this, _DiagnosticCollection_data, ( (new ResourceMap(uri => extUri.getComparisonKey(uri)))), "f");
+        __classPrivateFieldSet(this, _DiagnosticCollection_data, ( (new ResourceMap$1(uri => extUri.getComparisonKey(uri)))), "f");
         __classPrivateFieldSet(this, _DiagnosticCollection_proxy, proxy, "f");
         __classPrivateFieldSet(this, _DiagnosticCollection_onDidChangeDiagnostics, onDidChangeDiagnostics, "f");
     }
@@ -5739,7 +6637,7 @@ class DiagnosticCollection {
                     orderLoop: for (let i = 0; i < 4; i++) {
                         for (const diagnostic of diagnostics) {
                             if (diagnostic.severity === order[i]) {
-                                const len = marker.push(Diagnostic.from(diagnostic));
+                                const len = marker.push({ ...Diagnostic.from(diagnostic), modelVersionId: this._modelVersionIdProvider(uri) });
                                 if (len === this._maxDiagnosticsPerFile) {
                                     break orderLoop;
                                 }
@@ -5760,7 +6658,7 @@ class DiagnosticCollection {
                     });
                 }
                 else {
-                    marker = diagnostics.map(diag => Diagnostic.from(diag));
+                    marker = diagnostics.map(diag => ({ ...Diagnostic.from(diag), modelVersionId: this._modelVersionIdProvider(uri) }));
                 }
             }
             entries.push([uri, marker]);
@@ -5823,23 +6721,24 @@ class DiagnosticCollection {
     }
 }
 let ExtHostDiagnostics = class ExtHostDiagnostics {
-    constructor(mainContext, _logService, _fileSystemInfoService) {
+    static _mapper(last) {
+        const map = ( (new ResourceMap$1()));
+        for (const uri of last) {
+            map.set(uri, uri);
+        }
+        return { uris: ( (Object.freeze(Array.from(( (map.values())))))) };
+    }
+    constructor(mainContext, _logService, _fileSystemInfoService, _extHostDocumentsAndEditors) {
         this._logService = _logService;
         this._fileSystemInfoService = _fileSystemInfoService;
+        this._extHostDocumentsAndEditors = _extHostDocumentsAndEditors;
         this._collections = ( (new Map()));
         this._onDidChangeDiagnostics = ( (new DebounceEmitter({ merge: all => all.flat(), delay: 50 })));
         this.onDidChangeDiagnostics = Event.map(this._onDidChangeDiagnostics.event, ExtHostDiagnostics._mapper);
         this._proxy = mainContext.getProxy(MainContext.MainThreadDiagnostics);
     }
-    static _mapper(last) {
-        const map = ( (new ResourceMap()));
-        for (const uri of last) {
-            map.set(uri, uri);
-        }
-        return { uris: ( (Object.freeze(Array.from(( (map.values())))))) };
-    }
     createDiagnosticCollection(extensionId, name) {
-        const { _collections, _proxy, _onDidChangeDiagnostics, _logService, _fileSystemInfoService } = this;
+        const { _collections, _proxy, _onDidChangeDiagnostics, _logService, _fileSystemInfoService, _extHostDocumentsAndEditors } = this;
         const loggingProxy = new (class {
             $changeMany(owner, entries) {
                 _proxy.$changeMany(owner, entries);
@@ -5869,7 +6768,7 @@ let ExtHostDiagnostics = class ExtHostDiagnostics {
         }
         const result = new (class extends DiagnosticCollection {
             constructor() {
-                super(name, owner, ExtHostDiagnostics._maxDiagnosticsPerFile, _fileSystemInfoService.extUri, loggingProxy, _onDidChangeDiagnostics);
+                super(name, owner, ExtHostDiagnostics._maxDiagnosticsPerFile, uri => _extHostDocumentsAndEditors.getDocument(uri)?.version, _fileSystemInfoService.extUri, loggingProxy, _onDidChangeDiagnostics);
                 _collections.set(owner, this);
             }
             dispose() {
@@ -5916,6 +6815,7 @@ let ExtHostDiagnostics = class ExtHostDiagnostics {
                 name,
                 name,
                 ExtHostDiagnostics._maxDiagnosticsPerFile,
+                _uri => undefined,
                 this._fileSystemInfoService.extUri,
                 undefined,
                 this._onDidChangeDiagnostics
@@ -5942,6 +6842,9 @@ function _transformIncomingURIs(obj, transformer, revive, depth) {
         if (obj.$mid === 1 ) {
             return revive ? URI.revive(transformer.transformIncoming(obj)) : transformer.transformIncoming(obj);
         }
+        if (obj instanceof VSBuffer) {
+            return null;
+        }
         for (const key in obj) {
             if (Object.hasOwnProperty.call(obj, key)) {
                 const r = _transformIncomingURIs(obj[key], transformer, revive, depth + 1);
@@ -6098,7 +7001,7 @@ class RPCProtocol extends Disposable$1 {
     constructor(protocol, logger = null, transformer = null) {
         super();
         this[_a] = true;
-        this._onDidChangeResponsiveState = this._register(( (new Emitter())));
+        this._onDidChangeResponsiveState = this._register(( (new Emitter$1())));
         this.onDidChangeResponsiveState = this._onDidChangeResponsiveState.event;
         this._protocol = protocol;
         this._logger = logger;
@@ -6411,10 +7314,6 @@ class RPCProtocol extends Disposable$1 {
 _a = _RPCProtocolSymbol;
 RPCProtocol.UNRESPONSIVE_TIME = 3 * 1000;
 class MessageBuffer {
-    constructor(buff, offset) {
-        this._buff = buff;
-        this._offset = offset;
-    }
     static alloc(type, req, messageSize) {
         const result = ( (new MessageBuffer(VSBuffer.alloc(messageSize + 1  + 4 ), 0)));
         result.writeUInt8(type);
@@ -6429,6 +7328,10 @@ class MessageBuffer {
     get buffer() {
         return this._buff;
     }
+    constructor(buff, offset) {
+        this._buff = buff;
+        this._offset = offset;
+    }
     static sizeUInt8() {
         return 1;
     }
@@ -6795,12 +7698,12 @@ class BufferedEmitter {
         this._hasListeners = false;
         this._isDeliveringMessages = false;
         this._bufferedMessages = [];
-        this._emitter = ( (new Emitter({
-            onFirstListenerAdd: () => {
+        this._emitter = ( (new Emitter$1({
+            onWillAddFirstListener: () => {
                 this._hasListeners = true;
                 queueMicrotask(() => this._deliverMessages());
             },
-            onLastListenerRemove: () => {
+            onDidRemoveLastListener: () => {
                 this._hasListeners = false;
             }
         })));
@@ -7055,10 +7958,10 @@ class ExtHostDocumentLine {
 }
 class ExtHostDocuments {
     constructor(mainContext, documentsAndEditors) {
-        this._onDidAddDocument = ( (new Emitter()));
-        this._onDidRemoveDocument = ( (new Emitter()));
-        this._onDidChangeDocument = ( (new Emitter()));
-        this._onDidSaveDocument = ( (new Emitter()));
+        this._onDidAddDocument = ( (new Emitter$1()));
+        this._onDidRemoveDocument = ( (new Emitter$1()));
+        this._onDidChangeDocument = ( (new Emitter$1()));
+        this._onDidSaveDocument = ( (new Emitter$1()));
         this.onDidAddDocument = this._onDidAddDocument.event;
         this.onDidRemoveDocument = this._onDidRemoveDocument.event;
         this.onDidChangeDocument = this._onDidChangeDocument.event;
@@ -7196,7 +8099,7 @@ function createExtHostQuickOpen(mainContext, workspace, commands) {
             this._workspace = workspace;
             this._commands = commands;
         }
-        showQuickPick(itemsOrItemsPromise, options, token = CancellationToken.None) {
+        showQuickPick(extension, itemsOrItemsPromise, options, token = CancellationToken.None) {
             this._onDidSelectItem = undefined;
             const itemsPromise = Promise.resolve(itemsOrItemsPromise);
             const instance = ++this._instances;
@@ -7214,6 +8117,7 @@ function createExtHostQuickOpen(mainContext, workspace, commands) {
                 if (result === widgetClosedMarker) {
                     return undefined;
                 }
+                const allowedTooltips = isProposedApiEnabled(extension, 'quickPickItemTooltip');
                 return itemsPromise.then(items => {
                     const pickItems = [];
                     for (let handle = 0; handle < items.length; handle++) {
@@ -7225,12 +8129,16 @@ function createExtHostQuickOpen(mainContext, workspace, commands) {
                             pickItems.push({ type: 'separator', label: item.label });
                         }
                         else {
+                            if (item.tooltip && !allowedTooltips) {
+                                console.warn(`Extension '${extension.identifier.value}' uses a tooltip which is proposed API that is only available when running out of dev or with the following command line switch: --enable-proposed-api ${extension.identifier.value}`);
+                            }
                             pickItems.push({
                                 label: item.label,
                                 description: item.description,
                                 detail: item.detail,
                                 picked: item.picked,
                                 alwaysShow: item.alwaysShow,
+                                tooltip: allowedTooltips ? MarkdownString.fromStrict(item.tooltip) : undefined,
                                 handle
                             });
                         }
@@ -7327,9 +8235,7 @@ function createExtHostQuickOpen(mainContext, workspace, commands) {
         }
         $onDidAccept(sessionId) {
             const session = this._sessions.get(sessionId);
-            if (session) {
-                session._fireDidAccept();
-            }
+            session?._fireDidAccept();
         }
         $onDidChangeActive(sessionId, handles) {
             const session = this._sessions.get(sessionId);
@@ -7355,9 +8261,7 @@ function createExtHostQuickOpen(mainContext, workspace, commands) {
         }
         $onDidHide(sessionId) {
             const session = this._sessions.get(sessionId);
-            if (session) {
-                session._fireDidHide();
-            }
+            session?._fireDidHide();
         }
     }
     class ExtHostQuickInput {
@@ -7373,10 +8277,10 @@ function createExtHostQuickOpen(mainContext, workspace, commands) {
             this._value = '';
             this._buttons = [];
             this._handlesToButtons = ( (new Map()));
-            this._onDidAcceptEmitter = ( (new Emitter()));
-            this._onDidChangeValueEmitter = ( (new Emitter()));
-            this._onDidTriggerButtonEmitter = ( (new Emitter()));
-            this._onDidHideEmitter = ( (new Emitter()));
+            this._onDidAcceptEmitter = ( (new Emitter$1()));
+            this._onDidChangeValueEmitter = ( (new Emitter$1()));
+            this._onDidTriggerButtonEmitter = ( (new Emitter$1()));
+            this._onDidHideEmitter = ( (new Emitter$1()));
             this._pendingUpdate = { id: this._id };
             this._disposed = false;
             this._disposables = [
@@ -7571,6 +8475,7 @@ function createExtHostQuickOpen(mainContext, workspace, commands) {
     class ExtHostQuickPick extends ExtHostQuickInput {
         constructor(extension, onDispose) {
             super(extension.identifier, onDispose);
+            this.extension = extension;
             this._items = [];
             this._handlesToItems = ( (new Map()));
             this._itemsToHandles = ( (new Map()));
@@ -7580,10 +8485,10 @@ function createExtHostQuickOpen(mainContext, workspace, commands) {
             this._sortByLabel = true;
             this._keepScrollPosition = false;
             this._activeItems = [];
-            this._onDidChangeActiveEmitter = ( (new Emitter()));
+            this._onDidChangeActiveEmitter = ( (new Emitter$1()));
             this._selectedItems = [];
-            this._onDidChangeSelectionEmitter = ( (new Emitter()));
-            this._onDidTriggerItemButtonEmitter = ( (new Emitter()));
+            this._onDidChangeSelectionEmitter = ( (new Emitter$1()));
+            this._onDidTriggerItemButtonEmitter = ( (new Emitter$1()));
             this.onDidChangeActive = this._onDidChangeActiveEmitter.event;
             this.onDidChangeSelection = this._onDidChangeSelectionEmitter.event;
             this.onDidTriggerItemButton = this._onDidTriggerItemButtonEmitter.event;
@@ -7601,6 +8506,7 @@ function createExtHostQuickOpen(mainContext, workspace, commands) {
                 this._handlesToItems.set(i, item);
                 this._itemsToHandles.set(item, i);
             });
+            const allowedTooltips = isProposedApiEnabled(this.extension, 'quickPickItemTooltip');
             const pickItems = [];
             for (let handle = 0; handle < items.length; handle++) {
                 const item = items[handle];
@@ -7608,6 +8514,9 @@ function createExtHostQuickOpen(mainContext, workspace, commands) {
                     pickItems.push({ type: 'separator', label: item.label });
                 }
                 else {
+                    if (item.tooltip && !allowedTooltips) {
+                        console.warn(`Extension '${this.extension.identifier.value}' uses a tooltip which is proposed API that is only available when running out of dev or with the following command line switch: --enable-proposed-api ${this.extension.identifier.value}`);
+                    }
                     pickItems.push({
                         handle,
                         label: item.label,
@@ -7615,6 +8524,7 @@ function createExtHostQuickOpen(mainContext, workspace, commands) {
                         detail: item.detail,
                         picked: item.picked,
                         alwaysShow: item.alwaysShow,
+                        tooltip: allowedTooltips ? MarkdownString.fromStrict(item.tooltip) : undefined,
                         buttons: item.buttons?.map((button, i) => {
                             return {
                                 ...getIconPathOrClass(button),
@@ -7722,6 +8632,13 @@ function createExtHostQuickOpen(mainContext, workspace, commands) {
             this._prompt = prompt;
             this.update({ prompt });
         }
+        get valueSelection() {
+            return this._valueSelection;
+        }
+        set valueSelection(valueSelection) {
+            this._valueSelection = valueSelection;
+            this.update({ valueSelection });
+        }
         get validationMessage() {
             return this._validationMessage;
         }
@@ -7742,7 +8659,23 @@ function createExtHostQuickOpen(mainContext, workspace, commands) {
          (new ExtHostQuickOpenImpl(workspace, commands))
     );
 }
-const IExtHostInitDataService = ( (createDecorator('IExtHostInitDataService')));
+const IURITransformerService = ( (createDecorator('IURITransformerService')));
+class URITransformerService {
+    constructor(delegate) {
+        if (!delegate) {
+            this.transformIncoming = arg => arg;
+            this.transformOutgoing = arg => arg;
+            this.transformOutgoingURI = arg => arg;
+            this.transformOutgoingScheme = arg => arg;
+        }
+        else {
+            this.transformIncoming = delegate.transformIncoming.bind(delegate);
+            this.transformOutgoing = delegate.transformOutgoing.bind(delegate);
+            this.transformOutgoingURI = delegate.transformOutgoingURI.bind(delegate);
+            this.transformOutgoingScheme = delegate.transformOutgoingScheme.bind(delegate);
+        }
+    }
+}
 function resultIsMatch(result) {
     return !!result.preview;
 }
@@ -7768,17 +8701,6 @@ function ignorePathCasing(uri, extHostFileSystemInfo) {
     return !(capabilities && ((capabilities & 1024) ));
 }
 class ExtHostWorkspaceImpl extends Workspace {
-    constructor(id, _name, folders, transient, configuration, _isUntitled, ignorePathCasing) {
-        super(id, folders.map(f => ( (new WorkspaceFolder(f)))), transient, configuration, ignorePathCasing);
-        this._name = _name;
-        this._isUntitled = _isUntitled;
-        this._workspaceFolders = [];
-        this._structure = TernarySearchTree.forUris(ignorePathCasing);
-        folders.forEach(folder => {
-            this._workspaceFolders.push(folder);
-            this._structure.set(folder.uri, folder);
-        });
-    }
     static toExtHostWorkspace(data, previousConfirmedWorkspace, previousUnconfirmedWorkspace, extHostFileSystemInfo) {
         if (!data) {
             return { workspace: null, added: [], removed: [] };
@@ -7825,6 +8747,17 @@ class ExtHostWorkspaceImpl extends Workspace {
         }
         return undefined;
     }
+    constructor(id, _name, folders, transient, configuration, _isUntitled, ignorePathCasing) {
+        super(id, folders.map(f => ( (new WorkspaceFolder(f)))), transient, configuration, ignorePathCasing);
+        this._name = _name;
+        this._isUntitled = _isUntitled;
+        this._workspaceFolders = [];
+        this._structure = TernarySearchTree.forUris(ignorePathCasing);
+        folders.forEach(folder => {
+            this._workspaceFolders.push(folder);
+            this._structure.set(folder.uri, folder);
+        });
+    }
     get name() {
         return this._name;
     }
@@ -7845,15 +8778,19 @@ class ExtHostWorkspaceImpl extends Workspace {
     }
 }
 let ExtHostWorkspace = class ExtHostWorkspace {
-    constructor(extHostRpc, initData, extHostFileSystemInfo, logService) {
-        this._onDidChangeWorkspace = ( (new Emitter()));
+    constructor(extHostRpc, initData, extHostFileSystemInfo, logService, uriTransformerService) {
+        this._onDidChangeWorkspace = ( (new Emitter$1()));
         this.onDidChangeWorkspace = this._onDidChangeWorkspace.event;
-        this._onDidGrantWorkspaceTrust = ( (new Emitter()));
+        this._onDidGrantWorkspaceTrust = ( (new Emitter$1()));
         this.onDidGrantWorkspaceTrust = this._onDidGrantWorkspaceTrust.event;
         this._activeSearchCallbacks = [];
         this._trusted = false;
+        this._editSessionIdentityProviders = ( (new Map()));
+        this._providerHandlePool = 0;
+        this._onWillCreateEditSessionIdentityEvent = ( (new AsyncEmitter()));
         this._logService = logService;
         this._extHostFileSystemInfo = extHostFileSystemInfo;
+        this._uriTransformerService = uriTransformerService;
         this._requestIdProvider = ( (new Counter()));
         this._barrier = ( (new Barrier()));
         this._proxy = extHostRpc.getProxy(MainContext.MainThreadWorkspace);
@@ -8145,12 +9082,89 @@ let ExtHostWorkspace = class ExtHostWorkspace {
             this._onDidGrantWorkspaceTrust.fire();
         }
     }
+    registerEditSessionIdentityProvider(scheme, provider) {
+        if (this._editSessionIdentityProviders.has(scheme)) {
+            throw new Error(`A provider has already been registered for scheme ${scheme}`);
+        }
+        this._editSessionIdentityProviders.set(scheme, provider);
+        const outgoingScheme = this._uriTransformerService.transformOutgoingScheme(scheme);
+        const handle = this._providerHandlePool++;
+        this._proxy.$registerEditSessionIdentityProvider(handle, outgoingScheme);
+        return toDisposable(() => {
+            this._editSessionIdentityProviders.delete(scheme);
+            this._proxy.$unregisterEditSessionIdentityProvider(handle);
+        });
+    }
+    async $getEditSessionIdentifier(workspaceFolder, cancellationToken) {
+        this._logService.info('Getting edit session identifier for workspaceFolder', workspaceFolder);
+        const folder = await this.resolveWorkspaceFolder(URI.revive(workspaceFolder));
+        if (!folder) {
+            this._logService.warn('Unable to resolve workspace folder');
+            return undefined;
+        }
+        this._logService.info('Invoking #provideEditSessionIdentity for workspaceFolder', folder);
+        const provider = this._editSessionIdentityProviders.get(folder.uri.scheme);
+        this._logService.info(`Provider for scheme ${folder.uri.scheme} is defined: `, !!provider);
+        if (!provider) {
+            return undefined;
+        }
+        const result = await provider.provideEditSessionIdentity(folder, cancellationToken);
+        this._logService.info('Provider returned edit session identifier: ', result);
+        if (!result) {
+            return undefined;
+        }
+        return result;
+    }
+    async $provideEditSessionIdentityMatch(workspaceFolder, identity1, identity2, cancellationToken) {
+        this._logService.info('Getting edit session identifier for workspaceFolder', workspaceFolder);
+        const folder = await this.resolveWorkspaceFolder(URI.revive(workspaceFolder));
+        if (!folder) {
+            this._logService.warn('Unable to resolve workspace folder');
+            return undefined;
+        }
+        this._logService.info('Invoking #provideEditSessionIdentity for workspaceFolder', folder);
+        const provider = this._editSessionIdentityProviders.get(folder.uri.scheme);
+        this._logService.info(`Provider for scheme ${folder.uri.scheme} is defined: `, !!provider);
+        if (!provider) {
+            return undefined;
+        }
+        const result = await provider.provideEditSessionIdentityMatch?.(identity1, identity2, cancellationToken);
+        this._logService.info('Provider returned edit session identifier match result: ', result);
+        if (!result) {
+            return undefined;
+        }
+        return result;
+    }
+    getOnWillCreateEditSessionIdentityEvent(extension) {
+        return (listener, thisArg, disposables) => {
+            const wrappedListener = function wrapped(e) { listener.call(thisArg, e); };
+            wrappedListener.extension = extension;
+            return this._onWillCreateEditSessionIdentityEvent.event(wrappedListener, undefined, disposables);
+        };
+    }
+    async $onWillCreateEditSessionIdentity(workspaceFolder, token, timeout) {
+        const folder = await this.resolveWorkspaceFolder(URI.revive(workspaceFolder));
+        if (folder === undefined) {
+            throw new Error('Unable to resolve workspace folder');
+        }
+        await this._onWillCreateEditSessionIdentityEvent.fireAsync({ workspaceFolder: folder }, token, async (thenable, listener) => {
+            const now = Date.now();
+            await Promise.resolve(thenable);
+            if (Date.now() - now > timeout) {
+                this._logService.warn('SLOW edit session create-participant', listener.extension.identifier);
+            }
+        });
+        if (token.isCancellationRequested) {
+            return undefined;
+        }
+    }
 };
 ExtHostWorkspace = ( (__decorate([
     ( (__param(0, IExtHostRpcService))),
     ( (__param(1, IExtHostInitDataService))),
     ( (__param(2, IExtHostFileSystemInfo))),
-    ( (__param(3, ILogService)))
+    ( (__param(3, ILogService))),
+    ( (__param(4, IURITransformerService)))
 ], ExtHostWorkspace)));
 const IExtHostWorkspace = ( (createDecorator('IExtHostWorkspace')));
 function parseSearchInclude(include) {
@@ -8416,29 +9430,15 @@ let MainThreadMessageService = class MainThreadMessageService {
     _showMessage(severity, message, commands, options) {
         return (
              (new Promise(resolve => {
-                const primaryActions = [];
-                class MessageItemAction extends Action {
-                    constructor(id, label, handle) {
-                        super(id, label, undefined, true, () => {
-                            resolve(handle);
-                            return Promise.resolve();
-                        });
-                    }
-                }
-                class ManageExtensionAction extends Action {
-                    constructor(id, label, commandService) {
-                        super(id.value, label, undefined, true, () => {
-                            return commandService.executeCommand('_extensions.manage', id.value);
-                        });
+                const primaryActions = commands.map(command => toAction({
+                    id: `_extension_message_handle_${command.handle}`,
+                    label: command.title,
+                    enabled: true,
+                    run: () => {
+                        resolve(command.handle);
+                        return Promise.resolve();
                     }
-                }
-                commands.forEach(command => {
-                    primaryActions.push(( (new MessageItemAction(
-                        '_extension_message_handle_' + command.handle,
-                        command.title,
-                        command.handle
-                    ))));
-                });
+                }));
                 let source;
                 if (options.source) {
                     source = {
@@ -8451,11 +9451,13 @@ let MainThreadMessageService = class MainThreadMessageService {
                 }
                 const secondaryActions = [];
                 if (options.source) {
-                    secondaryActions.push(( (new ManageExtensionAction(
-                        options.source.identifier,
-                         (localize('manageExtension', "Manage Extension")),
-                        this._commandService
-                    ))));
+                    secondaryActions.push(toAction({
+                        id: options.source.identifier.value,
+                        label: ( (localize('manageExtension', "Manage Extension"))),
+                        run: () => {
+                            return this._commandService.executeCommand('_extensions.manage', options.source.identifier.value);
+                        }
+                    }));
                 }
                 const messageHandle = this._notificationService.notify({
                     severity,
@@ -8464,32 +9466,49 @@ let MainThreadMessageService = class MainThreadMessageService {
                     source
                 });
                 Event.once(messageHandle.onDidClose)(() => {
-                    dispose(primaryActions);
-                    dispose(secondaryActions);
                     resolve(undefined);
                 });
             }))
         );
     }
     async _showModalMessage(severity, message, detail, commands, useCustom) {
-        let cancelId = undefined;
-        const buttons = commands.map((command, index) => {
-            if (command.isCloseAffordance === true) {
-                cancelId = index;
+        const buttons = [];
+        let cancelButton = undefined;
+        for (const command of commands) {
+            const button = {
+                label: command.title,
+                run: () => command.handle
+            };
+            if (command.isCloseAffordance) {
+                cancelButton = button;
             }
-            return command.title;
-        });
-        if (cancelId === undefined) {
+            else {
+                buttons.push(button);
+            }
+        }
+        if (!cancelButton) {
             if (buttons.length > 0) {
-                buttons.push(( (localize('cancel', "Cancel"))));
+                cancelButton = {
+                    label: ( (localize('cancel', "Cancel"))),
+                    run: () => undefined
+                };
             }
             else {
-                buttons.push(( (localize('ok', "OK"))));
+                cancelButton = {
+                    label: ( (localize({ key: 'ok', comment: ['&& denotes a mnemonic'] }, "&&OK"))),
+                    run: () => undefined
+                };
             }
-            cancelId = buttons.length - 1;
         }
-        const { choice } = await this._dialogService.show(severity, message, buttons, { cancelId, custom: useCustom, detail });
-        return choice === commands.length ? undefined : commands[choice].handle;
+        const { result } = await this._dialogService.prompt({
+            type: severity,
+            message,
+            detail,
+            buttons,
+            cancelButton,
+            custom: useCustom
+        });
+        return result;
     }
 };
 MainThreadMessageService = ( (__decorate([
@@ -8524,9 +9543,7 @@ class ExtHostProgress {
         const progressEnd = (handle) => {
             this._proxy.$progressEnd(handle);
             this._mapHandleToCancellationSource.delete(handle);
-            if (source) {
-                source.dispose();
-            }
+            source?.dispose();
         };
         let p;
         try {
@@ -8623,12 +9640,12 @@ let MainThreadDocumentContentProviders = class MainThreadDocumentContentProvider
         this._languageService = _languageService;
         this._modelService = _modelService;
         this._editorWorkerService = _editorWorkerService;
-        this._resourceContentProvider = ( (new Map()));
+        this._resourceContentProvider = ( (new DisposableMap()));
         this._pendingUpdate = ( (new Map()));
         this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostDocumentContentProviders);
     }
     dispose() {
-        dispose(( (this._resourceContentProvider.values())));
+        this._resourceContentProvider.dispose();
         dispose(( (this._pendingUpdate.values())));
     }
     $registerTextContentProvider(handle, scheme) {
@@ -8647,11 +9664,7 @@ let MainThreadDocumentContentProviders = class MainThreadDocumentContentProvider
         this._resourceContentProvider.set(handle, registration);
     }
     $unregisterTextContentProvider(handle) {
-        const registration = this._resourceContentProvider.get(handle);
-        if (registration) {
-            registration.dispose();
-            this._resourceContentProvider.delete(handle);
-        }
+        this._resourceContentProvider.deleteAndDispose(handle);
     }
     $onVirtualDocumentChange(uri, value) {
         const model = this._modelService.getModel(URI.revive(uri));
@@ -8659,9 +9672,7 @@ let MainThreadDocumentContentProviders = class MainThreadDocumentContentProvider
             return;
         }
         const pending = this._pendingUpdate.get(model.id);
-        if (pending) {
-            pending.cancel();
-        }
+        pending?.cancel();
         const myToken = ( (new CancellationTokenSource()));
         this._pendingUpdate.set(model.id, myToken);
         this._editorWorkerService.computeMoreMinimalEdits(model.uri, [{ text: value, range: model.getFullModelRange() }]).then(edits => {
@@ -8838,6 +9849,12 @@ class ExtHostTextEditorOptions {
             set tabSize(value) {
                 that._setTabSize(value);
             },
+            get indentSize() {
+                return that._indentSize;
+            },
+            set indentSize(value) {
+                that._setIndentSize(value);
+            },
             get insertSpaces() {
                 return that._insertSpaces;
             },
@@ -8860,6 +9877,7 @@ class ExtHostTextEditorOptions {
     }
     _accept(source) {
         this._tabSize = source.tabSize;
+        this._indentSize = source.indentSize;
         this._insertSpaces = source.insertSpaces;
         this._cursorStyle = source.cursorStyle;
         this._lineNumbers = TextEditorLineNumbersStyle.to(source.lineNumbers);
@@ -8896,6 +9914,38 @@ class ExtHostTextEditorOptions {
             tabSize: tabSize
         }));
     }
+    _validateIndentSize(value) {
+        if (value === 'tabSize') {
+            return 'tabSize';
+        }
+        if (typeof value === 'number') {
+            const r = Math.floor(value);
+            return (r > 0 ? r : null);
+        }
+        if (typeof value === 'string') {
+            const r = parseInt(value, 10);
+            if (isNaN(r)) {
+                return null;
+            }
+            return (r > 0 ? r : null);
+        }
+        return null;
+    }
+    _setIndentSize(value) {
+        const indentSize = this._validateIndentSize(value);
+        if (indentSize === null) {
+            return;
+        }
+        if (typeof indentSize === 'number') {
+            if (this._indentSize === indentSize) {
+                return;
+            }
+            this._indentSize = indentSize;
+        }
+        this._warnOnError('setIndentSize', this._proxy.$trySetOptions(this._id, {
+            indentSize: indentSize
+        }));
+    }
     _validateInsertSpaces(value) {
         if (value === 'auto') {
             return 'auto';
@@ -8947,6 +9997,18 @@ class ExtHostTextEditorOptions {
                 bulkConfigurationUpdate.tabSize = tabSize;
             }
         }
+        if (typeof newOptions.indentSize !== 'undefined') {
+            const indentSize = this._validateIndentSize(newOptions.indentSize);
+            if (indentSize === 'tabSize') {
+                hasUpdate = true;
+                bulkConfigurationUpdate.indentSize = indentSize;
+            }
+            else if (typeof indentSize === 'number' && this._indentSize !== indentSize) {
+                this._indentSize = indentSize;
+                hasUpdate = true;
+                bulkConfigurationUpdate.indentSize = indentSize;
+            }
+        }
         if (typeof newOptions.insertSpaces !== 'undefined') {
             const insertSpaces = this._validateInsertSpaces(newOptions.insertSpaces);
             if (insertSpaces === 'auto') {
@@ -8998,7 +10060,7 @@ class ExtHostTextEditor {
         const that = this;
         this.value = ( (Object.freeze({
             get document() {
-                return document.getValue();
+                return document.value;
             },
             set document(_value) {
                 throw readonly('document');
@@ -9047,7 +10109,7 @@ class ExtHostTextEditor {
                 if (that._disposed) {
                     return Promise.reject(( (new Error('TextEditor#edit not possible on closed editors'))));
                 }
-                const edit = ( (new TextEditorEdit(document.getValue(), options)));
+                const edit = ( (new TextEditorEdit(document.value, options)));
                 callback(edit);
                 return that._applyEdit(edit);
             },
@@ -9078,7 +10140,7 @@ class ExtHostTextEditor {
                         }
                     }
                 }
-                return _proxy.$tryInsertSnippet(id, document.getValue().version, snippet.value, ranges, options);
+                return _proxy.$tryInsertSnippet(id, document.value.version, snippet.value, ranges, options);
             },
             setDecorations(decorationType, ranges) {
                 const willBeEmpty = (ranges.length === 0);
@@ -9213,11 +10275,11 @@ let ExtHostDocumentsAndEditors = class ExtHostDocumentsAndEditors {
         this._logService = _logService;
         this._activeEditorId = null;
         this._editors = ( (new Map()));
-        this._documents = ( (new ResourceMap()));
-        this._onDidAddDocuments = ( (new Emitter()));
-        this._onDidRemoveDocuments = ( (new Emitter()));
-        this._onDidChangeVisibleTextEditors = ( (new Emitter()));
-        this._onDidChangeActiveTextEditor = ( (new Emitter()));
+        this._documents = ( (new ResourceMap$1()));
+        this._onDidAddDocuments = ( (new Emitter$1()));
+        this._onDidRemoveDocuments = ( (new Emitter$1()));
+        this._onDidChangeVisibleTextEditors = ( (new Emitter$1()));
+        this._onDidChangeActiveTextEditor = ( (new Emitter$1()));
         this.onDidAddDocuments = this._onDidAddDocuments.event;
         this.onDidRemoveDocuments = this._onDidRemoveDocuments.event;
         this.onDidChangeVisibleTextEditors = this._onDidChangeVisibleTextEditors.event;
@@ -9345,12 +10407,12 @@ ExtHostDocumentsAndEditors = ( (__decorate([
 class ExtHostEditors {
     constructor(mainContext, _extHostDocumentsAndEditors) {
         this._extHostDocumentsAndEditors = _extHostDocumentsAndEditors;
-        this._onDidChangeTextEditorSelection = ( (new Emitter()));
-        this._onDidChangeTextEditorOptions = ( (new Emitter()));
-        this._onDidChangeTextEditorVisibleRanges = ( (new Emitter()));
-        this._onDidChangeTextEditorViewColumn = ( (new Emitter()));
-        this._onDidChangeActiveTextEditor = ( (new Emitter()));
-        this._onDidChangeVisibleTextEditors = ( (new Emitter()));
+        this._onDidChangeTextEditorSelection = ( (new Emitter$1()));
+        this._onDidChangeTextEditorOptions = ( (new Emitter$1()));
+        this._onDidChangeTextEditorVisibleRanges = ( (new Emitter$1()));
+        this._onDidChangeTextEditorViewColumn = ( (new Emitter$1()));
+        this._onDidChangeActiveTextEditor = ( (new Emitter$1()));
+        this._onDidChangeVisibleTextEditors = ( (new Emitter$1()));
         this.onDidChangeTextEditorSelection = this._onDidChangeTextEditorSelection.event;
         this.onDidChangeTextEditorOptions = this._onDidChangeTextEditorOptions.event;
         this.onDidChangeTextEditorVisibleRanges = this._onDidChangeTextEditorVisibleRanges.event;
@@ -9540,9 +10602,9 @@ let MainThreadDocuments = class MainThreadDocuments extends Disposable$1 {
         this._environmentService = _environmentService;
         this._uriIdentityService = _uriIdentityService;
         this._pathService = _pathService;
-        this._onIsCaughtUpWithContentChanges = this._store.add(( (new Emitter())));
+        this._onIsCaughtUpWithContentChanges = this._store.add(( (new Emitter$1())));
         this.onIsCaughtUpWithContentChanges = this._onIsCaughtUpWithContentChanges.event;
-        this._modelTrackers = ( (new ResourceMap()));
+        this._modelTrackers = ( (new ResourceMap$1()));
         this._modelReferenceCollection = this._store.add(( (new BoundModelReferenceCollection(_uriIdentityService.extUri))));
         this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostDocuments);
         this._store.add(_modelService.onModelLanguageChanged(this._onModelModeChanged, this));
@@ -9689,13 +10751,8 @@ MainThreadDocuments = ( (__decorate([
     ( (__param(7, IWorkingCopyFileService))),
     ( (__param(8, IPathService)))
 ], MainThreadDocuments)));
-const Selection = monaco.Selection;
-class MainThreadTextEditorProperties {
-    constructor(selections, options, visibleRanges) {
-        this.selections = selections;
-        this.options = options;
-        this.visibleRanges = visibleRanges;
-    }
+const Selection = monaco.Selection;
+class MainThreadTextEditorProperties {
     static readFromEditor(previousProperties, model, codeEditor) {
         const selections = MainThreadTextEditorProperties._readSelectionsFromCodeEditor(previousProperties, codeEditor);
         const options = MainThreadTextEditorProperties._readOptionsFromCodeEditor(previousProperties, model, codeEditor);
@@ -9730,8 +10787,8 @@ class MainThreadTextEditorProperties {
         let lineNumbers;
         if (codeEditor) {
             const options = codeEditor.getOptions();
-            const lineNumbersOpts = options.get(62 );
-            cursorStyle = options.get(24 );
+            const lineNumbersOpts = options.get(64 );
+            cursorStyle = options.get(25 );
             lineNumbers = lineNumbersOpts.renderType;
         }
         else if (previousProperties) {
@@ -9746,6 +10803,7 @@ class MainThreadTextEditorProperties {
         return {
             insertSpaces: modelOptions.insertSpaces,
             tabSize: modelOptions.tabSize,
+            indentSize: modelOptions.indentSize,
             cursorStyle: cursorStyle,
             lineNumbers: lineNumbers
         };
@@ -9756,6 +10814,11 @@ class MainThreadTextEditorProperties {
         }
         return [];
     }
+    constructor(selections, options, visibleRanges) {
+        this.selections = selections;
+        this.options = options;
+        this.visibleRanges = visibleRanges;
+    }
     generateDelta(oldProps, selectionChangeSource) {
         const delta = {
             options: null,
@@ -9793,6 +10856,7 @@ class MainThreadTextEditorProperties {
             return true;
         }
         return (a.tabSize === b.tabSize
+            && a.indentSize === b.indentSize
             && a.insertSpaces === b.insertSpaces
             && a.cursorStyle === b.cursorStyle
             && a.lineNumbers === b.lineNumbers);
@@ -9810,7 +10874,7 @@ class MainThreadTextEditor {
         this._mainThreadDocuments = mainThreadDocuments;
         this._modelService = modelService;
         this._clipboardService = clipboardService;
-        this._onPropertiesChanged = ( (new Emitter()));
+        this._onPropertiesChanged = ( (new Emitter$1()));
         this._modelListeners.add(this._model.onDidChangeOptions((e) => {
             this._updatePropertiesNow(null);
         }));
@@ -9945,6 +11009,9 @@ class MainThreadTextEditor {
         if (typeof newConfiguration.tabSize !== 'undefined') {
             newOpts.tabSize = newConfiguration.tabSize;
         }
+        if (typeof newConfiguration.indentSize !== 'undefined') {
+            newOpts.indentSize = newConfiguration.indentSize;
+        }
         this._model.updateOptions(newOpts);
     }
     setConfiguration(newConfiguration) {
@@ -10067,7 +11134,9 @@ class MainThreadTextEditor {
                 return false;
             }
         }
-        if (this._codeEditor.getModel().getVersionId() !== modelVersionId) ;
+        if (this._codeEditor.getModel().getVersionId() !== modelVersionId) {
+            return false;
+        }
         const snippetController = SnippetController2.get(this._codeEditor);
         if (!snippetController) {
             return false;
@@ -10083,31 +11152,44 @@ class MainThreadTextEditor {
         return true;
     }
 }
-function columnToEditorGroup(editorGroupService, column) {
-    if (typeof column !== 'number' ||
-        column === ACTIVE_GROUP ||
-        (editorGroupService.count === 1 && editorGroupService.activeGroup.isEmpty)) {
-        return ACTIVE_GROUP;
-    }
-    if (column === SIDE_GROUP) {
-        return SIDE_GROUP;
+var EditorActivation;
+( ((function(EditorActivation) {
+    EditorActivation[EditorActivation["ACTIVATE"] = 1] = "ACTIVATE";
+    EditorActivation[EditorActivation["RESTORE"] = 2] = "RESTORE";
+    EditorActivation[EditorActivation["PRESERVE"] = 3] = "PRESERVE";
+})(EditorActivation || (EditorActivation = {}))));
+var EditorResolution;
+( ((function(EditorResolution) {
+    EditorResolution[EditorResolution["PICK"] = 0] = "PICK";
+    EditorResolution[EditorResolution["EXCLUSIVE_ONLY"] = 1] = "EXCLUSIVE_ONLY";
+})(EditorResolution || (EditorResolution = {}))));
+function columnToEditorGroup(editorGroupService, configurationService, column = ACTIVE_GROUP) {
+    if (column === ACTIVE_GROUP || column === SIDE_GROUP) {
+        return column;
     }
-    const groupInColumn = editorGroupService.getGroups(2 )[column];
-    if (groupInColumn) {
-        return groupInColumn.id;
+    let groupInColumn = editorGroupService.getGroups(2 )[column];
+    if (!groupInColumn && column < 9) {
+        for (let i = 0; i <= column; i++) {
+            const editorGroups = editorGroupService.getGroups(2 );
+            if (!editorGroups[i]) {
+                editorGroupService.addGroup(editorGroups[i - 1], preferredSideBySideGroupDirection(configurationService));
+            }
+        }
+        groupInColumn = editorGroupService.getGroups(2 )[column];
     }
-    return SIDE_GROUP;
+    return groupInColumn?.id ?? SIDE_GROUP;
 }
 function editorGroupToColumn(editorGroupService, editorGroup) {
     const group = (typeof editorGroup === 'number') ? editorGroupService.getGroup(editorGroup) : editorGroup;
     return editorGroupService.getGroups(2 ).indexOf(group ?? editorGroupService.activeGroup);
 }
 let MainThreadTextEditors = class MainThreadTextEditors {
-    constructor(_editorLocator, extHostContext, _codeEditorService, _editorService, _editorGroupService) {
+    constructor(_editorLocator, extHostContext, _codeEditorService, _editorService, _editorGroupService, _configurationService) {
         this._editorLocator = _editorLocator;
         this._codeEditorService = _codeEditorService;
         this._editorService = _editorService;
         this._editorGroupService = _editorGroupService;
+        this._configurationService = _configurationService;
         this._toDispose = ( (new DisposableStore()));
         this._instanceId = String(++MainThreadTextEditors.INSTANCE_COUNT);
         this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostEditors);
@@ -10165,17 +11247,19 @@ let MainThreadTextEditors = class MainThreadTextEditors {
             pinned: options.pinned,
             selection: options.selection,
             activation: options.preserveFocus ? EditorActivation.RESTORE : undefined,
-            override: EditorResolution.DISABLED
+            override: EditorResolution.EXCLUSIVE_ONLY
         };
         const input = {
             resource: uri,
             options: editorOptions
         };
-        const editor = await this._editorService.openEditor(input, columnToEditorGroup(this._editorGroupService, options.position));
+        const editor = await this._editorService.openEditor(input, columnToEditorGroup(this._editorGroupService, this._configurationService, options.position));
         if (!editor) {
             return undefined;
         }
-        return this._editorLocator.findTextEditorIdFor(editor);
+        const editorControl = editor.getControl();
+        const codeEditor = getCodeEditor(editorControl);
+        return codeEditor ? this._editorLocator.getIdOfCodeEditor(codeEditor) : undefined;
     }
     async $tryShowEditor(id, position) {
         const mainThreadEditor = this._editorLocator.getEditor(id);
@@ -10184,7 +11268,7 @@ let MainThreadTextEditors = class MainThreadTextEditors {
             await this._editorService.openEditor({
                 resource: model.uri,
                 options: { preserveFocus: false }
-            }, columnToEditorGroup(this._editorGroupService, position));
+            }, columnToEditorGroup(this._editorGroupService, this._configurationService, position));
             return;
         }
     }
@@ -10292,7 +11376,8 @@ MainThreadTextEditors.INSTANCE_COUNT = 0;
 MainThreadTextEditors = ( (__decorate([
     ( (__param(2, ICodeEditorService))),
     ( (__param(3, IEditorService))),
-    ( (__param(4, IEditorGroupsService)))
+    ( (__param(4, IEditorGroupsService))),
+    ( (__param(5, IConfigurationService)))
 ], MainThreadTextEditors)));
 class AbstractTextEditor {}
 class TextEditorSnapshot {
@@ -10326,11 +11411,6 @@ class DocumentAndEditorStateDelta {
     }
 }
 class DocumentAndEditorState {
-    constructor(documents, textEditors, activeEditor) {
-        this.documents = documents;
-        this.textEditors = textEditors;
-        this.activeEditor = activeEditor;
-    }
     static compute(before, after) {
         if (!before) {
             return (
@@ -10359,6 +11439,11 @@ class DocumentAndEditorState {
             ))
         );
     }
+    constructor(documents, textEditors, activeEditor) {
+        this.documents = documents;
+        this.textEditors = textEditors;
+        this.activeEditor = activeEditor;
+    }
 }
 let MainThreadDocumentAndEditorStateComputer = class MainThreadDocumentAndEditorStateComputer {
     constructor(_onDidChangeState, _modelService, _codeEditorService, _editorService, _paneCompositeService) {
@@ -10368,7 +11453,7 @@ let MainThreadDocumentAndEditorStateComputer = class MainThreadDocumentAndEditor
         this._editorService = _editorService;
         this._paneCompositeService = _paneCompositeService;
         this._toDispose = ( (new DisposableStore()));
-        this._toDisposeOnEditorRemove = ( (new Map()));
+        this._toDisposeOnEditorRemove = ( (new DisposableMap()));
         this._activeEditorOrder = 0 ;
         this._modelService.onModelAdded(this._updateStateOnModelAdd, this, this._toDispose);
         this._modelService.onModelRemoved(_ => this._updateState(), this, this._toDispose);
@@ -10383,16 +11468,16 @@ let MainThreadDocumentAndEditorStateComputer = class MainThreadDocumentAndEditor
     }
     dispose() {
         this._toDispose.dispose();
+        this._toDisposeOnEditorRemove.dispose();
     }
     _onDidAddEditor(e) {
         this._toDisposeOnEditorRemove.set(e.getId(), combinedDisposable(e.onDidChangeModel(() => this._updateState()), e.onDidFocusEditorText(() => this._updateState()), e.onDidFocusEditorWidget(() => this._updateState(e))));
         this._updateState();
     }
     _onDidRemoveEditor(e) {
-        const sub = this._toDisposeOnEditorRemove.get(e.getId());
-        if (sub) {
-            this._toDisposeOnEditorRemove.delete(e.getId());
-            sub.dispose();
+        const id = e.getId();
+        if (this._toDisposeOnEditorRemove.has(id)) {
+            this._toDisposeOnEditorRemove.deleteAndDispose(id);
             this._updateState();
         }
     }
@@ -10484,7 +11569,7 @@ MainThreadDocumentAndEditorStateComputer = ( (__decorate([
     ( (__param(4, IPaneCompositePartService)))
 ], MainThreadDocumentAndEditorStateComputer)));
 let MainThreadDocumentsAndEditors = class MainThreadDocumentsAndEditors {
-    constructor(extHostContext, _modelService, _textFileService, _editorService, codeEditorService, fileService, textModelResolverService, _editorGroupService, paneCompositeService, environmentService, workingCopyFileService, uriIdentityService, _clipboardService, pathService, instantiationService) {
+    constructor(extHostContext, _modelService, _textFileService, _editorService, codeEditorService, fileService, textModelResolverService, _editorGroupService, paneCompositeService, environmentService, workingCopyFileService, uriIdentityService, _clipboardService, pathService, configurationService) {
         this._modelService = _modelService;
         this._textFileService = _textFileService;
         this._editorService = _editorService;
@@ -10510,7 +11595,8 @@ let MainThreadDocumentsAndEditors = class MainThreadDocumentsAndEditors {
             extHostContext,
             codeEditorService,
             this._editorService,
-            this._editorGroupService
+            this._editorGroupService,
+            configurationService
         ))));
         extHostContext.set(MainContext.MainThreadTextEditors, this._mainThreadEditors);
         this._toDispose.add(( (new MainThreadDocumentAndEditorStateComputer(
@@ -10643,7 +11729,7 @@ MainThreadDocumentsAndEditors = ( (__decorate([
     ( (__param(11, IUriIdentityService))),
     ( (__param(12, IClipboardService))),
     ( (__param(13, IPathService))),
-    ( (__param(14, IInstantiationService)))
+    ( (__param(14, IConfigurationService)))
 ], MainThreadDocumentsAndEditors)));
 let MainThreadDiagnostics = class MainThreadDiagnostics {
     constructor(extHostContext, _markerService, _uriIdentService) {
@@ -10705,47 +11791,29 @@ MainThreadDiagnostics = ( (__decorate([
     ( (__param(1, IMarkerService))),
     ( (__param(2, IUriIdentityService)))
 ], MainThreadDiagnostics)));
-function supportsTelemetry(productService, environmentService) {
-    return !(environmentService.disableTelemetry || !productService.enableTelemetry || environmentService.extensionTestsLocationURI);
-}
-function getTelemetryLevel(configurationService) {
-    const newConfig = configurationService.getValue(TELEMETRY_SETTING_ID);
-    const crashReporterConfig = configurationService.getValue('telemetry.enableCrashReporter');
-    const oldConfig = configurationService.getValue(TELEMETRY_OLD_SETTING_ID);
-    if (oldConfig === false || crashReporterConfig === false) {
-        return 0 ;
-    }
-    switch (newConfig ?? "all" ) {
-        case "all" :
-            return 3 ;
-        case "error" :
-            return 2 ;
-        case "crash" :
-            return 1 ;
-        case "off" :
-            return 0 ;
-    }
-}
 var MainThreadTelemetry_1;
 let MainThreadTelemetry = MainThreadTelemetry_1 = class MainThreadTelemetry extends Disposable$1 {
-    constructor(extHostContext, _telemetryService, _environmentService, _productService) {
+    constructor(extHostContext, _telemetryService, _configurationService, _environmentService, _productService) {
         super();
         this._telemetryService = _telemetryService;
+        this._configurationService = _configurationService;
         this._environmentService = _environmentService;
         this._productService = _productService;
         this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostTelemetry);
         if (supportsTelemetry(this._productService, this._environmentService)) {
-            this._register(_telemetryService.telemetryLevel.onDidChange(level => {
-                this._proxy.$onDidChangeTelemetryLevel(level);
+            this._register(this._configurationService.onDidChangeConfiguration(e => {
+                if (e.affectsConfiguration(TELEMETRY_SETTING_ID) || e.affectsConfiguration(TELEMETRY_OLD_SETTING_ID)) {
+                    this._proxy.$onDidChangeTelemetryLevel(this.telemetryLevel);
+                }
             }));
         }
-        this._proxy.$initializeTelemetryLevel(this.telemetryLevel, this._productService.enabledTelemetryLevels);
+        this._proxy.$initializeTelemetryLevel(this.telemetryLevel, supportsTelemetry(this._productService, this._environmentService), this._productService.enabledTelemetryLevels);
     }
     get telemetryLevel() {
         if (!supportsTelemetry(this._productService, this._environmentService)) {
             return 0 ;
         }
-        return this._telemetryService.telemetryLevel.value;
+        return this._telemetryService.telemetryLevel;
     }
     $publicLog(eventName, data = Object.create(null)) {
         data[MainThreadTelemetry_1._name] = true;
@@ -10759,8 +11827,9 @@ MainThreadTelemetry._name = 'pluginHostTelemetry';
 MainThreadTelemetry = MainThreadTelemetry_1 = ( (__decorate([
     extHostNamedCustomer(MainContext.MainThreadTelemetry),
     ( (__param(1, ITelemetryService))),
-    ( (__param(2, IEnvironmentService))),
-    ( (__param(3, IProductService)))
+    ( (__param(2, IConfigurationService))),
+    ( (__param(3, IEnvironmentService))),
+    ( (__param(4, IProductService)))
 ], MainThreadTelemetry)));
 let ExtHostBulkEdits = class ExtHostBulkEdits {
     constructor(extHostRpc, extHostDocumentsAndEditors) {
@@ -10770,22 +11839,15 @@ let ExtHostBulkEdits = class ExtHostBulkEdits {
             getNotebookDocumentVersion: () => undefined
         };
     }
-    applyWorkspaceEdit(edit, extension) {
-        const allowSnippetTextEdit = isProposedApiEnabled(extension, 'snippetWorkspaceEdit');
-        const dto = WorkspaceEdit.from(edit, this._versionInformationProvider, allowSnippetTextEdit);
-        return this._proxy.$tryApplyWorkspaceEdit(dto);
+    applyWorkspaceEdit(edit, extension, metadata) {
+        const dto = WorkspaceEdit.from(edit, this._versionInformationProvider);
+        return this._proxy.$tryApplyWorkspaceEdit(dto, undefined, metadata?.isRefactoring ?? false);
     }
 };
 ExtHostBulkEdits = ( (__decorate([
     ( (__param(0, IExtHostRpcService)))
 ], ExtHostBulkEdits)));
 class ResourceNotebookCellEdit extends ResourceEdit {
-    constructor(resource, cellEdit, notebookVersionId = undefined, metadata) {
-        super(metadata);
-        this.resource = resource;
-        this.cellEdit = cellEdit;
-        this.notebookVersionId = notebookVersionId;
-    }
     static is(candidate) {
         if (candidate instanceof ResourceNotebookCellEdit) {
             return true;
@@ -10801,35 +11863,24 @@ class ResourceNotebookCellEdit extends ResourceEdit {
              (new ResourceNotebookCellEdit(edit.resource, edit.cellEdit, edit.notebookVersionId, edit.metadata))
         );
     }
-}
-function reviveWorkspaceEditDto2(data) {
-    const edits = reviveWorkspaceEditDto(data)?.edits;
-    if (!edits) {
-        return [];
+    constructor(resource, cellEdit, notebookVersionId = undefined, metadata) {
+        super(metadata);
+        this.resource = resource;
+        this.cellEdit = cellEdit;
+        this.notebookVersionId = notebookVersionId;
     }
-    return edits.map(edit => {
-        if (ResourceTextEdit.is(edit)) {
-            return ResourceTextEdit.lift(edit);
-        }
-        if (ResourceFileEdit.is(edit)) {
-            return ResourceFileEdit.lift(edit);
-        }
-        if (ResourceNotebookCellEdit.is(edit)) {
-            return ResourceNotebookCellEdit.lift(edit);
-        }
-        throw new Error('Unsupported edit');
-    });
 }
 let MainThreadBulkEdits = class MainThreadBulkEdits {
-    constructor(_extHostContext, _bulkEditService, _logService) {
+    constructor(_extHostContext, _bulkEditService, _logService, _uriIdentService) {
         this._bulkEditService = _bulkEditService;
         this._logService = _logService;
+        this._uriIdentService = _uriIdentService;
     }
     dispose() { }
-    $tryApplyWorkspaceEdit(dto, undoRedoGroupId) {
-        const edits = reviveWorkspaceEditDto2(dto);
-        return this._bulkEditService.apply(edits, { undoRedoGroupId }).then(() => true, err => {
-            this._logService.warn('IGNORING workspace edit', err);
+    $tryApplyWorkspaceEdit(dto, undoRedoGroupId, isRefactoring) {
+        const edits = reviveWorkspaceEditDto(dto, this._uriIdentService);
+        return this._bulkEditService.apply(edits, { undoRedoGroupId, respectAutoSaveConfig: isRefactoring }).then((res) => res.isApplied, err => {
+            this._logService.warn(`IGNORING workspace edit: ${err}`);
             return false;
         });
     }
@@ -10837,8 +11888,28 @@ let MainThreadBulkEdits = class MainThreadBulkEdits {
 MainThreadBulkEdits = ( (__decorate([
     extHostNamedCustomer(MainContext.MainThreadBulkEdits),
     ( (__param(1, IBulkEditService))),
-    ( (__param(2, ILogService)))
+    ( (__param(2, ILogService))),
+    ( (__param(3, IUriIdentityService)))
 ], MainThreadBulkEdits)));
+function reviveWorkspaceEditDto(data, uriIdentityService) {
+    if (!data || !data.edits) {
+        return data;
+    }
+    const result = revive(data);
+    for (const edit of result.edits) {
+        if (ResourceTextEdit.is(edit)) {
+            edit.resource = uriIdentityService.asCanonicalUri(edit.resource);
+        }
+        if (ResourceFileEdit.is(edit)) {
+            edit.newResource = edit.newResource && uriIdentityService.asCanonicalUri(edit.newResource);
+            edit.oldResource = edit.oldResource && uriIdentityService.asCanonicalUri(edit.oldResource);
+        }
+        if (ResourceNotebookCellEdit.is(edit)) {
+            edit.resource = uriIdentityService.asCanonicalUri(edit.resource);
+        }
+    }
+    return data;
+}
 class ExtHostLanguages {
     constructor(mainContext, _documents, _commands, _uriTransformer) {
         this._documents = _documents;
@@ -11003,7 +12074,7 @@ let MainThreadLanguages = class MainThreadLanguages {
         this._resolverService = _resolverService;
         this._languageStatusService = _languageStatusService;
         this._disposables = ( (new DisposableStore()));
-        this._status = ( (new Map()));
+        this._status = ( (new DisposableMap()));
         this._proxy = _extHostContext.getProxy(ExtHostContext.ExtHostLanguages);
         this._proxy.$acceptLanguageIds(_languageService.getRegisteredLanguageIds());
         this._disposables.add(_languageService.onDidChange(_ => {
@@ -11012,10 +12083,7 @@ let MainThreadLanguages = class MainThreadLanguages {
     }
     dispose() {
         this._disposables.dispose();
-        for (const status of ( (this._status.values()))) {
-            status.dispose();
-        }
-        this._status.clear();
+        this._status.dispose();
     }
     async $changeLanguage(resource, languageId) {
         if (!this._languageService.isRegisteredLanguageId(languageId)) {
@@ -11064,31 +12132,15 @@ MainThreadLanguages = ( (__decorate([
     ( (__param(3, ITextModelService))),
     ( (__param(4, ILanguageStatusService)))
 ], MainThreadLanguages)));
-class URITransformerService {
-    constructor(delegate) {
-        if (!delegate) {
-            this.transformIncoming = arg => arg;
-            this.transformOutgoing = arg => arg;
-            this.transformOutgoingURI = arg => arg;
-            this.transformOutgoingScheme = arg => arg;
-        }
-        else {
-            this.transformIncoming = delegate.transformIncoming.bind(delegate);
-            this.transformOutgoing = delegate.transformOutgoing.bind(delegate);
-            this.transformOutgoingURI = delegate.transformOutgoingURI.bind(delegate);
-            this.transformOutgoingScheme = delegate.transformOutgoingScheme.bind(delegate);
-        }
-    }
-}
 let ExtHostWindow = class ExtHostWindow {
+    get state() { return this._state; }
     constructor(extHostRpc) {
-        this._onDidChangeWindowState = ( (new Emitter()));
+        this._onDidChangeWindowState = ( (new Emitter$1()));
         this.onDidChangeWindowState = this._onDidChangeWindowState.event;
         this._state = ExtHostWindow.InitialState;
         this._proxy = extHostRpc.getProxy(MainContext.MainThreadWindow);
         this._proxy.$getWindowVisibility().then(isFocused => this.$onDidChangeWindowFocus(isFocused));
     }
-    get state() { return this._state; }
     $onDidChangeWindowFocus(focused) {
         if (focused === this._state.focused) {
             return;
@@ -11136,16 +12188,11 @@ let MainThreadWindow = class MainThreadWindow {
         this.hostService = hostService;
         this.openerService = openerService;
         this.disposables = ( (new DisposableStore()));
-        this.resolved = ( (new Map()));
         this.proxy = extHostContext.getProxy(ExtHostContext.ExtHostWindow);
         Event.latch(hostService.onDidChangeFocus)(this.proxy.$onDidChangeWindowFocus, this.proxy, this.disposables);
     }
     dispose() {
         this.disposables.dispose();
-        for (const value of ( (this.resolved.values()))) {
-            value.dispose();
-        }
-        this.resolved.clear();
     }
     $getWindowVisibility() {
         return Promise.resolve(this.hostService.hasFocus);
@@ -11205,38 +12252,6 @@ class ExtHostClipboard {
         })));
     }
 }
-class ExtHostTelemetry {
-    constructor() {
-        this._onDidChangeTelemetryEnabled = ( (new Emitter()));
-        this.onDidChangeTelemetryEnabled = this._onDidChangeTelemetryEnabled.event;
-        this._onDidChangeTelemetryConfiguration = ( (new Emitter()));
-        this.onDidChangeTelemetryConfiguration = this._onDidChangeTelemetryConfiguration.event;
-        this._productConfig = { usage: true, error: true };
-        this._level = 0 ;
-    }
-    getTelemetryConfiguration() {
-        return this._level === 3 ;
-    }
-    getTelemetryDetails() {
-        return {
-            isCrashEnabled: this._level >= 1 ,
-            isErrorsEnabled: this._productConfig.error ? this._level >= 2  : false,
-            isUsageEnabled: this._productConfig.usage ? this._level >= 3  : false
-        };
-    }
-    $initializeTelemetryLevel(level, productConfig) {
-        this._level = level;
-        this._productConfig = productConfig || { usage: true, error: true };
-    }
-    $onDidChangeTelemetryLevel(level) {
-        this._oldTelemetryEnablement = this.getTelemetryConfiguration();
-        this._level = level;
-        if (this._oldTelemetryEnablement !== this.getTelemetryConfiguration()) {
-            this._onDidChangeTelemetryEnabled.fire(this.getTelemetryConfiguration());
-        }
-        this._onDidChangeTelemetryConfiguration.fire(this.getTelemetryDetails());
-    }
-}
 function reverseEndianness(arr) {
     for (let i = 0, len = arr.length; i < len; i += 4) {
         const b0 = arr[i + 0];
@@ -11668,7 +12683,7 @@ class CodeActionAdapter {
                     title: candidate.title,
                     command: candidate.command && this._commands.toInternal(candidate.command, disposables),
                     diagnostics: candidate.diagnostics && candidate.diagnostics.map(Diagnostic.from),
-                    edit: candidate.edit && WorkspaceEdit.from(candidate.edit, undefined, isProposedApiEnabled(this._extension, 'snippetWorkspaceEdit')),
+                    edit: candidate.edit && WorkspaceEdit.from(candidate.edit, undefined),
                     kind: candidate.kind && candidate.kind.value,
                     isPreferred: candidate.isPreferred,
                     disabled: candidate.disabled?.reason
@@ -11688,7 +12703,7 @@ class CodeActionAdapter {
         }
         const resolvedItem = (await this._provider.resolveCodeAction(item, token)) ?? item;
         return resolvedItem?.edit
-            ? WorkspaceEdit.from(resolvedItem.edit, undefined, isProposedApiEnabled(this._extension, 'snippetWorkspaceEdit'))
+            ? WorkspaceEdit.from(resolvedItem.edit, undefined)
             : undefined;
     }
     releaseCodeActions(cachedId) {
@@ -11723,8 +12738,8 @@ class DocumentPasteEditProvider {
     async providePasteEdits(requestId, resource, ranges, dataTransferDto, token) {
         const doc = this._documents.getDocument(resource);
         const vscodeRanges = ranges.map(range => Range.to(range));
-        const dataTransfer = DataTransfer.toDataTransfer(dataTransferDto, async (index) => {
-            return (await this._proxy.$resolvePasteFileData(this._handle, requestId, index)).buffer;
+        const dataTransfer = DataTransfer.toDataTransfer(dataTransferDto, async (id) => {
+            return (await this._proxy.$resolvePasteFileData(this._handle, requestId, id)).buffer;
         });
         const edit = await this._provider.provideDocumentPasteEdits(doc, vscodeRanges, dataTransfer, token);
         if (!edit) {
@@ -11732,7 +12747,7 @@ class DocumentPasteEditProvider {
         }
         return {
             insertText: typeof edit.insertText === 'string' ? edit.insertText : { snippet: edit.insertText.value },
-            additionalEdit: edit.additionalEdit ? WorkspaceEdit.from(edit.additionalEdit, undefined, true) : undefined,
+            additionalEdit: edit.additionalEdit ? WorkspaceEdit.from(edit.additionalEdit, undefined) : undefined,
         };
     }
 }
@@ -11829,14 +12844,14 @@ class NavigateTypeAdapter {
     }
 }
 class RenameAdapter {
+    static supportsResolving(provider) {
+        return typeof provider.prepareRename === 'function';
+    }
     constructor(_documents, _provider, _logService) {
         this._documents = _documents;
         this._provider = _provider;
         this._logService = _logService;
     }
-    static supportsResolving(provider) {
-        return typeof provider.prepareRename === 'function';
-    }
     async provideRenameEdits(resource, position, newName, token) {
         const doc = this._documents.getDocument(resource);
         const pos = Position.to(position);
@@ -12060,6 +13075,9 @@ class DocumentRangeSemanticTokensAdapter {
     }
 }
 class CompletionsAdapter {
+    static supportsResolving(provider) {
+        return typeof provider.resolveCompletionItem === 'function';
+    }
     constructor(_documents, _commands, _provider, _apiDeprecation, _extension) {
         this._documents = _documents;
         this._commands = _commands;
@@ -12069,9 +13087,6 @@ class CompletionsAdapter {
         this._cache = ( (new Cache('CompletionItem')));
         this._disposables = ( (new Map()));
     }
-    static supportsResolving(provider) {
-        return typeof provider.resolveCompletionItem === 'function';
-    }
     async provideCompletionItems(resource, position, context, token) {
         const doc = this._documents.getDocument(resource);
         const pos = Position.to(position);
@@ -12128,20 +13143,23 @@ class CompletionsAdapter {
         if (!disposables) {
             throw Error('DisposableStore is missing...');
         }
+        const command = this._commands.toInternal(item.command, disposables);
         const result = {
             x: id,
             ["a" ]: item.label,
             ["b" ]: item.kind !== undefined ? CompletionItemKind.from(item.kind) : undefined,
-            ["n" ]: item.tags && item.tags.map(CompletionItemTag.from),
+            ["m" ]: item.tags && item.tags.map(CompletionItemTag.from),
             ["c" ]: item.detail,
             ["d" ]: typeof item.documentation === 'undefined' ? undefined : MarkdownString.fromStrict(item.documentation),
             ["e" ]: item.sortText !== item.label ? item.sortText : undefined,
             ["f" ]: item.filterText !== item.label ? item.filterText : undefined,
             ["g" ]: item.preselect || undefined,
-            ["i" ]: item.keepWhitespace ? 1  : 0,
-            ["k" ]: item.commitCharacters,
+            ["i" ]: item.keepWhitespace ? 1  : 0 ,
+            ["k" ]: item.commitCharacters?.join(''),
             ["l" ]: item.additionalTextEdits && item.additionalTextEdits.map(TextEdit.from),
-            ["m" ]: this._commands.toInternal(item.command, disposables),
+            ["n" ]: command?.$ident,
+            ["o" ]: command?.id,
+            ["p" ]: command?.$ident ? undefined : command?.arguments,
         };
         if (item.textEdit) {
             this._apiDeprecation.report('CompletionItem.textEdit', this._extension, `Use 'CompletionItem.insertText' and 'CompletionItem.range' instead.`);
@@ -12179,6 +13197,7 @@ class InlineCompletionAdapterBase {
     }
     disposeCompletions(pid) { }
     handleDidShowCompletionItem(pid, idx) { }
+    handlePartialAccept(pid, idx, acceptedCharacters) { }
 }
 class InlineCompletionAdapter extends InlineCompletionAdapterBase {
     constructor(_extension, _documents, _provider, _commands) {
@@ -12194,8 +13213,10 @@ class InlineCompletionAdapter extends InlineCompletionAdapterBase {
             [InlineCompletionTriggerKind$1.Explicit]: InlineCompletionTriggerKind.Invoke,
         };
     }
-    get supportsHandleDidShowCompletionItem() {
-        return isProposedApiEnabled(this._extension, 'inlineCompletionsAdditions') && typeof this._provider.handleDidShowCompletionItem === 'function';
+    get supportsHandleEvents() {
+        return isProposedApiEnabled(this._extension, 'inlineCompletionsAdditions')
+            && (typeof this._provider.handleDidShowCompletionItem === 'function'
+                || typeof this._provider.handleDidPartiallyAcceptCompletionItem === 'function');
     }
     async provideInlineCompletions(resource, position, context, token) {
         const doc = this._documents.getDocument(resource);
@@ -12215,14 +13236,12 @@ class InlineCompletionAdapter extends InlineCompletionAdapterBase {
         if (token.isCancellationRequested) {
             return undefined;
         }
-        const normalizedResult = isArray(result) ? result : result.items;
-        const commands = this._isAdditionsProposedApiEnabled ? isArray(result) ? [] : result.commands || [] : [];
+        const normalizedResult = Array.isArray(result) ? result : result.items;
+        const commands = this._isAdditionsProposedApiEnabled ? Array.isArray(result) ? [] : result.commands || [] : [];
         let disposableStore = undefined;
         const pid = this._references.createReferenceId({
             dispose() {
-                if (disposableStore) {
-                    disposableStore.dispose();
-                }
+                disposableStore?.dispose();
             },
             items: normalizedResult
         });
@@ -12266,87 +13285,11 @@ class InlineCompletionAdapter extends InlineCompletionAdapterBase {
             }
         }
     }
-}
-class InlineCompletionAdapterNew extends InlineCompletionAdapterBase {
-    constructor(extension, _documents, _provider, _commands) {
-        super();
-        this.extension = extension;
-        this._documents = _documents;
-        this._provider = _provider;
-        this._commands = _commands;
-        this._references = ( (new ReferenceMap()));
-        this.isAdditionProposedApiEnabled = isProposedApiEnabled(this.extension, 'inlineCompletionsAdditions');
-        this.languageTriggerKindToVSCodeTriggerKind = {
-            [InlineCompletionTriggerKind$1.Automatic]: InlineCompletionTriggerKindNew.Automatic,
-            [InlineCompletionTriggerKind$1.Explicit]: InlineCompletionTriggerKindNew.Invoke,
-        };
-    }
-    async provideInlineCompletions(resource, position, context, token) {
-        const doc = this._documents.getDocument(resource);
-        const pos = Position.to(position);
-        const result = await this._provider.provideInlineCompletionItems(doc, pos, {
-            selectedCompletionInfo: context.selectedSuggestionInfo
-                ? {
-                    range: Range.to(context.selectedSuggestionInfo.range),
-                    text: context.selectedSuggestionInfo.text
-                }
-                : undefined,
-            triggerKind: this.languageTriggerKindToVSCodeTriggerKind[context.triggerKind]
-        }, token);
-        if (!result) {
-            return undefined;
-        }
-        if (token.isCancellationRequested) {
-            return undefined;
-        }
-        const normalizedResult = isArray(result) ? result : result.items;
-        const commands = isArray(result) ? [] : result.commands || [];
-        let disposableStore = undefined;
-        const pid = this._references.createReferenceId({
-            dispose() {
-                if (disposableStore) {
-                    disposableStore.dispose();
-                }
-            },
-            items: normalizedResult
-        });
-        return {
-            pid,
-            items: normalizedResult.map((item, idx) => {
-                let command = undefined;
-                if (item.command) {
-                    if (!disposableStore) {
-                        disposableStore = ( (new DisposableStore()));
-                    }
-                    command = this._commands.toInternal(item.command, disposableStore);
-                }
-                const insertText = item.insertText;
-                return ({
-                    insertText: typeof insertText === 'string' ? insertText : { snippet: insertText.value },
-                    filterText: item.filterText,
-                    range: item.range ? Range.from(item.range) : undefined,
-                    command,
-                    idx: idx,
-                    completeBracketPairs: this.isAdditionProposedApiEnabled ? item.completeBracketPairs : false
-                });
-            }),
-            commands: commands.map(c => {
-                if (!disposableStore) {
-                    disposableStore = ( (new DisposableStore()));
-                }
-                return this._commands.toInternal(c, disposableStore);
-            })
-        };
-    }
-    disposeCompletions(pid) {
-        const data = this._references.disposeReferenceId(pid);
-        data?.dispose();
-    }
-    handleDidShowCompletionItem(pid, idx) {
+    handlePartialAccept(pid, idx, acceptedCharacters) {
         const completionItem = this._references.get(pid)?.items[idx];
         if (completionItem) {
-            if (this._provider.handleDidShowCompletionItem && this.isAdditionProposedApiEnabled) {
-                this._provider.handleDidShowCompletionItem(completionItem);
+            if (this._provider.handleDidPartiallyAcceptCompletionItem && this._isAdditionsProposedApiEnabled) {
+                this._provider.handleDidPartiallyAcceptCompletionItem(completionItem, acceptedCharacters);
             }
         }
     }
@@ -12786,8 +13729,8 @@ class DocumentOnDropEditAdapter {
     async provideDocumentOnDropEdits(requestId, uri, position, dataTransferDto, token) {
         const doc = this._documents.getDocument(uri);
         const pos = Position.to(position);
-        const dataTransfer = DataTransfer.toDataTransfer(dataTransferDto, async (index) => {
-            return (await this._proxy.$resolveDocumentOnDropFileData(this._handle, requestId, index)).buffer;
+        const dataTransfer = DataTransfer.toDataTransfer(dataTransferDto, async (id) => {
+            return (await this._proxy.$resolveDocumentOnDropFileData(this._handle, requestId, id)).buffer;
         });
         const edit = await this._provider.provideDocumentDropEdits(doc, pos, dataTransfer, token);
         if (!edit) {
@@ -12795,7 +13738,7 @@ class DocumentOnDropEditAdapter {
         }
         return {
             insertText: typeof edit.insertText === 'string' ? edit.insertText : { snippet: edit.insertText.value },
-            additionalEdit: edit.additionalEdit ? WorkspaceEdit.from(edit.additionalEdit, undefined, true) : undefined,
+            additionalEdit: edit.additionalEdit ? WorkspaceEdit.from(edit.additionalEdit, undefined) : undefined,
         };
     }
 }
@@ -12806,15 +13749,16 @@ class AdapterData {
     }
 }
 class ExtHostLanguageFeatures {
-    constructor(mainContext, uriTransformer, documents, commands, diagnostics, logService, apiDeprecationService) {
+    constructor(mainContext, _uriTransformer, _documents, _commands, _diagnostics, _logService, _apiDeprecation, _extensionTelemetry) {
+        this._uriTransformer = _uriTransformer;
+        this._documents = _documents;
+        this._commands = _commands;
+        this._diagnostics = _diagnostics;
+        this._logService = _logService;
+        this._apiDeprecation = _apiDeprecation;
+        this._extensionTelemetry = _extensionTelemetry;
         this._adapter = ( (new Map()));
-        this._uriTransformer = uriTransformer;
         this._proxy = mainContext.getProxy(MainContext.MainThreadLanguageFeatures);
-        this._documents = documents;
-        this._commands = commands;
-        this._diagnostics = diagnostics;
-        this._logService = logService;
-        this._apiDeprecation = apiDeprecationService;
     }
     _transformDocumentSelector(selector) {
         return DocumentSelector.from(selector, this._uriTransformer);
@@ -12844,6 +13788,7 @@ class ExtHostLanguageFeatures {
             if (!isCancellationError(err)) {
                 this._logService.error(`[${data.extension.identifier.value}] provider FAILED`);
                 this._logService.error(err);
+                this._extensionTelemetry.onExtensionError(data.extension.identifier, err);
             }
         }).finally(() => {
             if (!doNotLog) {
@@ -13118,12 +14063,7 @@ class ExtHostLanguageFeatures {
     registerInlineCompletionsProvider(extension, selector, provider) {
         const adapter = ( (new InlineCompletionAdapter(extension, this._documents, provider, this._commands.converter)));
         const handle = this._addNewAdapter(adapter, extension);
-        this._proxy.$registerInlineCompletionsSupport(handle, this._transformDocumentSelector(selector), adapter.supportsHandleDidShowCompletionItem);
-        return this._createDisposable(handle);
-    }
-    registerInlineCompletionsProviderNew(extension, selector, provider) {
-        const handle = this._addNewAdapter(( (new InlineCompletionAdapterNew(extension, this._documents, provider, this._commands.converter))), extension);
-        this._proxy.$registerInlineCompletionsSupport(handle, this._transformDocumentSelector(selector), true);
+        this._proxy.$registerInlineCompletionsSupport(handle, this._transformDocumentSelector(selector), adapter.supportsHandleEvents);
         return this._createDisposable(handle);
     }
     $provideInlineCompletions(handle, resource, position, context, token) {
@@ -13134,6 +14074,11 @@ class ExtHostLanguageFeatures {
             adapter.handleDidShowCompletionItem(pid, idx);
         }, undefined, undefined);
     }
+    $handleInlineCompletionPartialAccept(handle, pid, idx, acceptedCharacters) {
+        this._withAdapter(handle, InlineCompletionAdapterBase, async (adapter) => {
+            adapter.handlePartialAccept(pid, idx, acceptedCharacters);
+        }, undefined, undefined);
+    }
     $freeInlineCompletionsList(handle, pid) {
         this._withAdapter(handle, InlineCompletionAdapterBase, async (adapter) => { adapter.disposeCompletions(pid); }, undefined, undefined);
     }
@@ -13209,7 +14154,7 @@ class ExtHostLanguageFeatures {
              (new FoldingProviderAdapter(this._documents, provider)),
             extension
         ))));
-        this._proxy.$registerFoldingRangeProvider(handle, this._transformDocumentSelector(selector), eventHandle);
+        this._proxy.$registerFoldingRangeProvider(handle, this._transformDocumentSelector(selector), extension.identifier, eventHandle);
         let result = this._createDisposable(handle);
         if (eventHandle !== undefined) {
             const subscription = provider.onDidChangeFoldingRanges(() => this._proxy.$emitFoldingRangeEvent(eventHandle));
@@ -13366,14 +14311,18 @@ class DataTransferCache {
             }
         };
     }
-    async resolveDropFileData(requestId, dataItemIndex) {
+    async resolveDropFileData(requestId, dataItemId) {
         const entry = this.dataTransfers.get(requestId);
         if (!entry) {
             throw new Error('No data transfer found');
         }
-        const file = entry[dataItemIndex]?.asFile();
+        const item = entry.find(x => x.id === dataItemId);
+        if (!item) {
+            throw new Error('No item found in data transfer');
+        }
+        const file = item.asFile();
         if (!file) {
-            throw new Error('No file item found in data transfer');
+            throw new Error('Found data transfer item is not a file');
         }
         return VSBuffer.wrap(await file.data());
     }
@@ -13411,12 +14360,13 @@ var WorkspaceSymbolProviderRegistry;
 const TypeHierarchyProviderRegistry = ( (new LanguageFeatureRegistry()));
 var MainThreadLanguageFeatures_1;
 let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThreadLanguageFeatures extends Disposable$1 {
-    constructor(extHostContext, _languageService, _languageConfigurationService, _languageFeaturesService) {
+    constructor(extHostContext, _languageService, _languageConfigurationService, _languageFeaturesService, _uriIdentService) {
         super();
         this._languageService = _languageService;
         this._languageConfigurationService = _languageConfigurationService;
         this._languageFeaturesService = _languageFeaturesService;
-        this._registrations = ( (new Map()));
+        this._uriIdentService = _uriIdentService;
+        this._registrations = this._register(( (new DisposableMap())));
         this._pasteEditProviders = ( (new Map()));
         this._documentOnDropEditProviders = ( (new Map()));
         this._proxy = extHostContext.getProxy(ExtHostContext.ExtHostLanguageFeatures);
@@ -13449,19 +14399,8 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
             updateAllWordDefinitions();
         }
     }
-    dispose() {
-        for (const registration of ( (this._registrations.values()))) {
-            registration.dispose();
-        }
-        this._registrations.clear();
-        super.dispose();
-    }
     $unregister(handle) {
-        const registration = this._registrations.get(handle);
-        if (registration) {
-            registration.dispose();
-            this._registrations.delete(handle);
-        }
+        this._registrations.deleteAndDispose(handle);
     }
     static _reviveLocationDto(data) {
         if (!data) {
@@ -13502,8 +14441,8 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
             return data;
         }
     }
-    static _reviveCodeActionDto(data) {
-        data?.forEach(code => reviveWorkspaceEditDto(code.edit));
+    static _reviveCodeActionDto(data, uriIdentService) {
+        data?.forEach(code => reviveWorkspaceEditDto(code.edit, uriIdentService));
         return data;
     }
     static _reviveLinkDTO(data) {
@@ -13549,7 +14488,7 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
             }
         };
         if (typeof eventHandle === 'number') {
-            const emitter = ( (new Emitter()));
+            const emitter = ( (new Emitter$1()));
             this._registrations.set(eventHandle, emitter);
             provider.onDidChange = emitter.event;
         }
@@ -13557,7 +14496,7 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
     }
     $emitCodeLensEvent(eventHandle, event) {
         const obj = this._registrations.get(eventHandle);
-        if (obj instanceof Emitter) {
+        if (obj instanceof Emitter$1) {
             obj.fire(event);
         }
     }
@@ -13610,7 +14549,7 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
             }
         };
         if (typeof eventHandle === 'number') {
-            const emitter = ( (new Emitter()));
+            const emitter = ( (new Emitter$1()));
             this._registrations.set(eventHandle, emitter);
             provider.onDidChangeInlineValues = emitter.event;
         }
@@ -13618,7 +14557,7 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
     }
     $emitInlineValuesEvent(eventHandle, event) {
         const obj = this._registrations.get(eventHandle);
-        if (obj instanceof Emitter) {
+        if (obj instanceof Emitter$1) {
             obj.fire(event);
         }
     }
@@ -13658,7 +14597,7 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
                     return undefined;
                 }
                 return {
-                    actions: MainThreadLanguageFeatures_1._reviveCodeActionDto(listDto.actions),
+                    actions: MainThreadLanguageFeatures_1._reviveCodeActionDto(listDto.actions, this._uriIdentService),
                     dispose: () => {
                         if (typeof listDto.cacheId === 'number') {
                             this._proxy.$releaseCodeActions(handle, listDto.cacheId);
@@ -13673,23 +14612,23 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
         if (supportsResolve) {
             provider.resolveCodeAction = async (codeAction, token) => {
                 const data = await this._proxy.$resolveCodeAction(handle, codeAction.cacheId, token);
-                codeAction.edit = reviveWorkspaceEditDto(data);
+                codeAction.edit = reviveWorkspaceEditDto(data, this._uriIdentService);
                 return codeAction;
             };
         }
         this._registrations.set(handle, this._languageFeaturesService.codeActionProvider.register(selector, provider));
     }
     $registerPasteEditProvider(handle, selector, supportsCopy, pasteMimeTypes) {
-        const provider = ( (new MainThreadPasteEditProvider(handle, this._proxy, supportsCopy, pasteMimeTypes)));
+        const provider = ( (new MainThreadPasteEditProvider(handle, this._proxy, supportsCopy, pasteMimeTypes, this._uriIdentService)));
         this._pasteEditProviders.set(handle, provider);
         this._registrations.set(handle, combinedDisposable(this._languageFeaturesService.documentPasteEditProvider.register(selector, provider), toDisposable(() => this._pasteEditProviders.delete(handle))));
     }
-    $resolvePasteFileData(handle, requestId, dataIndex) {
+    $resolvePasteFileData(handle, requestId, dataId) {
         const provider = this._pasteEditProviders.get(handle);
         if (!provider) {
             throw new Error('Could not find provider');
         }
-        return provider.resolveFileData(requestId, dataIndex);
+        return provider.resolveFileData(requestId, dataId);
     }
     $registerDocumentFormattingSupport(handle, selector, extensionId, displayName) {
         this._registrations.set(handle, this._languageFeaturesService.documentFormattingEditProvider.register(selector, {
@@ -13741,7 +14680,7 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
     $registerRenameSupport(handle, selector, supportResolveLocation) {
         this._registrations.set(handle, this._languageFeaturesService.renameProvider.register(selector, {
             provideRenameEdits: (model, position, newName, token) => {
-                return this._proxy.$provideRenameEdits(handle, model.uri, position, newName, token).then(reviveWorkspaceEditDto);
+                return this._proxy.$provideRenameEdits(handle, model.uri, position, newName, token).then(data => reviveWorkspaceEditDto(data, this._uriIdentService));
             },
             resolveRenameLocation: supportResolveLocation
                 ? (model, position, token) => this._proxy.$resolveRenameLocation(handle, model.uri, position, token)
@@ -13751,7 +14690,7 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
     $registerDocumentSemanticTokensProvider(handle, selector, legend, eventHandle) {
         let event = undefined;
         if (typeof eventHandle === 'number') {
-            const emitter = ( (new Emitter()));
+            const emitter = ( (new Emitter$1()));
             this._registrations.set(eventHandle, emitter);
             event = emitter.event;
         }
@@ -13759,7 +14698,7 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
     }
     $emitDocumentSemanticTokensEvent(eventHandle) {
         const obj = this._registrations.get(eventHandle);
-        if (obj instanceof Emitter) {
+        if (obj instanceof Emitter$1) {
             obj.fire(undefined);
         }
     }
@@ -13768,10 +14707,13 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
     }
     static _inflateSuggestDto(defaultRange, data) {
         const label = data["a" ];
+        const commandId = data["o" ];
+        const commandIdent = data["n" ];
+        const commitChars = data["k" ];
         return {
             label,
             kind: data["b" ] ?? 9 ,
-            tags: data["n" ],
+            tags: data["m" ],
             detail: data["c" ],
             documentation: data["d" ],
             sortText: data["e" ],
@@ -13780,9 +14722,14 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
             insertText: data["h" ] ?? (typeof label === 'string' ? label : label.label),
             range: data["j" ] ?? defaultRange,
             insertTextRules: data["i" ],
-            commitCharacters: data["k" ],
+            commitCharacters: commitChars ? Array.from(commitChars) : undefined,
             additionalTextEdits: data["l" ],
-            command: data["m" ],
+            command: commandId ? {
+                $ident: commandIdent,
+                id: commandId,
+                title: '',
+                arguments: commandIdent ? [commandIdent] : data["p" ],
+            } : undefined,
             _id: data.x,
         };
     }
@@ -13820,16 +14767,21 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
         }
         this._registrations.set(handle, this._languageFeaturesService.completionProvider.register(selector, provider));
     }
-    $registerInlineCompletionsSupport(handle, selector, supportsHandleDidShowCompletionItem) {
+    $registerInlineCompletionsSupport(handle, selector, supportsHandleEvents) {
         const provider = {
             provideInlineCompletions: async (model, position, context, token) => {
                 return this._proxy.$provideInlineCompletions(handle, model.uri, position, context, token);
             },
             handleItemDidShow: async (completions, item) => {
-                if (supportsHandleDidShowCompletionItem) {
+                if (supportsHandleEvents) {
                     await this._proxy.$handleInlineCompletionDidShow(handle, completions.pid, item.idx);
                 }
             },
+            handlePartialAccept: async (completions, item, acceptedCharacters) => {
+                if (supportsHandleEvents) {
+                    await this._proxy.$handleInlineCompletionPartialAccept(handle, completions.pid, item.idx, acceptedCharacters);
+                }
+            },
             freeInlineCompletions: (completions) => {
                 this._proxy.$freeInlineCompletionsList(handle, completions.pid);
             }
@@ -13893,7 +14845,7 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
             };
         }
         if (typeof eventHandle === 'number') {
-            const emitter = ( (new Emitter()));
+            const emitter = ( (new Emitter$1()));
             this._registrations.set(eventHandle, emitter);
             provider.onDidChangeInlayHints = emitter.event;
         }
@@ -13901,7 +14853,7 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
     }
     $emitInlayHintsEvent(eventHandle) {
         const obj = this._registrations.get(eventHandle);
-        if (obj instanceof Emitter) {
+        if (obj instanceof Emitter$1) {
             obj.fire(undefined);
         }
     }
@@ -13965,14 +14917,15 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
             }
         }));
     }
-    $registerFoldingRangeProvider(handle, selector, eventHandle) {
+    $registerFoldingRangeProvider(handle, selector, extensionId, eventHandle) {
         const provider = {
+            id: extensionId.value,
             provideFoldingRanges: (model, context, token) => {
                 return this._proxy.$provideFoldingRanges(handle, model.uri, context, token);
             }
         };
         if (typeof eventHandle === 'number') {
-            const emitter = ( (new Emitter()));
+            const emitter = ( (new Emitter$1()));
             this._registrations.set(eventHandle, emitter);
             provider.onDidChange = emitter.event;
         }
@@ -13980,7 +14933,7 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
     }
     $emitFoldingRangeEvent(eventHandle, event) {
         const obj = this._registrations.get(eventHandle);
-        if (obj instanceof Emitter) {
+        if (obj instanceof Emitter$1) {
             obj.fire(event);
         }
     }
@@ -14112,28 +15065,30 @@ let MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = class MainThread
         }));
     }
     $registerDocumentOnDropEditProvider(handle, selector) {
-        const provider = ( (new MainThreadDocumentOnDropEditProvider(handle, this._proxy)));
+        const provider = ( (new MainThreadDocumentOnDropEditProvider(handle, 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))));
     }
-    async $resolveDocumentOnDropFileData(handle, requestId, dataIndex) {
+    async $resolveDocumentOnDropFileData(handle, requestId, dataId) {
         const provider = this._documentOnDropEditProviders.get(handle);
         if (!provider) {
             throw new Error('Could not find provider');
         }
-        return provider.resolveDocumentOnDropFileData(requestId, dataIndex);
+        return provider.resolveDocumentOnDropFileData(requestId, dataId);
     }
 };
 MainThreadLanguageFeatures = MainThreadLanguageFeatures_1 = ( (__decorate([
     extHostNamedCustomer(MainContext.MainThreadLanguageFeatures),
     ( (__param(1, ILanguageService))),
     ( (__param(2, ILanguageConfigurationService))),
-    ( (__param(3, ILanguageFeaturesService)))
+    ( (__param(3, ILanguageFeaturesService))),
+    ( (__param(4, IUriIdentityService)))
 ], MainThreadLanguageFeatures)));
-class MainThreadPasteEditProvider {
-    constructor(handle, _proxy, supportsCopy, pasteMimeTypes) {
+let MainThreadPasteEditProvider = class MainThreadPasteEditProvider {
+    constructor(handle, _proxy, supportsCopy, pasteMimeTypes, _uriIdentService) {
         this.handle = handle;
         this._proxy = _proxy;
+        this._uriIdentService = _uriIdentService;
         this.dataTransfers = ( (new DataTransferCache()));
         this.pasteMimeTypes = pasteMimeTypes;
         if (supportsCopy) {
@@ -14164,21 +15119,25 @@ class MainThreadPasteEditProvider {
             }
             return {
                 insertText: result.insertText,
-                additionalEdit: result.additionalEdit ? reviveWorkspaceEditDto(result.additionalEdit) : undefined,
+                additionalEdit: result.additionalEdit ? reviveWorkspaceEditDto(result.additionalEdit, this._uriIdentService) : undefined,
             };
         }
         finally {
             request.dispose();
         }
     }
-    resolveFileData(requestId, dataIndex) {
-        return this.dataTransfers.resolveDropFileData(requestId, dataIndex);
+    resolveFileData(requestId, dataId) {
+        return this.dataTransfers.resolveDropFileData(requestId, dataId);
     }
-}
-class MainThreadDocumentOnDropEditProvider {
-    constructor(handle, _proxy) {
+};
+MainThreadPasteEditProvider = ( (__decorate([
+    ( (__param(4, IUriIdentityService)))
+], MainThreadPasteEditProvider)));
+let MainThreadDocumentOnDropEditProvider = class MainThreadDocumentOnDropEditProvider {
+    constructor(handle, _proxy, _uriIdentService) {
         this.handle = handle;
         this._proxy = _proxy;
+        this._uriIdentService = _uriIdentService;
         this.dataTransfers = ( (new DataTransferCache()));
     }
     async provideDocumentOnDropEdits(model, position, dataTransfer, token) {
@@ -14191,17 +15150,20 @@ class MainThreadDocumentOnDropEditProvider {
             }
             return {
                 insertText: edit.insertText,
-                additionalEdit: reviveWorkspaceEditDto(edit.additionalEdit),
+                additionalEdit: reviveWorkspaceEditDto(edit.additionalEdit, this._uriIdentService),
             };
         }
         finally {
             request.dispose();
         }
     }
-    resolveDocumentOnDropFileData(requestId, dataIndex) {
-        return this.dataTransfers.resolveDropFileData(requestId, dataIndex);
+    resolveDocumentOnDropFileData(requestId, dataId) {
+        return this.dataTransfers.resolveDropFileData(requestId, dataId);
     }
-}
+};
+MainThreadDocumentOnDropEditProvider = ( (__decorate([
+    ( (__param(2, IUriIdentityService)))
+], MainThreadDocumentOnDropEditProvider)));
 class MainThreadDocumentSemanticTokensProvider {
     constructor(_proxy, _handle, _legend, onDidChange) {
         this._proxy = _proxy;
@@ -14315,7 +15277,7 @@ function scopeToOverrides(scope) {
 }
 class ExtHostConfigProvider {
     constructor(proxy, extHostWorkspace, data, logService) {
-        this._onDidChangeConfiguration = ( (new Emitter()));
+        this._onDidChangeConfiguration = ( (new Emitter$1()));
         this._proxy = proxy;
         this._logService = logService;
         this._extHostWorkspace = extHostWorkspace;
@@ -14426,19 +15388,19 @@ class ExtHostConfigProvider {
             },
             inspect: (key) => {
                 key = section ? `${section}.${key}` : key;
-                const config = deepClone(this._configuration.inspect(key, overrides, this._extHostWorkspace.workspace));
+                const config = this._configuration.inspect(key, overrides, this._extHostWorkspace.workspace);
                 if (config) {
                     return {
                         key,
-                        defaultValue: config.policy?.value ?? config.default?.value,
-                        globalValue: config.user?.value ?? config.application?.value,
-                        workspaceValue: config.workspace?.value,
-                        workspaceFolderValue: config.workspaceFolder?.value,
-                        defaultLanguageValue: config.default?.override,
-                        globalLanguageValue: config.user?.override ?? config.application?.override,
-                        workspaceLanguageValue: config.workspace?.override,
-                        workspaceFolderLanguageValue: config.workspaceFolder?.override,
-                        languageIds: config.overrideIdentifiers
+                        defaultValue: deepClone(config.policy?.value ?? config.default?.value),
+                        globalValue: deepClone(config.user?.value ?? config.application?.value),
+                        workspaceValue: deepClone(config.workspace?.value),
+                        workspaceFolderValue: deepClone(config.workspaceFolder?.value),
+                        defaultLanguageValue: deepClone(config.default?.override),
+                        globalLanguageValue: deepClone(config.user?.override ?? config.application?.override),
+                        workspaceLanguageValue: deepClone(config.workspace?.override),
+                        workspaceFolderLanguageValue: deepClone(config.workspaceFolder?.override),
+                        languageIds: deepClone(config.overrideIdentifiers)
                     };
                 }
                 return undefined;
@@ -14544,7 +15506,7 @@ let MainThreadConfiguration = class MainThreadConfiguration {
             : scopeToLanguage === false ? { resource: overrides.resource }
                 : overrides.overrideIdentifier && overriddenValue !== undefined ? overrides
                     : { resource: overrides.resource };
-        return this.configurationService.updateValue(key, value, overrides, configurationTarget, true);
+        return this.configurationService.updateValue(key, value, overrides, configurationTarget, { donotNotifyError: true });
     }
     deriveConfigurationTarget(key, overrides) {
         if (overrides.resource && this._workspaceContextService.getWorkbenchState() === 3 ) {
@@ -14572,10 +15534,46 @@ const DEFAULT_EXTENSION = {
     publisher: 'microsoft',
     version: '1.0.0',
     engines: {
-        vscode: "1.69.0"
+        vscode: "1.76.0"
     },
     targetPlatform: "web"
 };
+const environment = {
+    isExtensionDevelopmentDebug: false,
+    appName: 'Monaco',
+    appHost: 'web',
+    appLanguage: window.navigator.language ?? 'en-US',
+    extensionTelemetryLogResource: ( URI.from({ scheme: 'user', path: '/extensionTelemetryLogResource.log' })),
+    isExtensionTelemetryLoggingOnly: false,
+    get appUriScheme() { return unsupported(); },
+    get globalStorageHome() { return unsupported(); },
+    get workspaceStorageHome() { return unsupported(); }
+};
+const initData = {
+    _serviceBrand: undefined,
+    version: '1.0.0',
+    parentPid: 0,
+    environment,
+    get allExtensions() { return [Services.get().extension ?? DEFAULT_EXTENSION]; },
+    get myExtensions() { return [(Services.get().extension ?? DEFAULT_EXTENSION).identifier]; },
+    consoleForward: {
+        includeStack: false,
+        logNative: false
+    },
+    get telemetryInfo() { return unsupported(); },
+    logLevel: LogLevel.Trace,
+    get logsLocation() { return unsupported(); },
+    get logFile() { return unsupported(); },
+    autoStart: false,
+    remote: {
+        isRemote: false,
+        authority: undefined,
+        connectionData: null
+    },
+    uiKind: UIKind.Web,
+    loggers: [],
+    logName: 'browser'
+};
 class SimpleMessagePassingProtocol {
     constructor() {
         this._onMessage = new BufferedEmitter();
@@ -14652,7 +15650,8 @@ function createExtHostServices() {
     const configurationService = StandaloneServices.get(IConfigurationService);
     const workspaceContextService = StandaloneServices.get(IWorkspaceContextService);
     const extensionService = StandaloneServices.get(IExtensionService);
-    const instantiationService = StandaloneServices.get(IInstantiationService);
+    const loggerService = StandaloneServices.get(ILoggerService);
+    const logService = StandaloneServices.get(ILogService);
     const imessagePassingProtocol = new SimpleMessagePassingProtocol();
     const rpcProtocol = new RPCProtocol(imessagePassingProtocol);
     const extHostFileSystemInfo = new ExtHostFileSystemInfo();
@@ -14676,65 +15675,41 @@ function createExtHostServices() {
             rpcProtocol.dispose();
         }
     };
-    const initData = {
-        _serviceBrand: undefined,
-        version: '1.0.0',
-        parentPid: 0,
-        get environment() { return unsupported(); },
-        allExtensions: [Services.get().extension ?? DEFAULT_EXTENSION],
-        myExtensions: [(Services.get().extension ?? DEFAULT_EXTENSION).identifier],
-        consoleForward: {
-            includeStack: false,
-            logNative: false
-        },
-        get telemetryInfo() { return unsupported(); },
-        logLevel: LogLevel.Trace,
-        get logsLocation() { return unsupported(); },
-        get logFile() { return unsupported(); },
-        autoStart: false,
-        remote: {
-            isRemote: false,
-            authority: undefined,
-            connectionData: null
-        },
-        uiKind: UIKind.Web
-    };
-    const extHostLogService = new LogService(new ConsoleMainLogger());
-    const extHostApiDeprecationService = new ExtHostApiDeprecationService(mainContext, extHostLogService);
-    const extHostMessageService = new ExtHostMessageService(mainContext, extHostLogService);
+    const extHostApiDeprecationService = new ExtHostApiDeprecationService(mainContext, logService);
+    const extHostMessageService = new ExtHostMessageService(mainContext, logService);
     const uriTransformerService = new URITransformerService(null);
     rpcProtocol.set(MainContext.MainThreadWindow, new MainThreadWindow(mainContext, hostService, openerService));
     rpcProtocol.set(MainContext.MainThreadCommands, new MainThreadCommands(mainContext, commandsService, extensionService));
-    const extHostCommands = rpcProtocol.set(ExtHostContext.ExtHostCommands, new ExtHostCommands(mainContext, extHostLogService));
-    const extHostDocumentsAndEditors = rpcProtocol.set(ExtHostContext.ExtHostDocumentsAndEditors, new ExtHostDocumentsAndEditors(mainContext, extHostLogService));
+    const extHostTelemetry = rpcProtocol.set(ExtHostContext.ExtHostTelemetry, new ExtHostTelemetry(initData, loggerService));
+    const extHostCommands = rpcProtocol.set(ExtHostContext.ExtHostCommands, new ExtHostCommands(mainContext, logService, extHostTelemetry));
+    const extHostDocumentsAndEditors = rpcProtocol.set(ExtHostContext.ExtHostDocumentsAndEditors, new ExtHostDocumentsAndEditors(mainContext, logService));
     const extHostDocuments = rpcProtocol.set(ExtHostContext.ExtHostDocuments, new ExtHostDocuments(mainContext, extHostDocumentsAndEditors));
     const extHostLanguages = rpcProtocol.set(ExtHostContext.ExtHostLanguages, new ExtHostLanguages(mainContext, extHostDocuments, extHostCommands.converter, uriTransformerService));
     const extHostWindow = rpcProtocol.set(ExtHostContext.ExtHostWindow, new ExtHostWindow(mainContext));
     const extHostQuickOpen = rpcProtocol.set(ExtHostContext.ExtHostQuickOpen, createExtHostQuickOpen(mainContext, null, extHostCommands));
-    const extHostDiagnostics = rpcProtocol.set(ExtHostContext.ExtHostDiagnostics, new ExtHostDiagnostics(mainContext, extHostLogService, extHostFileSystemInfo));
+    const extHostDiagnostics = rpcProtocol.set(ExtHostContext.ExtHostDiagnostics, new ExtHostDiagnostics(mainContext, logService, extHostFileSystemInfo, extHostDocumentsAndEditors));
     const extHostProgress = rpcProtocol.set(ExtHostContext.ExtHostProgress, new ExtHostProgress(rpcProtocol.getProxy(MainContext.MainThreadProgress)));
-    const extHostDocumentContentProviders = rpcProtocol.set(ExtHostContext.ExtHostDocumentContentProviders, new ExtHostDocumentContentProvider(mainContext, extHostDocumentsAndEditors, extHostLogService));
+    const extHostDocumentContentProviders = rpcProtocol.set(ExtHostContext.ExtHostDocumentContentProviders, new ExtHostDocumentContentProvider(mainContext, extHostDocumentsAndEditors, logService));
     const extHostEditors = rpcProtocol.set(ExtHostContext.ExtHostEditors, new ExtHostEditors(mainContext, extHostDocumentsAndEditors));
     const extHostClipboard = new ExtHostClipboard(mainContext);
-    const extHostLanguageFeatures = rpcProtocol.set(ExtHostContext.ExtHostLanguageFeatures, new ExtHostLanguageFeatures(rpcProtocol, uriTransformerService, extHostDocuments, extHostCommands, extHostDiagnostics, extHostLogService, extHostApiDeprecationService));
-    const extHostWorkspace = rpcProtocol.set(ExtHostContext.ExtHostWorkspace, new ExtHostWorkspace(mainContext, initData, extHostFileSystemInfo, extHostLogService));
-    const extHostConfiguration = rpcProtocol.set(ExtHostContext.ExtHostConfiguration, new SyncExtHostConfiguration(mainContext, extHostWorkspace, extHostLogService));
-    rpcProtocol.set(ExtHostContext.ExtHostTelemetry, new ExtHostTelemetry());
+    const extHostLanguageFeatures = rpcProtocol.set(ExtHostContext.ExtHostLanguageFeatures, new ExtHostLanguageFeatures(rpcProtocol, uriTransformerService, extHostDocuments, extHostCommands, extHostDiagnostics, logService, extHostApiDeprecationService, extHostTelemetry));
+    const extHostWorkspace = rpcProtocol.set(ExtHostContext.ExtHostWorkspace, new ExtHostWorkspace(mainContext, initData, extHostFileSystemInfo, logService, uriTransformerService));
+    const extHostConfiguration = rpcProtocol.set(ExtHostContext.ExtHostConfiguration, new SyncExtHostConfiguration(mainContext, extHostWorkspace, logService));
     rpcProtocol.set(MainContext.MainThreadMessageService, new MainThreadMessageServiceWithoutSource(mainContext, notificationService, commandsService, dialogService));
     rpcProtocol.set(MainContext.MainThreadDiagnostics, new MainThreadDiagnostics(mainContext, markerService, uriIdentityService));
     rpcProtocol.set(MainContext.MainThreadQuickOpen, new MainThreadQuickOpen(mainContext, quickInputService));
-    rpcProtocol.set(MainContext.MainThreadTelemetry, new MainThreadTelemetry(mainContext, telemetryService, workbenchEnvironmentService, productService));
+    rpcProtocol.set(MainContext.MainThreadTelemetry, new MainThreadTelemetry(mainContext, telemetryService, configurationService, workbenchEnvironmentService, productService));
     rpcProtocol.set(MainContext.MainThreadProgress, new MainThreadProgress(mainContext, progressService, commandsService));
     rpcProtocol.set(MainContext.MainThreadDocumentContentProviders, new MainThreadDocumentContentProviders(mainContext, textModelService, languageService, modelService, editorWorkerService));
-    rpcProtocol.set(MainContext.MainThreadBulkEdits, new MainThreadBulkEdits(mainContext, bulkEditService, extHostLogService));
+    rpcProtocol.set(MainContext.MainThreadBulkEdits, new MainThreadBulkEdits(mainContext, bulkEditService, logService, uriIdentityService));
     rpcProtocol.set(MainContext.MainThreadLanguages, new MainThreadLanguages(mainContext, languageService, modelService, textModelService, languageStatusService));
     rpcProtocol.set(MainContext.MainThreadClipboard, new MainThreadClipboard(mainContext, clipboardService));
-    rpcProtocol.set(MainContext.MainThreadLanguageFeatures, new MainThreadLanguageFeatures(mainContext, languageService, languageConfigurationService, languageFeaturesService));
+    rpcProtocol.set(MainContext.MainThreadLanguageFeatures, new MainThreadLanguageFeatures(mainContext, languageService, languageConfigurationService, languageFeaturesService, uriIdentityService));
     rpcProtocol.set(MainContext.MainThreadConfiguration, new MainThreadConfiguration(mainContext, workspaceContextService, configurationService, workbenchEnvironmentService));
-    new MainThreadDocumentsAndEditors(mainContext, modelService, textFileService, editorService, codeEditorService, fileService, textModelService, editorGroupsService, paneCompositePartService, workbenchEnvironmentService, workingCopyFileService, uriIdentityService, clipboardService, pathService, instantiationService);
+    new MainThreadDocumentsAndEditors(mainContext, modelService, textFileService, editorService, codeEditorService, fileService, textModelService, editorGroupsService, paneCompositePartService, workbenchEnvironmentService, workingCopyFileService, uriIdentityService, clipboardService, pathService, configurationService);
     const extHostBulkEdits = new ExtHostBulkEdits(mainContext, extHostDocumentsAndEditors);
     return {
-        extHostLogService,
+        extHostLogService: logService,
         extHostApiDeprecationService,
         extHostMessageService,
         extHostDocumentsAndEditors,
@@ -14751,7 +15726,8 @@ function createExtHostServices() {
         extHostClipboard,
         extHostLanguageFeatures,
         extHostWorkspace,
-        extHostConfiguration
+        extHostConfiguration,
+        extHostTelemetry
     };
 }
 let extHostServices;
@@ -14761,4 +15737,4 @@ function getExtHostServices() {
     }
     return extHostServices;
 }
-export { ParameterInformation$1 as $, DiagnosticSeverity$1 as A, Breakpoint as B, CallHierarchyIncomingCall as C, DebugAdapterExecutable as D, DiagnosticTag$1 as E, Disposable as F, DocumentHighlight$1 as G, DocumentHighlightKind as H, DocumentLink$1 as I, DocumentSymbol$1 as J, EndOfLine$1 as K, EnvironmentVariableMutatorType as L, EvaluatableExpression$1 as M, InlineValueText as N, InlineValueVariableLookup as O, InlineValueEvaluatableExpression as P, ExtensionKind as Q, ExtensionMode as R, FileChangeType as S, FileDecoration as T, FileSystemError as U, FoldingRange$1 as V, FoldingRangeKind$1 as W, FunctionBreakpoint as X, Hover$1 as Y, Location as Z, MarkdownString$1 as _, CallHierarchyItem$1 as a, LanguageStatusSeverity as a$, Position$1 as a0, ProcessExecution as a1, ProgressLocation$1 as a2, QuickInputButtons as a3, Range$1 as a4, RelativePattern as a5, Selection$2 as a6, SelectionRange$1 as a7, SemanticTokens as a8, SemanticTokensBuilder as a9, TextEditorSelectionChangeKind as aA, TextDocumentChangeReason as aB, ThemeColor as aC, ThemeIcon as aD, TreeItem as aE, TreeItemCollapsibleState as aF, TypeHierarchyItem$1 as aG, UIKind as aH, ViewColumn$1 as aI, WorkspaceEdit$1 as aJ, InlayHint as aK, InlayHintLabelPart as aL, InlayHintKind$1 as aM, NotebookRange$1 as aN, NotebookCellKind$1 as aO, NotebookCellData$1 as aP, NotebookData as aQ, NotebookCellStatusBarAlignment as aR, NotebookCellOutput$1 as aS, NotebookCellOutputItem$1 as aT, NotebookCellStatusBarItem as aU, NotebookControllerAffinity as aV, LinkedEditingRanges as aW, TestRunRequest as aX, TestMessage as aY, TestTag as aZ, TestRunProfileKind as a_, SemanticTokensEdit as aa, SemanticTokensEdits as ab, SemanticTokensLegend as ac, ShellExecution as ad, ShellQuoting as ae, SignatureHelp$1 as af, SignatureHelpTriggerKind as ag, SignatureInformation$1 as ah, SnippetString as ai, SourceBreakpoint as aj, StatusBarAlignment as ak, SymbolInformation as al, SymbolKind$1 as am, SymbolTag$1 as an, Task as ao, TaskGroup as ap, TaskPanelKind as aq, TaskRevealKind as ar, TaskScope as as, TerminalLink as at, TerminalLocation as au, TerminalProfile as av, TextDocumentSaveReason as aw, TextEdit$1 as ax, TextEditorLineNumbersStyle$1 as ay, TextEditorRevealType$1 as az, CallHierarchyOutgoingCall as b, QuickPickItemKind as b0, TextDiffTabInput as b1, CustomEditorTabInput as b2, NotebookEditorTabInput as b3, NotebookDiffEditorTabInput as b4, WebviewEditorTabInput as b5, TerminalEditorTabInput as b6, InputBoxValidationSeverity as b7, InlineSuggestionList as b8, InlineCompletionTriggerKind as b9, InlineSuggestion as ba, DocumentDropEdit as bb, NotebookEditorRevealType as bc, getExtHostServices as bd, DEFAULT_EXTENSION as be, LanguageSelector as bf, Position$2 as bg, keyFromOverrideIdentifiers as bh, configurationDefaultsSchemaId as bi, ConfigurationScope as bj, Range$2 as bk, supportsTelemetry as bl, getTelemetryLevel as bm, CancellationTokenSource as c, CodeAction as d, CodeActionKind as e, CodeActionTriggerKind$1 as f, CodeLens as g, Color$1 as h, ColorInformation as i, ColorPresentation$1 as j, CommentMode as k, CommentThreadCollapsibleState as l, CompletionItem as m, CompletionItemKind$1 as n, CompletionItemTag$1 as o, CompletionList as p, CompletionTriggerKind$1 as q, ConfigurationTarget as r, CustomExecution as s, DebugAdapterInlineImplementation as t, DebugAdapterNamedPipeServer as u, DebugAdapterServer as v, DebugConsoleMode as w, DecorationRangeBehavior$1 as x, Diagnostic$1 as y, DiagnosticRelatedInformation$1 as z };
+export { ParameterInformation$1 as $, DiagnosticSeverity$1 as A, Breakpoint as B, CallHierarchyIncomingCall as C, DebugAdapterExecutable as D, DiagnosticTag$1 as E, Disposable as F, DocumentHighlight$1 as G, DocumentHighlightKind as H, DocumentLink$1 as I, DocumentSymbol$1 as J, EndOfLine$1 as K, EnvironmentVariableMutatorType as L, EvaluatableExpression$1 as M, InlineValueText as N, InlineValueVariableLookup as O, InlineValueEvaluatableExpression as P, ExtensionKind as Q, ExtensionMode as R, FileChangeType as S, FileDecoration as T, FileSystemError as U, FoldingRange$1 as V, FoldingRangeKind$1 as W, FunctionBreakpoint as X, Hover$1 as Y, Location as Z, MarkdownString$1 as _, CallHierarchyItem$1 as a, LanguageStatusSeverity as a$, Position$1 as a0, ProcessExecution as a1, ProgressLocation$1 as a2, QuickInputButtons as a3, Range$1 as a4, RelativePattern as a5, Selection$2 as a6, SelectionRange$1 as a7, SemanticTokens as a8, SemanticTokensBuilder as a9, TextEditorSelectionChangeKind as aA, TextDocumentChangeReason as aB, ThemeColor as aC, ThemeIcon as aD, TreeItem as aE, TreeItemCollapsibleState as aF, TypeHierarchyItem$1 as aG, UIKind as aH, ViewColumn$1 as aI, WorkspaceEdit$1 as aJ, InlayHint as aK, InlayHintLabelPart as aL, InlayHintKind$1 as aM, NotebookRange$1 as aN, NotebookCellKind$1 as aO, NotebookCellData$1 as aP, NotebookData as aQ, NotebookCellStatusBarAlignment as aR, NotebookCellOutput$1 as aS, NotebookCellOutputItem$1 as aT, NotebookCellStatusBarItem as aU, NotebookControllerAffinity as aV, LinkedEditingRanges as aW, TestRunRequest as aX, TestMessage as aY, TestTag as aZ, TestRunProfileKind as a_, SemanticTokensEdit as aa, SemanticTokensEdits as ab, SemanticTokensLegend as ac, ShellExecution as ad, ShellQuoting as ae, SignatureHelp$1 as af, SignatureHelpTriggerKind as ag, SignatureInformation$1 as ah, SnippetString as ai, SourceBreakpoint as aj, StatusBarAlignment as ak, SymbolInformation as al, SymbolKind$1 as am, SymbolTag$1 as an, Task as ao, TaskGroup as ap, TaskPanelKind as aq, TaskRevealKind as ar, TaskScope as as, TerminalLink as at, TerminalLocation as au, TerminalProfile as av, TextDocumentSaveReason as aw, TextEdit$1 as ax, TextEditorLineNumbersStyle$1 as ay, TextEditorRevealType$1 as az, CallHierarchyOutgoingCall as b, QuickPickItemKind as b0, TextDiffTabInput as b1, CustomEditorTabInput as b2, NotebookEditorTabInput as b3, NotebookDiffEditorTabInput as b4, WebviewEditorTabInput as b5, TerminalEditorTabInput as b6, InputBoxValidationSeverity as b7, InlineSuggestionList as b8, InlineCompletionTriggerKind as b9, InlineSuggestion as ba, DocumentDropEdit as bb, NotebookEditorRevealType as bc, SnippetTextEdit as bd, NotebookEdit as be, TerminalExitReason as bf, CommentThreadState as bg, TelemetryTrustedValue as bh, getExtHostServices as bi, DEFAULT_EXTENSION as bj, LanguageSelector as bk, initData as bl, ExtHostTelemetryLogger as bm, Position$2 as bn, keyFromOverrideIdentifiers as bo, configurationDefaultsSchemaId as bp, ConfigurationScope as bq, getRemoteAuthority as br, Range$2 as bs, getRemoteServerRootPath as bt, supportsTelemetry as bu, getTelemetryLevel as bv, CancellationTokenSource as c, CodeAction as d, CodeActionKind as e, CodeActionTriggerKind$1 as f, CodeLens as g, Color$1 as h, ColorInformation as i, ColorPresentation$1 as j, CommentMode as k, CommentThreadCollapsibleState as l, CompletionItem as m, CompletionItemKind$1 as n, CompletionItemTag$1 as o, CompletionList as p, CompletionTriggerKind$1 as q, ConfigurationTarget as r, CustomExecution as s, DebugAdapterInlineImplementation as t, DebugAdapterNamedPipeServer as u, DebugAdapterServer as v, DebugConsoleMode as w, DecorationRangeBehavior$1 as x, Diagnostic$1 as y, DiagnosticRelatedInformation$1 as z };