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

package/dist/polyfill.js

@@ -1,47 +1,52 @@
 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 { 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 { 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 +113,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 +125,7 @@ class ErrorNoTelemetry extends Error {
         return result;
     }
     static isErrorNoTelemetry(err) {
-        return err.name === 'ErrorNoTelemetry';
+        return err.name === 'CodeExpectedError';
     }
 }
 function isReadableStream(obj) {
@@ -452,10 +457,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 +516,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 +636,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 +744,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 +771,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 +864,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 +920,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 +1072,7 @@ class LanguageSelection {
         }
         if (!this._emitter) {
             this._emitter = ( (new Emitter({
-                onLastListenerRemove: () => {
+                onDidRemoveLastListener: () => {
                     this._dispose();
                 }
             })));
@@ -1737,1733 +1800,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++;
+    getKeysForOverrideIdentifier(identifier) {
+        const keys = [];
+        for (const override of this.overrides) {
+            if (override.identifiers.includes(identifier)) {
+                keys.push(...override.keys);
+            }
+        }
+        return distinct(keys);
+    }
+    getAllOverrideIdentifiers() {
+        const result = [];
+        for (const override of this.overrides) {
+            result.push(...override.identifiers);
+        }
+        return distinct(result);
+    }
+    override(identifier) {
+        let overrideConfigurationModel = this.overrideConfigurations.get(identifier);
+        if (!overrideConfigurationModel) {
+            overrideConfigurationModel = this.createOverrideConfigurationModel(identifier);
+            this.overrideConfigurations.set(identifier, overrideConfigurationModel);
+        }
+        return overrideConfigurationModel;
+    }
+    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 PathIterator {
-    constructor(_splitOnBackslash = true, _caseSensitive = true) {
-        this._splitOnBackslash = _splitOnBackslash;
-        this._caseSensitive = _caseSensitive;
+        return (
+             (new ConfigurationModel(
+                contents,
+                keys,
+                overrides,
+                raws.every(raw => raw instanceof ConfigurationModel) ? undefined : raws
+            ))
+        );
     }
-    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;
+    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;
         }
-        return this.next();
+        return (
+             (new ConfigurationModel(contents, this.keys, this.overrides))
+        );
     }
-    hasNext() {
-        return this._to < this._valueLen;
+    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]);
+        }
     }
-    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++;
+    getContentsForOverrideIdentifer(identifier) {
+        let contentsForIdentifierOnly = null;
+        let contents = null;
+        const mergeContents = (contentsToMerge) => {
+            if (contentsToMerge) {
+                if (contents) {
+                    this.mergeContents(contents, contentsToMerge);
                 }
                 else {
-                    break;
+                    contents = deepClone(contentsToMerge);
                 }
             }
-            else {
-                justSeps = false;
+        };
+        for (const override of this.overrides) {
+            if (equals$1(override.identifiers, [identifier])) {
+                contentsForIdentifierOnly = override.contents;
+            }
+            else if (override.identifiers.includes(identifier)) {
+                mergeContents(override.contents);
             }
         }
-        return this;
+        mergeContents(contentsForIdentifierOnly);
+        return contents;
     }
-    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);
+    toJSON() {
+        return {
+            contents: this.contents,
+            overrides: this.overrides,
+            keys: this.keys
+        };
     }
-    value() {
-        return this._value.substring(this._from, this._to);
+    addValue(key, value) {
+        this.updateValue(key, value, true);
     }
-}
-class UriIterator {
-    constructor(_ignorePathCasing, _ignoreQueryAndFragment) {
-        this._ignorePathCasing = _ignorePathCasing;
-        this._ignoreQueryAndFragment = _ignoreQueryAndFragment;
-        this._states = [];
-        this._stateIdx = 0;
+    setValue(key, value) {
+        this.updateValue(key, value, false);
     }
-    reset(key) {
-        this._value = key;
-        this._states = [];
-        if (this._value.scheme) {
-            this._states.push(1 );
-        }
-        if (this._value.authority) {
-            this._states.push(2 );
-        }
-        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 );
-            }
+    removeValue(key) {
+        const index = this.keys.indexOf(key);
+        if (index === -1) {
+            return;
         }
-        if (!this._ignoreQueryAndFragment(key)) {
-            if (this._value.query) {
-                this._states.push(4 );
-            }
-            if (this._value.fragment) {
-                this._states.push(5 );
-            }
+        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);
         }
-        this._stateIdx = 0;
-        return this;
     }
