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

package/dist/polyfill.js

@@ -1,47 +1,54 @@
 import { VSBuffer as VSBuffer$1 } from 'monaco-editor/esm/vs/base/common/buffer.js';
-import { Disposable, DisposableStore, dispose, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { onUnexpectedError, ErrorHandler as ErrorHandler$1 } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { Disposable, DisposableMap as DisposableMap$1, DisposableStore, dispose as dispose$1, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ErrorHandler as ErrorHandler$1, illegalArgument, onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
 import { Themable as Themable$1 } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
 import { ProgressBar as ProgressBar$1 } from 'monaco-editor/esm/vs/base/browser/ui/progressbar/progressbar.js';
-import { mixin, equals, deepClone, deepFreeze } from 'monaco-editor/esm/vs/base/common/objects.js';
 import { RunOnceScheduler, timeout } from 'monaco-editor/esm/vs/base/common/async.js';
-import { show, hide, createStyleSheet } from 'monaco-editor/esm/vs/base/browser/dom.js';
-import { isNumber, isObject, isUndefinedOrNull } from 'monaco-editor/esm/vs/base/common/types.js';
-import { Color as Color$1, RGBA as RGBA$1 } from 'monaco-editor/esm/vs/base/common/color.js';
+import { show, hide, EventHelper, createStyleSheet, asCssValueWithDefault } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { isNumber, isObject as isObject$1, isUndefinedOrNull as isUndefinedOrNull$1 } from 'monaco-editor/esm/vs/base/common/types.js';
+import { E as Emitter, R as RawContextKey, e as NoOpNotification$1, _ as __decorate, a as __param } from './contextkey.js';
 import { LanguageService as LanguageService$1 } from 'monaco-editor/esm/vs/editor/common/services/languageService.js';
-import { E as Emitter, W as WorkspaceFolder, R as RawContextKey, e as NoOpNotification$1 } from './workspace.js';
 import { LanguagesRegistry as LanguagesRegistry$1 } from 'monaco-editor/esm/vs/editor/common/services/languagesRegistry.js';
-import { firstOrDefault, distinct, equals as equals$1, binarySearch, range } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { firstOrDefault, distinct, equals as equals$1, binarySearch, range, coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
 import { PLAINTEXT_LANGUAGE_ID, ModesRegistry } from 'monaco-editor/esm/vs/editor/common/languages/modesRegistry.js';
 import { TokenizationRegistry } from 'monaco-editor/esm/vs/editor/common/languages.js';
 import { NoOpNotification } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
 import { StandaloneConfigurationService as StandaloneConfigurationService$1 } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
 import { Configuration as Configuration$1, ConfigurationModel as ConfigurationModel$1, ConfigurationChangeEvent } from 'monaco-editor/esm/vs/platform/configuration/common/configurationModels.js';
-import { DefaultConfigurationModel } from 'monaco-editor/esm/vs/platform/configuration/common/configurations.js';
+import { DefaultConfiguration as DefaultConfiguration$1 } from 'monaco-editor/esm/vs/platform/configuration/common/configurations.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { TernarySearchTree as TernarySearchTree$1, ResourceMap as ResourceMap$1 } from 'monaco-editor/esm/vs/base/common/map.js';
+import { TernarySearchTree as TernarySearchTree$1 } from 'monaco-editor/esm/vs/base/common/ternarySearchTree.js';
 import { regExpLeadsToEndlessLoop, compareIgnoreCase, compareSubstring, compareSubstringIgnoreCase, compare as compare$1 } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
 import { Extensions as Extensions$2, overrideIdentifiersFromKey, OVERRIDE_PROPERTY_REGEX } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
-import { getConfigurationValue, addToValueTree, removeFromValueTree, toValuesTree } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { equals, deepClone, deepFreeze } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { getConfigurationValue, removeFromValueTree, addToValueTree, toValuesTree } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import { Event, EventBufferer } from 'monaco-editor/esm/vs/base/common/event.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
 import { RawContextKey as RawContextKey$1 } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
 import { clearPlatformLanguageAssociations, registerPlatformLanguageAssociation, getLanguageIds } from 'monaco-editor/esm/vs/editor/common/services/languagesAssociations.js';
 import { WorkspaceFolder as WorkspaceFolder$1 } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
 import { List as List$1 } from 'monaco-editor/esm/vs/base/browser/ui/list/listWidget.js';
-import { ListView } from 'monaco-editor/esm/vs/base/browser/ui/list/listView.js';
-import { CombinedSpliceable } from 'monaco-editor/esm/vs/base/browser/ui/list/splice.js';
-import { DomEmitter, stopEvent } from 'monaco-editor/esm/vs/base/browser/event.js';
+import { DomEmitter } from 'monaco-editor/esm/vs/base/browser/event.js';
 import { StandardKeyboardEvent } from 'monaco-editor/esm/vs/base/browser/keyboardEvent.js';
+import { CombinedSpliceable } from 'monaco-editor/esm/vs/base/browser/ui/list/splice.js';
+import { ListView } from 'monaco-editor/esm/vs/base/browser/ui/list/listView.js';
 import { ListError } from 'monaco-editor/esm/vs/base/browser/ui/list/list.js';
 import { clamp } from 'monaco-editor/esm/vs/base/common/numbers.js';
-import { isMacintosh, isWindows } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { isMacintosh } from 'monaco-editor/esm/vs/base/common/platform.js';
 import { alert } from 'monaco-editor/esm/vs/base/browser/ui/aria/aria.js';
 import { matchesPrefix } from 'monaco-editor/esm/vs/base/common/filters.js';
 import { Gesture } from 'monaco-editor/esm/vs/base/browser/touch.js';
-import { LogService as LogService$1 } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { Color as Color$1, RGBA as RGBA$1 } from 'monaco-editor/esm/vs/base/common/color.js';
+import { LogService as LogService$1 } from 'monaco-editor/esm/vs/platform/log/common/logService.js';
+import { MultiplexLogger, ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { SnippetParser } from 'monaco-editor/esm/vs/editor/contrib/snippet/browser/snippetParser.js';
-import { QuickInputController } from 'monaco-editor/esm/vs/base/parts/quickinput/browser/quickInput.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Keybinding as Keybinding$1, KeyCodeChord as KeyCodeChord$1 } from 'monaco-editor/esm/vs/base/common/keybindings.js';
+import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
+import { once } from 'monaco-editor/esm/vs/base/common/functional.js';
+import { QuickInputController } from 'monaco-editor/esm/vs/platform/quickinput/browser/quickInput.js';
 import { getSingletonServiceDescriptors } from 'monaco-editor/esm/vs/platform/instantiation/common/extensions.js';
 import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
 class ErrorHandler {
@@ -108,7 +115,7 @@ class NotImplementedError extends Error {
 class ErrorNoTelemetry extends Error {
     constructor(msg) {
         super(msg);
-        this.name = 'ErrorNoTelemetry';
+        this.name = 'CodeExpectedError';
     }
     static fromError(err) {
         if (err instanceof ErrorNoTelemetry) {
@@ -120,7 +127,118 @@ class ErrorNoTelemetry extends Error {
         return result;
     }
     static isErrorNoTelemetry(err) {
-        return err.name === 'ErrorNoTelemetry';
+        return err.name === 'CodeExpectedError';
+    }
+}
+function dispose(arg) {
+    if (Iterable.is(arg)) {
+        const errors = [];
+        for (const d of arg) {
+            if (d) {
+                try {
+                    d.dispose();
+                }
+                catch (e) {
+                    errors.push(e);
+                }
+            }
+        }
+        if (errors.length === 1) {
+            throw errors[0];
+        }
+        else if (errors.length > 1) {
+            throw new AggregateError(errors, 'Encountered errors while disposing of store');
+        }
+        return Array.isArray(arg) ? [] : arg;
+    }
+    else if (arg) {
+        arg.dispose();
+        return arg;
+    }
+}
+class ReferenceCollection {
+    constructor() {
+        this.references = ( (new Map()));
+    }
+    acquire(key, ...args) {
+        let reference = this.references.get(key);
+        if (!reference) {
+            reference = { counter: 0, object: this.createReferencedObject(key, ...args) };
+            this.references.set(key, reference);
+        }
+        const { object } = reference;
+        const dispose = once(() => {
+            if (--reference.counter === 0) {
+                this.destroyReferencedObject(key, reference.object);
+                this.references.delete(key);
+            }
+        });
+        reference.counter++;
+        return { object, dispose };
+    }
+}
+class AsyncReferenceCollection {
+    constructor(referenceCollection) {
+        this.referenceCollection = referenceCollection;
+    }
+    async acquire(key, ...args) {
+        const ref = this.referenceCollection.acquire(key, ...args);
+        try {
+            const object = await ref.object;
+            return {
+                object,
+                dispose: () => ref.dispose()
+            };
+        }
+        catch (error) {
+            ref.dispose();
+            throw error;
+        }
+    }
+}
+class DisposableMap {
+    constructor() {
+        this._store = ( (new Map()));
+        this._isDisposed = false;
+    }
+    dispose() {
+        this._isDisposed = true;
+        this.clearAndDisposeAll();
+    }
+    clearAndDisposeAll() {
+        if (!this._store.size) {
+            return;
+        }
+        try {
+            dispose(( (this._store.values())));
+        }
+        finally {
+            this._store.clear();
+        }
+    }
+    has(key) {
+        return this._store.has(key);
+    }
+    get(key) {
+        return this._store.get(key);
+    }
+    set(key, value, skipDisposeOnOverwrite = false) {
+        if (this._isDisposed) {
+            console.warn(( (new Error(
+                'Trying to add a disposable to a DisposableMap that has already been disposed of. The added object will be leaked!'
+            ))).stack);
+        }
+        if (!skipDisposeOnOverwrite) {
+            this._store.get(key)?.dispose();
+        }
+        this._store.set(key, value);
+    }
+    deleteAndDispose(key) {
+        this._store.get(key)?.dispose();
+        this._store.delete(key);
+    }
+    [Symbol.iterator]() {
+        return this._store[Symbol.iterator]();
     }
 }
 function isReadableStream(obj) {
@@ -452,10 +570,6 @@ const hasBuffer = (typeof Buffer !== 'undefined');
 let textEncoder;
 let textDecoder;
 class VSBuffer {
-    constructor(buffer) {
-        this.buffer = buffer;
-        this.byteLength = this.buffer.byteLength;
-    }
     static alloc(byteLength) {
         if (hasBuffer) {
             return (
@@ -515,6 +629,10 @@ class VSBuffer {
         }
         return ret;
     }
+    constructor(buffer) {
+        this.buffer = buffer;
+        this.byteLength = this.buffer.byteLength;
+    }
     clone() {
         const result = VSBuffer.alloc(this.byteLength);
         result.set(this);
@@ -631,6 +749,87 @@ async function bufferedStreamToBuffer(bufferedStream) {
 function newWriteableBufferStream(options) {
     return newWriteableStream(chunks => VSBuffer.concat(chunks), options);
 }
+const base64Alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const base64UrlSafeAlphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+function encodeBase64({ buffer }, padded = true, urlSafe = false) {
+    const dictionary = urlSafe ? base64UrlSafeAlphabet : base64Alphabet;
+    let output = '';
+    const remainder = buffer.byteLength % 3;
+    let i = 0;
+    for (; i < buffer.byteLength - remainder; i += 3) {
+        const a = buffer[i + 0];
+        const b = buffer[i + 1];
+        const c = buffer[i + 2];
+        output += dictionary[a >>> 2];
+        output += dictionary[(a << 4 | b >>> 4) & 0b111111];
+        output += dictionary[(b << 2 | c >>> 6) & 0b111111];
+        output += dictionary[c & 0b111111];
+    }
+    if (remainder === 1) {
+        const a = buffer[i + 0];
+        output += dictionary[a >>> 2];
+        output += dictionary[(a << 4) & 0b111111];
+        if (padded) {
+            output += '==';
+        }
+    }
+    else if (remainder === 2) {
+        const a = buffer[i + 0];
+        const b = buffer[i + 1];
+        output += dictionary[a >>> 2];
+        output += dictionary[(a << 4 | b >>> 4) & 0b111111];
+        output += dictionary[(b << 2) & 0b111111];
+        if (padded) {
+            output += '=';
+        }
+    }
+    return output;
+}
+function isString(str) {
+    return (typeof str === 'string');
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every(elem => isString(elem));
+}
+function isObject(obj) {
+    return typeof obj === 'object'
+        && obj !== null
+        && !Array.isArray(obj)
+        && !(obj instanceof RegExp)
+        && !(obj instanceof Date);
+}
+function isUndefined(obj) {
+    return (typeof obj === 'undefined');
+}
+function isUndefinedOrNull(obj) {
+    return (isUndefined(obj) || obj === null);
+}
+function assertAllDefined(...args) {
+    const result = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (isUndefinedOrNull(arg)) {
+            throw new Error(`Assertion Failed: argument at index ${i} is undefined or null`);
+        }
+        result.push(arg);
+    }
+    return result;
+}
+const hasOwnProperty$1 = Object.prototype.hasOwnProperty;
+function isEmptyObject(obj) {
+    if (!isObject(obj)) {
+        return false;
+    }
+    for (const key in obj) {
+        if (hasOwnProperty$1.call(obj, key)) {
+            return false;
+        }
+    }
+    return true;
+}
+function withUndefinedAsNull(x) {
+    return typeof x === 'undefined' ? null : x;
+}
 const Extensions$1 = {
     ThemingContribution: 'base.contributions.theming'
 };
@@ -658,29 +857,26 @@ class Themable extends Disposable {
 const Extensions = {
     JSONContribution: 'base.contributions.json'
 };
+var e=[],t=[];function n(n,r){if(n&&"undefined"!=typeof document){var a,s=!0===r.prepend?"prepend":"append",d=!0===r.singleTag,i="string"==typeof r.container?document.querySelector(r.container):document.getElementsByTagName("head")[0];if(d){var u=e.indexOf(i);-1===u&&(u=e.push(i)-1,t[u]={}),a=t[u]&&t[u][s]?t[u][s]:t[u][s]=c();}else a=c();65279===n.charCodeAt(0)&&(n=n.substring(1)),a.styleSheet?a.styleSheet.cssText+=n:a.appendChild(document.createTextNode(n));}function c(){var e=document.createElement("style");if(e.setAttribute("type","text/css"),r.attributes)for(var t=( Object.keys(r.attributes)),n=0;n<t.length;n++)e.setAttribute(t[n],r.attributes[t[n]]);var a="prepend"===s?"afterbegin":"beforeend";return i.insertAdjacentElement(a,e),e}}
+var css$1 = ".monaco-progress-container{height:5px;overflow:hidden;width:100%}.monaco-progress-container .progress-bit{display:none;height:5px;left:0;position:absolute;width:2%}.monaco-progress-container.active .progress-bit{display:inherit}.monaco-progress-container.discrete .progress-bit{left:0;transition:width .1s linear}.monaco-progress-container.discrete.done .progress-bit{width:100%}.monaco-progress-container.infinite .progress-bit{animation-duration:4s;animation-iteration-count:infinite;animation-name:progress;animation-timing-function:linear;transform:translateZ(0)}.monaco-progress-container.infinite.infinite-long-running .progress-bit{animation-timing-function:steps(100)}@keyframes progress{0%{transform:translateX(0) scaleX(1)}50%{transform:translateX(2500%) scaleX(3)}to{transform:translateX(4900%) scaleX(1)}}";
+n(css$1,{});
 const CSS_DONE = 'done';
 const CSS_ACTIVE = 'active';
 const CSS_INFINITE = 'infinite';
 const CSS_INFINITE_LONG_RUNNING = 'infinite-long-running';
 const CSS_DISCRETE = 'discrete';
-const defaultOpts = {
-    progressBarBackground: ( (Color$1.fromHex('#0E70C0')))
-};
 class ProgressBar extends Disposable {
     constructor(container, options) {
         super();
-        this.options = options || Object.create(null);
-        mixin(this.options, defaultOpts, false);
         this.workedVal = 0;
-        this.progressBarBackground = this.options.progressBarBackground;
         this.showDelayedScheduler = this._register(( (new RunOnceScheduler(() => show(this.element), 0))));
         this.longRunningScheduler = this._register(( (new RunOnceScheduler(
             () => this.infiniteLongRunning(),
             ProgressBar.LONG_RUNNING_INFINITE_THRESHOLD
         ))));
-        this.create(container);
+        this.create(container, options);
     }
-    create(container) {
+    create(container, options) {
         this.element = document.createElement('div');
         this.element.classList.add('monaco-progress-container');
         this.element.setAttribute('role', 'progressbar');
@@ -688,8 +884,8 @@ class ProgressBar extends Disposable {
         container.appendChild(this.element);
         this.bit = document.createElement('div');
         this.bit.classList.add('progress-bit');
+        this.bit.style.backgroundColor = options?.progressBarBackground || '#0E70C0';
         this.element.appendChild(this.bit);
-        this.applyStyles();
     }
     off() {
         this.bit.style.width = 'inherit';
@@ -781,16 +977,6 @@ class ProgressBar extends Disposable {
         hide(this.element);
         this.showDelayedScheduler.cancel();
     }
-    style(styles) {
-        this.progressBarBackground = styles.progressBarBackground;
-        this.applyStyles();
-    }
-    applyStyles() {
-        if (this.bit) {
-            const background = this.progressBarBackground ? ( (this.progressBarBackground.toString())) : '';
-            this.bit.style.backgroundColor = background;
-        }
-    }
 }
 ProgressBar.LONG_RUNNING_INFINITE_THRESHOLD = 10000;
 function sortedDiff(before, after, compare) {
@@ -847,16 +1033,6 @@ function delta(before, after, compare) {
     }
     return { removed, added };
 }
-function coalesceInPlace(array) {
-    let to = 0;
-    for (let i = 0; i < array.length; i++) {
-        if (!!array[i]) {
-            array[to] = array[i];
-            to += 1;
-        }
-    }
-    array.length = to;
-}
 function flatten(arr) {
     return [].concat(...arr);
 }
@@ -1009,7 +1185,7 @@ class LanguageSelection {
         }
         if (!this._emitter) {
             this._emitter = ( (new Emitter({
-                onLastListenerRemove: () => {
+                onDidRemoveLastListener: () => {
                     this._dispose();
                 }
             })));
@@ -1737,1733 +1913,1814 @@ function getNodeType(value) {
         default: return 'null';
     }
 }
-var _a$1, _b$1;
-class StringIterator {
-    constructor() {
-        this._value = '';
-        this._pos = 0;
+function freeze(data) {
+    return Object.isFrozen(data) ? data : deepFreeze(data);
+}
+class ConfigurationModel {
+    constructor(_contents = {}, _keys = [], _overrides = [], raw) {
+        this._contents = _contents;
+        this._keys = _keys;
+        this._overrides = _overrides;
+        this.raw = raw;
+        this.overrideConfigurations = ( (new Map()));
     }
-    reset(key) {
-        this._value = key;
-        this._pos = 0;
-        return this;
+    get rawConfiguration() {
+        if (!this._rawConfiguration) {
+            if (this.raw?.length) {
+                const rawConfigurationModels = this.raw.map(raw => {
+                    if (raw instanceof ConfigurationModel) {
+                        return raw;
+                    }
+                    const parser = ( (new ConfigurationModelParser('')));
+                    parser.parseRaw(raw);
+                    return parser.configurationModel;
+                });
+                this._rawConfiguration = rawConfigurationModels.reduce((previous, current) => current === previous ? current : previous.merge(current), rawConfigurationModels[0]);
+            }
+            else {
+                this._rawConfiguration = this;
+            }
+        }
+        return this._rawConfiguration;
     }
-    next() {
-        this._pos += 1;
-        return this;
+    get contents() {
+        return this._contents;
     }
-    hasNext() {
-        return this._pos < this._value.length - 1;
+    get overrides() {
+        return this._overrides;
     }
-    cmp(a) {
-        const aCode = a.charCodeAt(0);
-        const thisCode = this._value.charCodeAt(this._pos);
-        return aCode - thisCode;
+    get keys() {
+        return this._keys;
     }
-    value() {
-        return this._value[this._pos];
+    isEmpty() {
+        return this._keys.length === 0 && ( (Object.keys(this._contents))).length === 0 && this._overrides.length === 0;
     }
-}
-class ConfigKeysIterator {
-    constructor(_caseSensitive = true) {
-        this._caseSensitive = _caseSensitive;
+    getValue(section) {
+        return section ? getConfigurationValue(this.contents, section) : this.contents;
     }
-    reset(key) {
-        this._value = key;
-        this._from = 0;
-        this._to = 0;
-        return this.next();
+    inspect(section, overrideIdentifier) {
+        const value = this.rawConfiguration.getValue(section);
+        const override = overrideIdentifier ? this.rawConfiguration.getOverrideValue(section, overrideIdentifier) : undefined;
+        const merged = overrideIdentifier ? this.rawConfiguration.override(overrideIdentifier).getValue(section) : value;
+        return { value, override, merged };
     }
-    hasNext() {
-        return this._to < this._value.length;
+    getOverrideValue(section, overrideIdentifier) {
+        const overrideContents = this.getContentsForOverrideIdentifer(overrideIdentifier);
+        return overrideContents
+            ? section ? getConfigurationValue(overrideContents, section) : overrideContents
+            : undefined;
     }
-    next() {
-        this._from = this._to;
-        let justSeps = true;
-        for (; this._to < this._value.length; this._to++) {
-            const ch = this._value.charCodeAt(this._to);
-            if (ch === 46 ) {
-                if (justSeps) {
-                    this._from++;
-                }
-                else {
-                    break;
-                }
-            }
-            else {
-                justSeps = false;
+    getKeysForOverrideIdentifier(identifier) {
+        const keys = [];
+        for (const override of this.overrides) {
+            if (override.identifiers.includes(identifier)) {
+                keys.push(...override.keys);
             }
         }
-        return this;
-    }
-    cmp(a) {
-        return this._caseSensitive
-            ? compareSubstring(a, this._value, 0, a.length, this._from, this._to)
-            : compareSubstringIgnoreCase(a, this._value, 0, a.length, this._from, this._to);
-    }
-    value() {
-        return this._value.substring(this._from, this._to);
-    }
-}
-class PathIterator {
-    constructor(_splitOnBackslash = true, _caseSensitive = true) {
-        this._splitOnBackslash = _splitOnBackslash;
-        this._caseSensitive = _caseSensitive;
+        return distinct(keys);
     }
-    reset(key) {
-        this._from = 0;
-        this._to = 0;
-        this._value = key;
-        this._valueLen = key.length;
-        for (let pos = key.length - 1; pos >= 0; pos--, this._valueLen--) {
-            const ch = this._value.charCodeAt(pos);
-            if (!((ch === 47  || this._splitOnBackslash && ch === 92) )) {
-                break;
-            }
+    getAllOverrideIdentifiers() {
+        const result = [];
+        for (const override of this.overrides) {
+            result.push(...override.identifiers);
         }
-        return this.next();
+        return distinct(result);
     }
-    hasNext() {
-        return this._to < this._valueLen;
+    override(identifier) {
+        let overrideConfigurationModel = this.overrideConfigurations.get(identifier);
+        if (!overrideConfigurationModel) {
+            overrideConfigurationModel = this.createOverrideConfigurationModel(identifier);
+            this.overrideConfigurations.set(identifier, overrideConfigurationModel);
+        }
+        return overrideConfigurationModel;
     }
-    next() {
-        this._from = this._to;
-        let justSeps = true;
-        for (; this._to < this._valueLen; this._to++) {
-            const ch = this._value.charCodeAt(this._to);
-            if (ch === 47  || this._splitOnBackslash && ch === 92 ) {
-                if (justSeps) {
-                    this._from++;
+    merge(...others) {
+        const contents = deepClone(this.contents);
+        const overrides = deepClone(this.overrides);
+        const keys = [...this.keys];
+        const raws = this.raw?.length ? [...this.raw] : [this];
+        for (const other of others) {
+            raws.push(...(other.raw?.length ? other.raw : [other]));
+            if (other.isEmpty()) {
+                continue;
+            }
+            this.mergeContents(contents, other.contents);
+            for (const otherOverride of other.overrides) {
+                const [override] = overrides.filter(o => equals$1(o.identifiers, otherOverride.identifiers));
+                if (override) {
+                    this.mergeContents(override.contents, otherOverride.contents);
+                    override.keys.push(...otherOverride.keys);
+                    override.keys = distinct(override.keys);
                 }
                 else {
-                    break;
+                    overrides.push(deepClone(otherOverride));
                 }
             }
-            else {
-                justSeps = false;
+            for (const key of other.keys) {
+                if (keys.indexOf(key) === -1) {
+                    keys.push(key);
+                }
             }
         }
-        return this;
-    }
-    cmp(a) {
-        return this._caseSensitive
-            ? compareSubstring(a, this._value, 0, a.length, this._from, this._to)
-            : compareSubstringIgnoreCase(a, this._value, 0, a.length, this._from, this._to);
-    }
-    value() {
-        return this._value.substring(this._from, this._to);
-    }
-}
-class UriIterator {
-    constructor(_ignorePathCasing, _ignoreQueryAndFragment) {
-        this._ignorePathCasing = _ignorePathCasing;
-        this._ignoreQueryAndFragment = _ignoreQueryAndFragment;
-        this._states = [];
-        this._stateIdx = 0;
+        return (
+             (new ConfigurationModel(
+                contents,
+                keys,
+                overrides,
+                raws.every(raw => raw instanceof ConfigurationModel) ? undefined : raws
+            ))
+        );
     }
-    reset(key) {
-        this._value = key;
-        this._states = [];
-        if (this._value.scheme) {
-            this._states.push(1 );
+    createOverrideConfigurationModel(identifier) {
+        const overrideContents = this.getContentsForOverrideIdentifer(identifier);
+        if (!overrideContents || typeof overrideContents !== 'object' || !( (Object.keys(overrideContents))).length) {
+            return this;
         }
-        if (this._value.authority) {
-            this._states.push(2 );
+        const contents = {};
+        for (const key of distinct([...( (Object.keys(this.contents))), ...( (Object.keys(overrideContents)))])) {
+            let contentsForKey = this.contents[key];
+            const overrideContentsForKey = overrideContents[key];
+            if (overrideContentsForKey) {
+                if (typeof contentsForKey === 'object' && typeof overrideContentsForKey === 'object') {
+                    contentsForKey = deepClone(contentsForKey);
+                    this.mergeContents(contentsForKey, overrideContentsForKey);
+                }
+                else {
+                    contentsForKey = overrideContentsForKey;
+                }
+            }
+            contents[key] = contentsForKey;
         }
-        if (this._value.path) {
-            this._pathIterator = ( (new PathIterator(false, !this._ignorePathCasing(key))));
-            this._pathIterator.reset(key.path);
-            if (this._pathIterator.value()) {
-                this._states.push(3 );
+        return (
+             (new ConfigurationModel(contents, this.keys, this.overrides))
+        );
+    }
+    mergeContents(source, target) {
+        for (const key of ( (Object.keys(target)))) {
+            if (key in source) {
+                if (isObject$1(source[key]) && isObject$1(target[key])) {
+                    this.mergeContents(source[key], target[key]);
+                    continue;
+                }
             }
+            source[key] = deepClone(target[key]);
         }
-        if (!this._ignoreQueryAndFragment(key)) {
-            if (this._value.query) {
-                this._states.push(4 );
+    }
+    getContentsForOverrideIdentifer(identifier) {
+        let contentsForIdentifierOnly = null;
+        let contents = null;
+        const mergeContents = (contentsToMerge) => {
+            if (contentsToMerge) {
+                if (contents) {
+                    this.mergeContents(contents, contentsToMerge);
+                }
+                else {
+                    contents = deepClone(contentsToMerge);
+                }
             }
-            if (this._value.fragment) {
-                this._states.push(5 );
+        };
+        for (const override of this.overrides) {
+            if (equals$1(override.identifiers, [identifier])) {
+                contentsForIdentifierOnly = override.contents;
+            }
+            else if (override.identifiers.includes(identifier)) {
+                mergeContents(override.contents);
             }
         }
-        this._stateIdx = 0;
-        return this;
+        mergeContents(contentsForIdentifierOnly);
+        return contents;
     }
-    next() {
-        if (this._states[this._stateIdx] === 3  && this._pathIterator.hasNext()) {
-            this._pathIterator.next();
-        }
-        else {
-            this._stateIdx += 1;
-        }
-        return this;
+    toJSON() {
+        return {
+            contents: this.contents,
+            overrides: this.overrides,
+            keys: this.keys
+        };
     }
-    hasNext() {
-        return (this._states[this._stateIdx] === 3  && this._pathIterator.hasNext())
-            || this._stateIdx < this._states.length - 1;
+    addValue(key, value) {
+        this.updateValue(key, value, true);
     }
-    cmp(a) {
-        if (this._states[this._stateIdx] === 1 ) {
-            return compareIgnoreCase(a, this._value.scheme);
-        }
-        else if (this._states[this._stateIdx] === 2 ) {
-            return compareIgnoreCase(a, this._value.authority);
-        }
-        else if (this._states[this._stateIdx] === 3 ) {
-            return this._pathIterator.cmp(a);
-        }
-        else if (this._states[this._stateIdx] === 4 ) {
-            return compare$1(a, this._value.query);
-        }
-        else if (this._states[this._stateIdx] === 5 ) {
-            return compare$1(a, this._value.fragment);
-        }
-        throw new Error();
+    setValue(key, value) {
+        this.updateValue(key, value, false);
     }
-    value() {
-        if (this._states[this._stateIdx] === 1 ) {
-            return this._value.scheme;
-        }
-        else if (this._states[this._stateIdx] === 2 ) {
-            return this._value.authority;
+    removeValue(key) {
+        const index = this.keys.indexOf(key);
+        if (index === -1) {
+            return;
         }
-        else if (this._states[this._stateIdx] === 3 ) {
-            return this._pathIterator.value();
+        this.keys.splice(index, 1);
+        removeFromValueTree(this.contents, key);
+        if (OVERRIDE_PROPERTY_REGEX.test(key)) {
+            this.overrides.splice(this.overrides.findIndex(o => equals$1(o.identifiers, overrideIdentifiersFromKey(key))), 1);
         }
-        else if (this._states[this._stateIdx] === 4 ) {
-            return this._value.query;
+    }
+    updateValue(key, value, add) {
+        addToValueTree(this.contents, key, value, e => console.error(e));
+        add = add || this.keys.indexOf(key) === -1;
+        if (add) {
+            this.keys.push(key);
         }
-        else if (this._states[this._stateIdx] === 5 ) {
-            return this._value.fragment;
+        if (OVERRIDE_PROPERTY_REGEX.test(key)) {
+            this.overrides.push({
+                identifiers: overrideIdentifiersFromKey(key),
+                keys: ( (Object.keys(this.contents[key]))),
+                contents: toValuesTree(this.contents[key], message => console.error(message)),
+            });
         }
-        throw new Error();
     }
 }
-class TernarySearchTreeNode {
-    constructor() {
-        this.height = 1;
-    }
-    isEmpty() {
-        return !this.left && !this.mid && !this.right && !this.value;
-    }
-    rotateLeft() {
-        const tmp = this.right;
-        this.right = tmp.left;
-        tmp.left = this;
-        this.updateHeight();
-        tmp.updateHeight();
-        return tmp;
-    }
-    rotateRight() {
-        const tmp = this.left;
-        this.left = tmp.right;
-        tmp.right = this;
-        this.updateHeight();
-        tmp.updateHeight();
-        return tmp;
-    }
-    updateHeight() {
-        this.height = 1 + Math.max(this.heightLeft, this.heightRight);
-    }
-    balanceFactor() {
-        return this.heightRight - this.heightLeft;
-    }
-    get heightLeft() {
-        return this.left?.height ?? 0;
-    }
-    get heightRight() {
-        return this.right?.height ?? 0;
+class ConfigurationModelParser {
+    constructor(_name) {
+        this._name = _name;
+        this._raw = null;
+        this._configurationModel = null;
+        this._restrictedConfigurations = [];
+        this._parseErrors = [];
     }
-}
-class TernarySearchTree {
-    constructor(segments) {
-        this._iter = segments;
+    get configurationModel() {
+        return this._configurationModel || ( (new ConfigurationModel()));
     }
-    static forUris(ignorePathCasing = () => false, ignoreQueryAndFragment = () => false) {
-        return (
-             (new TernarySearchTree( (new UriIterator(ignorePathCasing, ignoreQueryAndFragment))))
-        );
+    get restrictedConfigurations() {
+        return this._restrictedConfigurations;
     }
-    static forPaths(ignorePathCasing = false) {
-        return (
-             (new TernarySearchTree( (new PathIterator(undefined, !ignorePathCasing))))
-        );
+    get errors() {
+        return this._parseErrors;
     }
-    static forStrings() {
-        return (
-             (new TernarySearchTree( (new StringIterator())))
-        );
+    parse(content, options) {
+        if (!isUndefinedOrNull$1(content)) {
+            const raw = this.doParseContent(content);
+            this.parseRaw(raw, options);
+        }
     }
-    static forConfigKeys() {
-        return (
-             (new TernarySearchTree( (new ConfigKeysIterator())))
-        );
+    reparse(options) {
+        if (this._raw) {
+            this.parseRaw(this._raw, options);
+        }
     }
-    clear() {
-        this._root = undefined;
+    parseRaw(raw, options) {
+        this._raw = raw;
+        const { contents, keys, overrides, restricted, hasExcludedProperties } = this.doParseRaw(raw, options);
+        this._configurationModel = ( (new ConfigurationModel(
+            contents,
+            keys,
+            overrides,
+            hasExcludedProperties ? [raw] : undefined
+        )));
+        this._restrictedConfigurations = restricted || [];
     }
-    fill(values, keys) {
-        if (keys) {
-            const arr = keys.slice(0);
-            shuffle(arr);
-            for (const k of arr) {
-                this.set(k, values);
+    doParseContent(content) {
+        let raw = {};
+        let currentProperty = null;
+        let currentParent = [];
+        const previousParents = [];
+        function onValue(value) {
+            if (Array.isArray(currentParent)) {
+                currentParent.push(value);
             }
-        }
-        else {
-            const arr = values.slice(0);
-            shuffle(arr);
-            for (const entry of arr) {
-                this.set(entry[0], entry[1]);
+            else if (currentProperty !== null) {
+                currentParent[currentProperty] = value;
             }
         }
-    }
-    set(key, element) {
-        const iter = this._iter.reset(key);
-        let node;
-        if (!this._root) {
-            this._root = ( (new TernarySearchTreeNode()));
-            this._root.segment = iter.value();
-        }
-        const stack = [];
-        node = this._root;
-        while (true) {
-            const val = iter.cmp(node.segment);
-            if (val > 0) {
-                if (!node.left) {
-                    node.left = ( (new TernarySearchTreeNode()));
-                    node.left.segment = iter.value();
-                }
-                stack.push([-1 , node]);
-                node = node.left;
-            }
-            else if (val < 0) {
-                if (!node.right) {
-                    node.right = ( (new TernarySearchTreeNode()));
-                    node.right.segment = iter.value();
-                }
-                stack.push([1 , node]);
-                node = node.right;
-            }
-            else if (iter.hasNext()) {
-                iter.next();
-                if (!node.mid) {
-                    node.mid = ( (new TernarySearchTreeNode()));
-                    node.mid.segment = iter.value();
-                }
-                stack.push([0 , node]);
-                node = node.mid;
+        const visitor = {
+            onObjectBegin: () => {
+                const object = {};
+                onValue(object);
+                previousParents.push(currentParent);
+                currentParent = object;
+                currentProperty = null;
+            },
+            onObjectProperty: (name) => {
+                currentProperty = name;
+            },
+            onObjectEnd: () => {
+                currentParent = previousParents.pop();
+            },
+            onArrayBegin: () => {
+                const array = [];
+                onValue(array);
+                previousParents.push(currentParent);
+                currentParent = array;
+                currentProperty = null;
+            },
+            onArrayEnd: () => {
+                currentParent = previousParents.pop();
+            },
+            onLiteralValue: onValue,
+            onError: (error, offset, length) => {
             }
-            else {
-                break;
+        };
+        if (content) {
+            try {
+                visit(content, visitor);
+                raw = currentParent[0] || {};
+            }
+            catch (e) {
+                console.error(`Error while parsing settings file ${this._name}: ${e}`);
+                this._parseErrors = [e];
             }
         }
-        const oldElement = node.value;
-        node.value = element;
-        node.key = key;
-        for (let i = stack.length - 1; i >= 0; i--) {
-            const node = stack[i][1];
-            node.updateHeight();
-            const bf = node.balanceFactor();
-            if (bf < -1 || bf > 1) {
-                const d1 = stack[i][0];
-                const d2 = stack[i + 1][0];
-                if (d1 === 1  && d2 === 1 ) {
-                    stack[i][1] = node.rotateLeft();
-                }
-                else if (d1 === -1  && d2 === -1 ) {
-                    stack[i][1] = node.rotateRight();
-                }
-                else if (d1 === 1  && d2 === -1 ) {
-                    node.right = stack[i + 1][1] = stack[i + 1][1].rotateRight();
-                    stack[i][1] = node.rotateLeft();
+        return raw;
+    }
+    doParseRaw(raw, options) {
+        const configurationProperties = ( (Registry.as(Extensions$2.Configuration))).getConfigurationProperties();
+        const filtered = this.filter(raw, configurationProperties, true, options);
+        raw = filtered.raw;
+        const contents = toValuesTree(raw, message => console.error(`Conflict in settings file ${this._name}: ${message}`));
+        const keys = ( (Object.keys(raw)));
+        const overrides = this.toOverrides(raw, message => console.error(`Conflict in settings file ${this._name}: ${message}`));
+        return { contents, keys, overrides, restricted: filtered.restricted, hasExcludedProperties: filtered.hasExcludedProperties };
+    }
+    filter(properties, configurationProperties, filterOverriddenProperties, options) {
+        let hasExcludedProperties = false;
+        if (!options?.scopes && !options?.skipRestricted) {
+            return { raw: properties, restricted: [], hasExcludedProperties };
+        }
+        const raw = {};
+        const restricted = [];
+        for (const key in properties) {
+            if (OVERRIDE_PROPERTY_REGEX.test(key) && filterOverriddenProperties) {
+                const result = this.filter(properties[key], configurationProperties, false, options);
+                raw[key] = result.raw;
+                hasExcludedProperties = hasExcludedProperties || result.hasExcludedProperties;
+                restricted.push(...result.restricted);
+            }
+            else {
+                const propertySchema = configurationProperties[key];
+                const scope = propertySchema ? typeof propertySchema.scope !== 'undefined' ? propertySchema.scope : 3  : undefined;
+                if (propertySchema?.restricted) {
+                    restricted.push(key);
                 }
-                else if (d1 === -1  && d2 === 1 ) {
-                    node.left = stack[i + 1][1] = stack[i + 1][1].rotateLeft();
-                    stack[i][1] = node.rotateRight();
+                if ((scope === undefined || options.scopes === undefined || options.scopes.includes(scope))
+                    && !(options.skipRestricted && propertySchema?.restricted)) {
+                    raw[key] = properties[key];
                 }
                 else {
-                    throw new Error();
-                }
-                if (i > 0) {
-                    switch (stack[i - 1][0]) {
-                        case -1 :
-                            stack[i - 1][1].left = stack[i][1];
-                            break;
-                        case 1 :
-                            stack[i - 1][1].right = stack[i][1];
-                            break;
-                        case 0 :
-                            stack[i - 1][1].mid = stack[i][1];
-                            break;
-                    }
+                    hasExcludedProperties = true;
                 }
-                else {
-                    this._root = stack[0][1];
+            }
+        }
+        return { raw, restricted, hasExcludedProperties };
+    }
+    toOverrides(raw, conflictReporter) {
+        const overrides = [];
+        for (const key of ( (Object.keys(raw)))) {
+            if (OVERRIDE_PROPERTY_REGEX.test(key)) {
+                const overrideRaw = {};
+                for (const keyInOverrideRaw in raw[key]) {
+                    overrideRaw[keyInOverrideRaw] = raw[key][keyInOverrideRaw];
                 }
+                overrides.push({
+                    identifiers: overrideIdentifiersFromKey(key),
+                    keys: ( (Object.keys(overrideRaw))),
+                    contents: toValuesTree(overrideRaw, conflictReporter)
+                });
             }
         }
-        return oldElement;
+        return overrides;
     }
-    get(key) {
-        return this._getNode(key)?.value;
+}
+class UserSettings extends Disposable {
+    constructor(userSettingsResource, scopes, extUri, fileService) {
+        super();
+        this.userSettingsResource = userSettingsResource;
+        this.scopes = scopes;
+        this.fileService = fileService;
+        this._onDidChange = this._register(( (new Emitter())));
+        this.onDidChange = this._onDidChange.event;
+        this.parser = ( (new ConfigurationModelParser( (this.userSettingsResource.toString()))));
+        this.parseOptions = { scopes: this.scopes };
+        this._register(this.fileService.watch(extUri.dirname(this.userSettingsResource)));
+        this._register(this.fileService.watch(this.userSettingsResource));
+        this._register(Event.any(Event.filter(this.fileService.onDidFilesChange, e => e.contains(this.userSettingsResource)), Event.filter(this.fileService.onDidRunOperation, e => (e.isOperation(0 ) || e.isOperation(3 ) || e.isOperation(1 ) || e.isOperation(4 )) && extUri.isEqual(e.resource, userSettingsResource)))(() => this._onDidChange.fire()));
     }
-    _getNode(key) {
-        const iter = this._iter.reset(key);
-        let node = this._root;
-        while (node) {
-            const val = iter.cmp(node.segment);
-            if (val > 0) {
-                node = node.left;
-            }
-            else if (val < 0) {
-                node = node.right;
-            }
-            else if (iter.hasNext()) {
-                iter.next();
-                node = node.mid;
-            }
-            else {
-                break;
-            }
+    async loadConfiguration() {
+        try {
+            const content = await this.fileService.readFile(this.userSettingsResource);
+            this.parser.parse(( (content.value.toString())) || '{}', this.parseOptions);
+            return this.parser.configurationModel;
+        }
+        catch (e) {
+            return (
+                 (new ConfigurationModel())
+            );
         }
-        return node;
     }
-    has(key) {
-        const node = this._getNode(key);
-        return !(node?.value === undefined && node?.mid === undefined);
+    reparse() {
+        this.parser.reparse(this.parseOptions);
+        return this.parser.configurationModel;
     }
-    delete(key) {
-        return this._delete(key, false);
+    getRestrictedSettings() {
+        return this.parser.restrictedConfigurations;
     }
-    deleteSuperstr(key) {
-        return this._delete(key, true);
+}
+class ConfigurationInspectValue {
+    constructor(key, overrides, _value, overrideIdentifiers, defaultConfiguration, policyConfiguration, applicationConfiguration, userConfiguration, localUserConfiguration, remoteUserConfiguration, workspaceConfiguration, folderConfigurationModel, memoryConfigurationModel) {
+        this.key = key;
+        this.overrides = overrides;
+        this._value = _value;
+        this.overrideIdentifiers = overrideIdentifiers;
+        this.defaultConfiguration = defaultConfiguration;
+        this.policyConfiguration = policyConfiguration;
+        this.applicationConfiguration = applicationConfiguration;
+        this.userConfiguration = userConfiguration;
+        this.localUserConfiguration = localUserConfiguration;
+        this.remoteUserConfiguration = remoteUserConfiguration;
+        this.workspaceConfiguration = workspaceConfiguration;
+        this.folderConfigurationModel = folderConfigurationModel;
+        this.memoryConfigurationModel = memoryConfigurationModel;
+    }
+    get value() {
+        return freeze(this._value);
+    }
+    inspect(model, section, overrideIdentifier) {
+        const inspectValue = model.inspect(section, overrideIdentifier);
+        return {
+            get value() { return freeze(inspectValue.value); },
+            get override() { return freeze(inspectValue.override); },
+            get merged() { return freeze(inspectValue.merged); }
+        };
     }
-    _delete(key, superStr) {
-        const iter = this._iter.reset(key);
-        const stack = [];
-        let node = this._root;
-        while (node) {
-            const val = iter.cmp(node.segment);
-            if (val > 0) {
-                stack.push([-1 , node]);
-                node = node.left;
-            }
-            else if (val < 0) {
-                stack.push([1 , node]);
-                node = node.right;
-            }
-            else if (iter.hasNext()) {
-                iter.next();
-                stack.push([0 , node]);
-                node = node.mid;
-            }
-            else {
-                break;
-            }
+    get defaultInspectValue() {
+        if (!this._defaultInspectValue) {
+            this._defaultInspectValue = this.inspect(this.defaultConfiguration, this.key, this.overrides.overrideIdentifier);
         }
-        if (!node) {
-            return;
+        return this._defaultInspectValue;
+    }
+    get defaultValue() {
+        return this.defaultInspectValue.merged;
+    }
+    get default() {
+        return this.defaultInspectValue.value !== undefined || this.defaultInspectValue.override !== undefined ? { value: this.defaultInspectValue.value, override: this.defaultInspectValue.override } : undefined;
+    }
+    get policyInspectValue() {
+        if (this._policyInspectValue === undefined) {
+            this._policyInspectValue = this.policyConfiguration ? this.inspect(this.policyConfiguration, this.key) : null;
         }
-        if (superStr) {
-            node.left = undefined;
-            node.mid = undefined;
-            node.right = undefined;
-            node.height = 1;
+        return this._policyInspectValue;
+    }
+    get policyValue() {
+        return this.policyInspectValue?.merged;
+    }
+    get policy() {
+        return this.policyInspectValue?.value !== undefined ? { value: this.policyInspectValue.value } : undefined;
+    }
+    get applicationInspectValue() {
+        if (this._applicationInspectValue === undefined) {
+            this._applicationInspectValue = this.applicationConfiguration ? this.inspect(this.applicationConfiguration, this.key) : null;
         }
-        else {
-            node.key = undefined;
-            node.value = undefined;
+        return this._applicationInspectValue;
+    }
+    get applicationValue() {
+        return this.applicationInspectValue?.merged;
+    }
+    get application() {
+        return this.applicationInspectValue?.value !== undefined || this.applicationInspectValue?.override !== undefined ? { value: this.applicationInspectValue.value, override: this.applicationInspectValue.override } : undefined;
+    }
+    get userInspectValue() {
+        if (!this._userInspectValue) {
+            this._userInspectValue = this.inspect(this.userConfiguration, this.key, this.overrides.overrideIdentifier);
         }
-        if (!node.mid && !node.value) {
-            if (node.left && node.right) {
-                const min = this._min(node.right);
-                const { key, value, segment } = min;
-                this._delete(min.key, false);
-                node.key = key;
-                node.value = value;
-                node.segment = segment;
-            }
-            else {
-                const newChild = node.left ?? node.right;
-                if (stack.length > 0) {
-                    const [dir, parent] = stack[stack.length - 1];
-                    switch (dir) {
-                        case -1 :
-                            parent.left = newChild;
-                            break;
-                        case 0 :
-                            parent.mid = newChild;
-                            break;
-                        case 1 :
-                            parent.right = newChild;
-                            break;
-                    }
-                }
-                else {
-                    this._root = newChild;
-                }
-            }
-        }
-        for (let i = stack.length - 1; i >= 0; i--) {
-            const node = stack[i][1];
-            node.updateHeight();
-            const bf = node.balanceFactor();
-            if (bf > 1) {
-                if (node.right.balanceFactor() >= 0) {
-                    stack[i][1] = node.rotateLeft();
-                }
-                else {
-                    node.right = node.right.rotateRight();
-                    stack[i][1] = node.rotateLeft();
-                }
-            }
-            else if (bf < -1) {
-                if (node.left.balanceFactor() <= 0) {
-                    stack[i][1] = node.rotateRight();
-                }
-                else {
-                    node.left = node.left.rotateLeft();
-                    stack[i][1] = node.rotateRight();
-                }
-            }
-            if (i > 0) {
-                switch (stack[i - 1][0]) {
-                    case -1 :
-                        stack[i - 1][1].left = stack[i][1];
-                        break;
-                    case 1 :
-                        stack[i - 1][1].right = stack[i][1];
-                        break;
-                    case 0 :
-                        stack[i - 1][1].mid = stack[i][1];
-                        break;
-                }
-            }
-            else {
-                this._root = stack[0][1];
-            }
+        return this._userInspectValue;
+    }
+    get userValue() {
+        return this.userInspectValue.merged;
+    }
+    get user() {
+        return this.userInspectValue.value !== undefined || this.userInspectValue.override !== undefined ? { value: this.userInspectValue.value, override: this.userInspectValue.override } : undefined;
+    }
+    get userLocalInspectValue() {
+        if (!this._userLocalInspectValue) {
+            this._userLocalInspectValue = this.inspect(this.localUserConfiguration, this.key, this.overrides.overrideIdentifier);
         }
+        return this._userLocalInspectValue;
     }
-    _min(node) {
-        while (node.left) {
-            node = node.left;
+    get userLocalValue() {
+        return this.userLocalInspectValue.merged;
+    }
+    get userLocal() {
+        return this.userLocalInspectValue.value !== undefined || this.userLocalInspectValue.override !== undefined ? { value: this.userLocalInspectValue.value, override: this.userLocalInspectValue.override } : undefined;
+    }
+    get userRemoteInspectValue() {
+        if (!this._userRemoteInspectValue) {
+            this._userRemoteInspectValue = this.inspect(this.remoteUserConfiguration, this.key, this.overrides.overrideIdentifier);
         }
-        return node;
+        return this._userRemoteInspectValue;
     }
-    findSubstr(key) {
-        const iter = this._iter.reset(key);
-        let node = this._root;
-        let candidate = undefined;
-        while (node) {
-            const val = iter.cmp(node.segment);
-            if (val > 0) {
-                node = node.left;
-            }
-            else if (val < 0) {
-                node = node.right;
-            }
-            else if (iter.hasNext()) {
-                iter.next();
-                candidate = node.value || candidate;
-                node = node.mid;
-            }
-            else {
-                break;
-            }
+    get userRemoteValue() {
+        return this.userRemoteInspectValue.merged;
+    }
+    get userRemote() {
+        return this.userRemoteInspectValue.value !== undefined || this.userRemoteInspectValue.override !== undefined ? { value: this.userRemoteInspectValue.value, override: this.userRemoteInspectValue.override } : undefined;
+    }
+    get workspaceInspectValue() {
+        if (this._workspaceInspectValue === undefined) {
+            this._workspaceInspectValue = this.workspaceConfiguration ? this.inspect(this.workspaceConfiguration, this.key, this.overrides.overrideIdentifier) : null;
         }
-        return node && node.value || candidate;
+        return this._workspaceInspectValue;
     }
-    findSuperstr(key) {
-        const iter = this._iter.reset(key);
-        let node = this._root;
-        while (node) {
-            const val = iter.cmp(node.segment);
-            if (val > 0) {
-                node = node.left;
-            }
-            else if (val < 0) {
-                node = node.right;
-            }
-            else if (iter.hasNext()) {
-                iter.next();
-                node = node.mid;
-            }
-            else {
-                if (!node.mid) {
-                    return undefined;
-                }
-                else {
-                    return this._entries(node.mid);
-                }
-            }
+    get workspaceValue() {
+        return this.workspaceInspectValue?.merged;
+    }
+    get workspace() {
+        return this.workspaceInspectValue?.value !== undefined || this.workspaceInspectValue?.override !== undefined ? { value: this.workspaceInspectValue.value, override: this.workspaceInspectValue.override } : undefined;
+    }
+    get workspaceFolderInspectValue() {
+        if (this._workspaceFolderInspectValue === undefined) {
+            this._workspaceFolderInspectValue = this.folderConfigurationModel ? this.inspect(this.folderConfigurationModel, this.key, this.overrides.overrideIdentifier) : null;
         }
-        return undefined;
+        return this._workspaceFolderInspectValue;
     }
-    forEach(callback) {
-        for (const [key, value] of this) {
-            callback(value, key);
+    get workspaceFolderValue() {
+        return this.workspaceFolderInspectValue?.merged;
+    }
+    get workspaceFolder() {
+        return this.workspaceFolderInspectValue?.value !== undefined || this.workspaceFolderInspectValue?.override !== undefined ? { value: this.workspaceFolderInspectValue.value, override: this.workspaceFolderInspectValue.override } : undefined;
+    }
+    get memoryInspectValue() {
+        if (this._memoryInspectValue === undefined) {
+            this._memoryInspectValue = this.inspect(this.memoryConfigurationModel, this.key, this.overrides.overrideIdentifier);
         }
+        return this._memoryInspectValue;
     }
-    *[Symbol.iterator]() {
-        yield* this._entries(this._root);
+    get memoryValue() {
+        return this.memoryInspectValue.merged;
     }
-    _entries(node) {
-        const result = [];
-        this._dfsEntries(node, result);
-        return result[Symbol.iterator]();
+    get memory() {
+        return this.memoryInspectValue.value !== undefined || this.memoryInspectValue.override !== undefined ? { value: this.memoryInspectValue.value, override: this.memoryInspectValue.override } : undefined;
     }
-    _dfsEntries(node, bucket) {
-        if (!node) {
-            return;
+}
+class Configuration {
+    constructor(_defaultConfiguration, _policyConfiguration, _applicationConfiguration, _localUserConfiguration, _remoteUserConfiguration = ( (new ConfigurationModel())), _workspaceConfiguration = ( (new ConfigurationModel())), _folderConfigurations = ( (new ResourceMap())), _memoryConfiguration = ( (new ConfigurationModel())), _memoryConfigurationByResource = ( (new ResourceMap()))) {
+        this._defaultConfiguration = _defaultConfiguration;
+        this._policyConfiguration = _policyConfiguration;
+        this._applicationConfiguration = _applicationConfiguration;
+        this._localUserConfiguration = _localUserConfiguration;
+        this._remoteUserConfiguration = _remoteUserConfiguration;
+        this._workspaceConfiguration = _workspaceConfiguration;
+        this._folderConfigurations = _folderConfigurations;
+        this._memoryConfiguration = _memoryConfiguration;
+        this._memoryConfigurationByResource = _memoryConfigurationByResource;
+        this._workspaceConsolidatedConfiguration = null;
+        this._foldersConsolidatedConfigurations = ( (new ResourceMap()));
+        this._userConfiguration = null;
+    }
+    getValue(section, overrides, workspace) {
+        const consolidateConfigurationModel = this.getConsolidatedConfigurationModel(section, overrides, workspace);
+        return consolidateConfigurationModel.getValue(section);
+    }
+    updateValue(key, value, overrides = {}) {
+        let memoryConfiguration;
+        if (overrides.resource) {
+            memoryConfiguration = this._memoryConfigurationByResource.get(overrides.resource);
+            if (!memoryConfiguration) {
+                memoryConfiguration = ( (new ConfigurationModel()));
+                this._memoryConfigurationByResource.set(overrides.resource, memoryConfiguration);
+            }
         }
-        if (node.left) {
-            this._dfsEntries(node.left, bucket);
+        else {
+            memoryConfiguration = this._memoryConfiguration;
         }
-        if (node.value) {
-            bucket.push([node.key, node.value]);
+        if (value === undefined) {
+            memoryConfiguration.removeValue(key);
         }
-        if (node.mid) {
-            this._dfsEntries(node.mid, bucket);
+        else {
+            memoryConfiguration.setValue(key, value);
         }
-        if (node.right) {
-            this._dfsEntries(node.right, bucket);
+        if (!overrides.resource) {
+            this._workspaceConsolidatedConfiguration = null;
         }
     }
-    _isBalanced() {
-        const nodeIsBalanced = (node) => {
-            if (!node) {
-                return true;
-            }
-            const bf = node.balanceFactor();
-            if (bf < -1 || bf > 1) {
-                return false;
+    inspect(key, overrides, workspace) {
+        const consolidateConfigurationModel = this.getConsolidatedConfigurationModel(key, overrides, workspace);
+        const folderConfigurationModel = this.getFolderConfigurationModelForResource(overrides.resource, workspace);
+        const memoryConfigurationModel = overrides.resource ? this._memoryConfigurationByResource.get(overrides.resource) || this._memoryConfiguration : this._memoryConfiguration;
+        const overrideIdentifiers = ( (new Set()));
+        for (const override of consolidateConfigurationModel.overrides) {
+            for (const overrideIdentifier of override.identifiers) {
+                if (consolidateConfigurationModel.getOverrideValue(key, overrideIdentifier) !== undefined) {
+                    overrideIdentifiers.add(overrideIdentifier);
+                }
             }
-            return nodeIsBalanced(node.left) && nodeIsBalanced(node.right);
+        }
+        return (
+             (new ConfigurationInspectValue(
+                key,
+                overrides,
+                consolidateConfigurationModel.getValue(key),
+                overrideIdentifiers.size ? [...overrideIdentifiers] : undefined,
+                this._defaultConfiguration,
+                this._policyConfiguration.isEmpty() ? undefined : this._policyConfiguration,
+                this.applicationConfiguration.isEmpty() ? undefined : this.applicationConfiguration,
+                this.userConfiguration,
+                this.localUserConfiguration,
+                this.remoteUserConfiguration,
+                workspace ? this._workspaceConfiguration : undefined,
+                folderConfigurationModel ? folderConfigurationModel : undefined,
+                memoryConfigurationModel
+            ))
+        );
+    }
+    keys(workspace) {
+        const folderConfigurationModel = this.getFolderConfigurationModelForResource(undefined, workspace);
+        return {
+            default: this._defaultConfiguration.keys.slice(0),
+            user: this.userConfiguration.keys.slice(0),
+            workspace: this._workspaceConfiguration.keys.slice(0),
+            workspaceFolder: folderConfigurationModel ? folderConfigurationModel.keys.slice(0) : []
         };
-        return nodeIsBalanced(this._root);
     }
-}
-class ResourceMapEntry {
-    constructor(uri, value) {
-        this.uri = uri;
-        this.value = value;
+    updateDefaultConfiguration(defaultConfiguration) {
+        this._defaultConfiguration = defaultConfiguration;
+        this._workspaceConsolidatedConfiguration = null;
+        this._foldersConsolidatedConfigurations.clear();
     }
-}
-class ResourceMap {
-    constructor(mapOrKeyFn, toKey) {
-        this[_a$1] = 'ResourceMap';
-        if (mapOrKeyFn instanceof ResourceMap) {
-            this.map = ( (new Map(mapOrKeyFn.map)));
-            this.toKey = toKey ?? ResourceMap.defaultToKey;
-        }
-        else {
-            this.map = ( (new Map()));
-            this.toKey = mapOrKeyFn ?? ResourceMap.defaultToKey;
-        }
+    updatePolicyConfiguration(policyConfiguration) {
+        this._policyConfiguration = policyConfiguration;
     }
-    set(resource, value) {
-        this.map.set(this.toKey(resource), ( (new ResourceMapEntry(resource, value))));
-        return this;
+    updateApplicationConfiguration(applicationConfiguration) {
+        this._applicationConfiguration = applicationConfiguration;
+        this._workspaceConsolidatedConfiguration = null;
+        this._foldersConsolidatedConfigurations.clear();
     }
-    get(resource) {
-        return this.map.get(this.toKey(resource))?.value;
+    updateLocalUserConfiguration(localUserConfiguration) {
+        this._localUserConfiguration = localUserConfiguration;
+        this._userConfiguration = null;
+        this._workspaceConsolidatedConfiguration = null;
+        this._foldersConsolidatedConfigurations.clear();
     }
-    has(resource) {
-        return this.map.has(this.toKey(resource));
+    updateRemoteUserConfiguration(remoteUserConfiguration) {
+        this._remoteUserConfiguration = remoteUserConfiguration;
+        this._userConfiguration = null;
+        this._workspaceConsolidatedConfiguration = null;
+        this._foldersConsolidatedConfigurations.clear();
     }
-    get size() {
-        return this.map.size;
+    updateWorkspaceConfiguration(workspaceConfiguration) {
+        this._workspaceConfiguration = workspaceConfiguration;
+        this._workspaceConsolidatedConfiguration = null;
+        this._foldersConsolidatedConfigurations.clear();
     }
-    clear() {
-        this.map.clear();
+    updateFolderConfiguration(resource, configuration) {
+        this._folderConfigurations.set(resource, configuration);
+        this._foldersConsolidatedConfigurations.delete(resource);
     }
-    delete(resource) {
-        return this.map.delete(this.toKey(resource));
+    deleteFolderConfiguration(resource) {
+        this.folderConfigurations.delete(resource);
+        this._foldersConsolidatedConfigurations.delete(resource);
     }
-    forEach(clb, thisArg) {
-        if (typeof thisArg !== 'undefined') {
-            clb = clb.bind(thisArg);
+    compareAndUpdateDefaultConfiguration(defaults, keys) {
+        const overrides = [];
+        if (!keys) {
+            const { added, updated, removed } = compare(this._defaultConfiguration, defaults);
+            keys = [...added, ...updated, ...removed];
         }
-        for (const [_, entry] of this.map) {
-            clb(entry.value, entry.uri, this);
+        for (const key of keys) {
+            for (const overrideIdentifier of overrideIdentifiersFromKey(key)) {
+                const fromKeys = this._defaultConfiguration.getKeysForOverrideIdentifier(overrideIdentifier);
+                const toKeys = defaults.getKeysForOverrideIdentifier(overrideIdentifier);
+                const keys = [
+                    ...toKeys.filter(key => fromKeys.indexOf(key) === -1),
+                    ...fromKeys.filter(key => toKeys.indexOf(key) === -1),
+                    ...fromKeys.filter(key => !equals(this._defaultConfiguration.override(overrideIdentifier).getValue(key), defaults.override(overrideIdentifier).getValue(key)))
+                ];
+                overrides.push([overrideIdentifier, keys]);
+            }
         }
+        this.updateDefaultConfiguration(defaults);
+        return { keys, overrides };
     }
-    *values() {
-        for (const entry of ( (this.map.values()))) {
-            yield entry.value;
+    compareAndUpdatePolicyConfiguration(policyConfiguration) {
+        const { added, updated, removed } = compare(this._policyConfiguration, policyConfiguration);
+        const keys = [...added, ...updated, ...removed];
+        if (keys.length) {
+            this.updatePolicyConfiguration(policyConfiguration);
         }
+        return { keys, overrides: [] };
     }
-    *keys() {
-        for (const entry of ( (this.map.values()))) {
-            yield entry.uri;
+    compareAndUpdateApplicationConfiguration(application) {
+        const { added, updated, removed, overrides } = compare(this.applicationConfiguration, application);
+        const keys = [...added, ...updated, ...removed];
+        if (keys.length) {
+            this.updateApplicationConfiguration(application);
         }
+        return { keys, overrides };
     }
-    *entries() {
-        for (const entry of ( (this.map.values()))) {
-            yield [entry.uri, entry.value];
+    compareAndUpdateLocalUserConfiguration(user) {
+        const { added, updated, removed, overrides } = compare(this.localUserConfiguration, user);
+        const keys = [...added, ...updated, ...removed];
+        if (keys.length) {
+            this.updateLocalUserConfiguration(user);
         }
+        return { keys, overrides };
     }
-    *[(_a$1 = Symbol.toStringTag, Symbol.iterator)]() {
-        for (const [, entry] of this.map) {
-            yield [entry.uri, entry.value];
+    compareAndUpdateRemoteUserConfiguration(user) {
+        const { added, updated, removed, overrides } = compare(this.remoteUserConfiguration, user);
+        const keys = [...added, ...updated, ...removed];
+        if (keys.length) {
+            this.updateRemoteUserConfiguration(user);
         }
+        return { keys, overrides };
     }
-}
-ResourceMap.defaultToKey = (resource) => ( (resource.toString()));
-class ResourceSet {
-    constructor(entriesOrKey, toKey) {
-        this[_b$1] = 'ResourceSet';
-        if (!entriesOrKey || typeof entriesOrKey === 'function') {
-            this._map = ( (new ResourceMap(entriesOrKey)));
-        }
-        else {
-            this._map = ( (new ResourceMap(toKey)));
-            entriesOrKey.forEach(this.add, this);
+    compareAndUpdateWorkspaceConfiguration(workspaceConfiguration) {
+        const { added, updated, removed, overrides } = compare(this.workspaceConfiguration, workspaceConfiguration);
+        const keys = [...added, ...updated, ...removed];
+        if (keys.length) {
+            this.updateWorkspaceConfiguration(workspaceConfiguration);
         }
+        return { keys, overrides };
     }
-    get size() {
-        return this._map.size;
-    }
-    add(value) {
-        this._map.set(value, value);
-        return this;
-    }
-    clear() {
-        this._map.clear();
-    }
-    delete(value) {
-        return this._map.delete(value);
-    }
-    forEach(callbackfn, thisArg) {
-        this._map.forEach((_value, key) => callbackfn.call(thisArg, key, key, this));
-    }
-    has(value) {
-        return this._map.has(value);
-    }
-    entries() {
-        return this._map.entries();
-    }
-    keys() {
-        return (
-             (this._map.keys())
-        );
-    }
-    values() {
-        return (
-             (this._map.keys())
-        );
-    }
-    [(_b$1 = Symbol.toStringTag, Symbol.iterator)]() {
-        return (
-             (this.keys())
-        );
-    }
-}
-class ConfigurationModel {
-    constructor(_contents = {}, _keys = [], _overrides = []) {
-        this._contents = _contents;
-        this._keys = _keys;
-        this._overrides = _overrides;
-        this.frozen = false;
-        this.overrideConfigurations = ( (new Map()));
+    compareAndUpdateFolderConfiguration(resource, folderConfiguration) {
+        const currentFolderConfiguration = this.folderConfigurations.get(resource);
+        const { added, updated, removed, overrides } = compare(currentFolderConfiguration, folderConfiguration);
+        const keys = [...added, ...updated, ...removed];
+        if (keys.length || !currentFolderConfiguration) {
+            this.updateFolderConfiguration(resource, folderConfiguration);
+        }
+        return { keys, overrides };
     }
-    get contents() {
-        return this.checkAndFreeze(this._contents);
+    compareAndDeleteFolderConfiguration(folder) {
+        const folderConfig = this.folderConfigurations.get(folder);
+        if (!folderConfig) {
+            throw new Error('Unknown folder');
+        }
+        this.deleteFolderConfiguration(folder);
+        const { added, updated, removed, overrides } = compare(folderConfig, undefined);
+        return { keys: [...added, ...updated, ...removed], overrides };
     }
-    get overrides() {
-        return this.checkAndFreeze(this._overrides);
+    get defaults() {
+        return this._defaultConfiguration;
     }
-    get keys() {
-        return this.checkAndFreeze(this._keys);
+    get applicationConfiguration() {
+        return this._applicationConfiguration;
     }
-    isEmpty() {
-        return this._keys.length === 0 && ( (Object.keys(this._contents))).length === 0 && this._overrides.length === 0;
+    get userConfiguration() {
+        if (!this._userConfiguration) {
+            this._userConfiguration = this._remoteUserConfiguration.isEmpty() ? this._localUserConfiguration : this._localUserConfiguration.merge(this._remoteUserConfiguration);
+        }
+        return this._userConfiguration;
     }
-    isFrozen() {
-        return this.frozen;
+    get localUserConfiguration() {
+        return this._localUserConfiguration;
     }
-    getValue(section) {
-        return section ? getConfigurationValue(this.contents, section) : this.contents;
+    get remoteUserConfiguration() {
+        return this._remoteUserConfiguration;
     }
-    getOverrideValue(section, overrideIdentifier) {
-        const overrideContents = this.getContentsForOverrideIdentifer(overrideIdentifier);
-        return overrideContents
-            ? section ? getConfigurationValue(overrideContents, section) : overrideContents
-            : undefined;
+    get workspaceConfiguration() {
+        return this._workspaceConfiguration;
     }
-    getKeysForOverrideIdentifier(identifier) {
-        const keys = [];
-        for (const override of this.overrides) {
-            if (override.identifiers.includes(identifier)) {
-                keys.push(...override.keys);
-            }
-        }
-        return distinct(keys);
+    get folderConfigurations() {
+        return this._folderConfigurations;
     }
-    getAllOverrideIdentifiers() {
-        const result = [];
-        for (const override of this.overrides) {
-            result.push(...override.identifiers);
+    getConsolidatedConfigurationModel(section, overrides, workspace) {
+        let configurationModel = this.getConsolidatedConfigurationModelForResource(overrides, workspace);
+        if (overrides.overrideIdentifier) {
+            configurationModel = configurationModel.override(overrides.overrideIdentifier);
         }
-        return distinct(result);
-    }
-    override(identifier) {
-        let overrideConfigurationModel = this.overrideConfigurations.get(identifier);
-        if (!overrideConfigurationModel) {
-            overrideConfigurationModel = this.createOverrideConfigurationModel(identifier);
-            this.overrideConfigurations.set(identifier, overrideConfigurationModel);
+        if (!this._policyConfiguration.isEmpty() && this._policyConfiguration.getValue(section) !== undefined) {
+            configurationModel = configurationModel.merge(this._policyConfiguration);
         }
-        return overrideConfigurationModel;
+        return configurationModel;
     }
-    merge(...others) {
-        const contents = deepClone(this.contents);
-        const overrides = deepClone(this.overrides);
-        const keys = [...this.keys];
-        for (const other of others) {
-            if (other.isEmpty()) {
-                continue;
-            }
-            this.mergeContents(contents, other.contents);
-            for (const otherOverride of other.overrides) {
-                const [override] = overrides.filter(o => equals$1(o.identifiers, otherOverride.identifiers));
-                if (override) {
-                    this.mergeContents(override.contents, otherOverride.contents);
-                    override.keys.push(...otherOverride.keys);
-                    override.keys = distinct(override.keys);
-                }
-                else {
-                    overrides.push(deepClone(otherOverride));
-                }
+    getConsolidatedConfigurationModelForResource({ resource }, workspace) {
+        let consolidateConfiguration = this.getWorkspaceConsolidatedConfiguration();
+        if (workspace && resource) {
+            const root = workspace.getFolder(resource);
+            if (root) {
+                consolidateConfiguration = this.getFolderConsolidatedConfiguration(root.uri) || consolidateConfiguration;
             }
-            for (const key of other.keys) {
-                if (keys.indexOf(key) === -1) {
-                    keys.push(key);
-                }
+            const memoryConfigurationForResource = this._memoryConfigurationByResource.get(resource);
+            if (memoryConfigurationForResource) {
+                consolidateConfiguration = consolidateConfiguration.merge(memoryConfigurationForResource);
             }
         }
-        return (
-             (new ConfigurationModel(contents, keys, overrides))
-        );
-    }
-    freeze() {
-        this.frozen = true;
-        return this;
-    }
-    clone() {
-        return (
-             (new ConfigurationModel(deepClone(this.contents), [...this.keys], deepClone(this.overrides)))
-        );
+        return consolidateConfiguration;
     }
-    createOverrideConfigurationModel(identifier) {
-        const overrideContents = this.getContentsForOverrideIdentifer(identifier);
-        if (!overrideContents || typeof overrideContents !== 'object' || !( (Object.keys(overrideContents))).length) {
-            return this;
-        }
-        const contents = {};
-        for (const key of distinct([...( (Object.keys(this.contents))), ...( (Object.keys(overrideContents)))])) {
-            let contentsForKey = this.contents[key];
-            const overrideContentsForKey = overrideContents[key];
-            if (overrideContentsForKey) {
-                if (typeof contentsForKey === 'object' && typeof overrideContentsForKey === 'object') {
-                    contentsForKey = deepClone(contentsForKey);
-                    this.mergeContents(contentsForKey, overrideContentsForKey);
-                }
-                else {
-                    contentsForKey = overrideContentsForKey;
-                }
-            }
-            contents[key] = contentsForKey;
+    getWorkspaceConsolidatedConfiguration() {
+        if (!this._workspaceConsolidatedConfiguration) {
+            this._workspaceConsolidatedConfiguration = this._defaultConfiguration.merge(this.applicationConfiguration, this.userConfiguration, this._workspaceConfiguration, this._memoryConfiguration);
         }
-        return (
-             (new ConfigurationModel(contents, this.keys, this.overrides))
-        );
+        return this._workspaceConsolidatedConfiguration;
     }
-    mergeContents(source, target) {
-        for (const key of ( (Object.keys(target)))) {
-            if (key in source) {
-                if (isObject(source[key]) && isObject(target[key])) {
-                    this.mergeContents(source[key], target[key]);
-                    continue;
-                }
+    getFolderConsolidatedConfiguration(folder) {
+        let folderConsolidatedConfiguration = this._foldersConsolidatedConfigurations.get(folder);
+        if (!folderConsolidatedConfiguration) {
+            const workspaceConsolidateConfiguration = this.getWorkspaceConsolidatedConfiguration();
+            const folderConfiguration = this._folderConfigurations.get(folder);
+            if (folderConfiguration) {
+                folderConsolidatedConfiguration = workspaceConsolidateConfiguration.merge(folderConfiguration);
+                this._foldersConsolidatedConfigurations.set(folder, folderConsolidatedConfiguration);
+            }
+            else {
+                folderConsolidatedConfiguration = workspaceConsolidateConfiguration;
             }
-            source[key] = deepClone(target[key]);
-        }
-    }
-    checkAndFreeze(data) {
-        if (this.frozen && !Object.isFrozen(data)) {
-            return deepFreeze(data);
         }
-        return data;
+        return folderConsolidatedConfiguration;
     }
-    getContentsForOverrideIdentifer(identifier) {
-        let contentsForIdentifierOnly = null;
-        let contents = null;
-        const mergeContents = (contentsToMerge) => {
-            if (contentsToMerge) {
-                if (contents) {
-                    this.mergeContents(contents, contentsToMerge);
-                }
-                else {
-                    contents = deepClone(contentsToMerge);
-                }
-            }
-        };
-        for (const override of this.overrides) {
-            if (equals$1(override.identifiers, [identifier])) {
-                contentsForIdentifierOnly = override.contents;
-            }
-            else if (override.identifiers.includes(identifier)) {
-                mergeContents(override.contents);
+    getFolderConfigurationModelForResource(resource, workspace) {
+        if (workspace && resource) {
+            const root = workspace.getFolder(resource);
+            if (root) {
+                return this._folderConfigurations.get(root.uri);
             }
         }
-        mergeContents(contentsForIdentifierOnly);
-        return contents;
+        return undefined;
     }
-    toJSON() {
+    toData() {
         return {
-            contents: this.contents,
-            overrides: this.overrides,
-            keys: this.keys
+            defaults: {
+                contents: this._defaultConfiguration.contents,
+                overrides: this._defaultConfiguration.overrides,
+                keys: this._defaultConfiguration.keys
+            },
+            policy: {
+                contents: this._policyConfiguration.contents,
+                overrides: this._policyConfiguration.overrides,
+                keys: this._policyConfiguration.keys
+            },
+            application: {
+                contents: this.applicationConfiguration.contents,
+                overrides: this.applicationConfiguration.overrides,
+                keys: this.applicationConfiguration.keys
+            },
+            user: {
+                contents: this.userConfiguration.contents,
+                overrides: this.userConfiguration.overrides,
+                keys: this.userConfiguration.keys
+            },
+            workspace: {
+                contents: this._workspaceConfiguration.contents,
+                overrides: this._workspaceConfiguration.overrides,
+                keys: this._workspaceConfiguration.keys
+            },
+            folders: [...( (this._folderConfigurations.keys()))].reduce((result, folder) => {
+                const { contents, overrides, keys } = this._folderConfigurations.get(folder);
+                result.push([folder, { contents, overrides, keys }]);
+                return result;
+            }, [])
         };
     }
-    setValue(key, value) {
-        this.addKey(key);
-        addToValueTree(this.contents, key, value, e => { throw new Error(e); });
-    }
-    removeValue(key) {
-        if (this.removeKey(key)) {
-            removeFromValueTree(this.contents, key);
-        }
+    allKeys() {
+        const keys = ( (new Set()));
+        this._defaultConfiguration.keys.forEach(key => keys.add(key));
+        this.userConfiguration.keys.forEach(key => keys.add(key));
+        this._workspaceConfiguration.keys.forEach(key => keys.add(key));
+        this._folderConfigurations.forEach(folderConfiguraiton => folderConfiguraiton.keys.forEach(key => keys.add(key)));
+        return [...( (keys.values()))];
     }
-    addKey(key) {
-        let index = this.keys.length;
-        for (let i = 0; i < index; i++) {
-            if (key.indexOf(this.keys[i]) === 0) {
-                index = i;
-            }
-        }
-        this.keys.splice(index, 1, key);
+    allOverrideIdentifiers() {
+        const keys = ( (new Set()));
+        this._defaultConfiguration.getAllOverrideIdentifiers().forEach(key => keys.add(key));
+        this.userConfiguration.getAllOverrideIdentifiers().forEach(key => keys.add(key));
+        this._workspaceConfiguration.getAllOverrideIdentifiers().forEach(key => keys.add(key));
+        this._folderConfigurations.forEach(folderConfiguraiton => folderConfiguraiton.getAllOverrideIdentifiers().forEach(key => keys.add(key)));
+        return [...( (keys.values()))];
     }
-    removeKey(key) {
-        const index = this.keys.indexOf(key);
-        if (index !== -1) {
-            this.keys.splice(index, 1);
-            return true;
+    getAllKeysForOverrideIdentifier(overrideIdentifier) {
+        const keys = ( (new Set()));
+        this._defaultConfiguration.getKeysForOverrideIdentifier(overrideIdentifier).forEach(key => keys.add(key));
+        this.userConfiguration.getKeysForOverrideIdentifier(overrideIdentifier).forEach(key => keys.add(key));
+        this._workspaceConfiguration.getKeysForOverrideIdentifier(overrideIdentifier).forEach(key => keys.add(key));
+        this._folderConfigurations.forEach(folderConfiguraiton => folderConfiguraiton.getKeysForOverrideIdentifier(overrideIdentifier).forEach(key => keys.add(key)));
+        return [...( (keys.values()))];
+    }
+    static parse(data) {
+        const defaultConfiguration = this.parseConfigurationModel(data.defaults);
+        const policyConfiguration = this.parseConfigurationModel(data.policy);
+        const applicationConfiguration = this.parseConfigurationModel(data.application);
+        const userConfiguration = this.parseConfigurationModel(data.user);
+        const workspaceConfiguration = this.parseConfigurationModel(data.workspace);
+        const folders = data.folders.reduce((result, value) => {
+            result.set(URI.revive(value[0]), this.parseConfigurationModel(value[1]));
+            return result;
+        }, ( (new ResourceMap())));
+        return (
+             (new Configuration(
+                defaultConfiguration,
+                policyConfiguration,
+                applicationConfiguration,
+                userConfiguration,
+                 (new ConfigurationModel()),
+                workspaceConfiguration,
+                folders,
+                 (new ConfigurationModel()),
+                 (new ResourceMap())
+            ))
+        );
+    }
+    static parseConfigurationModel(model) {
+        return (
+             (new ConfigurationModel(model.contents, model.keys, model.overrides))
+        );
+    }
+}
+function compare(from, to) {
+    const { added, removed, updated } = compareConfigurationContents(to?.rawConfiguration, from?.rawConfiguration);
+    const overrides = [];
+    const fromOverrideIdentifiers = from?.getAllOverrideIdentifiers() || [];
+    const toOverrideIdentifiers = to?.getAllOverrideIdentifiers() || [];
+    if (to) {
+        const addedOverrideIdentifiers = toOverrideIdentifiers.filter(key => !fromOverrideIdentifiers.includes(key));
+        for (const identifier of addedOverrideIdentifiers) {
+            overrides.push([identifier, to.getKeysForOverrideIdentifier(identifier)]);
+        }
+    }
+    if (from) {
+        const removedOverrideIdentifiers = fromOverrideIdentifiers.filter(key => !toOverrideIdentifiers.includes(key));
+        for (const identifier of removedOverrideIdentifiers) {
+            overrides.push([identifier, from.getKeysForOverrideIdentifier(identifier)]);
+        }
+    }
+    if (to && from) {
+        for (const identifier of fromOverrideIdentifiers) {
+            if (toOverrideIdentifiers.includes(identifier)) {
+                const result = compareConfigurationContents({ contents: from.getOverrideValue(undefined, identifier) || {}, keys: from.getKeysForOverrideIdentifier(identifier) }, { contents: to.getOverrideValue(undefined, identifier) || {}, keys: to.getKeysForOverrideIdentifier(identifier) });
+                overrides.push([identifier, [...result.added, ...result.removed, ...result.updated]]);
+            }
         }
-        return false;
     }
+    return { added, removed, updated, overrides };
 }
-class ConfigurationModelParser {
-    constructor(_name) {
-        this._name = _name;
-        this._raw = null;
-        this._configurationModel = null;
-        this._restrictedConfigurations = [];
-        this._parseErrors = [];
+function compareConfigurationContents(to, from) {
+    const added = to
+        ? from ? to.keys.filter(key => from.keys.indexOf(key) === -1) : [...to.keys]
+        : [];
+    const removed = from
+        ? to ? from.keys.filter(key => to.keys.indexOf(key) === -1) : [...from.keys]
+        : [];
+    const updated = [];
+    if (to && from) {
+        for (const key of from.keys) {
+            if (to.keys.indexOf(key) !== -1) {
+                const value1 = getConfigurationValue(from.contents, key);
+                const value2 = getConfigurationValue(to.contents, key);
+                if (!equals(value1, value2)) {
+                    updated.push(key);
+                }
+            }
+        }
+    }
+    return { added, removed, updated };
+}
+class WorkspaceFolder {
+    constructor(data,
+    raw) {
+        this.raw = raw;
+        this.uri = data.uri;
+        this.index = data.index;
+        this.name = data.name;
+    }
+    toResource(relativePath) {
+        return joinPath(this.uri, relativePath);
+    }
+    toJSON() {
+        return { uri: this.uri, name: this.name, index: this.index };
+    }
+}
+const IPolicyService = ( (createDecorator('policy')));
+class NullPolicyService {
+    constructor() {
+        this.onDidChange = Event.None;
+    }
+    async updatePolicyDefinitions() { return {}; }
+    getPolicyValue() { return undefined; }
+    serialize() { return undefined; }
+}
+class DefaultConfiguration extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._onDidChangeConfiguration = this._register(( (new Emitter())));
+        this.onDidChangeConfiguration = this._onDidChangeConfiguration.event;
+        this._configurationModel = ( (new ConfigurationModel$1()));
     }
     get configurationModel() {
-        return this._configurationModel || ( (new ConfigurationModel()));
+        return this._configurationModel;
     }
-    get restrictedConfigurations() {
-        return this._restrictedConfigurations;
+    async initialize() {
+        this.resetConfigurationModel();
+        this._register(( (Registry.as(Extensions$2.Configuration))).onDidUpdateConfiguration(({ properties, defaultsOverrides }) => this.onDidUpdateConfiguration(Array.from(properties), defaultsOverrides)));
+        return this.configurationModel;
     }
-    get errors() {
-        return this._parseErrors;
+    reload() {
+        this.resetConfigurationModel();
+        return this.configurationModel;
     }
-    parse(content, options) {
-        if (!isUndefinedOrNull(content)) {
-            const raw = this.doParseContent(content);
-            this.parseRaw(raw, options);
-        }
+    onDidUpdateConfiguration(properties, defaultsOverrides) {
+        this.updateConfigurationModel(properties, ( (Registry.as(Extensions$2.Configuration))).getConfigurationProperties());
+        this._onDidChangeConfiguration.fire({ defaults: this.configurationModel, properties });
     }
-    reparse(options) {
-        if (this._raw) {
-            this.parseRaw(this._raw, options);
-        }
+    getConfigurationDefaultOverrides() {
+        return {};
     }
-    parseRaw(raw, options) {
-        this._raw = raw;
-        const { contents, keys, overrides, restricted } = this.doParseRaw(raw, options);
-        this._configurationModel = ( (new ConfigurationModel(contents, keys, overrides)));
-        this._restrictedConfigurations = restricted || [];
+    resetConfigurationModel() {
+        this._configurationModel = ( (new ConfigurationModel$1()));
+        const properties = ( (Registry.as(Extensions$2.Configuration))).getConfigurationProperties();
+        this.updateConfigurationModel(( (Object.keys(properties))), properties);
     }
-    doParseContent(content) {
-        let raw = {};
-        let currentProperty = null;
-        let currentParent = [];
-        const previousParents = [];
-        function onValue(value) {
-            if (Array.isArray(currentParent)) {
-                currentParent.push(value);
+    updateConfigurationModel(properties, configurationProperties) {
+        const configurationDefaultsOverrides = this.getConfigurationDefaultOverrides();
+        for (const key of properties) {
+            const defaultOverrideValue = configurationDefaultsOverrides[key];
+            const propertySchema = configurationProperties[key];
+            if (defaultOverrideValue !== undefined) {
+                this._configurationModel.addValue(key, defaultOverrideValue);
             }
-            else if (currentProperty !== null) {
-                currentParent[currentProperty] = value;
+            else if (propertySchema) {
+                this._configurationModel.addValue(key, propertySchema.default);
             }
-        }
-        const visitor = {
-            onObjectBegin: () => {
-                const object = {};
-                onValue(object);
-                previousParents.push(currentParent);
-                currentParent = object;
-                currentProperty = null;
-            },
-            onObjectProperty: (name) => {
-                currentProperty = name;
-            },
-            onObjectEnd: () => {
-                currentParent = previousParents.pop();
-            },
-            onArrayBegin: () => {
-                const array = [];
-                onValue(array);
-                previousParents.push(currentParent);
-                currentParent = array;
-                currentProperty = null;
-            },
-            onArrayEnd: () => {
-                currentParent = previousParents.pop();
-            },
-            onLiteralValue: onValue,
-            onError: (error, offset, length) => {
+            else {
+                this._configurationModel.removeValue(key);
             }
-        };
-        if (content) {
-            try {
-                visit(content, visitor);
-                raw = currentParent[0] || {};
+        }
+    }
+}
+class NullPolicyConfiguration {
+    constructor() {
+        this.onDidChangeConfiguration = Event.None;
+        this.configurationModel = ( (new ConfigurationModel$1()));
+    }
+    async initialize() { return this.configurationModel; }
+}
+let PolicyConfiguration = class PolicyConfiguration extends Disposable {
+    get configurationModel() { return this._configurationModel; }
+    constructor(defaultConfiguration, policyService, logService) {
+        super();
+        this.defaultConfiguration = defaultConfiguration;
+        this.policyService = policyService;
+        this.logService = logService;
+        this._onDidChangeConfiguration = this._register(( (new Emitter())));
+        this.onDidChangeConfiguration = this._onDidChangeConfiguration.event;
+        this._configurationModel = ( (new ConfigurationModel$1()));
+    }
+    async initialize() {
+        this.logService.trace('PolicyConfiguration#initialize');
+        this.update(await this.updatePolicyDefinitions(this.defaultConfiguration.configurationModel.keys), false);
+        this._register(this.policyService.onDidChange(policyNames => this.onDidChangePolicies(policyNames)));
+        this._register(this.defaultConfiguration.onDidChangeConfiguration(async ({ properties }) => this.update(await this.updatePolicyDefinitions(properties), true)));
+        return this._configurationModel;
+    }
+    async updatePolicyDefinitions(properties) {
+        this.logService.trace('PolicyConfiguration#updatePolicyDefinitions', properties);
+        const policyDefinitions = {};
+        const keys = [];
+        const configurationProperties = ( (Registry.as(Extensions$2.Configuration))).getConfigurationProperties();
+        for (const key of properties) {
+            const config = configurationProperties[key];
+            if (!config) {
+                keys.push(key);
+                continue;
             }
-            catch (e) {
-                console.error(`Error while parsing settings file ${this._name}: ${e}`);
-                this._parseErrors = [e];
+            if (config.policy) {
+                if (config.type !== 'string' && config.type !== 'number') {
+                    this.logService.warn(`Policy ${config.policy.name} has unsupported type ${config.type}`);
+                    continue;
+                }
+                keys.push(key);
+                policyDefinitions[config.policy.name] = { type: config.type };
             }
         }
-        return raw;
+        if (!isEmptyObject(policyDefinitions)) {
+            await this.policyService.updatePolicyDefinitions(policyDefinitions);
+        }
+        return keys;
     }
-    doParseRaw(raw, options) {
-        const configurationProperties = ( (Registry.as(Extensions$2.Configuration))).getConfigurationProperties();
-        const filtered = this.filter(raw, configurationProperties, true, options);
-        raw = filtered.raw;
-        const contents = toValuesTree(raw, message => console.error(`Conflict in settings file ${this._name}: ${message}`));
-        const keys = ( (Object.keys(raw)));
-        const overrides = this.toOverrides(raw, message => console.error(`Conflict in settings file ${this._name}: ${message}`));
-        return { contents, keys, overrides, restricted: filtered.restricted };
+    onDidChangePolicies(policyNames) {
+        this.logService.trace('PolicyConfiguration#onDidChangePolicies', policyNames);
+        const policyConfigurations = ( (Registry.as(Extensions$2.Configuration))).getPolicyConfigurations();
+        const keys = coalesce(policyNames.map(policyName => policyConfigurations.get(policyName)));
+        this.update(keys, true);
     }
-    filter(properties, configurationProperties, filterOverriddenProperties, options) {
-        if (!options?.scopes && !options?.skipRestricted) {
-            return { raw: properties, restricted: [] };
-        }
-        const raw = {};
-        const restricted = [];
-        for (const key in properties) {
-            if (OVERRIDE_PROPERTY_REGEX.test(key) && filterOverriddenProperties) {
-                const result = this.filter(properties[key], configurationProperties, false, options);
-                raw[key] = result.raw;
-                restricted.push(...result.restricted);
+    update(keys, trigger) {
+        this.logService.trace('PolicyConfiguration#update', keys);
+        const configurationProperties = ( (Registry.as(Extensions$2.Configuration))).getConfigurationProperties();
+        const changed = [];
+        const wasEmpty = this._configurationModel.isEmpty();
+        for (const key of keys) {
+            const policyName = configurationProperties[key]?.policy?.name;
+            if (policyName) {
+                const policyValue = this.policyService.getPolicyValue(policyName);
+                if (wasEmpty ? policyValue !== undefined : !equals(this._configurationModel.getValue(key), policyValue)) {
+                    changed.push([key, policyValue]);
+                }
             }
             else {
-                const propertySchema = configurationProperties[key];
-                const scope = propertySchema ? typeof propertySchema.scope !== 'undefined' ? propertySchema.scope : 3  : undefined;
-                if (propertySchema?.restricted) {
-                    restricted.push(key);
-                }
-                if (scope === undefined || options.scopes === undefined || options.scopes.includes(scope)) {
-                    if (!(options.skipRestricted && propertySchema?.restricted)) {
-                        raw[key] = properties[key];
-                    }
+                if (this._configurationModel.getValue(key) !== undefined) {
+                    changed.push([key, undefined]);
                 }
             }
         }
-        return { raw, restricted };
-    }
-    toOverrides(raw, conflictReporter) {
-        const overrides = [];
-        for (const key of ( (Object.keys(raw)))) {
-            if (OVERRIDE_PROPERTY_REGEX.test(key)) {
-                const overrideRaw = {};
-                for (const keyInOverrideRaw in raw[key]) {
-                    overrideRaw[keyInOverrideRaw] = raw[key][keyInOverrideRaw];
+        if (changed.length) {
+            this.logService.trace('PolicyConfiguration#changed', changed);
+            const old = this._configurationModel;
+            this._configurationModel = ( (new ConfigurationModel$1()));
+            for (const key of old.keys) {
+                this._configurationModel.setValue(key, old.getValue(key));
+            }
+            for (const [key, policyValue] of changed) {
+                if (policyValue === undefined) {
+                    this._configurationModel.removeValue(key);
                 }
-                overrides.push({
-                    identifiers: overrideIdentifiersFromKey(key),
-                    keys: ( (Object.keys(overrideRaw))),
-                    contents: toValuesTree(overrideRaw, conflictReporter)
-                });
+                else {
+                    this._configurationModel.setValue(key, policyValue);
+                }
+            }
+            if (trigger) {
+                this._onDidChangeConfiguration.fire(this._configurationModel);
             }
         }
-        return overrides;
     }
+};
+PolicyConfiguration = ( (__decorate([
+    ( (__param(1, IPolicyService))),
+    ( (__param(2, ILogService)))
+], PolicyConfiguration)));
+function isConfigurationOverrides(thing) {
+    return thing
+        && typeof thing === 'object'
+        && (!thing.overrideIdentifier || typeof thing.overrideIdentifier === 'string')
+        && (!thing.resource || thing.resource instanceof URI);
 }
-class UserSettings extends Disposable {
-    constructor(userSettingsResource, scopes, extUri, fileService) {
-        super();
-        this.userSettingsResource = userSettingsResource;
-        this.scopes = scopes;
-        this.fileService = fileService;
-        this._onDidChange = this._register(( (new Emitter())));
-        this.onDidChange = this._onDidChange.event;
-        this.parser = ( (new ConfigurationModelParser( (this.userSettingsResource.toString()))));
-        this.parseOptions = { scopes: this.scopes };
-        this._register(this.fileService.watch(extUri.dirname(this.userSettingsResource)));
-        this._register(this.fileService.watch(this.userSettingsResource));
-        this._register(Event.any(Event.filter(this.fileService.onDidFilesChange, e => e.contains(this.userSettingsResource)), Event.filter(this.fileService.onDidRunOperation, e => (e.isOperation(0 ) || e.isOperation(3 ) || e.isOperation(1 ) || e.isOperation(4 )) && extUri.isEqual(e.resource, userSettingsResource)))(() => this._onDidChange.fire()));
+class StandaloneConfigurationService {
+    constructor() {
+        this._onDidChangeConfiguration = ( (new Emitter()));
+        this.onDidChangeConfiguration = this._onDidChangeConfiguration.event;
+        const defaultConfiguration = ( (new DefaultConfiguration$1()));
+        this._configuration = ( (new Configuration$1(
+            defaultConfiguration.reload(),
+             (new ConfigurationModel$1()),
+             (new ConfigurationModel$1()),
+             (new ConfigurationModel$1())
+        )));
+        defaultConfiguration.dispose();
     }
-    async loadConfiguration() {
-        try {
-            const content = await this.fileService.readFile(this.userSettingsResource);
-            this.parser.parse(( (content.value.toString())) || '{}', this.parseOptions);
-            return this.parser.configurationModel;
-        }
-        catch (e) {
-            return (
-                 (new ConfigurationModel())
-            );
-        }
+    getValue(arg1, arg2) {
+        const section = typeof arg1 === 'string' ? arg1 : undefined;
+        const overrides = isConfigurationOverrides(arg1) ? arg1 : isConfigurationOverrides(arg2) ? arg2 : {};
+        return this._configuration.getValue(section, overrides, undefined);
     }
-    reparse() {
-        this.parser.reparse(this.parseOptions);
-        return this.parser.configurationModel;
+    updateValues(values) {
+        const previous = { data: this._configuration.toData() };
+        const changedKeys = [];
+        for (const entry of values) {
+            const [key, value] = entry;
+            if (this.getValue(key) === value) {
+                continue;
+            }
+            this._configuration.updateValue(key, value);
+            changedKeys.push(key);
+        }
+        if (changedKeys.length > 0) {
+            const configurationChangeEvent = ( (new ConfigurationChangeEvent({ keys: changedKeys, overrides: [] }, previous, this._configuration)));
+            configurationChangeEvent.source = 8 ;
+            configurationChangeEvent.sourceConfig = null;
+            this._onDidChangeConfiguration.fire(configurationChangeEvent);
+        }
+        return Promise.resolve();
     }
-    getRestrictedSettings() {
-        return this.parser.restrictedConfigurations;
+    updateValue(key, value, arg3, arg4) {
+        return this.updateValues([[key, value]]);
     }
-}
-class Configuration {
-    constructor(_defaultConfiguration, _policyConfiguration, _applicationConfiguration, _localUserConfiguration, _remoteUserConfiguration = ( (new ConfigurationModel())), _workspaceConfiguration = ( (new ConfigurationModel())), _folderConfigurations = ( (new ResourceMap$1())), _memoryConfiguration = ( (new ConfigurationModel())), _memoryConfigurationByResource = ( (new ResourceMap$1())), _freeze = true) {
-        this._defaultConfiguration = _defaultConfiguration;
-        this._policyConfiguration = _policyConfiguration;
-        this._applicationConfiguration = _applicationConfiguration;
-        this._localUserConfiguration = _localUserConfiguration;
-        this._remoteUserConfiguration = _remoteUserConfiguration;
-        this._workspaceConfiguration = _workspaceConfiguration;
-        this._folderConfigurations = _folderConfigurations;
-        this._memoryConfiguration = _memoryConfiguration;
-        this._memoryConfigurationByResource = _memoryConfigurationByResource;
-        this._freeze = _freeze;
-        this._workspaceConsolidatedConfiguration = null;
-        this._foldersConsolidatedConfigurations = ( (new ResourceMap$1()));
-        this._userConfiguration = null;
+    inspect(key, options = {}) {
+        return this._configuration.inspect(key, options, undefined);
     }
-    getValue(section, overrides, workspace) {
-        const consolidateConfigurationModel = this.getConsolidatedConfigurationModel(section, overrides, workspace);
-        return consolidateConfigurationModel.getValue(section);
+    keys() {
+        return (
+             (this._configuration.keys(undefined))
+        );
     }
-    updateValue(key, value, overrides = {}) {
-        let memoryConfiguration;
-        if (overrides.resource) {
-            memoryConfiguration = this._memoryConfigurationByResource.get(overrides.resource);
-            if (!memoryConfiguration) {
-                memoryConfiguration = ( (new ConfigurationModel()));
-                this._memoryConfigurationByResource.set(overrides.resource, memoryConfiguration);
-            }
-        }
-        else {
-            memoryConfiguration = this._memoryConfiguration;
-        }
-        if (value === undefined) {
-            memoryConfiguration.removeValue(key);
-        }
-        else {
-            memoryConfiguration.setValue(key, value);
-        }
-        if (!overrides.resource) {
-            this._workspaceConsolidatedConfiguration = null;
-        }
+    reloadConfiguration() {
+        return Promise.resolve(undefined);
     }
-    inspect(key, overrides, workspace) {
-        const consolidateConfigurationModel = this.getConsolidatedConfigurationModel(key, overrides, workspace);
-        const folderConfigurationModel = this.getFolderConfigurationModelForResource(overrides.resource, workspace);
-        const memoryConfigurationModel = overrides.resource ? this._memoryConfigurationByResource.get(overrides.resource) || this._memoryConfiguration : this._memoryConfiguration;
-        const defaultValue = overrides.overrideIdentifier ? this._defaultConfiguration.freeze().override(overrides.overrideIdentifier).getValue(key) : this._defaultConfiguration.freeze().getValue(key);
-        const policyValue = this._policyConfiguration.isEmpty() ? undefined : this._policyConfiguration.freeze().getValue(key);
-        const applicationValue = this.applicationConfiguration.isEmpty() ? undefined : this.applicationConfiguration.freeze().getValue(key);
-        const userValue = overrides.overrideIdentifier ? this.userConfiguration.freeze().override(overrides.overrideIdentifier).getValue(key) : this.userConfiguration.freeze().getValue(key);
-        const userLocalValue = overrides.overrideIdentifier ? this.localUserConfiguration.freeze().override(overrides.overrideIdentifier).getValue(key) : this.localUserConfiguration.freeze().getValue(key);
-        const userRemoteValue = overrides.overrideIdentifier ? this.remoteUserConfiguration.freeze().override(overrides.overrideIdentifier).getValue(key) : this.remoteUserConfiguration.freeze().getValue(key);
-        const workspaceValue = workspace ? overrides.overrideIdentifier ? this._workspaceConfiguration.freeze().override(overrides.overrideIdentifier).getValue(key) : this._workspaceConfiguration.freeze().getValue(key) : undefined;
-        const workspaceFolderValue = folderConfigurationModel ? overrides.overrideIdentifier ? folderConfigurationModel.freeze().override(overrides.overrideIdentifier).getValue(key) : folderConfigurationModel.freeze().getValue(key) : undefined;
-        const memoryValue = overrides.overrideIdentifier ? memoryConfigurationModel.override(overrides.overrideIdentifier).getValue(key) : memoryConfigurationModel.getValue(key);
-        const value = consolidateConfigurationModel.getValue(key);
-        const overrideIdentifiers = distinct(consolidateConfigurationModel.overrides.map(override => override.identifiers).flat()).filter(overrideIdentifier => consolidateConfigurationModel.getOverrideValue(key, overrideIdentifier) !== undefined);
-        return {
-            defaultValue,
-            policyValue,
-            applicationValue,
-            userValue,
-            userLocalValue,
-            userRemoteValue,
-            workspaceValue,
-            workspaceFolderValue,
-            memoryValue,
-            value,
-            default: defaultValue !== undefined ? { value: this._defaultConfiguration.freeze().getValue(key), override: overrides.overrideIdentifier ? this._defaultConfiguration.freeze().getOverrideValue(key, overrides.overrideIdentifier) : undefined } : undefined,
-            policy: policyValue !== undefined ? { value: policyValue } : undefined,
-            application: applicationValue !== undefined ? { value: applicationValue, override: overrides.overrideIdentifier ? this.applicationConfiguration.freeze().getOverrideValue(key, overrides.overrideIdentifier) : undefined } : undefined,
-            user: userValue !== undefined ? { value: this.userConfiguration.freeze().getValue(key), override: overrides.overrideIdentifier ? this.userConfiguration.freeze().getOverrideValue(key, overrides.overrideIdentifier) : undefined } : undefined,
-            userLocal: userLocalValue !== undefined ? { value: this.localUserConfiguration.freeze().getValue(key), override: overrides.overrideIdentifier ? this.localUserConfiguration.freeze().getOverrideValue(key, overrides.overrideIdentifier) : undefined } : undefined,
-            userRemote: userRemoteValue !== undefined ? { value: this.remoteUserConfiguration.freeze().getValue(key), override: overrides.overrideIdentifier ? this.remoteUserConfiguration.freeze().getOverrideValue(key, overrides.overrideIdentifier) : undefined } : undefined,
-            workspace: workspaceValue !== undefined ? { value: this._workspaceConfiguration.freeze().getValue(key), override: overrides.overrideIdentifier ? this._workspaceConfiguration.freeze().getOverrideValue(key, overrides.overrideIdentifier) : undefined } : undefined,
-            workspaceFolder: workspaceFolderValue !== undefined ? { value: folderConfigurationModel?.freeze().getValue(key), override: overrides.overrideIdentifier ? folderConfigurationModel?.freeze().getOverrideValue(key, overrides.overrideIdentifier) : undefined } : undefined,
-            memory: memoryValue !== undefined ? { value: memoryConfigurationModel.getValue(key), override: overrides.overrideIdentifier ? memoryConfigurationModel.getOverrideValue(key, overrides.overrideIdentifier) : undefined } : undefined,
-            overrideIdentifiers: overrideIdentifiers.length ? overrideIdentifiers : undefined
+    getConfigurationData() {
+        const emptyModel = {
+            contents: {},
+            keys: [],
+            overrides: []
         };
-    }
-    keys(workspace) {
-        const folderConfigurationModel = this.getFolderConfigurationModelForResource(undefined, workspace);
         return {
-            default: this._defaultConfiguration.freeze().keys,
-            user: this.userConfiguration.freeze().keys,
-            workspace: this._workspaceConfiguration.freeze().keys,
-            workspaceFolder: folderConfigurationModel ? folderConfigurationModel.freeze().keys : []
+            defaults: emptyModel,
+            policy: emptyModel,
+            application: emptyModel,
+            user: emptyModel,
+            workspace: emptyModel,
+            folders: []
         };
     }
-    updateDefaultConfiguration(defaultConfiguration) {
-        this._defaultConfiguration = defaultConfiguration;
-        this._workspaceConsolidatedConfiguration = null;
-        this._foldersConsolidatedConfigurations.clear();
+}
+class StringIterator {
+    constructor() {
+        this._value = '';
+        this._pos = 0;
     }
-    updatePolicyConfiguration(policyConfiguration) {
-        this._policyConfiguration = policyConfiguration;
+    reset(key) {
+        this._value = key;
+        this._pos = 0;
+        return this;
     }
-    updateApplicationConfiguration(applicationConfiguration) {
-        this._applicationConfiguration = applicationConfiguration;
-        this._workspaceConsolidatedConfiguration = null;
-        this._foldersConsolidatedConfigurations.clear();
+    next() {
+        this._pos += 1;
+        return this;
     }
-    updateLocalUserConfiguration(localUserConfiguration) {
-        this._localUserConfiguration = localUserConfiguration;
-        this._userConfiguration = null;
-        this._workspaceConsolidatedConfiguration = null;
-        this._foldersConsolidatedConfigurations.clear();
+    hasNext() {
+        return this._pos < this._value.length - 1;
     }
-    updateRemoteUserConfiguration(remoteUserConfiguration) {
-        this._remoteUserConfiguration = remoteUserConfiguration;
-        this._userConfiguration = null;
-        this._workspaceConsolidatedConfiguration = null;
-        this._foldersConsolidatedConfigurations.clear();
+    cmp(a) {
+        const aCode = a.charCodeAt(0);
+        const thisCode = this._value.charCodeAt(this._pos);
+        return aCode - thisCode;
     }
-    updateWorkspaceConfiguration(workspaceConfiguration) {
-        this._workspaceConfiguration = workspaceConfiguration;
-        this._workspaceConsolidatedConfiguration = null;
-        this._foldersConsolidatedConfigurations.clear();
+    value() {
+        return this._value[this._pos];
     }
-    updateFolderConfiguration(resource, configuration) {
-        this._folderConfigurations.set(resource, configuration);
-        this._foldersConsolidatedConfigurations.delete(resource);
+}
+class ConfigKeysIterator {
+    constructor(_caseSensitive = true) {
+        this._caseSensitive = _caseSensitive;
     }
-    deleteFolderConfiguration(resource) {
-        this.folderConfigurations.delete(resource);
-        this._foldersConsolidatedConfigurations.delete(resource);
+    reset(key) {
+        this._value = key;
+        this._from = 0;
+        this._to = 0;
+        return this.next();
     }
-    compareAndUpdateDefaultConfiguration(defaults, keys) {
-        const overrides = [];
-        if (!keys) {
-            const { added, updated, removed } = compare(this._defaultConfiguration, defaults);
-            keys = [...added, ...updated, ...removed];
-        }
-        for (const key of keys) {
-            for (const overrideIdentifier of overrideIdentifiersFromKey(key)) {
-                const fromKeys = this._defaultConfiguration.getKeysForOverrideIdentifier(overrideIdentifier);
-                const toKeys = defaults.getKeysForOverrideIdentifier(overrideIdentifier);
-                const keys = [
-                    ...toKeys.filter(key => fromKeys.indexOf(key) === -1),
-                    ...fromKeys.filter(key => toKeys.indexOf(key) === -1),
-                    ...fromKeys.filter(key => !equals(this._defaultConfiguration.override(overrideIdentifier).getValue(key), defaults.override(overrideIdentifier).getValue(key)))
-                ];
-                overrides.push([overrideIdentifier, keys]);
+    hasNext() {
+        return this._to < this._value.length;
+    }
+    next() {
+        this._from = this._to;
+        let justSeps = true;
+        for (; this._to < this._value.length; this._to++) {
+            const ch = this._value.charCodeAt(this._to);
+            if (ch === 46 ) {
+                if (justSeps) {
+                    this._from++;
+                }
+                else {
+                    break;
+                }
+            }
+            else {
+                justSeps = false;
             }
         }
-        this.updateDefaultConfiguration(defaults);
-        return { keys, overrides };
+        return this;
     }
-    compareAndUpdatePolicyConfiguration(policyConfiguration) {
-        const { added, updated, removed } = compare(this._policyConfiguration, policyConfiguration);
-        const keys = [...added, ...updated, ...removed];
-        if (keys.length) {
-            this.updatePolicyConfiguration(policyConfiguration);
-        }
-        return { keys, overrides: [] };
+    cmp(a) {
+        return this._caseSensitive
+            ? compareSubstring(a, this._value, 0, a.length, this._from, this._to)
+            : compareSubstringIgnoreCase(a, this._value, 0, a.length, this._from, this._to);
     }
-    compareAndUpdateApplicationConfiguration(application) {
-        const { added, updated, removed, overrides } = compare(this.applicationConfiguration, application);
-        const keys = [...added, ...updated, ...removed];
-        if (keys.length) {
-            this.updateApplicationConfiguration(application);
-        }
-        return { keys, overrides };
+    value() {
+        return this._value.substring(this._from, this._to);
     }
-    compareAndUpdateLocalUserConfiguration(user) {
-        const { added, updated, removed, overrides } = compare(this.localUserConfiguration, user);
-        const keys = [...added, ...updated, ...removed];
-        if (keys.length) {
-            this.updateLocalUserConfiguration(user);
-        }
-        return { keys, overrides };
+}
+class PathIterator {
+    constructor(_splitOnBackslash = true, _caseSensitive = true) {
+        this._splitOnBackslash = _splitOnBackslash;
+        this._caseSensitive = _caseSensitive;
     }
-    compareAndUpdateRemoteUserConfiguration(user) {
-        const { added, updated, removed, overrides } = compare(this.remoteUserConfiguration, user);
-        const keys = [...added, ...updated, ...removed];
-        if (keys.length) {
-            this.updateRemoteUserConfiguration(user);
+    reset(key) {
+        this._from = 0;
+        this._to = 0;
+        this._value = key;
+        this._valueLen = key.length;
+        for (let pos = key.length - 1; pos >= 0; pos--, this._valueLen--) {
+            const ch = this._value.charCodeAt(pos);
+            if (!((ch === 47  || this._splitOnBackslash && ch === 92) )) {
+                break;
+            }
         }
-        return { keys, overrides };
+        return this.next();
     }
-    compareAndUpdateWorkspaceConfiguration(workspaceConfiguration) {
-        const { added, updated, removed, overrides } = compare(this.workspaceConfiguration, workspaceConfiguration);
-        const keys = [...added, ...updated, ...removed];
-        if (keys.length) {
-            this.updateWorkspaceConfiguration(workspaceConfiguration);
-        }
-        return { keys, overrides };
+    hasNext() {
+        return this._to < this._valueLen;
     }
-    compareAndUpdateFolderConfiguration(resource, folderConfiguration) {
-        const currentFolderConfiguration = this.folderConfigurations.get(resource);
-        const { added, updated, removed, overrides } = compare(currentFolderConfiguration, folderConfiguration);
-        const keys = [...added, ...updated, ...removed];
-        if (keys.length || !currentFolderConfiguration) {
-            this.updateFolderConfiguration(resource, folderConfiguration);
-        }
-        return { keys, overrides };
-    }
-    compareAndDeleteFolderConfiguration(folder) {
-        const folderConfig = this.folderConfigurations.get(folder);
-        if (!folderConfig) {
-            throw new Error('Unknown folder');
-        }
-        this.deleteFolderConfiguration(folder);
-        const { added, updated, removed, overrides } = compare(folderConfig, undefined);
-        return { keys: [...added, ...updated, ...removed], overrides };
-    }
-    get defaults() {
-        return this._defaultConfiguration;
-    }
-    get applicationConfiguration() {
-        return this._applicationConfiguration;
-    }
-    get userConfiguration() {
-        if (!this._userConfiguration) {
-            this._userConfiguration = this._remoteUserConfiguration.isEmpty() ? this._localUserConfiguration : this._localUserConfiguration.merge(this._remoteUserConfiguration);
-            if (this._freeze) {
-                this._userConfiguration.freeze();
+    next() {
+        this._from = this._to;
+        let justSeps = true;
+        for (; this._to < this._valueLen; this._to++) {
+            const ch = this._value.charCodeAt(this._to);
+            if (ch === 47  || this._splitOnBackslash && ch === 92 ) {
+                if (justSeps) {
+                    this._from++;
+                }
+                else {
+                    break;
+                }
+            }
+            else {
+                justSeps = false;
             }
         }
-        return this._userConfiguration;
-    }
-    get localUserConfiguration() {
-        return this._localUserConfiguration;
+        return this;
     }
-    get remoteUserConfiguration() {
-        return this._remoteUserConfiguration;
+    cmp(a) {
+        return this._caseSensitive
+            ? compareSubstring(a, this._value, 0, a.length, this._from, this._to)
+            : compareSubstringIgnoreCase(a, this._value, 0, a.length, this._from, this._to);
     }
-    get workspaceConfiguration() {
-        return this._workspaceConfiguration;
+    value() {
+        return this._value.substring(this._from, this._to);
     }
-    get folderConfigurations() {
-        return this._folderConfigurations;
+}
+class UriIterator {
+    constructor(_ignorePathCasing, _ignoreQueryAndFragment) {
+        this._ignorePathCasing = _ignorePathCasing;
+        this._ignoreQueryAndFragment = _ignoreQueryAndFragment;
+        this._states = [];
+        this._stateIdx = 0;
     }
-    getConsolidatedConfigurationModel(section, overrides, workspace) {
-        let configurationModel = this.getConsolidatedConfigurationModelForResource(overrides, workspace);
-        if (overrides.overrideIdentifier) {
-            configurationModel = configurationModel.override(overrides.overrideIdentifier);
+    reset(key) {
+        this._value = key;
+        this._states = [];
+        if (this._value.scheme) {
+            this._states.push(1 );
         }
-        if (!this._policyConfiguration.isEmpty() && this._policyConfiguration.getValue(section) !== undefined) {
-            configurationModel = configurationModel.merge(this._policyConfiguration);
+        if (this._value.authority) {
+            this._states.push(2 );
         }
-        return configurationModel;
-    }
-    getConsolidatedConfigurationModelForResource({ resource }, workspace) {
-        let consolidateConfiguration = this.getWorkspaceConsolidatedConfiguration();
-        if (workspace && resource) {
-            const root = workspace.getFolder(resource);
-            if (root) {
-                consolidateConfiguration = this.getFolderConsolidatedConfiguration(root.uri) || consolidateConfiguration;
+        if (this._value.path) {
+            this._pathIterator = ( (new PathIterator(false, !this._ignorePathCasing(key))));
+            this._pathIterator.reset(key.path);
+            if (this._pathIterator.value()) {
+                this._states.push(3 );
             }
-            const memoryConfigurationForResource = this._memoryConfigurationByResource.get(resource);
-            if (memoryConfigurationForResource) {
-                consolidateConfiguration = consolidateConfiguration.merge(memoryConfigurationForResource);
+        }
+        if (!this._ignoreQueryAndFragment(key)) {
+            if (this._value.query) {
+                this._states.push(4 );
+            }
+            if (this._value.fragment) {
+                this._states.push(5 );
             }
         }
-        return consolidateConfiguration;
+        this._stateIdx = 0;
+        return this;
     }
-    getWorkspaceConsolidatedConfiguration() {
-        if (!this._workspaceConsolidatedConfiguration) {
-            this._workspaceConsolidatedConfiguration = this._defaultConfiguration.merge(this.applicationConfiguration, this.userConfiguration, this._workspaceConfiguration, this._memoryConfiguration);
-            if (this._freeze) {
-                this._workspaceConfiguration = this._workspaceConfiguration.freeze();
-            }
+    next() {
+        if (this._states[this._stateIdx] === 3  && this._pathIterator.hasNext()) {
+            this._pathIterator.next();
         }
-        return this._workspaceConsolidatedConfiguration;
+        else {
+            this._stateIdx += 1;
+        }
+        return this;
     }
-    getFolderConsolidatedConfiguration(folder) {
-        let folderConsolidatedConfiguration = this._foldersConsolidatedConfigurations.get(folder);
-        if (!folderConsolidatedConfiguration) {
-            const workspaceConsolidateConfiguration = this.getWorkspaceConsolidatedConfiguration();
-            const folderConfiguration = this._folderConfigurations.get(folder);
-            if (folderConfiguration) {
-                folderConsolidatedConfiguration = workspaceConsolidateConfiguration.merge(folderConfiguration);
-                if (this._freeze) {
-                    folderConsolidatedConfiguration = folderConsolidatedConfiguration.freeze();
-                }
-                this._foldersConsolidatedConfigurations.set(folder, folderConsolidatedConfiguration);
-            }
-            else {
-                folderConsolidatedConfiguration = workspaceConsolidateConfiguration;
-            }
+    hasNext() {
+        return (this._states[this._stateIdx] === 3  && this._pathIterator.hasNext())
+            || this._stateIdx < this._states.length - 1;
+    }
+    cmp(a) {
+        if (this._states[this._stateIdx] === 1 ) {
+            return compareIgnoreCase(a, this._value.scheme);
         }
-        return folderConsolidatedConfiguration;
+        else if (this._states[this._stateIdx] === 2 ) {
+            return compareIgnoreCase(a, this._value.authority);
+        }
+        else if (this._states[this._stateIdx] === 3 ) {
+            return this._pathIterator.cmp(a);
+        }
+        else if (this._states[this._stateIdx] === 4 ) {
+            return compare$1(a, this._value.query);
+        }
+        else if (this._states[this._stateIdx] === 5 ) {
+            return compare$1(a, this._value.fragment);
+        }
+        throw new Error();
     }
-    getFolderConfigurationModelForResource(resource, workspace) {
-        if (workspace && resource) {
-            const root = workspace.getFolder(resource);
-            if (root) {
-                return this._folderConfigurations.get(root.uri);
-            }
+    value() {
+        if (this._states[this._stateIdx] === 1 ) {
+            return this._value.scheme;
         }
-        return undefined;
+        else if (this._states[this._stateIdx] === 2 ) {
+            return this._value.authority;
+        }
+        else if (this._states[this._stateIdx] === 3 ) {
+            return this._pathIterator.value();
+        }
+        else if (this._states[this._stateIdx] === 4 ) {
+            return this._value.query;
+        }
+        else if (this._states[this._stateIdx] === 5 ) {
+            return this._value.fragment;
+        }
+        throw new Error();
     }
-    toData() {
-        return {
-            defaults: {
-                contents: this._defaultConfiguration.contents,
-                overrides: this._defaultConfiguration.overrides,
-                keys: this._defaultConfiguration.keys
-            },
-            policy: {
-                contents: this._policyConfiguration.contents,
-                overrides: this._policyConfiguration.overrides,
-                keys: this._policyConfiguration.keys
-            },
-            application: {
-                contents: this.applicationConfiguration.contents,
-                overrides: this.applicationConfiguration.overrides,
-                keys: this.applicationConfiguration.keys
-            },
-            user: {
-                contents: this.userConfiguration.contents,
-                overrides: this.userConfiguration.overrides,
-                keys: this.userConfiguration.keys
-            },
-            workspace: {
-                contents: this._workspaceConfiguration.contents,
-                overrides: this._workspaceConfiguration.overrides,
-                keys: this._workspaceConfiguration.keys
-            },
-            folders: [...( (this._folderConfigurations.keys()))].reduce((result, folder) => {
-                const { contents, overrides, keys } = this._folderConfigurations.get(folder);
-                result.push([folder, { contents, overrides, keys }]);
-                return result;
-            }, [])
-        };
+}
+class TernarySearchTreeNode {
+    constructor() {
+        this.height = 1;
     }
-    allKeys() {
-        const keys = ( (new Set()));
-        this._defaultConfiguration.freeze().keys.forEach(key => keys.add(key));
-        this.userConfiguration.freeze().keys.forEach(key => keys.add(key));
-        this._workspaceConfiguration.freeze().keys.forEach(key => keys.add(key));
-        this._folderConfigurations.forEach(folderConfiguraiton => folderConfiguraiton.freeze().keys.forEach(key => keys.add(key)));
-        return [...( (keys.values()))];
+    isEmpty() {
+        return !this.left && !this.mid && !this.right && !this.value;
     }
-    allOverrideIdentifiers() {
-        const keys = ( (new Set()));
-        this._defaultConfiguration.freeze().getAllOverrideIdentifiers().forEach(key => keys.add(key));
-        this.userConfiguration.freeze().getAllOverrideIdentifiers().forEach(key => keys.add(key));
-        this._workspaceConfiguration.freeze().getAllOverrideIdentifiers().forEach(key => keys.add(key));
-        this._folderConfigurations.forEach(folderConfiguraiton => folderConfiguraiton.freeze().getAllOverrideIdentifiers().forEach(key => keys.add(key)));
-        return [...( (keys.values()))];
+    rotateLeft() {
+        const tmp = this.right;
+        this.right = tmp.left;
+        tmp.left = this;
+        this.updateHeight();
+        tmp.updateHeight();
+        return tmp;
     }
-    getAllKeysForOverrideIdentifier(overrideIdentifier) {
-        const keys = ( (new Set()));
-        this._defaultConfiguration.getKeysForOverrideIdentifier(overrideIdentifier).forEach(key => keys.add(key));
-        this.userConfiguration.getKeysForOverrideIdentifier(overrideIdentifier).forEach(key => keys.add(key));
-        this._workspaceConfiguration.getKeysForOverrideIdentifier(overrideIdentifier).forEach(key => keys.add(key));
-        this._folderConfigurations.forEach(folderConfiguraiton => folderConfiguraiton.getKeysForOverrideIdentifier(overrideIdentifier).forEach(key => keys.add(key)));
-        return [...( (keys.values()))];
+    rotateRight() {
+        const tmp = this.left;
+        this.left = tmp.right;
+        tmp.right = this;
+        this.updateHeight();
+        tmp.updateHeight();
+        return tmp;
     }
-    static parse(data) {
-        const defaultConfiguration = this.parseConfigurationModel(data.defaults);
-        const policyConfiguration = this.parseConfigurationModel(data.policy);
-        const applicationConfiguration = this.parseConfigurationModel(data.application);
-        const userConfiguration = this.parseConfigurationModel(data.user);
-        const workspaceConfiguration = this.parseConfigurationModel(data.workspace);
-        const folders = data.folders.reduce((result, value) => {
-            result.set(URI.revive(value[0]), this.parseConfigurationModel(value[1]));
-            return result;
-        }, ( (new ResourceMap$1())));
+    updateHeight() {
+        this.height = 1 + Math.max(this.heightLeft, this.heightRight);
+    }
+    balanceFactor() {
+        return this.heightRight - this.heightLeft;
+    }
+    get heightLeft() {
+        return this.left?.height ?? 0;
+    }
+    get heightRight() {
+        return this.right?.height ?? 0;
+    }
+}
+class TernarySearchTree {
+    static forUris(ignorePathCasing = () => false, ignoreQueryAndFragment = () => false) {
         return (
-             (new Configuration(
-                defaultConfiguration,
-                policyConfiguration,
-                applicationConfiguration,
-                userConfiguration,
-                 (new ConfigurationModel()),
-                workspaceConfiguration,
-                folders,
-                 (new ConfigurationModel()),
-                 (new ResourceMap$1()),
-                false
-            ))
+             (new TernarySearchTree( (new UriIterator(ignorePathCasing, ignoreQueryAndFragment))))
         );
     }
-    static parseConfigurationModel(model) {
-        return ( (new ConfigurationModel(model.contents, model.keys, model.overrides))).freeze();
+    static forPaths(ignorePathCasing = false) {
+        return (
+             (new TernarySearchTree( (new PathIterator(undefined, !ignorePathCasing))))
+        );
     }
-}
-function compare(from, to) {
-    const { added, removed, updated } = compareConfigurationContents(to, from);
-    const overrides = [];
-    const fromOverrideIdentifiers = from?.getAllOverrideIdentifiers() || [];
-    const toOverrideIdentifiers = to?.getAllOverrideIdentifiers() || [];
-    if (to) {
-        const addedOverrideIdentifiers = toOverrideIdentifiers.filter(key => !fromOverrideIdentifiers.includes(key));
-        for (const identifier of addedOverrideIdentifiers) {
-            overrides.push([identifier, to.getKeysForOverrideIdentifier(identifier)]);
+    static forStrings() {
+        return (
+             (new TernarySearchTree( (new StringIterator())))
+        );
+    }
+    static forConfigKeys() {
+        return (
+             (new TernarySearchTree( (new ConfigKeysIterator())))
+        );
+    }
+    constructor(segments) {
+        this._iter = segments;
+    }
+    clear() {
+        this._root = undefined;
+    }
+    fill(values, keys) {
+        if (keys) {
+            const arr = keys.slice(0);
+            shuffle(arr);
+            for (const k of arr) {
+                this.set(k, values);
+            }
+        }
+        else {
+            const arr = values.slice(0);
+            shuffle(arr);
+            for (const entry of arr) {
+                this.set(entry[0], entry[1]);
+            }
         }
     }
-    if (from) {
-        const removedOverrideIdentifiers = fromOverrideIdentifiers.filter(key => !toOverrideIdentifiers.includes(key));
-        for (const identifier of removedOverrideIdentifiers) {
-            overrides.push([identifier, from.getKeysForOverrideIdentifier(identifier)]);
+    set(key, element) {
+        const iter = this._iter.reset(key);
+        let node;
+        if (!this._root) {
+            this._root = ( (new TernarySearchTreeNode()));
+            this._root.segment = iter.value();
+        }
+        const stack = [];
+        node = this._root;
+        while (true) {
+            const val = iter.cmp(node.segment);
+            if (val > 0) {
+                if (!node.left) {
+                    node.left = ( (new TernarySearchTreeNode()));
+                    node.left.segment = iter.value();
+                }
+                stack.push([-1 , node]);
+                node = node.left;
+            }
+            else if (val < 0) {
+                if (!node.right) {
+                    node.right = ( (new TernarySearchTreeNode()));
+                    node.right.segment = iter.value();
+                }
+                stack.push([1 , node]);
+                node = node.right;
+            }
+            else if (iter.hasNext()) {
+                iter.next();
+                if (!node.mid) {
+                    node.mid = ( (new TernarySearchTreeNode()));
+                    node.mid.segment = iter.value();
+                }
+                stack.push([0 , node]);
+                node = node.mid;
+            }
+            else {
+                break;
+            }
+        }
+        const oldElement = node.value;
+        node.value = element;
+        node.key = key;
+        for (let i = stack.length - 1; i >= 0; i--) {
+            const node = stack[i][1];
+            node.updateHeight();
+            const bf = node.balanceFactor();
+            if (bf < -1 || bf > 1) {
+                const d1 = stack[i][0];
+                const d2 = stack[i + 1][0];
+                if (d1 === 1  && d2 === 1 ) {
+                    stack[i][1] = node.rotateLeft();
+                }
+                else if (d1 === -1  && d2 === -1 ) {
+                    stack[i][1] = node.rotateRight();
+                }
+                else if (d1 === 1  && d2 === -1 ) {
+                    node.right = stack[i + 1][1] = stack[i + 1][1].rotateRight();
+                    stack[i][1] = node.rotateLeft();
+                }
+                else if (d1 === -1  && d2 === 1 ) {
+                    node.left = stack[i + 1][1] = stack[i + 1][1].rotateLeft();
+                    stack[i][1] = node.rotateRight();
+                }
+                else {
+                    throw new Error();
+                }
+                if (i > 0) {
+                    switch (stack[i - 1][0]) {
+                        case -1 :
+                            stack[i - 1][1].left = stack[i][1];
+                            break;
+                        case 1 :
+                            stack[i - 1][1].right = stack[i][1];
+                            break;
+                        case 0 :
+                            stack[i - 1][1].mid = stack[i][1];
+                            break;
+                    }
+                }
+                else {
+                    this._root = stack[0][1];
+                }
+            }
         }
+        return oldElement;
     }
-    if (to && from) {
-        for (const identifier of fromOverrideIdentifiers) {
-            if (toOverrideIdentifiers.includes(identifier)) {
-                const result = compareConfigurationContents({ contents: from.getOverrideValue(undefined, identifier) || {}, keys: from.getKeysForOverrideIdentifier(identifier) }, { contents: to.getOverrideValue(undefined, identifier) || {}, keys: to.getKeysForOverrideIdentifier(identifier) });
-                overrides.push([identifier, [...result.added, ...result.removed, ...result.updated]]);
+    get(key) {
+        return this._getNode(key)?.value;
+    }
+    _getNode(key) {
+        const iter = this._iter.reset(key);
+        let node = this._root;
+        while (node) {
+            const val = iter.cmp(node.segment);
+            if (val > 0) {
+                node = node.left;
+            }
+            else if (val < 0) {
+                node = node.right;
+            }
+            else if (iter.hasNext()) {
+                iter.next();
+                node = node.mid;
+            }
+            else {
+                break;
             }
         }
+        return node;
     }
-    return { added, removed, updated, overrides };
-}
-function compareConfigurationContents(to, from) {
-    const added = to
-        ? from ? to.keys.filter(key => from.keys.indexOf(key) === -1) : [...to.keys]
-        : [];
-    const removed = from
-        ? to ? from.keys.filter(key => to.keys.indexOf(key) === -1) : [...from.keys]
-        : [];
-    const updated = [];
-    if (to && from) {
-        for (const key of from.keys) {
-            if (to.keys.indexOf(key) !== -1) {
-                const value1 = getConfigurationValue(from.contents, key);
-                const value2 = getConfigurationValue(to.contents, key);
-                if (!equals(value1, value2)) {
-                    updated.push(key);
-                }
+    has(key) {
+        const node = this._getNode(key);
+        return !(node?.value === undefined && node?.mid === undefined);
+    }
+    delete(key) {
+        return this._delete(key, false);
+    }
+    deleteSuperstr(key) {
+        return this._delete(key, true);
+    }
+    _delete(key, superStr) {
+        const iter = this._iter.reset(key);
+        const stack = [];
+        let node = this._root;
+        while (node) {
+            const val = iter.cmp(node.segment);
+            if (val > 0) {
+                stack.push([-1 , node]);
+                node = node.left;
+            }
+            else if (val < 0) {
+                stack.push([1 , node]);
+                node = node.right;
+            }
+            else if (iter.hasNext()) {
+                iter.next();
+                stack.push([0 , node]);
+                node = node.mid;
+            }
+            else {
+                break;
             }
         }
-    }
-    return { added, removed, updated };
-}
-function now() {
-    return ( (new Date())).toISOString();
-}
-var LogLevel;
-( ((function(LogLevel) {
-    LogLevel[LogLevel["Trace"] = 0] = "Trace";
-    LogLevel[LogLevel["Debug"] = 1] = "Debug";
-    LogLevel[LogLevel["Info"] = 2] = "Info";
-    LogLevel[LogLevel["Warning"] = 3] = "Warning";
-    LogLevel[LogLevel["Error"] = 4] = "Error";
-    LogLevel[LogLevel["Critical"] = 5] = "Critical";
-    LogLevel[LogLevel["Off"] = 6] = "Off";
-})(LogLevel || (LogLevel = {}))));
-const DEFAULT_LOG_LEVEL = LogLevel.Info;
-class AbstractLogger extends Disposable {
-    constructor() {
-        super(...arguments);
-        this.level = DEFAULT_LOG_LEVEL;
-        this._onDidChangeLogLevel = this._register(( (new Emitter())));
-        this.onDidChangeLogLevel = this._onDidChangeLogLevel.event;
-    }
-    setLevel(level) {
-        if (this.level !== level) {
-            this.level = level;
-            this._onDidChangeLogLevel.fire(this.level);
+        if (!node) {
+            return;
         }
-    }
-    getLevel() {
-        return this.level;
-    }
-}
-class ConsoleMainLogger extends AbstractLogger {
-    constructor(logLevel = DEFAULT_LOG_LEVEL) {
-        super();
-        this.setLevel(logLevel);
-        this.useColors = !isWindows;
-    }
-    trace(message, ...args) {
-        if (this.getLevel() <= LogLevel.Trace) {
-            if (this.useColors) {
-                console.log(`\x1b[90m[main ${now()}]\x1b[0m`, message, ...args);
+        if (superStr) {
+            node.left = undefined;
+            node.mid = undefined;
+            node.right = undefined;
+            node.height = 1;
+        }
+        else {
+            node.key = undefined;
+            node.value = undefined;
+        }
+        if (!node.mid && !node.value) {
+            if (node.left && node.right) {
+                const min = this._min(node.right);
+                if (min.key) {
+                    const { key, value, segment } = min;
+                    this._delete(min.key, false);
+                    node.key = key;
+                    node.value = value;
+                    node.segment = segment;
+                }
             }
             else {
-                console.log(`[main ${now()}]`, message, ...args);
+                const newChild = node.left ?? node.right;
+                if (stack.length > 0) {
+                    const [dir, parent] = stack[stack.length - 1];
+                    switch (dir) {
+                        case -1 :
+                            parent.left = newChild;
+                            break;
+                        case 0 :
+                            parent.mid = newChild;
+                            break;
+                        case 1 :
+                            parent.right = newChild;
+                            break;
+                    }
+                }
+                else {
+                    this._root = newChild;
+                }
             }
         }
-    }
-    debug(message, ...args) {
-        if (this.getLevel() <= LogLevel.Debug) {
-            if (this.useColors) {
-                console.log(`\x1b[90m[main ${now()}]\x1b[0m`, message, ...args);
+        for (let i = stack.length - 1; i >= 0; i--) {
+            const node = stack[i][1];
+            node.updateHeight();
+            const bf = node.balanceFactor();
+            if (bf > 1) {
+                if (node.right.balanceFactor() >= 0) {
+                    stack[i][1] = node.rotateLeft();
+                }
+                else {
+                    node.right = node.right.rotateRight();
+                    stack[i][1] = node.rotateLeft();
+                }
             }
-            else {
-                console.log(`[main ${now()}]`, message, ...args);
+            else if (bf < -1) {
+                if (node.left.balanceFactor() <= 0) {
+                    stack[i][1] = node.rotateRight();
+                }
+                else {
+                    node.left = node.left.rotateLeft();
+                    stack[i][1] = node.rotateRight();
+                }
             }
-        }
-    }
-    info(message, ...args) {
-        if (this.getLevel() <= LogLevel.Info) {
-            if (this.useColors) {
-                console.log(`\x1b[90m[main ${now()}]\x1b[0m`, message, ...args);
+            if (i > 0) {
+                switch (stack[i - 1][0]) {
+                    case -1 :
+                        stack[i - 1][1].left = stack[i][1];
+                        break;
+                    case 1 :
+                        stack[i - 1][1].right = stack[i][1];
+                        break;
+                    case 0 :
+                        stack[i - 1][1].mid = stack[i][1];
+                        break;
+                }
             }
             else {
-                console.log(`[main ${now()}]`, message, ...args);
+                this._root = stack[0][1];
             }
         }
     }
-    warn(message, ...args) {
-        if (this.getLevel() <= LogLevel.Warning) {
-            if (this.useColors) {
-                console.warn(`\x1b[93m[main ${now()}]\x1b[0m`, message, ...args);
-            }
-            else {
-                console.warn(`[main ${now()}]`, message, ...args);
-            }
+    _min(node) {
+        while (node.left) {
+            node = node.left;
         }
+        return node;
     }
-    error(message, ...args) {
-        if (this.getLevel() <= LogLevel.Error) {
-            if (this.useColors) {
-                console.error(`\x1b[91m[main ${now()}]\x1b[0m`, message, ...args);
+    findSubstr(key) {
+        const iter = this._iter.reset(key);
+        let node = this._root;
+        let candidate = undefined;
+        while (node) {
+            const val = iter.cmp(node.segment);
+            if (val > 0) {
+                node = node.left;
+            }
+            else if (val < 0) {
+                node = node.right;
+            }
+            else if (iter.hasNext()) {
+                iter.next();
+                candidate = node.value || candidate;
+                node = node.mid;
             }
             else {
-                console.error(`[main ${now()}]`, message, ...args);
+                break;
             }
         }
+        return node && node.value || candidate;
+    }
+    findSuperstr(key) {
+        return this._findSuperstrOrElement(key, false);
     }
-    critical(message, ...args) {
-        if (this.getLevel() <= LogLevel.Critical) {
-            if (this.useColors) {
-                console.error(`\x1b[90m[main ${now()}]\x1b[0m`, message, ...args);
+    _findSuperstrOrElement(key, allowValue) {
+        const iter = this._iter.reset(key);
+        let node = this._root;
+        while (node) {
+            const val = iter.cmp(node.segment);
+            if (val > 0) {
+                node = node.left;
+            }
+            else if (val < 0) {
+                node = node.right;
+            }
+            else if (iter.hasNext()) {
+                iter.next();
+                node = node.mid;
             }
             else {
-                console.error(`[main ${now()}]`, message, ...args);
+                if (!node.mid) {
+                    if (allowValue) {
+                        return node.value;
+                    }
+                    else {
+                        return undefined;
+                    }
+                }
+                else {
+                    return this._entries(node.mid);
+                }
             }
         }
+        return undefined;
     }
-    dispose() {
-    }
-    flush() {
-    }
-}
-class LogService extends Disposable {
-    constructor(logger) {
-        super();
-        this.logger = logger;
-        this._register(logger);
-    }
-    get onDidChangeLogLevel() {
-        return this.logger.onDidChangeLogLevel;
-    }
-    setLevel(level) {
-        this.logger.setLevel(level);
-    }
-    getLevel() {
-        return this.logger.getLevel();
-    }
-    trace(message, ...args) {
-        this.logger.trace(message, ...args);
-    }
-    debug(message, ...args) {
-        this.logger.debug(message, ...args);
-    }
-    info(message, ...args) {
-        this.logger.info(message, ...args);
-    }
-    warn(message, ...args) {
-        this.logger.warn(message, ...args);
-    }
-    error(message, ...args) {
-        this.logger.error(message, ...args);
-    }
-    critical(message, ...args) {
-        this.logger.critical(message, ...args);
+    hasElementOrSubtree(key) {
+        return this._findSuperstrOrElement(key, true) !== undefined;
     }
-    flush() {
-        this.logger.flush();
+    forEach(callback) {
+        for (const [key, value] of this) {
+            callback(value, key);
+        }
     }
-}
-function isConfigurationOverrides(thing) {
-    return thing
-        && typeof thing === 'object'
-        && (!thing.overrideIdentifier || typeof thing.overrideIdentifier === 'string')
-        && (!thing.resource || thing.resource instanceof URI);
-}
-class StandaloneConfigurationService {
-    constructor() {
-        this._onDidChangeConfiguration = ( (new Emitter()));
-        this.onDidChangeConfiguration = this._onDidChangeConfiguration.event;
-        this._configuration = ( (new Configuration$1(
-             (new DefaultConfigurationModel()),
-             (new ConfigurationModel$1()),
-             (new ConfigurationModel$1()),
-             (new ConfigurationModel$1())
-        )));
+    *[Symbol.iterator]() {
+        yield* this._entries(this._root);
     }
-    getValue(arg1, arg2) {
-        const section = typeof arg1 === 'string' ? arg1 : undefined;
-        const overrides = isConfigurationOverrides(arg1) ? arg1 : isConfigurationOverrides(arg2) ? arg2 : {};
-        return this._configuration.getValue(section, overrides, undefined);
+    _entries(node) {
+        const result = [];
+        this._dfsEntries(node, result);
+        return result[Symbol.iterator]();
     }
-    updateValues(values) {
-        const previous = { data: this._configuration.toData() };
-        const changedKeys = [];
-        for (const entry of values) {
-            const [key, value] = entry;
-            if (this.getValue(key) === value) {
-                continue;
-            }
-            this._configuration.updateValue(key, value);
-            changedKeys.push(key);
+    _dfsEntries(node, bucket) {
+        if (!node) {
+            return;
         }
-        if (changedKeys.length > 0) {
-            const configurationChangeEvent = ( (new ConfigurationChangeEvent({ keys: changedKeys, overrides: [] }, previous, this._configuration)));
-            configurationChangeEvent.source = 8 ;
-            configurationChangeEvent.sourceConfig = null;
-            this._onDidChangeConfiguration.fire(configurationChangeEvent);
+        if (node.left) {
+            this._dfsEntries(node.left, bucket);
         }
-        return Promise.resolve();
-    }
-    updateValue(key, value, arg3, arg4) {
-        return this.updateValues([[key, value]]);
-    }
-    inspect(key, options = {}) {
-        return this._configuration.inspect(key, options, undefined);
-    }
-    keys() {
-        return (
-             (this._configuration.keys(undefined))
-        );
-    }
-    reloadConfiguration() {
-        return Promise.resolve(undefined);
-    }
-    getConfigurationData() {
-        const emptyModel = {
-            contents: {},
-            keys: [],
-            overrides: []
-        };
-        return {
-            defaults: emptyModel,
-            policy: emptyModel,
-            application: emptyModel,
-            user: emptyModel,
-            workspace: emptyModel,
-            folders: []
+        if (node.value) {
+            bucket.push([node.key, node.value]);
+        }
+        if (node.mid) {
+            this._dfsEntries(node.mid, bucket);
+        }
+        if (node.right) {
+            this._dfsEntries(node.right, bucket);
+        }
+    }
+    _isBalanced() {
+        const nodeIsBalanced = (node) => {
+            if (!node) {
+                return true;
+            }
+            const bf = node.balanceFactor();
+            if (bf < -1 || bf > 1) {
+                return false;
+            }
+            return nodeIsBalanced(node.left) && nodeIsBalanced(node.right);
         };
+        return nodeIsBalanced(this._root);
     }
 }
 const hasOwnProperty = Object.prototype.hasOwnProperty;
@@ -3623,7 +3880,7 @@ class LanguagesRegistry extends Disposable {
                 }
             }
             catch (err) {
-                onUnexpectedError(err);
+                console.warn(`[${lang.id}]: Invalid regular expression \`${firstLineRegexStr}\`: `, err);
             }
         }
         resolvedLanguage.aliases.push(langId);
@@ -3745,6 +4002,8 @@ class LanguagesRegistry extends Disposable {
     }
 }
 LanguagesRegistry.instanceCount = 0;
+var css = ".monaco-list{height:100%;position:relative;white-space:nowrap;width:100%}.monaco-list.mouse-support{user-select:none;-webkit-user-select:none}.monaco-list>.monaco-scrollable-element{height:100%}.monaco-list-rows{height:100%;position:relative;width:100%}.monaco-list.horizontal-scrolling .monaco-list-rows{min-width:100%;width:auto}.monaco-list-row{box-sizing:border-box;overflow:hidden;position:absolute;width:100%}.monaco-list.mouse-support .monaco-list-row{cursor:pointer;touch-action:none}.monaco-list-row.scrolling{display:none!important}.monaco-list.element-focused,.monaco-list.selection-multiple,.monaco-list.selection-single{outline:0!important}.monaco-drag-image{border-radius:10px;display:inline-block;font-size:12px;padding:1px 7px;position:absolute;z-index:1000}.monaco-list-type-filter-message{box-sizing:border-box;height:100%;left:0;opacity:.7;padding:40px 1em 1em;pointer-events:none;position:absolute;text-align:center;top:0;white-space:normal;width:100%}.monaco-list-type-filter-message:empty{display:none}";
+n(css,{});
 class TraitRenderer {
     constructor(trait) {
         this.trait = trait;
@@ -3800,6 +4059,12 @@ class TraitRenderer {
     }
 }
 class Trait {
+    get name() { return this._trait; }
+    get renderer() {
+        return (
+             (new TraitRenderer(this))
+        );
+    }
     constructor(_trait) {
         this._trait = _trait;
         this.length = 0;
@@ -3808,12 +4073,6 @@ class Trait {
         this._onChange = ( (new Emitter()));
         this.onChange = this._onChange.event;
     }
-    get name() { return this._trait; }
-    get renderer() {
-        return (
-             (new TraitRenderer(this))
-        );
-    }
     splice(start, deleteCount, elements) {
         deleteCount = Math.max(0, Math.min(deleteCount, this.length - start));
         const diff = elements.length - deleteCount;
@@ -3858,7 +4117,7 @@ class Trait {
         return binarySearch(this.sortedIndexes, index, numericSort) >= 0;
     }
     dispose() {
-        dispose(this._onChange);
+        dispose$1(this._onChange);
     }
 }
 class SelectionTrait extends Trait {
@@ -3909,6 +4168,11 @@ function isMonacoEditor(e) {
     return isMonacoEditor(e.parentElement);
 }
 class KeyboardController {
+    get onKeyDown() {
+        return this.disposables.add(Event.chain(this.disposables.add(( (new DomEmitter(this.view.domNode, 'keydown')))).event)
+            .filter(e => !isInputElement(e.target))
+            .map(e => ( (new StandardKeyboardEvent(e)))));
+    }
     constructor(list, view, options) {
         this.list = list;
         this.view = view;
@@ -3924,11 +4188,6 @@ class KeyboardController {
             this.onKeyDown.filter(e => (isMacintosh ? e.metaKey : e.ctrlKey) && e.keyCode === 31 ).on(this.onCtrlA, this, this.multipleSelectionDisposables);
         }
     }
-    get onKeyDown() {
-        return this.disposables.add(Event.chain(this.disposables.add(( (new DomEmitter(this.view.domNode, 'keydown')))).event)
-            .filter(e => !isInputElement(e.target))
-            .map(e => ( (new StandardKeyboardEvent(e)))));
-    }
     updateOptions(optionsUpdate) {
         if (optionsUpdate.multipleSelectionSupport !== undefined) {
             this.multipleSelectionDisposables.clear();
@@ -4059,10 +4318,10 @@ class TypeNavigationController {
             .map(event => ( (new StandardKeyboardEvent(event))))
             .filter(e => typing || this.keyboardNavigationEventFilter(e))
             .filter(e => this.delegate.mightProducePrintableCharacter(e))
-            .forEach(stopEvent)
+            .forEach(e => EventHelper.stop(e, true))
             .map(event => event.browserEvent.key)
             .event;
-        const onClear = Event.debounce(onChar, () => null, 800, undefined, undefined, this.enabledDisposables);
+        const onClear = Event.debounce(onChar, () => null, 800, undefined, undefined, undefined, this.enabledDisposables);
         const onInput = Event.reduce(Event.any(onChar, onClear), (r, i) => i === null ? null : ((r || '') + i), undefined, this.enabledDisposables);
         onInput(this.onInput, this, this.enabledDisposables);
         onClear(this.onClear, this, this.enabledDisposables);
@@ -4220,7 +4479,7 @@ class MouseController {
         }
     }
     onContextMenu(e) {
-        if (isMonacoEditor(e.browserEvent.target)) {
+        if (isInputElement(e.browserEvent.target) || isMonacoEditor(e.browserEvent.target)) {
             return;
         }
         const focus = typeof e.index === 'undefined' ? [] : [e.index];
@@ -4310,12 +4569,7 @@ class DefaultStyleController {
         const suffix = this.selectorSuffix && `.${this.selectorSuffix}`;
         const content = [];
         if (styles.listBackground) {
-            if (styles.listBackground.isOpaque()) {
-                content.push(`.monaco-list${suffix} .monaco-list-rows { background: ${styles.listBackground}; }`);
-            }
-            else if (!isMacintosh) {
-                console.warn(`List with id '${this.selectorSuffix}' was styled with a non-opaque background color. This will break sub-pixel antialiasing.`);
-            }
+            content.push(`.monaco-list${suffix} .monaco-list-rows { background: ${styles.listBackground}; }`);
         }
         if (styles.listFocusBackground) {
             content.push(`.monaco-list${suffix}:focus .monaco-list-row.focused { background-color: ${styles.listFocusBackground}; }`);
@@ -4334,9 +4588,6 @@ class DefaultStyleController {
         if (styles.listActiveSelectionIconForeground) {
             content.push(`.monaco-list${suffix}:focus .monaco-list-row.selected .codicon { color: ${styles.listActiveSelectionIconForeground}; }`);
         }
-        if (styles.listFocusAndSelectionOutline) {
-            content.push(`.monaco-list${suffix}:focus .monaco-list-row.selected { outline-color: ${styles.listFocusAndSelectionOutline} !important; }`);
-        }
         if (styles.listFocusAndSelectionBackground) {
             content.push(`
 				.monaco-drag-image,
@@ -4368,13 +4619,14 @@ class DefaultStyleController {
             content.push(`.monaco-list${suffix} .monaco-list-row.selected { color: ${styles.listInactiveSelectionForeground}; }`);
         }
         if (styles.listHoverBackground) {
-            content.push(`.monaco-list${suffix}:not(.drop-target) .monaco-list-row:hover:not(.selected):not(.focused) { background-color: ${styles.listHoverBackground}; }`);
+            content.push(`.monaco-list${suffix}:not(.drop-target):not(.dragging) .monaco-list-row:hover:not(.selected):not(.focused) { background-color: ${styles.listHoverBackground}; }`);
         }
         if (styles.listHoverForeground) {
-            content.push(`.monaco-list${suffix} .monaco-list-row:hover:not(.selected):not(.focused) { color:  ${styles.listHoverForeground}; }`);
+            content.push(`.monaco-list${suffix}:not(.drop-target):not(.dragging) .monaco-list-row:hover:not(.selected):not(.focused) { color:  ${styles.listHoverForeground}; }`);
         }
-        if (styles.listSelectionOutline) {
-            content.push(`.monaco-list${suffix} .monaco-list-row.selected { outline: 1px dotted ${styles.listSelectionOutline}; outline-offset: -1px; }`);
+        const focusAndSelectionOutline = asCssValueWithDefault(styles.listFocusAndSelectionOutline, asCssValueWithDefault(styles.listSelectionOutline, styles.listFocusOutline ?? ''));
+        if (focusAndSelectionOutline) {
+            content.push(`.monaco-list${suffix}:focus .monaco-list-row.focused.selected { outline: 1px solid ${focusAndSelectionOutline}; outline-offset: -1px;}`);
         }
         if (styles.listFocusOutline) {
             content.push(`
@@ -4383,6 +4635,13 @@ class DefaultStyleController {
 				.monaco-workbench.context-menu-visible .monaco-list${suffix}.last-focused .monaco-list-row.focused { outline: 1px solid ${styles.listFocusOutline}; outline-offset: -1px; }
 			`);
         }
+        const inactiveFocusAndSelectionOutline = asCssValueWithDefault(styles.listSelectionOutline, styles.listInactiveFocusOutline ?? '');
+        if (inactiveFocusAndSelectionOutline) {
+            content.push(`.monaco-list${suffix} .monaco-list-row.focused.selected { outline: 1px dotted ${inactiveFocusAndSelectionOutline}; outline-offset: -1px; }`);
+        }
+        if (styles.listSelectionOutline) {
+            content.push(`.monaco-list${suffix} .monaco-list-row.selected { outline: 1px dotted ${styles.listSelectionOutline}; outline-offset: -1px; }`);
+        }
         if (styles.listInactiveFocusOutline) {
             content.push(`.monaco-list${suffix} .monaco-list-row.focused { outline: 1px dotted ${styles.listInactiveFocusOutline}; outline-offset: -1px; }`);
         }
@@ -4398,10 +4657,18 @@ class DefaultStyleController {
         }
         if (styles.tableColumnsBorder) {
             content.push(`
-				.monaco-table:hover > .monaco-split-view2,
-				.monaco-table:hover > .monaco-split-view2 .monaco-sash.vertical::before {
+				.monaco-table > .monaco-split-view2,
+				.monaco-table > .monaco-split-view2 .monaco-sash.vertical::before,
+				.monaco-workbench:not(.reduce-motion) .monaco-table:hover > .monaco-split-view2,
+				.monaco-workbench:not(.reduce-motion) .monaco-table:hover > .monaco-split-view2 .monaco-sash.vertical::before {
 					border-color: ${styles.tableColumnsBorder};
-			}`);
+				}
+
+				.monaco-workbench:not(.reduce-motion) .monaco-table > .monaco-split-view2,
+				.monaco-workbench:not(.reduce-motion) .monaco-table > .monaco-split-view2 .monaco-sash.vertical::before {
+					border-color: transparent;
+				}
+			`);
         }
         if (styles.tableOddRowsBackgroundColor) {
             content.push(`
@@ -4415,22 +4682,6 @@ class DefaultStyleController {
         this.styleElement.textContent = content.join('\n');
     }
 }
-const defaultStyles = {
-    listFocusBackground: ( (Color$1.fromHex('#7FB0D0'))),
-    listActiveSelectionBackground: ( (Color$1.fromHex('#0E639C'))),
-    listActiveSelectionForeground: ( (Color$1.fromHex('#FFFFFF'))),
-    listActiveSelectionIconForeground: ( (Color$1.fromHex('#FFFFFF'))),
-    listFocusAndSelectionOutline: ( (Color$1.fromHex('#90C2F9'))),
-    listFocusAndSelectionBackground: ( (Color$1.fromHex('#094771'))),
-    listFocusAndSelectionForeground: ( (Color$1.fromHex('#FFFFFF'))),
-    listInactiveSelectionBackground: ( (Color$1.fromHex('#3F3F46'))),
-    listInactiveSelectionIconForeground: ( (Color$1.fromHex('#FFFFFF'))),
-    listHoverBackground: ( (Color$1.fromHex('#2A2D2E'))),
-    listDropBackground: ( (Color$1.fromHex('#383B3D'))),
-    treeIndentGuidesStroke: ( (Color$1.fromHex('#a9a9a9'))),
-    tableColumnsBorder: ( (( (Color$1.fromHex('#cccccc'))).transparent(0.2))),
-    tableOddRowsBackgroundColor: ( (( (Color$1.fromHex('#cccccc'))).transparent(0.04)))
-};
 const DefaultOptions = {
     keyboardSupport: true,
     mouseSupport: true,
@@ -4603,6 +4854,57 @@ class ListViewDragAndDrop {
     }
 }
 class List {
+    get onDidChangeFocus() {
+        return Event.map(this.eventBufferer.wrapEvent(this.focus.onChange), e => this.toListEvent(e), this.disposables);
+    }
+    get onDidChangeSelection() {
+        return Event.map(this.eventBufferer.wrapEvent(this.selection.onChange), e => this.toListEvent(e), this.disposables);
+    }
+    get domId() { return this.view.domId; }
+    get onDidScroll() { return this.view.onDidScroll; }
+    get onMouseClick() { return this.view.onMouseClick; }
+    get onMouseDblClick() { return this.view.onMouseDblClick; }
+    get onMouseMiddleClick() { return this.view.onMouseMiddleClick; }
+    get onPointer() { return this.mouseController.onPointer; }
+    get onMouseUp() { return this.view.onMouseUp; }
+    get onMouseDown() { return this.view.onMouseDown; }
+    get onMouseOver() { return this.view.onMouseOver; }
+    get onMouseMove() { return this.view.onMouseMove; }
+    get onMouseOut() { return this.view.onMouseOut; }
+    get onTouchStart() { return this.view.onTouchStart; }
+    get onTap() { return this.view.onTap; }
+    get onContextMenu() {
+        let didJustPressContextMenuKey = false;
+        const fromKeyDown = this.disposables.add(Event.chain(this.disposables.add(( (new DomEmitter(this.view.domNode, 'keydown')))).event))
+            .map(e => ( (new StandardKeyboardEvent(e))))
+            .filter(e => didJustPressContextMenuKey = e.keyCode === 58  || ((e.shiftKey && e.keyCode === 68) ))
+            .map(e => EventHelper.stop(e, true))
+            .filter(() => false)
+            .event;
+        const fromKeyUp = this.disposables.add(Event.chain(this.disposables.add(( (new DomEmitter(this.view.domNode, 'keyup')))).event))
+            .forEach(() => didJustPressContextMenuKey = false)
+            .map(e => ( (new StandardKeyboardEvent(e))))
+            .filter(e => e.keyCode === 58  || ((e.shiftKey && e.keyCode === 68) ))
+            .map(e => EventHelper.stop(e, true))
+            .map(({ browserEvent }) => {
+            const focus = this.getFocus();
+            const index = focus.length ? focus[0] : undefined;
+            const element = typeof index !== 'undefined' ? this.view.element(index) : undefined;
+            const anchor = typeof index !== 'undefined' ? this.view.domElement(index) : this.view.domNode;
+            return { index, element, anchor, browserEvent };
+        })
+            .event;
+        const fromMouse = this.disposables.add(Event.chain(this.view.onContextMenu))
+            .filter(_ => !didJustPressContextMenuKey)
+            .map(({ element, index, browserEvent }) => ({ element, index, anchor: { x: browserEvent.pageX + 1, y: browserEvent.pageY }, browserEvent }))
+            .event;
+        return Event.any(fromKeyDown, fromKeyUp, fromMouse);
+    }
+    get onKeyDown() { return this.disposables.add(( (new DomEmitter(this.view.domNode, 'keydown')))).event; }
+    get onKeyUp() { return this.disposables.add(( (new DomEmitter(this.view.domNode, 'keyup')))).event; }
+    get onKeyPress() { return this.disposables.add(( (new DomEmitter(this.view.domNode, 'keypress')))).event; }
+    get onDidFocus() { return Event.signal(this.disposables.add(( (new DomEmitter(this.view.domNode, 'focus', true)))).event); }
+    get onDidBlur() { return Event.signal(this.disposables.add(( (new DomEmitter(this.view.domNode, 'blur', true)))).event); }
     constructor(user, container, virtualDelegate, renderers, _options = DefaultOptions) {
         this.user = user;
         this._options = _options;
@@ -4615,7 +4917,6 @@ class List {
         this.onDidDispose = this._onDidDispose.event;
         const role = this._options.accessibilityProvider && this._options.accessibilityProvider.getWidgetRole ? this._options.accessibilityProvider?.getWidgetRole() : 'list';
         this.selection = ( (new SelectionTrait(role !== 'listbox')));
-        mixin(_options, defaultStyles, false);
         const baseRenderers = [this.focus.renderer, this.selection.renderer];
         this.accessibilityProvider = _options.accessibilityProvider;
         if (this.accessibilityProvider) {
@@ -4627,7 +4928,7 @@ class List {
             ..._options,
             dnd: _options.dnd && ( (new ListViewDragAndDrop(this, _options.dnd)))
         };
-        this.view = ( (new ListView(container, virtualDelegate, renderers, viewOptions)));
+        this.view = this.createListView(container, virtualDelegate, renderers, viewOptions);
         this.view.domNode.setAttribute('role', role);
         if (_options.styleController) {
             this.styleController = _options.styleController(this.view.domId);
@@ -4674,57 +4975,11 @@ class List {
             this.view.domNode.setAttribute('aria-multiselectable', 'true');
         }
     }
-    get onDidChangeFocus() {
-        return Event.map(this.eventBufferer.wrapEvent(this.focus.onChange), e => this.toListEvent(e), this.disposables);
-    }
-    get onDidChangeSelection() {
-        return Event.map(this.eventBufferer.wrapEvent(this.selection.onChange), e => this.toListEvent(e), this.disposables);
-    }
-    get domId() { return this.view.domId; }
-    get onDidScroll() { return this.view.onDidScroll; }
-    get onMouseClick() { return this.view.onMouseClick; }
-    get onMouseDblClick() { return this.view.onMouseDblClick; }
-    get onMouseMiddleClick() { return this.view.onMouseMiddleClick; }
-    get onPointer() { return this.mouseController.onPointer; }
-    get onMouseUp() { return this.view.onMouseUp; }
-    get onMouseDown() { return this.view.onMouseDown; }
-    get onMouseOver() { return this.view.onMouseOver; }
-    get onMouseMove() { return this.view.onMouseMove; }
-    get onMouseOut() { return this.view.onMouseOut; }
-    get onTouchStart() { return this.view.onTouchStart; }
-    get onTap() { return this.view.onTap; }
-    get onContextMenu() {
-        let didJustPressContextMenuKey = false;
-        const fromKeyDown = this.disposables.add(Event.chain(this.disposables.add(( (new DomEmitter(this.view.domNode, 'keydown')))).event))
-            .map(e => ( (new StandardKeyboardEvent(e))))
-            .filter(e => didJustPressContextMenuKey = e.keyCode === 58  || ((e.shiftKey && e.keyCode === 68) ))
-            .map(stopEvent)
-            .filter(() => false)
-            .event;
-        const fromKeyUp = this.disposables.add(Event.chain(this.disposables.add(( (new DomEmitter(this.view.domNode, 'keyup')))).event))
-            .forEach(() => didJustPressContextMenuKey = false)
-            .map(e => ( (new StandardKeyboardEvent(e))))
-            .filter(e => e.keyCode === 58  || ((e.shiftKey && e.keyCode === 68) ))
-            .map(stopEvent)
-            .map(({ browserEvent }) => {
-            const focus = this.getFocus();
-            const index = focus.length ? focus[0] : undefined;
-            const element = typeof index !== 'undefined' ? this.view.element(index) : undefined;
-            const anchor = typeof index !== 'undefined' ? this.view.domElement(index) : this.view.domNode;
-            return { index, element, anchor, browserEvent };
-        })
-            .event;
-        const fromMouse = this.disposables.add(Event.chain(this.view.onContextMenu))
-            .filter(_ => !didJustPressContextMenuKey)
-            .map(({ element, index, browserEvent }) => ({ element, index, anchor: { x: browserEvent.pageX + 1, y: browserEvent.pageY }, browserEvent }))
-            .event;
-        return Event.any(fromKeyDown, fromKeyUp, fromMouse);
+    createListView(container, virtualDelegate, renderers, viewOptions) {
+        return (
+             (new ListView(container, virtualDelegate, renderers, viewOptions))
+        );
     }
-    get onKeyDown() { return this.disposables.add(( (new DomEmitter(this.view.domNode, 'keydown')))).event; }
-    get onKeyUp() { return this.disposables.add(( (new DomEmitter(this.view.domNode, 'keyup')))).event; }
-    get onKeyPress() { return this.disposables.add(( (new DomEmitter(this.view.domNode, 'keypress')))).event; }
-    get onDidFocus() { return Event.signal(this.disposables.add(( (new DomEmitter(this.view.domNode, 'focus', true)))).event); }
-    get onDidBlur() { return Event.signal(this.disposables.add(( (new DomEmitter(this.view.domNode, 'blur', true)))).event); }
     createMouseController(options) {
         return (
              (new MouseController(this))
@@ -4822,9 +5077,7 @@ class List {
         this.view.layout(height, width);
     }
     triggerTypeNavigation() {
-        if (this.typeNavigationController) {
-            this.typeNavigationController.trigger();
-        }
+        this.typeNavigationController?.trigger();
     }
     setSelection(indexes, browserEvent) {
         for (const index of indexes) {
@@ -5245,6 +5498,32 @@ class HSVA {
     }
 }
 class Color {
+    static fromHex(hex) {
+        return Color.Format.CSS.parseHex(hex) || Color.red;
+    }
+    static equals(a, b) {
+        if (!a && !b) {
+            return true;
+        }
+        if (!a || !b) {
+            return false;
+        }
+        return a.equals(b);
+    }
+    get hsla() {
+        if (this._hsla) {
+            return this._hsla;
+        }
+        else {
+            return HSLA.fromRGBA(this.rgba);
+        }
+    }
+    get hsva() {
+        if (this._hsva) {
+            return this._hsva;
+        }
+        return HSVA.fromRGBA(this.rgba);
+    }
     constructor(arg) {
         if (!arg) {
             throw new Error('Color needs a value');
@@ -5264,23 +5543,6 @@ class Color {
             throw new Error('Invalid color ctor argument');
         }
     }
-    static fromHex(hex) {
-        return Color.Format.CSS.parseHex(hex) || Color.red;
-    }
-    get hsla() {
-        if (this._hsla) {
-            return this._hsla;
-        }
-        else {
-            return HSLA.fromRGBA(this.rgba);
-        }
-    }
-    get hsva() {
-        if (this._hsva) {
-            return this._hsva;
-        }
-        return HSVA.fromRGBA(this.rgba);
-    }
     equals(other) {
         return !!other && RGBA.equals(this.rgba, other.rgba) && HSLA.equals(this.hsla, other.hsla) && HSVA.equals(this.hsva, other.hsva);
     }
@@ -5559,6 +5821,112 @@ Color.transparent = ( (new Color( (new RGBA(0, 0, 0, 0)))));
         })(Format.CSS || (Format.CSS = {}))));
     })(Color.Format || (Color.Format = {}))));
 })(Color || (Color = {}))));
+class LogService extends Disposable {
+    constructor(primaryLogger, otherLoggers = []) {
+        super();
+        this.logger = ( (new MultiplexLogger([primaryLogger, ...otherLoggers])));
+        this._register(primaryLogger.onDidChangeLogLevel(level => this.setLevel(level)));
+    }
+    get onDidChangeLogLevel() {
+        return this.logger.onDidChangeLogLevel;
+    }
+    setLevel(level) {
+        this.logger.setLevel(level);
+    }
+    getLevel() {
+        return this.logger.getLevel();
+    }
+    trace(message, ...args) {
+        this.logger.trace(message, ...args);
+    }
+    debug(message, ...args) {
+        this.logger.debug(message, ...args);
+    }
+    info(message, ...args) {
+        this.logger.info(message, ...args);
+    }
+    warn(message, ...args) {
+        this.logger.warn(message, ...args);
+    }
+    error(message, ...args) {
+        this.logger.error(message, ...args);
+    }
+    flush() {
+        this.logger.flush();
+    }
+}
+class KeyCodeChord {
+    constructor(ctrlKey, shiftKey, altKey, metaKey, keyCode) {
+        this.ctrlKey = ctrlKey;
+        this.shiftKey = shiftKey;
+        this.altKey = altKey;
+        this.metaKey = metaKey;
+        this.keyCode = keyCode;
+    }
+    equals(other) {
+        return (other instanceof KeyCodeChord
+            && this.ctrlKey === other.ctrlKey
+            && this.shiftKey === other.shiftKey
+            && this.altKey === other.altKey
+            && this.metaKey === other.metaKey
+            && this.keyCode === other.keyCode);
+    }
+    getHashCode() {
+        const ctrl = this.ctrlKey ? '1' : '0';
+        const shift = this.shiftKey ? '1' : '0';
+        const alt = this.altKey ? '1' : '0';
+        const meta = this.metaKey ? '1' : '0';
+        return `K${ctrl}${shift}${alt}${meta}${this.keyCode}`;
+    }
+    isModifierKey() {
+        return (this.keyCode === 0
+            || this.keyCode === 5
+            || this.keyCode === 57
+            || this.keyCode === 6  || this.keyCode === 4) ;
+    }
+    toKeybinding() {
+        return (
+             (new Keybinding([this]))
+        );
+    }
+    isDuplicateModifierCase() {
+        return (((this.ctrlKey && this.keyCode === 5) )
+            || ((this.shiftKey && this.keyCode === 4) )
+            || ((this.altKey && this.keyCode === 6) ) || (this.metaKey && this.keyCode === 57)) ;
+    }
+}
+class Keybinding {
+    constructor(chords) {
+        if (chords.length === 0) {
+            throw illegalArgument(`chords`);
+        }
+        this.chords = chords;
+    }
+    getHashCode() {
+        let result = '';
+        for (let i = 0, len = this.chords.length; i < len; i++) {
+            if (i !== 0) {
+                result += ';';
+            }
+            result += this.chords[i].getHashCode();
+        }
+        return result;
+    }
+    equals(other) {
+        if (other === null) {
+            return false;
+        }
+        if (this.chords.length !== other.chords.length) {
+            return false;
+        }
+        for (let i = 0; i < this.chords.length; i++) {
+            if (!this.chords[i].equals(other.chords[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
 var _a, _b;
 if (SnippetParser.prototype.text == null) {
     SnippetParser.prototype.text = function (value) {
@@ -5593,6 +5961,23 @@ polyfillPrototypeSimple(LanguageService$1.prototype, LanguageService.prototype);
 polyfillPrototypeSimple(NoOpNotification.prototype, NoOpNotification$1.prototype);
 polyfillPrototypeSimple(Themable$1.prototype, Themable.prototype);
 polyfillPrototypeSimple(ProgressBar$1.prototype, ProgressBar.prototype);
+polyfillPrototypeSimple(DefaultConfiguration$1.prototype, DefaultConfiguration.prototype);
+polyfillPrototypeSimple(Keybinding$1.prototype, Keybinding.prototype);
+polyfillPrototypeSimple(KeyCodeChord$1.prototype, KeyCodeChord.prototype);
+polyfillPrototypeSimple(DisposableMap$1.prototype, DisposableMap.prototype);
+Object.defineProperty(DefaultConfiguration$1.prototype, '_onDidChangeConfiguration', {
+    get() {
+        if (this.__onDidChangeConfiguration == null) {
+            this.__onDidChangeConfiguration = this._register(new Emitter());
+        }
+        return this.__onDidChangeConfiguration;
+    }
+});
+Object.defineProperty(DefaultConfiguration$1.prototype, 'onDidChangeConfiguration', {
+    get() {
+        return this._onDidChangeConfiguration.event;
+    }
+});
 const jsonContributionRegistry = ( Registry.as(Extensions.JSONContribution));
 jsonContributionRegistry.getSchemaContributions ?? (jsonContributionRegistry.getSchemaContributions = () => ({
     schemas: jsonContributionRegistry.schemasById
@@ -5654,4 +6039,4 @@ function toVSCodeColor(value) {
     return value;
 }
 polyfillPrototype(Color$1.prototype, Color.prototype, toMonacoColor, toVSCodeColor);
-export { ConsoleMainLogger as C, NotImplementedError as N, ResourceSet as R, UserSettings as U, flatten as a, parse as b, createScanner as c, isReadableStream as d, peekStream as e, findNodeAtLocation as f, getNodeType as g, peekReadable as h, index as i, bufferToReadable as j, consumeStream as k, isReadableBufferedStream as l, listenStream as m, bufferedStreamToBuffer as n, newWriteableBufferStream as o, parseTree as p, newWriteableStream as q, readableToBuffer as r, streamToBuffer as s, transform as t, disposed as u, coalesceInPlace as v, mapArrayOrNot as w, delta as x, readonly as y };
+export { AsyncReferenceCollection as A, mapArrayOrNot as B, delta as C, readonly as D, NotImplementedError as E, encodeBase64 as F, IPolicyService as I, NullPolicyService as N, PolicyConfiguration as P, ReferenceCollection as R, UserSettings as U, assertAllDefined as a, NullPolicyConfiguration as b, parseTree as c, findNodeAtLocation as d, createScanner as e, flatten as f, getNodeType as g, isStringArray as h, index as i, isReadableStream as j, peekStream as k, peekReadable as l, bufferToReadable as m, n, consumeStream as o, parse as p, isReadableBufferedStream as q, listenStream as r, streamToBuffer as s, transform as t, bufferedStreamToBuffer as u, readableToBuffer as v, withUndefinedAsNull as w, newWriteableBufferStream as x, newWriteableStream as y, disposed as z };