@codingame/monaco-vscode-api 1.67.12 → 1.67.15

package/dist/api.js

@@ -1,40 +1,42 @@
-import { i as isStringArray, E as Emitter, u as unsupported$1 } from './missing-services-71e80bea.js';
-import { _ as __classPrivateFieldSet, a as __classPrivateFieldGet, b as __decorate, c as coalesceInPlace, m as markAsFileSystemProviderError, F as FileSystemProviderErrorCode, S as SIDE_GROUP, A as ACTIVE_GROUP, d as __param, C as CancellationTokenSource$1, I as IProgressService, r as readonly, e as ITextFileService, f as IFileService, g as IWorkbenchEnvironmentService, h as IUriIdentityService, i as IWorkingCopyFileService, j as IPathService, k as disposed, l as IEditorService, n as IEditorGroupsService, o as IPaneCompositePartService, p as IProductService, q as ILanguageStatusService, s as IHostService, t as Services, u as FileType$1, v as FilePermission$1 } from './services-fb7952fb.js';
+import { E as Emitter, u as unsupported$1 } from './missing-services-8687ea11.js';
+import { _ as __classPrivateFieldSet, a as __classPrivateFieldGet, b as __decorate, c as coalesceInPlace, m as markAsFileSystemProviderError, F as FileSystemProviderErrorCode, S as SIDE_GROUP, A as ACTIVE_GROUP, d as __param, C as CancellationTokenSource$1, e as delta$1, f as mapArrayOrNot, I as IProgressService, r as readonly, g as ITextFileService, h as IFileService, i as IWorkbenchEnvironmentService, j as IUriIdentityService, k as IWorkingCopyFileService, l as IPathService, n as disposed, o as IEditorService, p as IEditorGroupsService, q as IPaneCompositePartService, s as IProductService, t as ILanguageStatusService, u as IHostService, v as Services, w as FileType$1, x as FilePermission$1 } from './services-7a462d46.js';
+import { i as isStringArray, w as withUndefinedAsNull } from './types-371cc315.js';
 import { illegalArgument, onUnexpectedError, canceled, transformErrorForSerialization, isCancellationError, onUnexpectedExternalError, CancellationError as CancellationError$1 } from 'monaco-editor/esm/vs/base/common/errors.js';
 import { uriToFsPath, URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { equals, coalesce, asArray, isNonEmptyArray, groupBy, isFalsyOrEmpty } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { distinct, equals, coalesce, asArray, isNonEmptyArray, groupBy, isFalsyOrEmpty } from 'monaco-editor/esm/vs/base/common/arrays.js';
 import { MarkdownString as MarkdownString$3, parseHrefAndDimensions, isMarkdownString } from 'monaco-editor/esm/vs/base/common/htmlContent.js';
 import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
 import { compare, equalsIgnoreCase, nextCharLength, regExpLeadsToEndlessLoop, splitLines, isFalsyOrWhitespace, regExpFlags } from 'monaco-editor/esm/vs/base/common/strings.js';
 import { Mimes } from 'monaco-editor/esm/vs/base/common/mime.js';
-import { isArray, isString, isNumber, validateConstraint, assertIsDefined, withNullAsUndefined, isObject } from 'monaco-editor/esm/vs/base/common/types.js';
-import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { isString, isUndefinedOrNull, isUndefined, isArray, isNumber, validateConstraint, assertIsDefined, withNullAsUndefined, isObject } from 'monaco-editor/esm/vs/base/common/types.js';
+import { ResourceMap, TernarySearchTree } from 'monaco-editor/esm/vs/base/common/map.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 { MarkerSeverity, IMarkerService } from 'monaco-editor/esm/vs/platform/markers/common/markers.js';
 import { parse, revive } from 'monaco-editor/esm/vs/base/common/marshalling.js';
-import { cloneAndChange, deepFreeze, equals as equals$1, mixin } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { cloneAndChange, deepFreeze, equals as equals$1, mixin, deepClone } from 'monaco-editor/esm/vs/base/common/objects.js';
 import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { toErrorMessage } from 'monaco-editor/esm/vs/base/common/errorMessage.js';
-import { ILogService, LogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { ILogService, LogLevel as LogLevel$1, LogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { Disposable as Disposable$2, toDisposable, dispose, combinedDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { Event, DebounceEmitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { CommandsRegistry, ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-import { ExtUri as ExtUri$1, extUri as extUri$1 } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { ExtUri as ExtUri$1, basename as basename$1, dirname as dirname$1, basenameOrAuthority, relativePath, extUri as extUri$1 } from 'monaco-editor/esm/vs/base/common/resources.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { RunOnceScheduler, createCancelablePromise, 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 { a as asPromise, r as raceCancellationError } from './async-9ffe4d42.js';
+import { a as asPromise, B as Barrier, r as raceCancellationError } from './async-f842d13c.js';
 import { ThemeIcon as ThemeIcon$2 } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
 import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+import { Severity as Severity$1, INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { Workspace, WorkspaceFolder, IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
 import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
 import { IDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
-import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
 import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
 import { Progress } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
 import { EditOperation } from 'monaco-editor/esm/vs/editor/common/core/editOperation.js';
@@ -66,13 +68,17 @@ import { StopWatch } from 'monaco-editor/esm/vs/base/common/stopwatch.js';
 import { LanguageFeatureRegistry } from 'monaco-editor/esm/vs/editor/common/languageFeatureRegistry.js';
 import { LanguageConfigurationRegistry, ILanguageConfigurationService } from 'monaco-editor/esm/vs/editor/common/languages/languageConfigurationRegistry.js';
 import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
+import { Configuration, ConfigurationChangeEvent } from 'monaco-editor/esm/vs/platform/configuration/common/configurationModels.js';
+import { OVERRIDE_PROPERTY_REGEX as OVERRIDE_PROPERTY_REGEX$1, Extensions as Extensions$1 } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } 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';
 import { score } from 'monaco-editor/esm/vs/editor/common/languageSelector.js';
 import { IndentAction as IndentAction$1 } from 'monaco-editor/esm/vs/editor/common/languages/languageConfiguration.js';
 import 'monaco-editor/esm/vs/base/browser/ui/progressbar/progressbar.js';
-import 'monaco-editor/esm/vs/base/common/color.js';
 import 'monaco-editor/esm/vs/base/browser/dom.js';
+import 'monaco-editor/esm/vs/base/common/color.js';
 import 'monaco-editor/esm/vs/editor/common/services/languageService.js';
 import 'monaco-editor/esm/vs/editor/common/services/languagesRegistry.js';
 import 'monaco-editor/esm/vs/editor/common/languages/modesRegistry.js';
@@ -81,7 +87,6 @@ import 'monaco-editor/esm/vs/base/parts/quickinput/browser/quickInput.js';
 import 'monaco-editor/esm/vs/platform/instantiation/common/extensions.js';
 import 'monaco-editor/esm/vs/platform/label/common/label.js';
 import 'monaco-editor/esm/vs/base/browser/event.js';
-import 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
 import 'monaco-editor/esm/vs/base/common/linkedList.js';
 function originalFSPath(uri) {
     return uriToFsPath(uri, true);
@@ -274,6 +279,363 @@ function toLocalResource(resource, authority, localScheme) {
 }
 const Range$3 = monaco.Range;
 const FoldingRangeKind$3 = monaco.languages.FoldingRangeKind;
+const resourceLanguageSettingsSchemaId = 'vscode://schemas/settings/resourceLanguage';
+const contributionRegistry =  Registry.as(Extensions.JSONContribution);
+class ConfigurationRegistry {
+    constructor() {
+        this.overrideIdentifiers =  new Set();
+        this._onDidSchemaChange =  new Emitter();
+        this.onDidSchemaChange = this._onDidSchemaChange.event;
+        this._onDidUpdateConfiguration =  new Emitter();
+        this.onDidUpdateConfiguration = this._onDidUpdateConfiguration.event;
+        this.configurationDefaultsOverrides =  new Map();
+        this.defaultLanguageConfigurationOverridesNode = {
+            id: 'defaultOverrides',
+            title:  localize(
+                'defaultLanguageConfigurationOverrides.title',
+                "Default Language Configuration Overrides"
+            ),
+            properties: {}
+        };
+        this.configurationContributors = [this.defaultLanguageConfigurationOverridesNode];
+        this.resourceLanguageSettingsSchema = { properties: {}, patternProperties: {}, additionalProperties: false, errorMessage: 'Unknown editor configuration setting', allowTrailingCommas: true, allowComments: true };
+        this.configurationProperties = {};
+        this.excludedConfigurationProperties = {};
+        contributionRegistry.registerSchema(resourceLanguageSettingsSchemaId, this.resourceLanguageSettingsSchema);
+        this.registerOverridePropertyPatternKey();
+    }
+    registerConfiguration(configuration, validate = true) {
+        this.registerConfigurations([configuration], validate);
+    }
+    registerConfigurations(configurations, validate = true) {
+        const properties = this.doRegisterConfigurations(configurations, validate);
+        contributionRegistry.registerSchema(resourceLanguageSettingsSchemaId, this.resourceLanguageSettingsSchema);
+        this._onDidSchemaChange.fire();
+        this._onDidUpdateConfiguration.fire({ properties });
+    }
+    deregisterConfigurations(configurations) {
+        const properties = this.doDeregisterConfigurations(configurations);
+        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));
+        contributionRegistry.registerSchema(resourceLanguageSettingsSchemaId, this.resourceLanguageSettingsSchema);
+        this._onDidSchemaChange.fire();
+        this._onDidUpdateConfiguration.fire({ properties: distinct(properties) });
+    }
+    registerDefaultConfigurations(configurationDefaults) {
+        const properties = [];
+        const overrideIdentifiers = [];
+        for (const { overrides, source } of configurationDefaults) {
+            for (const key in overrides) {
+                properties.push(key);
+                if (OVERRIDE_PROPERTY_REGEX.test(key)) {
+                    const defaultValue = { ...(this.configurationDefaultsOverrides.get(key)?.value || {}), ...overrides[key] };
+                    this.configurationDefaultsOverrides.set(key, { source, value: defaultValue });
+                    const property = {
+                        type: 'object',
+                        default: defaultValue,
+                        description:  localize(
+                            'defaultLanguageConfiguration.description',
+                            "Configure settings to be overridden for {0} language.",
+                            key
+                        ),
+                        $ref: resourceLanguageSettingsSchemaId,
+                        defaultDefaultValue: defaultValue,
+                        source: isString(source) ? undefined : source,
+                    };
+                    overrideIdentifiers.push(...overrideIdentifiersFromKey(key));
+                    this.configurationProperties[key] = property;
+                    this.defaultLanguageConfigurationOverridesNode.properties[key] = property;
+                }
+                else {
+                    this.configurationDefaultsOverrides.set(key, { value: overrides[key], source });
+                    const property = this.configurationProperties[key];
+                    if (property) {
+                        this.updatePropertyDefaultValue(key, property);
+                        this.updateSchema(key, property);
+                    }
+                }
+            }
+        }
+        this.registerOverrideIdentifiers(overrideIdentifiers);
+        this._onDidSchemaChange.fire();
+        this._onDidUpdateConfiguration.fire({ properties, defaultsOverrides: true });
+    }
+    deregisterDefaultConfigurations(defaultConfigurations) {
+        const properties = [];
+        for (const { overrides, source } of defaultConfigurations) {
+            for (const key in overrides) {
+                const configurationDefaultsOverride = this.configurationDefaultsOverrides.get(key);
+                const id = isString(source) ? source : source?.id;
+                const configurationDefaultsOverrideSourceId = isString(configurationDefaultsOverride?.source) ? configurationDefaultsOverride?.source : configurationDefaultsOverride?.source?.id;
+                if (id !== configurationDefaultsOverrideSourceId) {
+                    continue;
+                }
+                properties.push(key);
+                this.configurationDefaultsOverrides.delete(key);
+                if (OVERRIDE_PROPERTY_REGEX.test(key)) {
+                    delete this.configurationProperties[key];
+                    delete this.defaultLanguageConfigurationOverridesNode.properties[key];
+                }
+                else {
+                    const property = this.configurationProperties[key];
+                    if (property) {
+                        this.updatePropertyDefaultValue(key, property);
+                        this.updateSchema(key, property);
+                    }
+                }
+            }
+        }
+        this.updateOverridePropertyPatternKey();
+        this._onDidSchemaChange.fire();
+        this._onDidUpdateConfiguration.fire({ properties, defaultsOverrides: true });
+    }
+    notifyConfigurationSchemaUpdated(...configurations) {
+        this._onDidSchemaChange.fire();
+    }
+    registerOverrideIdentifiers(overrideIdentifiers) {
+        for (const overrideIdentifier of overrideIdentifiers) {
+            this.overrideIdentifiers.add(overrideIdentifier);
+        }
+        this.updateOverridePropertyPatternKey();
+    }
+    doRegisterConfigurations(configurations, validate) {
+        const properties = [];
+        configurations.forEach(configuration => {
+            properties.push(...this.validateAndRegisterProperties(configuration, validate, configuration.extensionInfo, configuration.restrictedProperties));
+            this.configurationContributors.push(configuration);
+            this.registerJSONConfiguration(configuration);
+        });
+        return properties;
+    }
+    doDeregisterConfigurations(configurations) {
+        const properties = [];
+        const deregisterConfiguration = (configuration) => {
+            if (configuration.properties) {
+                for (const key in configuration.properties) {
+                    properties.push(key);
+                    delete this.configurationProperties[key];
+                    this.removeFromSchema(key, configuration.properties[key]);
+                }
+            }
+            if (configuration.allOf) {
+                configuration.allOf.forEach(node => deregisterConfiguration(node));
+            }
+        };
+        for (const configuration of configurations) {
+            deregisterConfiguration(configuration);
+            const index = this.configurationContributors.indexOf(configuration);
+            if (index !== -1) {
+                this.configurationContributors.splice(index, 1);
+            }
+        }
+        return properties;
+    }
+    validateAndRegisterProperties(configuration, validate = true, extensionInfo, restrictedProperties, scope = 3 ) {
+        scope = isUndefinedOrNull(configuration.scope) ? scope : configuration.scope;
+        let propertyKeys = [];
+        let properties = configuration.properties;
+        if (properties) {
+            for (let key in properties) {
+                if (validate && validateProperty(key)) {
+                    delete properties[key];
+                    continue;
+                }
+                const property = properties[key];
+                property.source = extensionInfo;
+                property.defaultDefaultValue = properties[key].default;
+                this.updatePropertyDefaultValue(key, property);
+                if (OVERRIDE_PROPERTY_REGEX.test(key)) {
+                    property.scope = undefined;
+                }
+                else {
+                    property.scope = isUndefinedOrNull(property.scope) ? scope : property.scope;
+                    property.restricted = isUndefinedOrNull(property.restricted) ? !!restrictedProperties?.includes(key) : property.restricted;
+                }
+                if (properties[key].hasOwnProperty('included') && !properties[key].included) {
+                    this.excludedConfigurationProperties[key] = properties[key];
+                    delete properties[key];
+                    continue;
+                }
+                else {
+                    this.configurationProperties[key] = properties[key];
+                }
+                if (!properties[key].deprecationMessage && properties[key].markdownDeprecationMessage) {
+                    properties[key].deprecationMessage = properties[key].markdownDeprecationMessage;
+                }
+                propertyKeys.push(key);
+            }
+        }
+        let subNodes = configuration.allOf;
+        if (subNodes) {
+            for (let node of subNodes) {
+                propertyKeys.push(...this.validateAndRegisterProperties(node, validate, extensionInfo, restrictedProperties, scope));
+            }
+        }
+        return propertyKeys;
+    }
+    getConfigurations() {
+        return this.configurationContributors;
+    }
+    getConfigurationProperties() {
+        return this.configurationProperties;
+    }
+    getExcludedConfigurationProperties() {
+        return this.excludedConfigurationProperties;
+    }
+    getConfigurationDefaultsOverrides() {
+        return this.configurationDefaultsOverrides;
+    }
+    registerJSONConfiguration(configuration) {
+    }
+    updateSchema(key, property) {
+        switch (property.scope) {
+            case 1 :
+                break;
+            case 2 :
+                break;
+            case 6 :
+                break;
+            case 3 :
+                break;
+            case 4 :
+                break;
+            case 5 :
+                this.resourceLanguageSettingsSchema.properties[key] = property;
+                break;
+        }
+    }
+    removeFromSchema(key, property) {
+        switch (property.scope) {
+            case 1 :
+                break;
+            case 2 :
+                break;
+            case 6 :
+                break;
+            case 3 :
+                break;
+            case 4 :
+            case 5 :
+                delete this.resourceLanguageSettingsSchema.properties[key];
+                break;
+        }
+    }
+    updateOverridePropertyPatternKey() {
+        for (const overrideIdentifier of this.overrideIdentifiers.values()) {
+            const overrideIdentifierProperty = `[${overrideIdentifier}]`;
+            const resourceLanguagePropertiesSchema = {
+                type: 'object',
+                description:  localize(
+                    'overrideSettings.defaultDescription',
+                    "Configure editor settings to be overridden for a language."
+                ),
+                errorMessage:  localize(
+                    'overrideSettings.errorMessage',
+                    "This setting does not support per-language configuration."
+                ),
+                $ref: resourceLanguageSettingsSchemaId,
+            };
+            this.updatePropertyDefaultValue(overrideIdentifierProperty, resourceLanguagePropertiesSchema);
+        }
+        this._onDidSchemaChange.fire();
+    }
+    registerOverridePropertyPatternKey() {
+        this._onDidSchemaChange.fire();
+    }
+    updatePropertyDefaultValue(key, property) {
+        const configurationdefaultOverride = this.configurationDefaultsOverrides.get(key);
+        let defaultValue = configurationdefaultOverride?.value;
+        let defaultSource = configurationdefaultOverride?.source;
+        if (isUndefined(defaultValue)) {
+            defaultValue = property.defaultDefaultValue;
+            defaultSource = undefined;
+        }
+        if (isUndefined(defaultValue)) {
+            defaultValue = getDefaultValue(property.type);
+        }
+        property.default = defaultValue;
+        property.defaultValueSource = defaultSource;
+    }
+}
+const OVERRIDE_IDENTIFIER_PATTERN = `\\[([^\\]]+)\\]`;
+const OVERRIDE_IDENTIFIER_REGEX =  new RegExp(OVERRIDE_IDENTIFIER_PATTERN, 'g');
+const OVERRIDE_PROPERTY_PATTERN = `^(${OVERRIDE_IDENTIFIER_PATTERN})+$`;
+const OVERRIDE_PROPERTY_REGEX =  new RegExp(OVERRIDE_PROPERTY_PATTERN);
+function overrideIdentifiersFromKey(key) {
+    const identifiers = [];
+    if (OVERRIDE_PROPERTY_REGEX.test(key)) {
+        let matches = OVERRIDE_IDENTIFIER_REGEX.exec(key);
+        while (matches?.length) {
+            const identifier = matches[1].trim();
+            if (identifier) {
+                identifiers.push(identifier);
+            }
+            matches = OVERRIDE_IDENTIFIER_REGEX.exec(key);
+        }
+    }
+    return distinct(identifiers);
+}
+function getDefaultValue(type) {
+    const t = Array.isArray(type) ? type[0] : type;
+    switch (t) {
+        case 'boolean':
+            return false;
+        case 'integer':
+        case 'number':
+            return 0;
+        case 'string':
+            return '';
+        case 'array':
+            return [];
+        case 'object':
+            return {};
+        default:
+            return null;
+    }
+}
+const configurationRegistry =  new ConfigurationRegistry();
+function validateProperty(property) {
+    if (!property.trim()) {
+        return (
+             localize('config.property.empty', "Cannot register an empty property")
+        );
+    }
+    if (OVERRIDE_PROPERTY_REGEX.test(property)) {
+        return (
+             localize(
+                'config.property.languageDefault',
+                "Cannot register '{0}'. This matches property pattern '\\\\[.*\\\\]$' for describing language specific editor settings. Use 'configurationDefaults' contribution.",
+                property
+            )
+        );
+    }
+    if (configurationRegistry.getConfigurationProperties()[property] !== undefined) {
+        return (
+             localize(
+                'config.property.duplicate',
+                "Cannot register '{0}'. This property is already registered.",
+                property
+            )
+        );
+    }
+    return null;
+}
+function getScopes() {
+    const scopes = [];
+    const configurationProperties = configurationRegistry.getConfigurationProperties();
+    for (const key of Object.keys(configurationProperties)) {
+        scopes.push([key, configurationProperties[key].scope]);
+    }
+    scopes.push(['launch', 4 ]);
+    scopes.push(['task', 4 ]);
+    return scopes;
+}
 const _simplePattern = /^(.+)\/(.+?)(;.+)?$/;
 function normalizeMimeType(mimeType, strict) {
     const match = _simplePattern.exec(mimeType);
@@ -7935,6 +8297,442 @@ function createExtHostQuickOpen(mainContext, workspace, commands) {
          new ExtHostQuickOpenImpl(workspace, commands)
     );
 }
+class Counter {
+    constructor() {
+        this._next = 0;
+    }
+    getNext() {
+        return this._next++;
+    }
+}
+const IExtHostInitDataService =  createDecorator('IExtHostInitDataService');
+function resultIsMatch(result) {
+    return !!result.preview;
+}
+function isFolderEqual(folderA, folderB, extHostFileSystemInfo) {
+    return (
+         new ExtUri$1(uri => ignorePathCasing(uri, extHostFileSystemInfo)).isEqual(folderA, folderB)
+    );
+}
+function compareWorkspaceFolderByUri(a, b, extHostFileSystemInfo) {
+    return isFolderEqual(a.uri, b.uri, extHostFileSystemInfo) ? 0 : compare(a.uri.toString(), b.uri.toString());
+}
+function compareWorkspaceFolderByUriAndNameAndIndex(a, b, extHostFileSystemInfo) {
+    if (a.index !== b.index) {
+        return a.index < b.index ? -1 : 1;
+    }
+    return isFolderEqual(a.uri, b.uri, extHostFileSystemInfo) ? compare(a.name, b.name) : compare(a.uri.toString(), b.uri.toString());
+}
+function delta(oldFolders, newFolders, compare, extHostFileSystemInfo) {
+    const oldSortedFolders = oldFolders.slice(0).sort((a, b) => compare(a, b, extHostFileSystemInfo));
+    const newSortedFolders = newFolders.slice(0).sort((a, b) => compare(a, b, extHostFileSystemInfo));
+    return delta$1(oldSortedFolders, newSortedFolders, (a, b) => compare(a, b, extHostFileSystemInfo));
+}
+function ignorePathCasing(uri, extHostFileSystemInfo) {
+    const capabilities = extHostFileSystemInfo.getCapabilities(uri.scheme);
+    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: [] };
+        }
+        const { id, name, folders, configuration, transient, isUntitled } = data;
+        const newWorkspaceFolders = [];
+        const oldWorkspace = previousConfirmedWorkspace;
+        if (previousConfirmedWorkspace) {
+            folders.forEach((folderData, index) => {
+                const folderUri = URI.revive(folderData.uri);
+                const existingFolder = ExtHostWorkspaceImpl._findFolder(previousUnconfirmedWorkspace || previousConfirmedWorkspace, folderUri, extHostFileSystemInfo);
+                if (existingFolder) {
+                    existingFolder.name = folderData.name;
+                    existingFolder.index = folderData.index;
+                    newWorkspaceFolders.push(existingFolder);
+                }
+                else {
+                    newWorkspaceFolders.push({ uri: folderUri, name: folderData.name, index });
+                }
+            });
+        }
+        else {
+            newWorkspaceFolders.push(...folders.map(({ uri, name, index }) => ({ uri: URI.revive(uri), name, index })));
+        }
+        newWorkspaceFolders.sort((f1, f2) => f1.index < f2.index ? -1 : 1);
+        const workspace =  new ExtHostWorkspaceImpl(
+            id,
+            name,
+            newWorkspaceFolders,
+            !!transient,
+            configuration ? URI.revive(configuration) : null,
+            !!isUntitled,
+            uri => ignorePathCasing(uri, extHostFileSystemInfo)
+        );
+        const { added, removed } = delta(oldWorkspace ? oldWorkspace.workspaceFolders : [], workspace.workspaceFolders, compareWorkspaceFolderByUri, extHostFileSystemInfo);
+        return { workspace, added, removed };
+    }
+    static _findFolder(workspace, folderUriToFind, extHostFileSystemInfo) {
+        for (let i = 0; i < workspace.folders.length; i++) {
+            const folder = workspace.workspaceFolders[i];
+            if (isFolderEqual(folder.uri, folderUriToFind, extHostFileSystemInfo)) {
+                return folder;
+            }
+        }
+        return undefined;
+    }
+    get name() {
+        return this._name;
+    }
+    get isUntitled() {
+        return this._isUntitled;
+    }
+    get workspaceFolders() {
+        return this._workspaceFolders.slice(0);
+    }
+    getWorkspaceFolder(uri, resolveParent) {
+        if (resolveParent && this._structure.get(uri)) {
+            uri = dirname$1(uri);
+        }
+        return this._structure.findSubstr(uri);
+    }
+    resolveWorkspaceFolder(uri) {
+        return this._structure.get(uri);
+    }
+}
+let ExtHostWorkspace = class ExtHostWorkspace {
+    constructor(extHostRpc, initData, extHostFileSystemInfo, logService) {
+        this._onDidChangeWorkspace =  new Emitter();
+        this.onDidChangeWorkspace = this._onDidChangeWorkspace.event;
+        this._onDidGrantWorkspaceTrust =  new Emitter();
+        this.onDidGrantWorkspaceTrust = this._onDidGrantWorkspaceTrust.event;
+        this._activeSearchCallbacks = [];
+        this._trusted = false;
+        this._logService = logService;
+        this._extHostFileSystemInfo = extHostFileSystemInfo;
+        this._requestIdProvider =  new Counter();
+        this._barrier =  new Barrier();
+        this._proxy = extHostRpc.getProxy(MainContext.MainThreadWorkspace);
+        this._messageService = extHostRpc.getProxy(MainContext.MainThreadMessageService);
+        const data = initData.workspace;
+        this._confirmedWorkspace = data ?  new ExtHostWorkspaceImpl(
+            data.id,
+            data.name,
+            [],
+            !!data.transient,
+            data.configuration ? URI.revive(data.configuration) : null,
+            !!data.isUntitled,
+            uri => ignorePathCasing(uri, extHostFileSystemInfo)
+        ) : undefined;
+    }
+    $initializeWorkspace(data, trusted) {
+        this._trusted = trusted;
+        this.$acceptWorkspaceData(data);
+        this._barrier.open();
+    }
+    waitForInitializeCall() {
+        return this._barrier.wait();
+    }
+    get workspace() {
+        return this._actualWorkspace;
+    }
+    get name() {
+        return this._actualWorkspace ? this._actualWorkspace.name : undefined;
+    }
+    get workspaceFile() {
+        if (this._actualWorkspace) {
+            if (this._actualWorkspace.configuration) {
+                if (this._actualWorkspace.isUntitled) {
+                    return URI.from({ scheme: Schemas.untitled, path: basename$1(dirname$1(this._actualWorkspace.configuration)) });
+                }
+                return this._actualWorkspace.configuration;
+            }
+        }
+        return undefined;
+    }
+    get _actualWorkspace() {
+        return this._unconfirmedWorkspace || this._confirmedWorkspace;
+    }
+    getWorkspaceFolders() {
+        if (!this._actualWorkspace) {
+            return undefined;
+        }
+        return this._actualWorkspace.workspaceFolders.slice(0);
+    }
+    async getWorkspaceFolders2() {
+        await this._barrier.wait();
+        if (!this._actualWorkspace) {
+            return undefined;
+        }
+        return this._actualWorkspace.workspaceFolders.slice(0);
+    }
+    updateWorkspaceFolders(extension, index, deleteCount, ...workspaceFoldersToAdd) {
+        const validatedDistinctWorkspaceFoldersToAdd = [];
+        if (Array.isArray(workspaceFoldersToAdd)) {
+            workspaceFoldersToAdd.forEach(folderToAdd => {
+                if (URI.isUri(folderToAdd.uri) && !validatedDistinctWorkspaceFoldersToAdd.some(f => isFolderEqual(f.uri, folderToAdd.uri, this._extHostFileSystemInfo))) {
+                    validatedDistinctWorkspaceFoldersToAdd.push({ uri: folderToAdd.uri, name: folderToAdd.name || basenameOrAuthority(folderToAdd.uri) });
+                }
+            });
+        }
+        if (!!this._unconfirmedWorkspace) {
+            return false;
+        }
+        if ([index, deleteCount].some(i => typeof i !== 'number' || i < 0)) {
+            return false;
+        }
+        if (deleteCount === 0 && validatedDistinctWorkspaceFoldersToAdd.length === 0) {
+            return false;
+        }
+        const currentWorkspaceFolders = this._actualWorkspace ? this._actualWorkspace.workspaceFolders : [];
+        if (index + deleteCount > currentWorkspaceFolders.length) {
+            return false;
+        }
+        const newWorkspaceFolders = currentWorkspaceFolders.slice(0);
+        newWorkspaceFolders.splice(index, deleteCount, ...validatedDistinctWorkspaceFoldersToAdd.map(f => ({ uri: f.uri, name: f.name || basenameOrAuthority(f.uri), index: undefined  })));
+        for (let i = 0; i < newWorkspaceFolders.length; i++) {
+            const folder = newWorkspaceFolders[i];
+            if (newWorkspaceFolders.some((otherFolder, index) => index !== i && isFolderEqual(folder.uri, otherFolder.uri, this._extHostFileSystemInfo))) {
+                return false;
+            }
+        }
+        newWorkspaceFolders.forEach((f, index) => f.index = index);
+        const { added, removed } = delta(currentWorkspaceFolders, newWorkspaceFolders, compareWorkspaceFolderByUriAndNameAndIndex, this._extHostFileSystemInfo);
+        if (added.length === 0 && removed.length === 0) {
+            return false;
+        }
+        if (this._proxy) {
+            const extName = extension.displayName || extension.name;
+            this._proxy.$updateWorkspaceFolders(extName, index, deleteCount, validatedDistinctWorkspaceFoldersToAdd).then(undefined, error => {
+                this._unconfirmedWorkspace = undefined;
+                const options = { source: { identifier: extension.identifier, label: extension.displayName || extension.name } };
+                this._messageService.$showMessage(Severity$1.Error,  localize(
+                    'updateerror',
+                    "Extension '{0}' failed to update workspace folders: {1}",
+                    extName,
+                    error.toString()
+                ), options, []);
+            });
+        }
+        this.trySetWorkspaceFolders(newWorkspaceFolders);
+        return true;
+    }
+    getWorkspaceFolder(uri, resolveParent) {
+        if (!this._actualWorkspace) {
+            return undefined;
+        }
+        return this._actualWorkspace.getWorkspaceFolder(uri, resolveParent);
+    }
+    async getWorkspaceFolder2(uri, resolveParent) {
+        await this._barrier.wait();
+        if (!this._actualWorkspace) {
+            return undefined;
+        }
+        return this._actualWorkspace.getWorkspaceFolder(uri, resolveParent);
+    }
+    async resolveWorkspaceFolder(uri) {
+        await this._barrier.wait();
+        if (!this._actualWorkspace) {
+            return undefined;
+        }
+        return this._actualWorkspace.resolveWorkspaceFolder(uri);
+    }
+    getPath() {
+        if (!this._actualWorkspace) {
+            return undefined;
+        }
+        const { folders } = this._actualWorkspace;
+        if (folders.length === 0) {
+            return undefined;
+        }
+        return folders[0].uri.fsPath;
+    }
+    getRelativePath(pathOrUri, includeWorkspace) {
+        let resource;
+        let path = '';
+        if (typeof pathOrUri === 'string') {
+            resource = URI.file(pathOrUri);
+            path = pathOrUri;
+        }
+        else if (typeof pathOrUri !== 'undefined') {
+            resource = pathOrUri;
+            path = pathOrUri.fsPath;
+        }
+        if (!resource) {
+            return path;
+        }
+        const folder = this.getWorkspaceFolder(resource, true);
+        if (!folder) {
+            return path;
+        }
+        if (typeof includeWorkspace === 'undefined' && this._actualWorkspace) {
+            includeWorkspace = this._actualWorkspace.folders.length > 1;
+        }
+        let result = relativePath(folder.uri, resource);
+        if (includeWorkspace && folder.name) {
+            result = `${folder.name}/${result}`;
+        }
+        return result;
+    }
+    trySetWorkspaceFolders(folders) {
+        if (this._actualWorkspace) {
+            this._unconfirmedWorkspace = ExtHostWorkspaceImpl.toExtHostWorkspace({
+                id: this._actualWorkspace.id,
+                name: this._actualWorkspace.name,
+                configuration: this._actualWorkspace.configuration,
+                folders,
+                isUntitled: this._actualWorkspace.isUntitled
+            }, this._actualWorkspace, undefined, this._extHostFileSystemInfo).workspace || undefined;
+        }
+    }
+    $acceptWorkspaceData(data) {
+        const { workspace, added, removed } = ExtHostWorkspaceImpl.toExtHostWorkspace(data, this._confirmedWorkspace, this._unconfirmedWorkspace, this._extHostFileSystemInfo);
+        this._confirmedWorkspace = workspace || undefined;
+        this._unconfirmedWorkspace = undefined;
+        this._onDidChangeWorkspace.fire( Object.freeze({
+            added,
+            removed,
+        }));
+    }
+    findFiles(include, exclude, maxResults, extensionId, token = CancellationToken.None) {
+        this._logService.trace(`extHostWorkspace#findFiles: fileSearch, extension: ${extensionId.value}, entryPoint: findFiles`);
+        let excludePatternOrDisregardExcludes = undefined;
+        if (exclude === null) {
+            excludePatternOrDisregardExcludes = false;
+        }
+        else if (exclude) {
+            if (typeof exclude === 'string') {
+                excludePatternOrDisregardExcludes = exclude;
+            }
+            else {
+                excludePatternOrDisregardExcludes = exclude.pattern;
+            }
+        }
+        if (token && token.isCancellationRequested) {
+            return Promise.resolve([]);
+        }
+        const { includePattern, folder } = parseSearchInclude(GlobPattern.from(include));
+        return this._proxy.$startFileSearch(withUndefinedAsNull(includePattern), withUndefinedAsNull(folder), withUndefinedAsNull(excludePatternOrDisregardExcludes), withUndefinedAsNull(maxResults), token)
+            .then(data => Array.isArray(data) ? data.map(d => URI.revive(d)) : []);
+    }
+    async findTextInFiles(query, options, callback, extensionId, token = CancellationToken.None) {
+        this._logService.trace(`extHostWorkspace#findTextInFiles: textSearch, extension: ${extensionId.value}, entryPoint: findTextInFiles`);
+        const requestId = this._requestIdProvider.getNext();
+        const previewOptions = typeof options.previewOptions === 'undefined' ?
+            {
+                matchLines: 100,
+                charsPerLine: 10000
+            } :
+            options.previewOptions;
+        const { includePattern, folder } = parseSearchInclude(GlobPattern.from(options.include));
+        const excludePattern = (typeof options.exclude === 'string') ? options.exclude :
+            options.exclude ? options.exclude.pattern : undefined;
+        const queryOptions = {
+            ignoreSymlinks: typeof options.followSymlinks === 'boolean' ? !options.followSymlinks : undefined,
+            disregardIgnoreFiles: typeof options.useIgnoreFiles === 'boolean' ? !options.useIgnoreFiles : undefined,
+            disregardGlobalIgnoreFiles: typeof options.useGlobalIgnoreFiles === 'boolean' ? !options.useGlobalIgnoreFiles : undefined,
+            disregardParentIgnoreFiles: typeof options.useParentIgnoreFiles === 'boolean' ? !options.useParentIgnoreFiles : undefined,
+            disregardExcludeSettings: typeof options.useDefaultExcludes === 'boolean' ? !options.useDefaultExcludes : true,
+            fileEncoding: options.encoding,
+            maxResults: options.maxResults,
+            previewOptions,
+            afterContext: options.afterContext,
+            beforeContext: options.beforeContext,
+            includePattern: includePattern,
+            excludePattern: excludePattern
+        };
+        this._activeSearchCallbacks[requestId] = p => {
+            const uri = URI.revive(p.resource);
+            p.results.forEach(result => {
+                if (resultIsMatch(result)) {
+                    callback({
+                        uri,
+                        preview: {
+                            text: result.preview.text,
+                            matches: mapArrayOrNot(result.preview.matches, m =>  new Range$2(m.startLineNumber, m.startColumn, m.endLineNumber, m.endColumn))
+                        },
+                        ranges: mapArrayOrNot(result.ranges, r =>  new Range$2(r.startLineNumber, r.startColumn, r.endLineNumber, r.endColumn))
+                    });
+                }
+                else {
+                    callback({
+                        uri,
+                        text: result.text,
+                        lineNumber: result.lineNumber
+                    });
+                }
+            });
+        };
+        if (token.isCancellationRequested) {
+            return {};
+        }
+        try {
+            const result = await this._proxy.$startTextSearch(query, withUndefinedAsNull(folder), queryOptions, requestId, token);
+            delete this._activeSearchCallbacks[requestId];
+            return result || {};
+        }
+        catch (err) {
+            delete this._activeSearchCallbacks[requestId];
+            throw err;
+        }
+    }
+    $handleTextSearchResult(result, requestId) {
+        if (this._activeSearchCallbacks[requestId]) {
+            this._activeSearchCallbacks[requestId](result);
+        }
+    }
+    saveAll(includeUntitled) {
+        return this._proxy.$saveAll(includeUntitled);
+    }
+    resolveProxy(url) {
+        return this._proxy.$resolveProxy(url);
+    }
+    get trusted() {
+        return this._trusted;
+    }
+    requestWorkspaceTrust(options) {
+        return this._proxy.$requestWorkspaceTrust(options);
+    }
+    $onDidGrantWorkspaceTrust() {
+        if (!this._trusted) {
+            this._trusted = true;
+            this._onDidGrantWorkspaceTrust.fire();
+        }
+    }
+};
+ExtHostWorkspace =  __decorate([
+     __param(0, IExtHostRpcService),
+     __param(1, IExtHostInitDataService),
+     __param(2, IExtHostFileSystemInfo),
+     __param(3, ILogService)
+], ExtHostWorkspace);
+const IExtHostWorkspace =  createDecorator('IExtHostWorkspace');
+function parseSearchInclude(include) {
+    let includePattern;
+    let includeFolder;
+    if (include) {
+        if (typeof include === 'string') {
+            includePattern = include;
+        }
+        else {
+            includePattern = include.pattern;
+            includeFolder = URI.revive(include.baseUri);
+        }
+    }
+    return {
+        includePattern,
+        folder: includeFolder
+    };
+}
 function reviveIconPathUris(iconPath) {
     iconPath.dark = URI.revive(iconPath.dark);
     if (iconPath.light) {
@@ -13863,6 +14661,302 @@ class MainThreadDocumentRangeSemanticTokensProvider {
         throw new Error(`Unexpected`);
     }
 }
+function lookUp(tree, key) {
+    if (key) {
+        const parts = key.split('.');
+        let node = tree;
+        for (let i = 0; node && i < parts.length; i++) {
+            node = node[parts[i]];
+        }
+        return node;
+    }
+}
+function isUri(thing) {
+    return thing instanceof URI;
+}
+function isResourceLanguage(thing) {
+    return thing
+        && thing.uri instanceof URI
+        && (thing.languageId && typeof thing.languageId === 'string');
+}
+function isLanguage(thing) {
+    return thing
+        && !thing.uri
+        && (thing.languageId && typeof thing.languageId === 'string');
+}
+function isWorkspaceFolder(thing) {
+    return thing
+        && thing.uri instanceof URI
+        && (!thing.name || typeof thing.name === 'string')
+        && (!thing.index || typeof thing.index === 'number');
+}
+function scopeToOverrides(scope) {
+    if (isUri(scope)) {
+        return { resource: scope };
+    }
+    if (isResourceLanguage(scope)) {
+        return { resource: scope.uri, overrideIdentifier: scope.languageId };
+    }
+    if (isLanguage(scope)) {
+        return { overrideIdentifier: scope.languageId };
+    }
+    if (isWorkspaceFolder(scope)) {
+        return { resource: scope.uri };
+    }
+    if (scope === null) {
+        return { resource: null };
+    }
+    return undefined;
+}
+class ExtHostConfigProvider {
+    constructor(proxy, extHostWorkspace, data, logService) {
+        this._onDidChangeConfiguration =  new Emitter();
+        this._proxy = proxy;
+        this._logService = logService;
+        this._extHostWorkspace = extHostWorkspace;
+        this._configuration = Configuration.parse(data);
+        this._configurationScopes = this._toMap(data.configurationScopes);
+    }
+    get onDidChangeConfiguration() {
+        return this._onDidChangeConfiguration && this._onDidChangeConfiguration.event;
+    }
+    $acceptConfigurationChanged(data, change) {
+        const previous = { data: this._configuration.toData(), workspace: this._extHostWorkspace.workspace };
+        this._configuration = Configuration.parse(data);
+        this._configurationScopes = this._toMap(data.configurationScopes);
+        this._onDidChangeConfiguration.fire(this._toConfigurationChangeEvent(change, previous));
+    }
+    getConfiguration(section, scope, extensionDescription) {
+        const overrides = scopeToOverrides(scope) || {};
+        const config = this._toReadonlyValue(section
+            ? lookUp(this._configuration.getValue(undefined, overrides, this._extHostWorkspace.workspace), section)
+            : this._configuration.getValue(undefined, overrides, this._extHostWorkspace.workspace));
+        if (section) {
+            this._validateConfigurationAccess(section, overrides, extensionDescription?.identifier);
+        }
+        function parseConfigurationTarget(arg) {
+            if (arg === undefined || arg === null) {
+                return null;
+            }
+            if (typeof arg === 'boolean') {
+                return arg ? 1  : 4 ;
+            }
+            switch (arg) {
+                case ConfigurationTarget$1.Global: return 1 ;
+                case ConfigurationTarget$1.Workspace: return 4 ;
+                case ConfigurationTarget$1.WorkspaceFolder: return 5 ;
+            }
+        }
+        const result = {
+            has(key) {
+                return typeof lookUp(config, key) !== 'undefined';
+            },
+            get: (key, defaultValue) => {
+                this._validateConfigurationAccess(section ? `${section}.${key}` : key, overrides, extensionDescription?.identifier);
+                let result = lookUp(config, key);
+                if (typeof result === 'undefined') {
+                    result = defaultValue;
+                }
+                else {
+                    let clonedConfig = undefined;
+                    const cloneOnWriteProxy = (target, accessor) => {
+                        let clonedTarget = undefined;
+                        const cloneTarget = () => {
+                            clonedConfig = clonedConfig ? clonedConfig : deepClone(config);
+                            clonedTarget = clonedTarget ? clonedTarget : lookUp(clonedConfig, accessor);
+                        };
+                        return isObject(target) ?
+                             new Proxy(target, {
+                                get: (target, property) => {
+                                    if (typeof property === 'string' && property.toLowerCase() === 'tojson') {
+                                        cloneTarget();
+                                        return () => clonedTarget;
+                                    }
+                                    if (clonedConfig) {
+                                        clonedTarget = clonedTarget ? clonedTarget : lookUp(clonedConfig, accessor);
+                                        return clonedTarget[property];
+                                    }
+                                    const result = target[property];
+                                    if (typeof property === 'string') {
+                                        return cloneOnWriteProxy(result, `${accessor}.${property}`);
+                                    }
+                                    return result;
+                                },
+                                set: (_target, property, value) => {
+                                    cloneTarget();
+                                    if (clonedTarget) {
+                                        clonedTarget[property] = value;
+                                    }
+                                    return true;
+                                },
+                                deleteProperty: (_target, property) => {
+                                    cloneTarget();
+                                    if (clonedTarget) {
+                                        delete clonedTarget[property];
+                                    }
+                                    return true;
+                                },
+                                defineProperty: (_target, property, descriptor) => {
+                                    cloneTarget();
+                                    if (clonedTarget) {
+                                        Object.defineProperty(clonedTarget, property, descriptor);
+                                    }
+                                    return true;
+                                }
+                            }) : target;
+                    };
+                    result = cloneOnWriteProxy(result, key);
+                }
+                return result;
+            },
+            update: (key, value, extHostConfigurationTarget, scopeToLanguage) => {
+                key = section ? `${section}.${key}` : key;
+                const target = parseConfigurationTarget(extHostConfigurationTarget);
+                if (value !== undefined) {
+                    return this._proxy.$updateConfigurationOption(target, key, value, overrides, scopeToLanguage);
+                }
+                else {
+                    return this._proxy.$removeConfigurationOption(target, key, overrides, scopeToLanguage);
+                }
+            },
+            inspect: (key) => {
+                key = section ? `${section}.${key}` : key;
+                const config = deepClone(this._configuration.inspect(key, overrides, this._extHostWorkspace.workspace));
+                if (config) {
+                    return {
+                        key,
+                        defaultValue: config.default?.value,
+                        globalValue: config.user?.value,
+                        workspaceValue: config.workspace?.value,
+                        workspaceFolderValue: config.workspaceFolder?.value,
+                        defaultLanguageValue: config.default?.override,
+                        globalLanguageValue: config.user?.override,
+                        workspaceLanguageValue: config.workspace?.override,
+                        workspaceFolderLanguageValue: config.workspaceFolder?.override,
+                        languageIds: config.overrideIdentifiers
+                    };
+                }
+                return undefined;
+            }
+        };
+        if (typeof config === 'object') {
+            mixin(result, config, false);
+        }
+        return (
+             Object.freeze(result)
+        );
+    }
+    _toReadonlyValue(result) {
+        const readonlyProxy = (target) => {
+            return isObject(target) ?
+                 new Proxy(target, {
+                    get: (target, property) => readonlyProxy(target[property]),
+                    set: (_target, property, _value) => { throw new Error(`TypeError: Cannot assign to read only property '${String(property)}' of object`); },
+                    deleteProperty: (_target, property) => { throw new Error(`TypeError: Cannot delete read only property '${String(property)}' of object`); },
+                    defineProperty: (_target, property) => { throw new Error(`TypeError: Cannot define property '${String(property)}' for a readonly object`); },
+                    setPrototypeOf: (_target) => { throw new Error(`TypeError: Cannot set prototype for a readonly object`); },
+                    isExtensible: () => false,
+                    preventExtensions: () => true
+                }) : target;
+        };
+        return readonlyProxy(result);
+    }
+    _validateConfigurationAccess(key, overrides, extensionId) {
+        const scope = OVERRIDE_PROPERTY_REGEX$1.test(key) ? 4  : this._configurationScopes.get(key);
+        const extensionIdText = extensionId ? `[${extensionId.value}] ` : '';
+        if (4  === scope) {
+            if (typeof overrides?.resource === 'undefined') {
+                this._logService.warn(`${extensionIdText}Accessing a resource scoped configuration without providing a resource is not expected. To get the effective value for '${key}', provide the URI of a resource or 'null' for any resource.`);
+            }
+            return;
+        }
+        if (3  === scope) {
+            if (overrides?.resource) {
+                this._logService.warn(`${extensionIdText}Accessing a window scoped configuration for a resource is not expected. To associate '${key}' to a resource, define its scope to 'resource' in configuration contributions in 'package.json'.`);
+            }
+            return;
+        }
+    }
+    _toConfigurationChangeEvent(change, previous) {
+        const event =  new ConfigurationChangeEvent(change, previous, this._configuration, this._extHostWorkspace.workspace);
+        return (
+             Object.freeze({
+                affectsConfiguration: (section, scope) => event.affectsConfiguration(section, scopeToOverrides(scope))
+            })
+        );
+    }
+    _toMap(scopes) {
+        return scopes.reduce((result, scope) => { result.set(scope[0], scope[1]); return result; },  new Map());
+    }
+}
+let MainThreadConfiguration = class MainThreadConfiguration {
+    constructor(extHostContext, _workspaceContextService, configurationService, _environmentService) {
+        this._workspaceContextService = _workspaceContextService;
+        this.configurationService = configurationService;
+        this._environmentService = _environmentService;
+        const proxy = extHostContext.getProxy(ExtHostContext.ExtHostConfiguration);
+        proxy.$initializeConfiguration(this._getConfigurationData());
+        this._configurationListener = configurationService.onDidChangeConfiguration(e => {
+            proxy.$acceptConfigurationChanged(this._getConfigurationData(), e.change);
+        });
+    }
+    _getConfigurationData() {
+        const configurationData = { ...(this.configurationService.getConfigurationData()), configurationScopes: [] };
+        if (!this._environmentService.isBuilt || this._environmentService.isExtensionDevelopment) {
+            configurationData.configurationScopes = getScopes();
+        }
+        return configurationData;
+    }
+    dispose() {
+        this._configurationListener.dispose();
+    }
+    $updateConfigurationOption(target, key, value, overrides, scopeToLanguage) {
+        overrides = { resource: overrides?.resource ? URI.revive(overrides.resource) : undefined, overrideIdentifier: overrides?.overrideIdentifier };
+        return this.writeConfiguration(target, key, value, overrides, scopeToLanguage);
+    }
+    $removeConfigurationOption(target, key, overrides, scopeToLanguage) {
+        overrides = { resource: overrides?.resource ? URI.revive(overrides.resource) : undefined, overrideIdentifier: overrides?.overrideIdentifier };
+        return this.writeConfiguration(target, key, undefined, overrides, scopeToLanguage);
+    }
+    writeConfiguration(target, key, value, overrides, scopeToLanguage) {
+        target = target !== null && target !== undefined ? target : this.deriveConfigurationTarget(key, overrides);
+        const configurationValue = this.configurationService.inspect(key, overrides);
+        switch (target) {
+            case 7 :
+                return this._updateValue(key, value, target, configurationValue?.memory?.override, overrides, scopeToLanguage);
+            case 5 :
+                return this._updateValue(key, value, target, configurationValue?.workspaceFolder?.override, overrides, scopeToLanguage);
+            case 4 :
+                return this._updateValue(key, value, target, configurationValue?.workspace?.override, overrides, scopeToLanguage);
+            case 3 :
+                return this._updateValue(key, value, target, configurationValue?.userRemote?.override, overrides, scopeToLanguage);
+            default:
+                return this._updateValue(key, value, target, configurationValue?.userLocal?.override, overrides, scopeToLanguage);
+        }
+    }
+    _updateValue(key, value, configurationTarget, overriddenValue, overrides, scopeToLanguage) {
+        overrides = scopeToLanguage === true ? overrides
+            : scopeToLanguage === false ? { resource: overrides.resource }
+                : overrides.overrideIdentifier && overriddenValue !== undefined ? overrides
+                    : { resource: overrides.resource };
+        return this.configurationService.updateValue(key, value, overrides, configurationTarget, true);
+    }
+    deriveConfigurationTarget(key, overrides) {
+        if (overrides.resource && this._workspaceContextService.getWorkbenchState() === 3 ) {
+            const configurationProperties =  Registry.as(Extensions$1.Configuration).getConfigurationProperties();
+            if (configurationProperties[key] && ((configurationProperties[key].scope === 4  || configurationProperties[key].scope === 5) )) {
+                return 5 ;
+            }
+        }
+        return 4 ;
+    }
+};
+MainThreadConfiguration =  __decorate([
+    extHostNamedCustomer(MainContext.MainThreadConfiguration),
+     __param(1, IWorkspaceContextService),
+     __param(2, IConfigurationService),
+     __param(3, IEnvironmentService)
+], MainThreadConfiguration);
 const DEFAULT_EXTENSION = {
     identifier: new ExtensionIdentifier('monaco'),
     isBuiltin: true,
@@ -13917,6 +15011,28 @@ class MainThreadMessageServiceWithoutSource extends MainThreadMessageService {
         };
     }
 }
+let SyncExtHostConfiguration = class SyncExtHostConfiguration {
+    constructor(extHostRpc, extHostWorkspace, logService) {
+        this._proxy = extHostRpc.getProxy(MainContext.MainThreadConfiguration);
+        this._extHostWorkspace = extHostWorkspace;
+        this._logService = logService;
+        this._actual = null;
+    }
+    getConfigProvider() {
+        return this._actual;
+    }
+    $initializeConfiguration(data) {
+        this._actual = new ExtHostConfigProvider(this._proxy, this._extHostWorkspace, data, this._logService);
+    }
+    $acceptConfigurationChanged(data, change) {
+        this.getConfigProvider().$acceptConfigurationChanged(data, change);
+    }
+};
+SyncExtHostConfiguration = __decorate([
+    __param(0, IExtHostRpcService),
+    __param(1, IExtHostWorkspace),
+    __param(2, ILogService)
+], SyncExtHostConfiguration);
 function createExtHostServices() {
     const commandsService = StandaloneServices.get(ICommandService);
     const notificationService = StandaloneServices.get(INotificationService);
@@ -13948,6 +15064,7 @@ function createExtHostServices() {
     const languageConfigurationService = StandaloneServices.get(ILanguageConfigurationService);
     const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
     const configurationService = StandaloneServices.get(IConfigurationService);
+    const workspaceContextService = StandaloneServices.get(IWorkspaceContextService);
     const imessagePassingProtocol = new SimpleMessagePassingProtocol();
     const rpcProtocol = new RPCProtocol(imessagePassingProtocol);
     const extHostFileSystemInfo = new ExtHostFileSystemInfo();
@@ -13968,6 +15085,26 @@ function createExtHostServices() {
             return rpcProtocol.drain();
         }
     };
+    const initData = {
+        _serviceBrand: undefined,
+        version: '1.0.0',
+        parentPid: 0,
+        get environment() { return unsupported$1(); },
+        resolvedExtensions: [],
+        hostExtensions: [],
+        extensions: [Services.get().extension ?? DEFAULT_EXTENSION],
+        get telemetryInfo() { return unsupported$1(); },
+        logLevel: LogLevel$1.Trace,
+        get logsLocation() { return unsupported$1(); },
+        get logFile() { return unsupported$1(); },
+        autoStart: false,
+        remote: {
+            isRemote: false,
+            authority: undefined,
+            connectionData: null
+        },
+        uiKind: UIKind$1.Web
+    };
     const extHostLogService = new LogService(new ConsoleMainLogger());
     const extensionService = new NullExtensionService();
     const extHostApiDeprecationService = new ExtHostApiDeprecationService(mainContext, extHostLogService);
@@ -13987,6 +15124,8 @@ function createExtHostServices() {
     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());
     rpcProtocol.set(MainContext.MainThreadMessageService, new MainThreadMessageServiceWithoutSource(mainContext, notificationService, commandsService, dialogService));
     rpcProtocol.set(MainContext.MainThreadDiagnostics, new MonacoMainThreadDiagnostics(mainContext, markerService, uriIdentityService));
@@ -13998,6 +15137,7 @@ function createExtHostServices() {
     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.MainThreadConfiguration, new MainThreadConfiguration(mainContext, workspaceContextService, configurationService, workbenchEnvironmentService));
     new MainThreadDocumentsAndEditors(mainContext, modelService, textFileService, editorService, codeEditorService, fileService, textModelService, editorGroupsService, bulkEditService, paneCompositePartService, workbenchEnvironmentService, workingCopyFileService, uriIdentityService, clipboardService, pathService);
     const extHostBulkEdits = new ExtHostBulkEdits(mainContext, extHostDocumentsAndEditors);
     return {
@@ -14016,7 +15156,9 @@ function createExtHostServices() {
         extHostLanguages,
         extHostWindow,
         extHostClipboard,
-        extHostLanguageFeatures
+        extHostLanguageFeatures,
+        extHostWorkspace,
+        extHostConfiguration
     };
 }
 let extHostServices;
@@ -14298,24 +15440,14 @@ const workspace$1 = {
         return extHostBulkEdits.applyWorkspaceEdit(edit);
     },
     getConfiguration: (section, scope) => {
-        const { workspace } = Services.get();
-        if (workspace?.getConfiguration != null) {
-            return workspace.getConfiguration(section, scope);
-        }
-        return {
-            get: (section, defaultValue) => {
-                return defaultValue;
-            },
-            has: () => {
-                return false;
-            },
-            inspect: unsupported$1,
-            update: unsupported$1
-        };
+        const { extHostConfiguration } = getExtHostServices();
+        const configProvider = extHostConfiguration.getConfigProvider();
+        return configProvider.getConfiguration(section, scope, Services.get().extension ?? DEFAULT_EXTENSION);
     },
-    get onDidChangeConfiguration() {
-        const { workspace } = Services.get();
-        return workspace?.onDidChangeConfiguration ?? Event.None;
+    onDidChangeConfiguration(listener, thisArgs, disposables) {
+        const { extHostConfiguration } = getExtHostServices();
+        const configProvider = extHostConfiguration.getConfigProvider();
+        return configProvider.onDidChangeConfiguration(listener, thisArgs, disposables);
     },
     get rootPath() {
         const { workspace } = Services.get();
@@ -14442,6 +15574,31 @@ const workspace$1 = {
     onDidChangeNotebookDocument: unsupported$1,
     onDidSaveNotebookDocument: unsupported$1
 };
+class TextTabInput {
+    constructor(uri) {
+        this.uri = uri;
+    }
+}
+function getTabFromModel(model, tabGroup) {
+    return {
+        label: model.uri.fsPath,
+        group: tabGroup,
+        get isActive() { return model.isAttachedToEditor(); },
+        isDirty: false,
+        isPinned: false,
+        isPreview: false,
+        input: new TextTabInput(model.uri)
+    };
+}
+const tabGroup = {
+    isActive: true,
+    activeTab: undefined,
+    viewColumn: ViewColumn$2.One,
+    get tabs() {
+        const modelService = StandaloneServices.get(IModelService);
+        return modelService.getModels().map(model => getTabFromModel(model, tabGroup));
+    }
+};
 const window$2 = {
     showInformationMessage(message, ...rest) {
         const { extHostMessageService } = getExtHostServices();
@@ -14569,8 +15726,32 @@ const window$2 = {
     registerFileDecorationProvider: unsupported$1,
     registerTerminalProfileProvider: unsupported$1,
     onDidChangeTerminalState: Event.None,
-    get tabGroups() {
-        return unsupported$1();
+    tabGroups: {
+        get all() {
+            return [tabGroup];
+        },
+        activeTabGroup: tabGroup,
+        onDidChangeTabGroups: Event.None,
+        onDidChangeTabs(listener) {
+            const modelService = StandaloneServices.get(IModelService);
+            const store = new DisposableStore();
+            store.add(modelService.onModelAdded((model) => {
+                listener({
+                    opened: [getTabFromModel(model, tabGroup)],
+                    closed: [],
+                    changed: []
+                });
+            }));
+            store.add(modelService.onModelRemoved((model) => {
+                listener({
+                    opened: [],
+                    closed: [getTabFromModel(model, tabGroup)],
+                    changed: []
+                });
+            }));
+            return store;
+        },
+        close: unsupported$1
     }
 };
 const env$1 = {
@@ -14764,7 +15945,7 @@ const api = {
     DataTransferItem: unsupported,
     LanguageStatusSeverity: LanguageStatusSeverity$1,
     QuickPickItemKind: QuickPickItemKind$1,
-    TabInputText: unsupported,
+    TabInputText: TextTabInput,
     TabInputTextDiff: unsupported,
     TabInputCustom: unsupported,
     TabInputNotebook: unsupported,