-    next() {
-        if (this._states[this._stateIdx] === 3  && this._pathIterator.hasNext()) {
-            this._pathIterator.next();
+    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 {
-            this._stateIdx += 1;
+        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)),
+            });
         }
-        return this;
     }
-    hasNext() {
-        return (this._states[this._stateIdx] === 3  && this._pathIterator.hasNext())
-            || this._stateIdx < this._states.length - 1;
+}
+class ConfigurationModelParser {
+    constructor(_name) {
+        this._name = _name;
+        this._raw = null;
+        this._configurationModel = null;
+        this._restrictedConfigurations = [];
+        this._parseErrors = [];
     }
-    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);
+    get configurationModel() {
+        return this._configurationModel || ( (new ConfigurationModel()));
+    }
+    get restrictedConfigurations() {
+        return this._restrictedConfigurations;
+    }
+    get errors() {
+        return this._parseErrors;
+    }
+    parse(content, options) {
+        if (!isUndefinedOrNull$1(content)) {
+            const raw = this.doParseContent(content);
+            this.parseRaw(raw, options);
         }
-        else if (this._states[this._stateIdx] === 3 ) {
-            return this._pathIterator.cmp(a);
+    }
+    reparse(options) {
+        if (this._raw) {
+            this.parseRaw(this._raw, options);
         }
-        else if (this._states[this._stateIdx] === 4 ) {
-            return compare$1(a, this._value.query);
+    }
+    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 || [];
+    }
+    doParseContent(content) {
+        let raw = {};
+        let currentProperty = null;
+        let currentParent = [];
+        const previousParents = [];
+        function onValue(value) {
+            if (Array.isArray(currentParent)) {
+                currentParent.push(value);
+            }
+            else if (currentProperty !== null) {
+                currentParent[currentProperty] = value;
+            }
         }
-        else if (this._states[this._stateIdx] === 5 ) {
-            return compare$1(a, this._value.fragment);
+        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) => {
+            }
+        };
+        if (content) {
+            try {
+                visit(content, visitor);
+                raw = currentParent[0] || {};
+            }
+            catch (e) {
+                console.error(`Error while parsing settings file ${this._name}: ${e}`);
+                this._parseErrors = [e];
+            }
         }
-        throw new Error();
+        return raw;
     }
-    value() {
-        if (this._states[this._stateIdx] === 1 ) {
-            return this._value.scheme;
+    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 };
         }
-        else if (this._states[this._stateIdx] === 2 ) {
-            return this._value.authority;
+        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);
+                }
+                if ((scope === undefined || options.scopes === undefined || options.scopes.includes(scope))
+                    && !(options.skipRestricted && propertySchema?.restricted)) {
+                    raw[key] = properties[key];
+                }
+                else {
+                    hasExcludedProperties = true;
+                }
+            }
         }
-        else if (this._states[this._stateIdx] === 3 ) {
-            return this._pathIterator.value();
+        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)
+                });
+            }
         }
