@codingame/monaco-vscode-api 1.67.14 → 1.67.17

package/dist/api.js

@@ -1,39 +1,43 @@
-import { i as isStringArray, E as Emitter, u as unsupported$1 } from './missing-services-0f9c8f22.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-621e567e.js';
+import { E as Emitter, u as unsupported$1 } from './missing-services-597951f0.js';
+import { _ as __classPrivateFieldSet, a as __classPrivateFieldGet, b as __decorate, c as __param } from './tslib.es6-16b40665.js';
+import { c as coalesceInPlace, m as markAsFileSystemProviderError, F as FileSystemProviderErrorCode, S as SIDE_GROUP, A as ACTIVE_GROUP, C as CancellationTokenSource$1, d as delta$1, a as mapArrayOrNot, I as IProgressService, r as readonly, b as ITextFileService, e as IFileService, f as IWorkbenchEnvironmentService, g as IUriIdentityService, h as IWorkingCopyFileService, i as IPathService, j as disposed, k as IEditorService, l as IEditorGroupsService, n as IPaneCompositePartService, o as IProductService, p as ILanguageStatusService, q as IHostService, s as Services, t as FileType$1, u as FilePermission$1 } from './services-9299c4ca.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 { P as Position$3 } from './position-291dfe99.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-c7fd4178.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 { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.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 { Progress } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
@@ -66,6 +70,10 @@ 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';
@@ -81,7 +89,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 +281,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);
@@ -324,7 +688,7 @@ _Disposable_callOnDispose =  new WeakMap();
 Disposable$1 = Disposable_1 =  __decorate([
     es5ClassCompat
 ], Disposable$1);