-        else if (this._states[this._stateIdx] === 4 ) {
-            return this._value.query;
+        return overrides;
+    }
+}
+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()));
+    }
+    async loadConfiguration() {
+        try {
+            const content = await this.fileService.readFile(this.userSettingsResource);
+            this.parser.parse(( (content.value.toString())) || '{}', this.parseOptions);
+            return this.parser.configurationModel;
         }
-        else if (this._states[this._stateIdx] === 5 ) {
-            return this._value.fragment;
+        catch (e) {
+            return (
+                 (new ConfigurationModel())
+            );
         }
-        throw new Error();
     }
-}
-class TernarySearchTreeNode {
-    constructor() {
-        this.height = 1;
+    reparse() {
+        this.parser.reparse(this.parseOptions);
+        return this.parser.configurationModel;
     }
-    isEmpty() {
-        return !this.left && !this.mid && !this.right && !this.value;
+    getRestrictedSettings() {
+        return this.parser.restrictedConfigurations;
     }
-    rotateLeft() {
-        const tmp = this.right;
-        this.right = tmp.left;
-        tmp.left = this;
-        this.updateHeight();
-        tmp.updateHeight();
-        return tmp;
+}
+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); }
+        };
     }
-    rotateRight() {
-        const tmp = this.left;
-        this.left = tmp.right;
-        tmp.right = this;
-        this.updateHeight();
-        tmp.updateHeight();
-        return tmp;
+    get defaultInspectValue() {
+        if (!this._defaultInspectValue) {
+            this._defaultInspectValue = this.inspect(this.defaultConfiguration, this.key, this.overrides.overrideIdentifier);
+        }
+        return this._defaultInspectValue;
     }
-    updateHeight() {
-        this.height = 1 + Math.max(this.heightLeft, this.heightRight);
+    get defaultValue() {
+        return this.defaultInspectValue.merged;
     }
-    balanceFactor() {
-        return this.heightRight - this.heightLeft;
+    get default() {
+        return this.defaultInspectValue.value !== undefined || this.defaultInspectValue.override !== undefined ? { value: this.defaultInspectValue.value, override: this.defaultInspectValue.override } : undefined;
     }
-    get heightLeft() {
-        return this.left?.height ?? 0;
+    get policyInspectValue() {
+        if (this._policyInspectValue === undefined) {
+            this._policyInspectValue = this.policyConfiguration ? this.inspect(this.policyConfiguration, this.key) : null;
+        }
+        return this._policyInspectValue;
     }
-    get heightRight() {
-        return this.right?.height ?? 0;
+    get policyValue() {
+        return this.policyInspectValue?.merged;
     }
-}
-class TernarySearchTree {
-    constructor(segments) {
-        this._iter = segments;
+    get policy() {
+        return this.policyInspectValue?.value !== undefined ? { value: this.policyInspectValue.value } : undefined;
     }
-    static forUris(ignorePathCasing = () => false, ignoreQueryAndFragment = () => false) {
-        return (
-             (new TernarySearchTree( (new UriIterator(ignorePathCasing, ignoreQueryAndFragment))))
-        );
+    get applicationInspectValue() {
+        if (this._applicationInspectValue === undefined) {
+            this._applicationInspectValue = this.applicationConfiguration ? this.inspect(this.applicationConfiguration, this.key) : null;
+        }
+        return this._applicationInspectValue;
     }
-    static forPaths(ignorePathCasing = false) {
-        return (
-             (new TernarySearchTree( (new PathIterator(undefined, !ignorePathCasing))))
-        );
+    get applicationValue() {
+        return this.applicationInspectValue?.merged;
     }
-    static forStrings() {
-        return (
-             (new TernarySearchTree( (new StringIterator())))
-        );
+    get application() {
+        return this.applicationInspectValue?.value !== undefined || this.applicationInspectValue?.override !== undefined ? { value: this.applicationInspectValue.value, override: this.applicationInspectValue.override } : undefined;
     }
-    static forConfigKeys() {
-        return (
-             (new TernarySearchTree( (new ConfigKeysIterator())))
-        );
+    get userInspectValue() {
+        if (!this._userInspectValue) {
+            this._userInspectValue = this.inspect(this.userConfiguration, this.key, this.overrides.overrideIdentifier);
+        }
+        return this._userInspectValue;
     }
-    clear() {
-        this._root = undefined;
+    get userValue() {
+        return this.userInspectValue.merged;
     }
-    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]);
-            }
+    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;
     }
-    set(key, element) {
-        const iter = this._iter.reset(key);
-        let node;
-        if (!this._root) {
-            this._root = ( (new TernarySearchTreeNode()));
-            this._root.segment = iter.value();
+    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);
         }
-        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;
-            }
+        return this._userRemoteInspectValue;
+    }
+    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;
         }
-        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 this._workspaceInspectValue;
+    }
+    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 oldElement;
+        return this._workspaceFolderInspectValue;
     }
-    get(key) {
-        return this._getNode(key)?.value;
+    get workspaceFolderValue() {
+        return this.workspaceFolderInspectValue?.merged;
     }
-    _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;
-            }
+    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 node;
+        return this._memoryInspectValue;
     }
-    has(key) {
-        const node = this._getNode(key);
-        return !(node?.value === undefined && node?.mid === undefined);
+    get memoryValue() {
+        return this.memoryInspectValue.merged;
     }
-    delete(key) {
-        return this._delete(key, false);
+    get memory() {
+        return this.memoryInspectValue.value !== undefined || this.memoryInspectValue.override !== undefined ? { value: this.memoryInspectValue.value, override: this.memoryInspectValue.override } : undefined;
     }
-    deleteSuperstr(key) {
-        return this._delete(key, true);
+}
+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;
     }
-    _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;
+    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) {
-            return;
+        else {
+            memoryConfiguration = this._memoryConfiguration;
         }
-        if (superStr) {
-            node.left = undefined;
-            node.mid = undefined;
-            node.right = undefined;
-            node.height = 1;
+        if (value === undefined) {
+            memoryConfiguration.removeValue(key);
         }
         else {
-            node.key = undefined;
-            node.value = undefined;
+            memoryConfiguration.setValue(key, value);
         }
-        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;
-                }
-            }
+        if (!overrides.resource) {
+            this._workspaceConsolidatedConfiguration = null;
         }
-        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();
+    }
+    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);
                 }
             }
-            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];
-            }
-        }
-    }
-    _min(node) {
-        while (node.left) {
-            node = node.left;
-        }
-        return node;
-    }
-    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;
-            }
-        }
-        return node && node.value || candidate;
-    }
-    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);
-                }
-            }
-        }
-        return undefined;
-    }
-    forEach(callback) {
-        for (const [key, value] of this) {
-            callback(value, key);
-        }
-    }
-    *[Symbol.iterator]() {
-        yield* this._entries(this._root);
-    }
-    _entries(node) {
-        const result = [];
-        this._dfsEntries(node, result);
-        return result[Symbol.iterator]();
-    }
-    _dfsEntries(node, bucket) {
-        if (!node) {
-            return;
-        }
-        if (node.left) {
-            this._dfsEntries(node.left, bucket);
-        }
-        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);
         }
+        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
+            ))
+        );
     }
-    _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);
+    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;
+    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 };
     }
-    add(value) {
-        this._map.set(value, value);
-        return this;
+    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 };
     }
-    clear() {
-        this._map.clear();
+    get defaults() {
+        return this._defaultConfiguration;
     }
-    delete(value) {
-        return this._map.delete(value);
+    get applicationConfiguration() {
+        return this._applicationConfiguration;
     }
-    forEach(callbackfn, thisArg) {
-        this._map.forEach((_value, key) => callbackfn.call(thisArg, key, key, this));
+    get userConfiguration() {
+        if (!this._userConfiguration) {
+            this._userConfiguration = this._remoteUserConfiguration.isEmpty() ? this._localUserConfiguration : this._localUserConfiguration.merge(this._remoteUserConfiguration);
+        }
+        return this._userConfiguration;
     }
-    has(value) {
-        return this._map.has(value);
+    get localUserConfiguration() {
+        return this._localUserConfiguration;
     }
-    entries() {
-        return this._map.entries();
+    get remoteUserConfiguration() {
+        return this._remoteUserConfiguration;
     }
-    keys() {
-        return (
-             (this._map.keys())
-        );
+    get workspaceConfiguration() {
+        return this._workspaceConfiguration;
     }
-    values() {
-        return (
-             (this._map.keys())
-        );
+    get folderConfigurations() {
+        return this._folderConfigurations;
     }
-    [(_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()));
-    }
-    get contents() {
-        return this.checkAndFreeze(this._contents);
-    }
-    get overrides() {
-        return this.checkAndFreeze(this._overrides);
-    }
-    get keys() {
-        return this.checkAndFreeze(this._keys);
-    }
-    isEmpty() {
-        return this._keys.length === 0 && ( (Object.keys(this._contents))).length === 0 && this._overrides.length === 0;
-    }
-    isFrozen() {
-        return this.frozen;
-    }
-    getValue(section) {
-        return section ? getConfigurationValue(this.contents, section) : this.contents;
-    }
-    getOverrideValue(section, overrideIdentifier) {
-        const overrideContents = this.getContentsForOverrideIdentifer(overrideIdentifier);
-        return overrideContents
-            ? section ? getConfigurationValue(overrideContents, section) : overrideContents
-            : undefined;
-    }
-    getKeysForOverrideIdentifier(identifier) {
-        const keys = [];
-        for (const override of this.overrides) {
-            if (override.identifiers.includes(identifier)) {
-                keys.push(...override.keys);
-            }
+    getConsolidatedConfigurationModel(section, overrides, workspace) {
+        let configurationModel = this.getConsolidatedConfigurationModelForResource(overrides, workspace);
+        if (overrides.overrideIdentifier) {
+            configurationModel = configurationModel.override(overrides.overrideIdentifier);
         }
-        return distinct(keys);
+        if (!this._policyConfiguration.isEmpty() && this._policyConfiguration.getValue(section) !== undefined) {
+            configurationModel = configurationModel.merge(this._policyConfiguration);
+        }
+        return configurationModel;
     }
-    getAllOverrideIdentifiers() {
-        const result = [];
-        for (const override of this.overrides) {
-            result.push(...override.identifiers);
+    getConsolidatedConfigurationModelForResource({ resource }, workspace) {
+        let consolidateConfiguration = this.getWorkspaceConsolidatedConfiguration();
+        if (workspace && resource) {
+            const root = workspace.getFolder(resource);
+            if (root) {
+                consolidateConfiguration = this.getFolderConsolidatedConfiguration(root.uri) || consolidateConfiguration;
+            }
+            const memoryConfigurationForResource = this._memoryConfigurationByResource.get(resource);
+            if (memoryConfigurationForResource) {
+                consolidateConfiguration = consolidateConfiguration.merge(memoryConfigurationForResource);
+            }
         }
-        return distinct(result);
+        return consolidateConfiguration;
     }
-    override(identifier) {
-        let overrideConfigurationModel = this.overrideConfigurations.get(identifier);
-        if (!overrideConfigurationModel) {
-            overrideConfigurationModel = this.createOverrideConfigurationModel(identifier);
-            this.overrideConfigurations.set(identifier, overrideConfigurationModel);
+    getWorkspaceConsolidatedConfiguration() {
+        if (!this._workspaceConsolidatedConfiguration) {
+            this._workspaceConsolidatedConfiguration = this._defaultConfiguration.merge(this.applicationConfiguration, this.userConfiguration, this._workspaceConfiguration, this._memoryConfiguration);
         }
-        return overrideConfigurationModel;
+        return this._workspaceConsolidatedConfiguration;
     }
-    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;
+    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);
             }
-            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));
-                }
+            else {
+                folderConsolidatedConfiguration = workspaceConsolidateConfiguration;
             }
-            for (const key of other.keys) {
-                if (keys.indexOf(key) === -1) {
-                    keys.push(key);
-                }
+        }
+        return folderConsolidatedConfiguration;
+    }
+    getFolderConfigurationModelForResource(resource, workspace) {
+        if (workspace && resource) {
+            const root = workspace.getFolder(resource);
+            if (root) {
+                return this._folderConfigurations.get(root.uri);
             }
         }
-        return (
-             (new ConfigurationModel(contents, keys, overrides))
-        );
+        return undefined;
     }
-    freeze() {
-        this.frozen = true;
-        return this;
+    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;
+            }, [])
+        };
     }
-    clone() {
+    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()))];
+    }
+    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()))];
+    }
+    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 ConfigurationModel(deepClone(this.contents), [...this.keys], deepClone(this.overrides)))
+             (new Configuration(
+                defaultConfiguration,
+                policyConfiguration,
+                applicationConfiguration,
+                userConfiguration,
+                 (new ConfigurationModel()),
+                workspaceConfiguration,
+                folders,
+                 (new ConfigurationModel()),
+                 (new ResourceMap())
+            ))
         );
     }