-let Position$3 = Position_1 = class Position {
+let Position$2 = Position_1 = class Position {
     constructor(line, character) {
         if (line < 0) {
             throw illegalArgument('line must be non-negative');
@@ -485,20 +849,20 @@ let Position$3 = Position_1 = class Position {
         return { line: this.line, character: this.character };
     }
 };
-Position$3 = Position_1 =  __decorate([
+Position$2 = Position_1 =  __decorate([
     es5ClassCompat
-], Position$3);
+], Position$2);
 let Range$2 = 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$3(startLineOrStart, startColumnOrEnd);
-            end =  new Position$3(endLine, endColumn);
+            start =  new Position$2(startLineOrStart, startColumnOrEnd);
+            end =  new Position$2(endLine, endColumn);
         }
-        else if (Position$3.isPosition(startLineOrStart) && Position$3.isPosition(startColumnOrEnd)) {
-            start = Position$3.of(startLineOrStart);
-            end = Position$3.of(startColumnOrEnd);
+        else if (Position$2.isPosition(startLineOrStart) && Position$2.isPosition(startColumnOrEnd)) {
+            start = Position$2.of(startLineOrStart);
+            end = Position$2.of(startColumnOrEnd);
         }
         if (!start || !end) {
             throw new Error('Invalid arguments');
@@ -519,8 +883,8 @@ let Range$2 = Range_1 = class Range {
         if (!thing) {
             return false;
         }
-        return Position$3.isPosition(thing.start)
-            && Position$3.isPosition(thing.end);
+        return Position$2.isPosition(thing.start)
+            && Position$2.isPosition(thing.end);
     }
     static of(obj) {
         if (obj instanceof Range_1) {
@@ -544,8 +908,8 @@ let Range$2 = Range_1 = class Range {
             return this.contains(positionOrRange.start)
                 && this.contains(positionOrRange.end);
         }
-        else if (Position$3.isPosition(positionOrRange)) {
-            if (Position$3.of(positionOrRange).isBefore(this._start)) {
+        else if (Position$2.isPosition(positionOrRange)) {
+            if (Position$2.of(positionOrRange).isBefore(this._start)) {
                 return false;
             }
             if (this._end.isBefore(positionOrRange)) {
@@ -559,8 +923,8 @@ let Range$2 = Range_1 = class Range {
         return this._start.isEqual(other._start) && this._end.isEqual(other._end);
     }
     intersection(other) {
-        const start = Position$3.Max(other.start, this._start);
-        const end = Position$3.Min(other.end, this._end);
+        const start = Position$2.Max(other.start, this._start);
+        const end = Position$2.Min(other.end, this._end);
         if (start.isAfter(end)) {
             return undefined;
         }
@@ -575,8 +939,8 @@ let Range$2 = Range_1 = class Range {
         else if (other.contains(this)) {
             return other;
         }
-        const start = Position$3.Min(other.start, this._start);
-        const end = Position$3.Max(other.end, this.end);
+        const start = Position$2.Min(other.start, this._start);
+        const end = Position$2.Max(other.end, this.end);
         return (
              new Range_1(start, end)
         );
@@ -595,7 +959,7 @@ let Range$2 = Range_1 = class Range {
         if (!startOrChange) {
             start = this.start;
         }
-        else if (Position$3.isPosition(startOrChange)) {
+        else if (Position$2.isPosition(startOrChange)) {
             start = startOrChange;
         }
         else {
@@ -621,12 +985,12 @@ let Selection$3 = Selection_1 = class Selection extends Range$2 {
         let anchor;
         let active;
         if (typeof anchorLineOrAnchor === 'number' && typeof anchorColumnOrActive === 'number' && typeof activeLine === 'number' && typeof activeColumn === 'number') {
-            anchor =  new Position$3(anchorLineOrAnchor, anchorColumnOrActive);
-            active =  new Position$3(activeLine, activeColumn);
+            anchor =  new Position$2(anchorLineOrAnchor, anchorColumnOrActive);
+            active =  new Position$2(activeLine, activeColumn);
         }
-        else if (Position$3.isPosition(anchorLineOrAnchor) && Position$3.isPosition(anchorColumnOrActive)) {
-            anchor = Position$3.of(anchorLineOrAnchor);
-            active = Position$3.of(anchorColumnOrActive);
+        else if (Position$2.isPosition(anchorLineOrAnchor) && Position$2.isPosition(anchorColumnOrActive)) {
+            anchor = Position$2.of(anchorLineOrAnchor);
+            active = Position$2.of(anchorColumnOrActive);
         }
         if (!anchor || !active) {
             throw new Error('Invalid arguments');
@@ -643,8 +1007,8 @@ let Selection$3 = Selection_1 = class Selection extends Range$2 {
             return false;
         }
         return Range$2.isRange(thing)
-            && Position$3.isPosition(thing.anchor)
-            && Position$3.isPosition(thing.active)
+            && Position$2.isPosition(thing.anchor)
+            && Position$2.isPosition(thing.active)
             && typeof thing.isReversed === 'boolean';
     }
     get anchor() {
@@ -706,7 +1070,7 @@ let TextEdit$2 = TextEdit_1 = class TextEdit {
         return TextEdit_1.replace(range, '');
     }
     static setEndOfLine(eol) {
-        const ret =  new TextEdit_1( new Range$2( new Position$3(0, 0),  new Position$3(0, 0)), '');
+        const ret =  new TextEdit_1( new Range$2( new Position$2(0, 0),  new Position$2(0, 0)), '');
         ret.newEol = eol;
         return ret;
     }
@@ -953,7 +1317,7 @@ let Location$1 = Location_1 = class Location {
         else if (Range$2.isRange(rangeOrPosition)) {
             this.range = Range$2.of(rangeOrPosition);
         }
-        else if (Position$3.isPosition(rangeOrPosition)) {
+        else if (Position$2.isPosition(rangeOrPosition)) {
             this.range =  new Range$2(rangeOrPosition, rangeOrPosition);
         }
         else {
@@ -2895,8 +3259,8 @@ var Selection$2;
  (function(Selection) {
     function to(selection) {
         const { selectionStartLineNumber, selectionStartColumn, positionLineNumber, positionColumn } = selection;
-        const start = new Position$3(selectionStartLineNumber - 1, selectionStartColumn - 1);
-        const end = new Position$3(positionLineNumber - 1, positionColumn - 1);
+        const start = new Position$2(selectionStartLineNumber - 1, selectionStartColumn - 1);
+        const end = new Position$2(positionLineNumber - 1, positionColumn - 1);
         return new Selection$3(start, end);
     }
     Selection.to = to;
@@ -2947,17 +3311,17 @@ var TokenType;
     }
     TokenType.to = to;
 })(TokenType || (TokenType = {}));
-var Position$2;
+var Position$1;
  (function(Position) {
     function to(position) {
-        return new Position$3(position.lineNumber - 1, position.column - 1);
+        return new Position$2(position.lineNumber - 1, position.column - 1);
     }
     Position.to = to;
     function from(position) {
         return { lineNumber: position.line + 1, column: position.character + 1 };
     }
     Position.from = from;
-})(Position$2 || (Position$2 = {}));
+})(Position$1 || (Position$1 = {}));
 var DocumentSelector;
  (function(DocumentSelector) {
     function from(value, uriTransformer) {
@@ -4539,7 +4903,6 @@ class ConsoleMainLogger extends AbstractLogger {
     flush() {
     }
 }
-const Position$1 = monaco.Position;
 const IExtHostRpcService =  createDecorator('IExtHostRpcService');
 var _ExtHostCommands_proxy;
 let ExtHostCommands = class ExtHostCommands {
@@ -4566,8 +4929,8 @@ let ExtHostCommands = class ExtHostCommands {
                         if (Range$3.isIRange(obj)) {
                             return Range$1.to(obj);
                         }
-                        if (Position$1.isIPosition(obj)) {
-                            return Position$2.to(obj);
+                        if (Position$3.isIPosition(obj)) {
+                            return Position$1.to(obj);
                         }
                         if (Range$3.isIRange(obj.range) && URI.isUri(obj.uri)) {
                             return location.to(obj);
@@ -4638,8 +5001,8 @@ let ExtHostCommands = class ExtHostCommands {
         else {
             let hasBuffers = false;
             const toArgs = cloneAndChange(args, function (value) {
-                if (value instanceof Position$3) {
-                    return Position$2.from(value);
+                if (value instanceof Position$2) {
+                    return Position$1.from(value);
                 }
                 else if (value instanceof Range$2) {
                     return Range$1.from(value);
@@ -7138,7 +7501,7 @@ class ExtHostDocumentData extends MirrorTextModel {
     }
     _lineAt(lineOrPosition) {
         let line;
-        if (lineOrPosition instanceof Position$3) {
+        if (lineOrPosition instanceof Position$2) {
             line = lineOrPosition.line;
         }
         else if (typeof lineOrPosition === 'number') {
@@ -7163,7 +7526,7 @@ class ExtHostDocumentData extends MirrorTextModel {
         const out = this._lineStarts.getIndexOf(offset);
         const lineLength = this._lines[out.index].length;
         return (
-             new Position$3(out.index, Math.min(out.remainder, lineLength))
+             new Position$2(out.index, Math.min(out.remainder, lineLength))
         );
     }
     _validateRange(range) {
@@ -7180,7 +7543,7 @@ class ExtHostDocumentData extends MirrorTextModel {
         );
     }
     _validatePosition(position) {
-        if (!(position instanceof Position$3)) {
+        if (!(position instanceof Position$2)) {
             throw new Error('Invalid argument');
         }
         if (this._lines.length === 0) {
@@ -7213,7 +7576,7 @@ class ExtHostDocumentData extends MirrorTextModel {
             return position;
         }
         return (
-             new Position$3(line, character)
+             new Position$2(line, character)
         );
     }
     _getWordRangeAtPosition(_position, regexp) {
@@ -7935,6 +8298,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) {
@@ -8541,7 +9340,7 @@ class TextEditorEdit {
     replace(location, value) {
         this._throwIfFinalized();
         let range = null;
-        if (location instanceof Position$3) {
+        if (location instanceof Position$2) {
             range =  new Range$2(location, location);
         }
         else if (location instanceof Range$2) {
@@ -8818,8 +9617,8 @@ class ExtHostTextEditor {
                 if (!where || (Array.isArray(where) && where.length === 0)) {
                     ranges = that._selections.map(range => Range$1.from(range));
                 }
-                else if (where instanceof Position$3) {
-                    const { lineNumber, column } = Position$2.from(where);
+                else if (where instanceof Position$2) {
+                    const { lineNumber, column } = Position$1.from(where);
                     ranges = [{ startLineNumber: lineNumber, startColumn: column, endLineNumber: lineNumber, endColumn: column }];
                 }
                 else if (where instanceof Range$2) {
@@ -8832,7 +9631,7 @@ class ExtHostTextEditor {
                             ranges.push(Range$1.from(posOrRange));
                         }
                         else {
-                            const { lineNumber, column } = Position$2.from(posOrRange);
+                            const { lineNumber, column } = Position$1.from(posOrRange);
                             ranges.push({ startLineNumber: lineNumber, startColumn: column, endLineNumber: lineNumber, endColumn: column });
                         }
                     }
@@ -10807,7 +11606,7 @@ class ExtHostLanguages {
     }
     async tokenAtPosition(document, position) {
         const versionNow = document.version;
-        const pos = Position$2.from(position);
+        const pos = Position$1.from(position);
         const info = await this._proxy.$tokensAtPosition(document.uri, pos);
         const defaultRange = {
             type: StandardTokenType.Other,
@@ -11403,7 +12202,7 @@ class DefinitionAdapter {
     }
     async provideDefinition(resource, position, token) {
         const doc = this._documents.getDocument(resource);
-        const pos = Position$2.to(position);
+        const pos = Position$1.to(position);
         const value = await this._provider.provideDefinition(doc, pos, token);
         return convertToLocationLinks(value);
     }
@@ -11415,7 +12214,7 @@ class DeclarationAdapter {
     }
     async provideDeclaration(resource, position, token) {
         const doc = this._documents.getDocument(resource);
-        const pos = Position$2.to(position);
+        const pos = Position$1.to(position);
         const value = await this._provider.provideDeclaration(doc, pos, token);
         return convertToLocationLinks(value);
     }
@@ -11427,7 +12226,7 @@ class ImplementationAdapter {
     }
     async provideImplementation(resource, position, token) {
         const doc = this._documents.getDocument(resource);
-        const pos = Position$2.to(position);
+        const pos = Position$1.to(position);
         const value = await this._provider.provideImplementation(doc, pos, token);
         return convertToLocationLinks(value);
     }
@@ -11439,7 +12238,7 @@ class TypeDefinitionAdapter {
     }
     async provideTypeDefinition(resource, position, token) {
         const doc = this._documents.getDocument(resource);
-        const pos = Position$2.to(position);
+        const pos = Position$1.to(position);
         const value = await this._provider.provideTypeDefinition(doc, pos, token);
         return convertToLocationLinks(value);
     }
@@ -11451,7 +12250,7 @@ class HoverAdapter {
     }
     async provideHover(resource, position, token) {
         const doc = this._documents.getDocument(resource);
-        const pos = Position$2.to(position);
+        const pos = Position$1.to(position);
         const value = await this._provider.provideHover(doc, pos, token);
         if (!value || isFalsyOrEmpty(value.contents)) {
             return undefined;
@@ -11472,7 +12271,7 @@ class EvaluatableExpressionAdapter {
     }
     async provideEvaluatableExpression(resource, position, token) {
         const doc = this._documents.getDocument(resource);
-        const pos = Position$2.to(position);
+        const pos = Position$1.to(position);
         const value = await this._provider.provideEvaluatableExpression(doc, pos, token);
         if (value) {
             return EvaluatableExpression$1.from(value);
@@ -11501,7 +12300,7 @@ class DocumentHighlightAdapter {
     }
     async provideDocumentHighlights(resource, position, token) {
         const doc = this._documents.getDocument(resource);
-        const pos = Position$2.to(position);
+        const pos = Position$1.to(position);
         const value = await this._provider.provideDocumentHighlights(doc, pos, token);
         if (Array.isArray(value)) {
             return value.map(DocumentHighlight$1.from);
@@ -11516,7 +12315,7 @@ class LinkedEditingRangeAdapter {
     }
     async provideLinkedEditingRanges(resource, position, token) {
         const doc = this._documents.getDocument(resource);
-        const pos = Position$2.to(position);
+        const pos = Position$1.to(position);
         const value = await this._provider.provideLinkedEditingRanges(doc, pos, token);
         if (value && Array.isArray(value.ranges)) {
             return {
@@ -11534,7 +12333,7 @@ class ReferenceAdapter {
     }
     async provideReferences(resource, position, context, token) {
         const doc = this._documents.getDocument(resource);
-        const pos = Position$2.to(position);
+        const pos = Position$1.to(position);
         const value = await this._provider.provideReferences(doc, pos, context, token);
         if (Array.isArray(value)) {
             return value.map(location.from);
@@ -11678,7 +12477,7 @@ class OnTypeFormattingAdapter {
     }
     async provideOnTypeFormattingEdits(resource, position, ch, options, token) {
         const document = this._documents.getDocument(resource);
-        const pos = Position$2.to(position);
+        const pos = Position$1.to(position);
         const value = await this._provider.provideOnTypeFormattingEdits(document, pos, ch, options, token);
         if (Array.isArray(value)) {
             return value.map(TextEdit$1.from);
@@ -11744,7 +12543,7 @@ class RenameAdapter {
     }
     async provideRenameEdits(resource, position, newName, token) {
         const doc = this._documents.getDocument(resource);
-        const pos = Position$2.to(position);
+        const pos = Position$1.to(position);
         try {
             const value = await this._provider.provideRenameEdits(doc, pos, newName, token);
             if (!value) {
@@ -11767,7 +12566,7 @@ class RenameAdapter {
             return Promise.resolve(undefined);
         }
         const doc = this._documents.getDocument(resource);
-        const pos = Position$2.to(position);
+        const pos = Position$1.to(position);
         try {
             const rangeOrLocation = await this._provider.prepareRename(doc, pos, token);
             let range;
@@ -11975,7 +12774,7 @@ class SuggestAdapter {
     }
     async provideCompletionItems(resource, position, context, token) {
         const doc = this._documents.getDocument(resource);
-        const pos = Position$2.to(position);
+        const pos = Position$1.to(position);
         const replaceRange = doc.getWordRangeAtPosition(pos) ||  new Range$2(pos, pos);
         const insertRange = replaceRange.with({ end: pos });
         const sw =  new StopWatch(true);
@@ -12084,7 +12883,7 @@ class InlineCompletionAdapter {
     }
     async provideInlineCompletions(resource, position, context, token) {
         const doc = this._documents.getDocument(resource);
-        const pos = Position$2.to(position);
+        const pos = Position$1.to(position);
         const result = await this._provider.provideInlineCompletionItems(doc, pos, {
             selectedCompletionInfo: context.selectedSuggestionInfo
                 ? {
@@ -12173,7 +12972,7 @@ class SignatureHelpAdapter {
     }
     async provideSignatureHelp(resource, position, context, token) {
         const doc = this._documents.getDocument(resource);
-        const pos = Position$2.to(position);
+        const pos = Position$1.to(position);
         const vscodeContext = this.reviveContext(context);
         const value = await this._provider.provideSignatureHelp(doc, pos, token, vscodeContext);
         if (value) {
@@ -12275,7 +13074,7 @@ class InlayHintsAdapter {
             label: '',
             cacheId: id,
             tooltip: MarkdownString$1.fromStrict(hint.tooltip),
-            position: Position$2.from(hint.position),
+            position: Position$1.from(hint.position),
             kind: hint.kind && InlayHintKind$1.from(hint.kind),
             paddingLeft: hint.paddingLeft,
             paddingRight: hint.paddingRight,
@@ -12408,7 +13207,7 @@ class SelectionRangeAdapter {
     }
     async provideSelectionRanges(resource, pos, token) {
         const document = this._documents.getDocument(resource);
-        const positions = pos.map(Position$2.to);
+        const positions = pos.map(Position$1.to);
         const allProviderRanges = await this._provider.provideSelectionRanges(document, positions, token);
         if (!isNonEmptyArray(allProviderRanges)) {
             return [];
@@ -12447,7 +13246,7 @@ class CallHierarchyAdapter {
     }
     async prepareSession(uri, position, token) {
         const doc = this._documents.getDocument(uri);
-        const pos = Position$2.to(position);
+        const pos = Position$1.to(position);
         const items = await this._provider.prepareCallHierarchy(doc, pos, token);
         if (!items) {
             return undefined;
@@ -12516,7 +13315,7 @@ class TypeHierarchyAdapter {
     }
     async prepareSession(uri, position, token) {
         const doc = this._documents.getDocument(uri);
-        const pos = Position$2.to(position);
+        const pos = Position$1.to(position);
         const items = await this._provider.prepareTypeHierarchy(doc, pos, token);
         if (!items) {
             return undefined;
@@ -13863,6 +14662,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 +15012,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 +15065,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 +15086,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 +15125,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 +15138,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 +15157,9 @@ function createExtHostServices() {
         extHostLanguages,
         extHostWindow,
         extHostClipboard,
-        extHostLanguageFeatures
+        extHostLanguageFeatures,
+        extHostWorkspace,
+        extHostConfiguration
     };
 }
 let extHostServices;
@@ -14298,24 +15441,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 +15575,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 +15727,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 = {
@@ -14695,7 +15877,7 @@ const api = {
     MarkdownString: MarkdownString$2,
     OverviewRulerLane: OverviewRulerLane$1,
     ParameterInformation: ParameterInformation$2,
-    Position: Position$3,
+    Position: Position$2,
     ProcessExecution: ProcessExecution$1,
     ProgressLocation: ProgressLocation$2,
     QuickInputButtons: QuickInputButtons$1,
@@ -14764,7 +15946,7 @@ const api = {
     DataTransferItem: unsupported,
     LanguageStatusSeverity: LanguageStatusSeverity$1,
     QuickPickItemKind: QuickPickItemKind$1,
-    TabInputText: unsupported,
+    TabInputText: TextTabInput,
     TabInputTextDiff: unsupported,
     TabInputCustom: unsupported,
     TabInputNotebook: unsupported,