-    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;
-        }
+    static parseConfigurationModel(model) {
         return (
-             (new ConfigurationModel(contents, this.keys, this.overrides))
+             (new ConfigurationModel(model.contents, model.keys, model.overrides))
         );
     }
-    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;
-                }
-            }
-            source[key] = deepClone(target[key]);
+}
+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)]);
         }
     }
-    checkAndFreeze(data) {
-        if (this.frozen && !Object.isFrozen(data)) {
-            return deepFreeze(data);
+    if (from) {
+        const removedOverrideIdentifiers = fromOverrideIdentifiers.filter(key => !toOverrideIdentifiers.includes(key));
+        for (const identifier of removedOverrideIdentifiers) {
+            overrides.push([identifier, from.getKeysForOverrideIdentifier(identifier)]);
         }
-        return data;
     }
-    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);
+    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]]);
             }
         }
-        mergeContents(contentsForIdentifierOnly);
-        return contents;
     }
-    toJSON() {
-        return {
-            contents: this.contents,
-            overrides: this.overrides,
-            keys: this.keys
-        };
+    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);
+                }
+            }
+        }
     }
-    setValue(key, value) {
-        this.addKey(key);
-        addToValueTree(this.contents, key, value, e => { throw new Error(e); });
+    return { added, removed, updated };
+}
+class WorkspaceFolder {
+    constructor(data,
+    raw) {
+        this.raw = raw;
+        this.uri = data.uri;
+        this.index = data.index;
+        this.name = data.name;
     }
-    removeValue(key) {
-        if (this.removeKey(key)) {
-            removeFromValueTree(this.contents, key);
-        }
+    toResource(relativePath) {
+        return joinPath(this.uri, relativePath);
     }
-    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);
+    toJSON() {
+        return { uri: this.uri, name: this.name, index: this.index };
     }
-    removeKey(key) {
-        const index = this.keys.indexOf(key);
-        if (index !== -1) {
-            this.keys.splice(index, 1);
-            return true;
-        }
-        return false;
+}
+const IPolicyService = ( (createDecorator('policy')));
+class NullPolicyService {
+    constructor() {
+        this.onDidChange = Event.None;
     }
+    async updatePolicyDefinitions() { return {}; }
+    getPolicyValue() { return undefined; }
+    serialize() { return undefined; }
 }
-class ConfigurationModelParser {
-    constructor(_name) {
-        this._name = _name;
-        this._raw = null;
-        this._configurationModel = null;
-        this._restrictedConfigurations = [];
-        this._parseErrors = [];
+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);
+                }
+                else {
+                    this._configurationModel.setValue(key, policyValue);
                 }
-                overrides.push({
-                    identifiers: overrideIdentifiersFromKey(key),
-                    keys: ( (Object.keys(overrideRaw))),
-                    contents: toValuesTree(overrideRaw, conflictReporter)
-                });
+            }
+            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;
+    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);
+    }
+    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);
         }
-        catch (e) {
-            return (
-                 (new ConfigurationModel())
-            );
+        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();
     }
-    reparse() {
-        this.parser.reparse(this.parseOptions);
-        return this.parser.configurationModel;
+    updateValue(key, value, arg3, arg4) {
+        return this.updateValues([[key, value]]);
     }
-    getRestrictedSettings() {
-        return this.parser.restrictedConfigurations;
+    inspect(key, options = {}) {
+        return this._configuration.inspect(key, options, undefined);
     }
-}
-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;
+    keys() {
+        return (
+             (this._configuration.keys(undefined))
+        );
     }
-    getValue(section, overrides, workspace) {
-        const consolidateConfigurationModel = this.getConsolidatedConfigurationModel(section, overrides, workspace);
-        return consolidateConfigurationModel.getValue(section);
+    reloadConfiguration() {
+        return Promise.resolve(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;
-        }
-    }
-    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);
+    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 { keys, overrides };
+        return this;
     }
-    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 };
+    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 defaults() {
-        return this._defaultConfiguration;
+    value() {
+        return this._value.substring(this._from, this._to);
     }
-    get applicationConfiguration() {
-        return this._applicationConfiguration;
+}
+class UriIterator {
+    constructor(_ignorePathCasing, _ignoreQueryAndFragment) {
+        this._ignorePathCasing = _ignorePathCasing;
+        this._ignoreQueryAndFragment = _ignoreQueryAndFragment;
+        this._states = [];
+        this._stateIdx = 0;
     }
-    get userConfiguration() {
-        if (!this._userConfiguration) {
-            this._userConfiguration = this._remoteUserConfiguration.isEmpty() ? this._localUserConfiguration : this._localUserConfiguration.merge(this._remoteUserConfiguration);
-            if (this._freeze) {
-                this._userConfiguration.freeze();
-            }
+    reset(key) {
+        this._value = key;
+        this._states = [];
+        if (this._value.scheme) {
+            this._states.push(1 );
         }
-        return this._userConfiguration;
-    }
-    get localUserConfiguration() {
-        return this._localUserConfiguration;
-    }
-    get remoteUserConfiguration() {
-        return this._remoteUserConfiguration;
-    }
-    get workspaceConfiguration() {
-        return this._workspaceConfiguration;
-    }
-    get folderConfigurations() {
-        return this._folderConfigurations;
-    }
-    getConsolidatedConfigurationModel(section, overrides, workspace) {
-        let configurationModel = this.getConsolidatedConfigurationModelForResource(overrides, workspace);
-        if (overrides.overrideIdentifier) {
-            configurationModel = configurationModel.override(overrides.overrideIdentifier);
+        if (this._value.authority) {
+            this._states.push(2 );
         }
-        if (!this._policyConfiguration.isEmpty() && this._policyConfiguration.getValue(section) !== undefined) {
-            configurationModel = configurationModel.merge(this._policyConfiguration);
+        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 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._ignoreQueryAndFragment(key)) {
+            if (this._value.query) {
+                this._states.push(4 );
             }
-            const memoryConfigurationForResource = this._memoryConfigurationByResource.get(resource);
-            if (memoryConfigurationForResource) {
-                consolidateConfiguration = consolidateConfiguration.merge(memoryConfigurationForResource);
+            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 +3767,7 @@ class LanguagesRegistry extends Disposable {
                 }
             }
             catch (err) {
-                onUnexpectedError(err);
+                console.warn(`[${lang.id}]: Invalid regular expression \`${firstLineRegexStr}\`: `, err);
             }
         }
         resolvedLanguage.aliases.push(langId);
@@ -3745,6 +3889,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 +3946,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 +3960,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;
@@ -3909,6 +4055,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 +4075,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 +4205,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 +4366,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 +4456,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 +4475,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 +4506,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 +4522,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 +4544,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 +4569,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 +4741,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 +4804,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 +4815,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 +4862,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 +4964,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 +5385,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 +5430,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 +5708,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 +5848,22 @@ 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);
+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 +5925,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 { mapArrayOrNot as A, delta as B, readonly as C, NotImplementedError as D, encodeBase64 as E, IPolicyService as I, NullPolicyService as N, PolicyConfiguration as P, 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 };