@codingame/monaco-vscode-api 1.69.7 → 1.69.10

package/dist/polyfill.js

@@ -1,5 +1,5 @@
 import { VSBuffer as VSBuffer$1 } from 'monaco-editor/esm/vs/base/common/buffer.js';
-import { toDisposable, DisposableStore, Disposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.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 { 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';
@@ -14,15 +14,15 @@ import { LanguagesRegistry as LanguagesRegistry$1 } from 'monaco-editor/esm/vs/e
 import { firstOrDefault, distinct, equals as equals$1, binarySearch, range } 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 as NoOpNotification$1 } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
-import { s as shuffle, R as RawContextKey, N as NoOpNotification } from './contextkey.js';
+import { NoOpNotification } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { R as RawContextKey, N as NoOpNotification$1, s as shuffle } from './contextkey.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 { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { ResourceMap as ResourceMap$1, TernarySearchTree as TernarySearchTree$1 } from 'monaco-editor/esm/vs/base/common/map.js';
-import { compareSubstring, compareSubstringIgnoreCase, compareIgnoreCase, compare as compare$1, regExpLeadsToEndlessLoop } from 'monaco-editor/esm/vs/base/common/strings.js';
-import { overrideIdentifiersFromKey, Extensions as Extensions$2, OVERRIDE_PROPERTY_REGEX } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { TernarySearchTree as TernarySearchTree$1, ResourceMap as ResourceMap$1 } from 'monaco-editor/esm/vs/base/common/map.js';
+import { regExpLeadsToEndlessLoop, compareIgnoreCase, compareSubstring, compareSubstringIgnoreCase, compare as compare$1 } from 'monaco-editor/esm/vs/base/common/strings.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 { Event, EventBufferer } from 'monaco-editor/esm/vs/base/common/event.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
@@ -37,20 +37,15 @@ import { DomEmitter, stopEvent } from 'monaco-editor/esm/vs/base/browser/event.j
 import { StandardKeyboardEvent } from 'monaco-editor/esm/vs/base/browser/keyboardEvent.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 } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { isMacintosh, isWindows } 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 { 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 { getSingletonServiceDescriptors } from 'monaco-editor/esm/vs/platform/instantiation/common/extensions.js';
 import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-// Avoid circular dependency on EventEmitter by implementing a subset of the interface.
 class ErrorHandler {
     constructor() {
         this.listeners = [];
@@ -90,33 +85,20 @@ class ErrorHandler {
         this.unexpectedErrorHandler(e);
         this.emit(e);
     }
-    // For external errors, we don't want the listeners to be called
     onUnexpectedExternalError(e) {
         this.unexpectedErrorHandler(e);
     }
 }
 function readonly(name) {
     return name
-        ? (/*#__PURE__*/ new Error(`readonly property '${name} cannot be changed'`))
-        : (/*#__PURE__*/ new Error('readonly property cannot be changed'));
+        ? ( (new Error(`readonly property '${name} cannot be changed'`)))
+        : ( (new Error('readonly property cannot be changed')));
 }
 function disposed(what) {
-    const result = (/*#__PURE__*/ new Error(`${what} has been disposed`));
+    const result = ( (new Error(`${what} has been disposed`)));
     result.name = 'DISPOSED';
     return result;
 }
-function getErrorMessage(err) {
-    if (!err) {
-        return 'Error';
-    }
-    if (err.message) {
-        return err.message;
-    }
-    if (err.stack) {
-        return err.stack.split('\n')[0];
-    }
-    return String(err);
-}
 class NotImplementedError extends Error {
     constructor(message) {
         super('NotImplemented');
@@ -125,9 +107,6 @@ class NotImplementedError extends Error {
         }
     }
 }
-/**
- * Error that when thrown won't be logged in telemetry as an unhandled error.
- */
 class ErrorNoTelemetry extends Error {
     constructor(msg) {
         super(msg);
@@ -137,7 +116,7 @@ class ErrorNoTelemetry extends Error {
         if (err instanceof ErrorNoTelemetry) {
             return err;
         }
-        const result = (/*#__PURE__*/ new ErrorNoTelemetry());
+        const result = ( (new ErrorNoTelemetry()));
         result.message = err.message;
         result.stack = err.stack;
         return result;
@@ -146,11 +125,6 @@ class ErrorNoTelemetry extends Error {
         return err.name === 'ErrorNoTelemetry';
     }
 }
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
 function isReadableStream(obj) {
     const candidate = obj;
     if (!candidate) {
@@ -166,7 +140,9 @@ function isReadableBufferedStream(obj) {
     return isReadableStream(candidate.stream) && Array.isArray(candidate.buffer) && typeof candidate.ended === 'boolean';
 }
 function newWriteableStream(reducer, options) {
-    return (/*#__PURE__*/ new WriteableStreamImpl(reducer, options));
+    return (
+         (new WriteableStreamImpl(reducer, options))
+    );
 }
 class WriteableStreamImpl {
     constructor(reducer, options) {
@@ -200,7 +176,6 @@ class WriteableStreamImpl {
         }
         if (!this.state.flowing) {
             this.state.flowing = true;
-            // emit buffered events
             this.flowData();
             this.flowErrors();
             this.flowEnd();
@@ -210,16 +185,15 @@ class WriteableStreamImpl {
         if (this.state.destroyed) {
             return;
         }
-        // flowing: directly send the data to listeners
         if (this.state.flowing) {
             this.emitData(data);
         }
-        // not yet flowing: buffer data until flowing
         else {
             this.buffer.data.push(data);
-            // highWaterMark: if configured, signal back when buffer reached limits
             if (typeof this.options?.highWaterMark === 'number' && this.buffer.data.length > this.options.highWaterMark) {
-                return (/*#__PURE__*/ new Promise(resolve => this.pendingWritePromises.push(resolve)));
+                return (
+                     (new Promise(resolve => this.pendingWritePromises.push(resolve)))
+                );
             }
         }
     }
@@ -227,11 +201,9 @@ class WriteableStreamImpl {
         if (this.state.destroyed) {
             return;
         }
-        // flowing: directly send the error to listeners
         if (this.state.flowing) {
             this.emitError(error);
         }
-        // not yet flowing: buffer errors until flowing
         else {
             this.buffer.error.push(error);
         }
@@ -240,33 +212,30 @@ class WriteableStreamImpl {
         if (this.state.destroyed) {
             return;
         }
-        // end with data if provided
         if (typeof result !== 'undefined') {
             this.write(result);
         }
-        // flowing: send end event to listeners
         if (this.state.flowing) {
             this.emitEnd();
             this.destroy();
         }
-        // not yet flowing: remember state
         else {
             this.state.ended = true;
         }
     }
     emitData(data) {
-        this.listeners.data.slice(0).forEach(listener => listener(data)); // slice to avoid listener mutation from delivering event
+        this.listeners.data.slice(0).forEach(listener => listener(data));
     }
     emitError(error) {
         if (this.listeners.error.length === 0) {
-            onUnexpectedError(error); // nobody listened to this error so we log it as unexpected
+            onUnexpectedError(error);
         }
         else {
-            this.listeners.error.slice(0).forEach(listener => listener(error)); // slice to avoid listener mutation from delivering event
+            this.listeners.error.slice(0).forEach(listener => listener(error));
         }
     }
     emitEnd() {
-        this.listeners.end.slice(0).forEach(listener => listener()); // slice to avoid listener mutation from delivering event
+        this.listeners.end.slice(0).forEach(listener => listener());
     }
     on(event, callback) {
         if (this.state.destroyed) {
@@ -275,24 +244,16 @@ class WriteableStreamImpl {
         switch (event) {
             case 'data':
                 this.listeners.data.push(callback);
-                // switch into flowing mode as soon as the first 'data'
-                // listener is added and we are not yet in flowing mode
                 this.resume();
                 break;
             case 'end':
                 this.listeners.end.push(callback);
-                // emit 'end' event directly if we are flowing
-                // and the end has already been reached
-                //
-                // finish() when it went through
                 if (this.state.flowing && this.flowEnd()) {
                     this.destroy();
                 }
                 break;
             case 'error':
                 this.listeners.error.push(callback);
-                // emit buffered 'error' events unless done already
-                // now that we know that we have at least one listener
                 if (this.state.flowing) {
                     this.flowErrors();
                 }
@@ -327,7 +288,6 @@ class WriteableStreamImpl {
             const fullDataBuffer = this.reducer(this.buffer.data);
             this.emitData(fullDataBuffer);
             this.buffer.data.length = 0;
-            // When the buffer is empty, resolve all pending writers
             const pendingWritePromises = [...this.pendingWritePromises];
             this.pendingWritePromises.length = 0;
             pendingWritePromises.forEach(pendingWritePromise => pendingWritePromise());
@@ -361,9 +321,6 @@ class WriteableStreamImpl {
         }
     }
 }
-/**
- * Helper to fully read a T readable into a T.
- */
 function consumeReadable(readable, reducer) {
     const chunks = [];
     let chunk;
@@ -372,76 +329,59 @@ function consumeReadable(readable, reducer) {
     }
     return reducer(chunks);
 }
-/**
- * Helper to read a T readable up to a maximum of chunks. If the limit is
- * reached, will return a readable instead to ensure all data can still
- * be read.
- */
 function peekReadable(readable, reducer, maxChunks) {
     const chunks = [];
     let chunk = undefined;
     while ((chunk = readable.read()) !== null && chunks.length < maxChunks) {
         chunks.push(chunk);
     }
-    // If the last chunk is null, it means we reached the end of
-    // the readable and return all the data at once
     if (chunk === null && chunks.length > 0) {
         return reducer(chunks);
     }
-    // Otherwise, we still have a chunk, it means we reached the maxChunks
-    // value and as such we return a new Readable that first returns
-    // the existing read chunks and then continues with reading from
-    // the underlying readable.
     return {
         read: () => {
-            // First consume chunks from our array
             if (chunks.length > 0) {
                 return chunks.shift();
             }
-            // Then ensure to return our last read chunk
             if (typeof chunk !== 'undefined') {
                 const lastReadChunk = chunk;
-                // explicitly use undefined here to indicate that we consumed
-                // the chunk, which could have either been null or valued.
                 chunk = undefined;
                 return lastReadChunk;
             }
-            // Finally delegate back to the Readable
             return readable.read();
         }
     };
 }
 function consumeStream(stream, reducer) {
-    return (/*#__PURE__*/ new Promise((resolve, reject) => {
-        const chunks = [];
-        listenStream(stream, {
-            onData: chunk => {
-                if (reducer) {
-                    chunks.push(chunk);
-                }
-            },
-            onError: error => {
-                if (reducer) {
-                    reject(error);
-                }
-                else {
-                    resolve(undefined);
-                }
-            },
-            onEnd: () => {
-                if (reducer) {
-                    resolve(reducer(chunks));
-                }
-                else {
-                    resolve(undefined);
+    return (
+         (new Promise((resolve, reject) => {
+            const chunks = [];
+            listenStream(stream, {
+                onData: chunk => {
+                    if (reducer) {
+                        chunks.push(chunk);
+                    }
+                },
+                onError: error => {
+                    if (reducer) {
+                        reject(error);
+                    }
+                    else {
+                        resolve(undefined);
+                    }
+                },
+                onEnd: () => {
+                    if (reducer) {
+                        resolve(reducer(chunks));
+                    }
+                    else {
+                        resolve(undefined);
+                    }
                 }
-            }
-        });
-    }));
+            });
+        }))
+    );
 }
-/**
- * Helper to listen to all events of a T stream in proper order.
- */
 function listenStream(stream, listener) {
     let destroyed = false;
     stream.on('error', error => {
@@ -454,9 +394,6 @@ function listenStream(stream, listener) {
             listener.onEnd();
         }
     });
-    // Adding the `data` listener will turn the stream
-    // into flowing mode. As such it is important to
-    // add this listener last (DO NOT CHANGE!)
     stream.on('data', data => {
         if (!destroyed) {
             listener.onData(data);
@@ -464,50 +401,34 @@ function listenStream(stream, listener) {
     });
     return toDisposable(() => destroyed = true);
 }
-/**
- * Helper to peek up to `maxChunks` into a stream. The return type signals if
- * the stream has ended or not. If not, caller needs to add a `data` listener
- * to continue reading.
- */
 function peekStream(stream, maxChunks) {
-    return (/*#__PURE__*/ new Promise((resolve, reject) => {
-        const streamListeners = (/*#__PURE__*/ new DisposableStore());
-        const buffer = [];
-        // Data Listener
-        const dataListener = (chunk) => {
-            // Add to buffer
-            buffer.push(chunk);
-            // We reached maxChunks and thus need to return
-            if (buffer.length > maxChunks) {
-                // Dispose any listeners and ensure to pause the
-                // stream so that it can be consumed again by caller
-                streamListeners.dispose();
-                stream.pause();
-                return resolve({ stream, buffer, ended: false });
-            }
-        };
-        // Error Listener
-        const errorListener = (error) => {
-            return reject(error);
-        };
-        // End Listener
-        const endListener = () => {
-            return resolve({ stream, buffer, ended: true });
-        };
-        streamListeners.add(toDisposable(() => stream.removeListener('error', errorListener)));
-        stream.on('error', errorListener);
-        streamListeners.add(toDisposable(() => stream.removeListener('end', endListener)));
-        stream.on('end', endListener);
-        // Important: leave the `data` listener last because
-        // this can turn the stream into flowing mode and we
-        // want `error` events to be received as well.
-        streamListeners.add(toDisposable(() => stream.removeListener('data', dataListener)));
-        stream.on('data', dataListener);
-    }));
+    return (
+         (new Promise((resolve, reject) => {
+            const streamListeners = ( (new DisposableStore()));
+            const buffer = [];
+            const dataListener = (chunk) => {
+                buffer.push(chunk);
+                if (buffer.length > maxChunks) {
+                    streamListeners.dispose();
+                    stream.pause();
+                    return resolve({ stream, buffer, ended: false });
+                }
+            };
+            const errorListener = (error) => {
+                return reject(error);
+            };
+            const endListener = () => {
+                return resolve({ stream, buffer, ended: true });
+            };
+            streamListeners.add(toDisposable(() => stream.removeListener('error', errorListener)));
+            stream.on('error', errorListener);
+            streamListeners.add(toDisposable(() => stream.removeListener('end', endListener)));
+            stream.on('end', endListener);
+            streamListeners.add(toDisposable(() => stream.removeListener('data', dataListener)));
+            stream.on('data', dataListener);
+        }))
+    );
 }
-/**
- * Helper to convert a T into a Readable<T>.
- */
 function toReadable(t) {
     let consumed = false;
     return {
@@ -520,9 +441,6 @@ function toReadable(t) {
         }
     };
 }
-/**
- * Helper to transform a readable stream into another stream.
- */
 function transform(stream, transformer, reducer) {
     const target = newWriteableStream(reducer);
     listenStream(stream, {
@@ -532,11 +450,6 @@ function transform(stream, transformer, reducer) {
     });
     return target;
 }
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
 const hasBuffer = (typeof Buffer !== 'undefined');
 let textEncoder;
 let textDecoder;
@@ -545,51 +458,42 @@ class VSBuffer {
         this.buffer = buffer;
         this.byteLength = this.buffer.byteLength;
     }
-    /**
-     * When running in a nodejs context, the backing store for the returned `VSBuffer` instance
-     * might use a nodejs Buffer allocated from node's Buffer pool, which is not transferrable.
-     */
     static alloc(byteLength) {
         if (hasBuffer) {
-            return (/*#__PURE__*/ new VSBuffer(Buffer.allocUnsafe(byteLength)));
+            return (
+                 (new VSBuffer(Buffer.allocUnsafe(byteLength)))
+            );
         }
         else {
-            return (/*#__PURE__*/ new VSBuffer((/*#__PURE__*/ new Uint8Array(byteLength))));
+            return (
+                 (new VSBuffer( (new Uint8Array(byteLength))))
+            );
         }
     }
-    /**
-     * When running in a nodejs context, if `actual` is not a nodejs Buffer, the backing store for
-     * the returned `VSBuffer` instance might use a nodejs Buffer allocated from node's Buffer pool,
-     * which is not transferrable.
-     */
     static wrap(actual) {
         if (hasBuffer && !(Buffer.isBuffer(actual))) {
-            // https://nodejs.org/dist/latest-v10.x/docs/api/buffer.html#buffer_class_method_buffer_from_arraybuffer_byteoffset_length
-            // Create a zero-copy Buffer wrapper around the ArrayBuffer pointed to by the Uint8Array
             actual = Buffer.from(actual.buffer, actual.byteOffset, actual.byteLength);
         }
-        return (/*#__PURE__*/ new VSBuffer(actual));
+        return (
+             (new VSBuffer(actual))
+        );
     }
-    /**
-     * When running in a nodejs context, the backing store for the returned `VSBuffer` instance
-     * might use a nodejs Buffer allocated from node's Buffer pool, which is not transferrable.
-     */
     static fromString(source, options) {
         const dontUseNodeBuffer = options?.dontUseNodeBuffer || false;
         if (!dontUseNodeBuffer && hasBuffer) {
-            return (/*#__PURE__*/ new VSBuffer(Buffer.from(source)));
+            return (
+                 (new VSBuffer(Buffer.from(source)))
+            );
         }
         else {
             if (!textEncoder) {
-                textEncoder = (/*#__PURE__*/ new TextEncoder());
+                textEncoder = ( (new TextEncoder()));
             }
-            return (/*#__PURE__*/ new VSBuffer(textEncoder.encode(source)));
+            return (
+                 (new VSBuffer(textEncoder.encode(source)))
+            );
         }
     }
-    /**
-     * When running in a nodejs context, the backing store for the returned `VSBuffer` instance
-     * might use a nodejs Buffer allocated from node's Buffer pool, which is not transferrable.
-     */
     static fromByteArray(source) {
         const result = VSBuffer.alloc(source.length);
         for (let i = 0, len = source.length; i < len; i++) {
@@ -597,10 +501,6 @@ class VSBuffer {
         }
         return result;
     }
-    /**
-     * When running in a nodejs context, the backing store for the returned `VSBuffer` instance
-     * might use a nodejs Buffer allocated from node's Buffer pool, which is not transferrable.
-     */
     static concat(buffers, totalLength) {
         if (typeof totalLength === 'undefined') {
             totalLength = 0;
@@ -617,10 +517,6 @@ class VSBuffer {
         }
         return ret;
     }
-    /**
-     * When running in a nodejs context, the backing store for the returned `VSBuffer` instance
-     * might use a nodejs Buffer allocated from node's Buffer pool, which is not transferrable.
-     */
     clone() {
         const result = VSBuffer.alloc(this.byteLength);
         result.set(this);
@@ -628,20 +524,21 @@ class VSBuffer {
     }
     toString() {
         if (hasBuffer) {
-            return (/*#__PURE__*/ this.buffer.toString());
+            return (
+                 (this.buffer.toString())
+            );
         }
         else {
             if (!textDecoder) {
-                textDecoder = (/*#__PURE__*/ new TextDecoder());
+                textDecoder = ( (new TextDecoder()));
             }
             return textDecoder.decode(this.buffer);
         }
     }
     slice(start, end) {
-        // IMPORTANT: use subarray instead of slice because TypedArray#slice
-        // creates shallow copy and NodeBuffer#slice doesn't. The use of subarray
-        // ensures the same, performance, behaviour.
-        return (/*#__PURE__*/ new VSBuffer(this.buffer.subarray(start, end)));
+        return (
+             (new VSBuffer(this.buffer.subarray(start, end)))
+        );
     }
     set(array, offset) {
         if (array instanceof VSBuffer) {
@@ -651,10 +548,10 @@ class VSBuffer {
             this.buffer.set(array, offset);
         }
         else if (array instanceof ArrayBuffer) {
-            this.buffer.set((/*#__PURE__*/ new Uint8Array(array)), offset);
+            this.buffer.set(( (new Uint8Array(array))), offset);
         }
         else if (ArrayBuffer.isView(array)) {
-            this.buffer.set((/*#__PURE__*/ new Uint8Array(array.buffer, array.byteOffset, array.byteLength)), offset);
+            this.buffer.set(( (new Uint8Array(array.buffer, array.byteOffset, array.byteLength))), offset);
         }
         else {
             throw new Error(`Unknown argument 'array'`);
@@ -729,35 +626,22 @@ async function bufferedStreamToBuffer(bufferedStream) {
         return VSBuffer.concat(bufferedStream.buffer);
     }
     return VSBuffer.concat([
-        // Include already read chunks...
         ...bufferedStream.buffer,
-        // ...and all additional chunks
         await streamToBuffer(bufferedStream.stream)
     ]);
 }
 function newWriteableBufferStream(options) {
     return newWriteableStream(chunks => VSBuffer.concat(chunks), options);
 }
-
 const Emitter = monaco.Emitter;
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-// static theming participant
 const Extensions$1 = {
     ThemingContribution: 'base.contributions.theming'
 };
-/**
- * Utility base class for all themable components.
- */
 class Themable extends Disposable {
     constructor(themeService) {
         super();
         this.themeService = themeService;
         this.theme = themeService.getColorTheme();
-        // Hook up to theme changes
         this._register(this.themeService.onDidColorThemeChange(theme => this.onThemeChange(theme)));
     }
     onThemeChange(theme) {
@@ -765,40 +649,26 @@ class Themable extends Disposable {
         this.updateStyles();
     }
     updateStyles() {
-        // Subclasses to override
     }
     getColor(id, modify) {
         let color = this.theme.getColor(id);
         if (color && modify) {
             color = modify(color, this.theme);
         }
-        return color ? (/*#__PURE__*/ color.toString()) : null;
+        return color ? ( (color.toString())) : null;
     }
 }
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
 const Extensions = {
     JSONContribution: 'base.contributions.json'
 };
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
 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: (/*#__PURE__*/ Color$1.fromHex('#0E70C0'))
+    progressBarBackground: ( (Color$1.fromHex('#0E70C0')))
 };
-/**
- * A progress bar with support for infinite or discrete progress.
- */
 class ProgressBar extends Disposable {
     constructor(container, options) {
         super();
@@ -806,11 +676,11 @@ class ProgressBar extends Disposable {
         mixin(this.options, defaultOpts, false);
         this.workedVal = 0;
         this.progressBarBackground = this.options.progressBarBackground;
-        this.showDelayedScheduler = this._register((/*#__PURE__*/ new RunOnceScheduler(() => show(this.element), 0)));
-        this.longRunningScheduler = this._register((/*#__PURE__*/ new RunOnceScheduler(
+        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);
     }
     create(container) {
@@ -832,21 +702,14 @@ class ProgressBar extends Disposable {
         this.totalWork = undefined;
         this.longRunningScheduler.cancel();
     }
-    /**
-     * Indicates to the progress bar that all work is done.
-     */
     done() {
         return this.doDone(true);
     }
-    /**
-     * Stops the progressbar from showing any progress instantly without fading out.
-     */
     stop() {
         return this.doDone(false);
     }
     doDone(delayed) {
         this.element.classList.add(CSS_DONE);
-        // discrete: let it grow to 100% width and hide afterwards
         if (!this.element.classList.contains(CSS_INFINITE)) {
             this.bit.style.width = 'inherit';
             if (delayed) {
@@ -856,7 +719,6 @@ class ProgressBar extends Disposable {
                 this.off();
             }
         }
-        // infinite: let it fade out and hide afterwards
         else {
             this.bit.style.opacity = '0';
             if (delayed) {
@@ -868,9 +730,6 @@ class ProgressBar extends Disposable {
         }
         return this;
     }
-    /**
-     * Use this mode to indicate progress that has no total number of work units.
-     */
     infinite() {
         this.bit.style.width = '2%';
         this.bit.style.opacity = '1';
@@ -882,32 +741,19 @@ class ProgressBar extends Disposable {
     infiniteLongRunning() {
         this.element.classList.add(CSS_INFINITE_LONG_RUNNING);
     }
-    /**
-     * Tells the progress bar the total number of work. Use in combination with workedVal() to let
-     * the progress bar show the actual progress based on the work that is done.
-     */
     total(value) {
         this.workedVal = 0;
         this.totalWork = value;
-        this.element.setAttribute('aria-valuemax', (/*#__PURE__*/ value.toString()));
+        this.element.setAttribute('aria-valuemax', ( (value.toString())));
         return this;
     }
-    /**
-     * Finds out if this progress bar is configured with total work
-     */
     hasTotal() {
         return isNumber(this.totalWork);
     }
-    /**
-     * Tells the progress bar that an increment of work has been completed.
-     */
     worked(value) {
         value = Math.max(1, Number(value));
         return this.doSetWorked(this.workedVal + value);
     }
-    /**
-     * Tells the progress bar the total amount of work that has been completed.
-     */
     setWorked(value) {
         value = Math.max(1, Number(value));
         return this.doSetWorked(value);
@@ -918,7 +764,7 @@ class ProgressBar extends Disposable {
         this.workedVal = Math.min(totalWork, this.workedVal);
         this.element.classList.remove(CSS_INFINITE, CSS_INFINITE_LONG_RUNNING, CSS_DONE);
         this.element.classList.add(CSS_ACTIVE, CSS_DISCRETE);
-        this.element.setAttribute('aria-valuenow', (/*#__PURE__*/ value.toString()));
+        this.element.setAttribute('aria-valuenow', ( (value.toString())));
         this.bit.style.width = 100 * (this.workedVal / (totalWork)) + '%';
         return this;
     }
@@ -944,37 +790,24 @@ class ProgressBar extends Disposable {
     }
     applyStyles() {
         if (this.bit) {
-            const background = this.progressBarBackground ? (/*#__PURE__*/ this.progressBarBackground.toString()) : '';
+            const background = this.progressBarBackground ? ( (this.progressBarBackground.toString())) : '';
             this.bit.style.backgroundColor = background;
         }
     }
 }
-/**
- * After a certain time of showing the progress bar, switch
- * to long-running mode and throttle animations to reduce
- * the pressure on the GPU process.
- *
- * https://github.com/microsoft/vscode/issues/97900
- * https://github.com/microsoft/vscode/issues/138396
- */
 ProgressBar.LONG_RUNNING_INFINITE_THRESHOLD = 10000;
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
 class LanguageService extends Disposable {
     constructor(warnOnOverwrite = false) {
         super();
-        this._onDidEncounterLanguage = this._register((/*#__PURE__*/ new Emitter()));
+        this._onDidEncounterLanguage = this._register(( (new Emitter())));
         this.onDidEncounterLanguage = this._onDidEncounterLanguage.event;
-        this._onDidChange = this._register((/*#__PURE__*/ new Emitter(
-            { leakWarningThreshold: 200 /* https://github.com/microsoft/vscode/issues/119968 */ }
-        )));
+        this._onDidChange = this._register(( (new Emitter(
+            { leakWarningThreshold: 200  }
+        ))));
         this.onDidChange = this._onDidChange.event;
         LanguageService.instanceCount++;
-        this._encounteredLanguages = (/*#__PURE__*/ new Set());
-        this._registry = this._register((/*#__PURE__*/ new LanguagesRegistry$1(true, warnOnOverwrite)));
+        this._encounteredLanguages = ( (new Set()));
+        this._registry = this._register(( (new LanguagesRegistry$1(true, warnOnOverwrite))));
         this.languageIdCodec = this._registry.languageIdCodec;
         this._register(this._registry.onDidChange(() => this._onDidChange.fire()));
     }
@@ -1023,32 +856,35 @@ class LanguageService extends Disposable {
         return firstOrDefault(languageIds, null);
     }
     createById(languageId) {
-        return (/*#__PURE__*/ new LanguageSelection(this.onDidChange, () => {
-            return this._createAndGetLanguageIdentifier(languageId);
-        }));
+        return (
+             (new LanguageSelection(this.onDidChange, () => {
+                return this._createAndGetLanguageIdentifier(languageId);
+            }))
+        );
     }
     createByMimeType(mimeType) {
-        return (/*#__PURE__*/ new LanguageSelection(this.onDidChange, () => {
-            const languageId = this.getLanguageIdByMimeType(mimeType);
-            return this._createAndGetLanguageIdentifier(languageId);
-        }));
+        return (
+             (new LanguageSelection(this.onDidChange, () => {
+                const languageId = this.getLanguageIdByMimeType(mimeType);
+                return this._createAndGetLanguageIdentifier(languageId);
+            }))
+        );
     }
     createByFilepathOrFirstLine(resource, firstLine) {
-        return (/*#__PURE__*/ new LanguageSelection(this.onDidChange, () => {
-            const languageId = this.guessLanguageIdByFilepathOrFirstLine(resource, firstLine);
-            return this._createAndGetLanguageIdentifier(languageId);
-        }));
+        return (
+             (new LanguageSelection(this.onDidChange, () => {
+                const languageId = this.guessLanguageIdByFilepathOrFirstLine(resource, firstLine);
+                return this._createAndGetLanguageIdentifier(languageId);
+            }))
+        );
     }
     _createAndGetLanguageIdentifier(languageId) {
         if (!languageId || !this.isRegisteredLanguageId(languageId)) {
-            // Fall back to plain text if language is unknown
             languageId = PLAINTEXT_LANGUAGE_ID;
         }
         if (!this._encounteredLanguages.has(languageId)) {
             this._encounteredLanguages.add(languageId);
-            // Ensure tokenizers are created
             TokenizationRegistry.getOrCreate(languageId);
-            // Fire event
             this._onDidEncounterLanguage.fire(languageId);
         }
         return languageId;
@@ -1078,59 +914,49 @@ class LanguageSelection {
             this._listener = this._onDidChangeLanguages(() => this._evaluate());
         }
         if (!this._emitter) {
-            this._emitter = (/*#__PURE__*/ new Emitter({
+            this._emitter = ( (new Emitter({
                 onLastListenerRemove: () => {
                     this._dispose();
                 }
-            }));
+            })));
         }
         return this._emitter.event;
     }
     _evaluate() {
         const languageId = this._selector();
         if (languageId === this.languageId) {
-            // no change
             return;
         }
         this.languageId = languageId;
         this._emitter?.fire(this.languageId);
     }
 }
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
 var ParseOptions;
-(/*#__PURE__*/ (function(ParseOptions) {
+( ((function(ParseOptions) {
     ParseOptions.DEFAULT = {
         allowTrailingComma: true
     };
-})(ParseOptions || (ParseOptions = {})));
-/**
- * Creates a JSON scanner on the given text.
- * If ignoreTrivia is set, whitespaces or comments are ignored.
- */
+})(ParseOptions || (ParseOptions = {}))));
 function createScanner(text, ignoreTrivia = false) {
     let pos = 0;
     const len = text.length;
     let value = '';
     let tokenOffset = 0;
-    let token = 16 /* SyntaxKind.Unknown */;
-    let scanError = 0 /* ScanError.None */;
+    let token = 16 ;
+    let scanError = 0 ;
     function scanHexDigits(count) {
         let digits = 0;
         let hexValue = 0;
         while (digits < count) {
             const ch = text.charCodeAt(pos);
-            if (ch >= 48 /* CharacterCodes._0 */ && ch <= 57 /* CharacterCodes._9 */) {
-                hexValue = hexValue * 16 + ch - 48 /* CharacterCodes._0 */;
+            if (ch >= 48  && ch <= 57 ) {
+                hexValue = hexValue * 16 + ch - 48 ;
             }
-            else if (ch >= 65 /* CharacterCodes.A */ && ch <= 70 /* CharacterCodes.F */) {
-                hexValue = hexValue * 16 + ch - 65 /* CharacterCodes.A */ + 10;
+            else if (ch >= 65  && ch <= 70 ) {
+                hexValue = hexValue * 16 + ch - 65  + 10;
             }
-            else if (ch >= 97 /* CharacterCodes.a */ && ch <= 102 /* CharacterCodes.f */) {
-                hexValue = hexValue * 16 + ch - 97 /* CharacterCodes.a */ + 10;
+            else if (ch >= 97  && ch <= 102 ) {
+                hexValue = hexValue * 16 + ch - 97  + 10;
             }
             else {
                 break;
@@ -1147,12 +973,12 @@ function createScanner(text, ignoreTrivia = false) {
         pos = newPosition;
         value = '';
         tokenOffset = 0;
-        token = 16 /* SyntaxKind.Unknown */;
-        scanError = 0 /* ScanError.None */;
+        token = 16 ;
+        scanError = 0 ;
     }
     function scanNumber() {
         const start = pos;
-        if (text.charCodeAt(pos) === 48 /* CharacterCodes._0 */) {
+        if (text.charCodeAt(pos) === 48 ) {
             pos++;
         }
         else {
@@ -1161,7 +987,7 @@ function createScanner(text, ignoreTrivia = false) {
                 pos++;
             }
         }
-        if (pos < text.length && text.charCodeAt(pos) === 46 /* CharacterCodes.dot */) {
+        if (pos < text.length && text.charCodeAt(pos) === 46 ) {
             pos++;
             if (pos < text.length && isDigit(text.charCodeAt(pos))) {
                 pos++;
@@ -1170,14 +996,14 @@ function createScanner(text, ignoreTrivia = false) {
                 }
             }
             else {
-                scanError = 3 /* ScanError.UnexpectedEndOfNumber */;
+                scanError = 3 ;
                 return text.substring(start, pos);
             }
         }
         let end = pos;
-        if (pos < text.length && ((text.charCodeAt(pos) === 69 /* CharacterCodes.E */ || text.charCodeAt(pos) === 101) /* CharacterCodes.e */)) {
+        if (pos < text.length && ((text.charCodeAt(pos) === 69  || text.charCodeAt(pos) === 101) )) {
             pos++;
-            if (pos < text.length && text.charCodeAt(pos) === 43 /* CharacterCodes.plus */ || text.charCodeAt(pos) === 45 /* CharacterCodes.minus */) {
+            if (pos < text.length && text.charCodeAt(pos) === 43  || text.charCodeAt(pos) === 45 ) {
                 pos++;
             }
             if (pos < text.length && isDigit(text.charCodeAt(pos))) {
@@ -1188,7 +1014,7 @@ function createScanner(text, ignoreTrivia = false) {
                 end = pos;
             }
             else {
-                scanError = 3 /* ScanError.UnexpectedEndOfNumber */;
+                scanError = 3 ;
             }
         }
         return text.substring(start, end);
@@ -1198,60 +1024,60 @@ function createScanner(text, ignoreTrivia = false) {
         while (true) {
             if (pos >= len) {
                 result += text.substring(start, pos);
-                scanError = 2 /* ScanError.UnexpectedEndOfString */;
+                scanError = 2 ;
                 break;
             }
             const ch = text.charCodeAt(pos);
-            if (ch === 34 /* CharacterCodes.doubleQuote */) {
+            if (ch === 34 ) {
                 result += text.substring(start, pos);
                 pos++;
                 break;
             }
-            if (ch === 92 /* CharacterCodes.backslash */) {
+            if (ch === 92 ) {
                 result += text.substring(start, pos);
                 pos++;
                 if (pos >= len) {
-                    scanError = 2 /* ScanError.UnexpectedEndOfString */;
+                    scanError = 2 ;
                     break;
                 }
                 const ch2 = text.charCodeAt(pos++);
                 switch (ch2) {
-                    case 34 /* CharacterCodes.doubleQuote */:
+                    case 34 :
                         result += '\"';
                         break;
-                    case 92 /* CharacterCodes.backslash */:
+                    case 92 :
                         result += '\\';
                         break;
-                    case 47 /* CharacterCodes.slash */:
+                    case 47 :
                         result += '/';
                         break;
-                    case 98 /* CharacterCodes.b */:
+                    case 98 :
                         result += '\b';
                         break;
-                    case 102 /* CharacterCodes.f */:
+                    case 102 :
                         result += '\f';
                         break;
-                    case 110 /* CharacterCodes.n */:
+                    case 110 :
                         result += '\n';
                         break;
-                    case 114 /* CharacterCodes.r */:
+                    case 114 :
                         result += '\r';
                         break;
-                    case 116 /* CharacterCodes.t */:
+                    case 116 :
                         result += '\t';
                         break;
-                    case 117 /* CharacterCodes.u */: {
+                    case 117 : {
                         const ch3 = scanHexDigits(4);
                         if (ch3 >= 0) {
                             result += String.fromCharCode(ch3);
                         }
                         else {
-                            scanError = 4 /* ScanError.InvalidUnicode */;
+                            scanError = 4 ;
                         }
                         break;
                     }
                     default:
-                        scanError = 5 /* ScanError.InvalidEscapeCharacter */;
+                        scanError = 5 ;
                 }
                 start = pos;
                 continue;
@@ -1259,12 +1085,11 @@ function createScanner(text, ignoreTrivia = false) {
             if (ch >= 0 && ch <= 0x1F) {
                 if (isLineBreak(ch)) {
                     result += text.substring(start, pos);
-                    scanError = 2 /* ScanError.UnexpectedEndOfString */;
+                    scanError = 2 ;
                     break;
                 }
                 else {
-                    scanError = 6 /* ScanError.InvalidCharacter */;
-                    // mark as error but continue with string
+                    scanError = 6 ;
                 }
             }
             pos++;
@@ -1273,63 +1098,56 @@ function createScanner(text, ignoreTrivia = false) {
     }
     function scanNext() {
         value = '';
-        scanError = 0 /* ScanError.None */;
+        scanError = 0 ;
         tokenOffset = pos;
         if (pos >= len) {
-            // at the end
             tokenOffset = len;
-            return token = 17 /* SyntaxKind.EOF */;
+            return token = 17 ;
         }
         let code = text.charCodeAt(pos);
-        // trivia: whitespace
         if (isWhitespace(code)) {
             do {
                 pos++;
                 value += String.fromCharCode(code);
                 code = text.charCodeAt(pos);
             } while (isWhitespace(code));
-            return token = 15 /* SyntaxKind.Trivia */;
+            return token = 15 ;
         }
-        // trivia: newlines
         if (isLineBreak(code)) {
             pos++;
             value += String.fromCharCode(code);
-            if (code === 13 /* CharacterCodes.carriageReturn */ && text.charCodeAt(pos) === 10 /* CharacterCodes.lineFeed */) {
+            if (code === 13  && text.charCodeAt(pos) === 10 ) {
                 pos++;
                 value += '\n';
             }
-            return token = 14 /* SyntaxKind.LineBreakTrivia */;
+            return token = 14 ;
         }
         switch (code) {
-            // tokens: []{}:,
-            case 123 /* CharacterCodes.openBrace */:
+            case 123 :
                 pos++;
-                return token = 1 /* SyntaxKind.OpenBraceToken */;
-            case 125 /* CharacterCodes.closeBrace */:
+                return token = 1 ;
+            case 125 :
                 pos++;
-                return token = 2 /* SyntaxKind.CloseBraceToken */;
-            case 91 /* CharacterCodes.openBracket */:
+                return token = 2 ;
+            case 91 :
                 pos++;
-                return token = 3 /* SyntaxKind.OpenBracketToken */;
-            case 93 /* CharacterCodes.closeBracket */:
+                return token = 3 ;
+            case 93 :
                 pos++;
-                return token = 4 /* SyntaxKind.CloseBracketToken */;
-            case 58 /* CharacterCodes.colon */:
+                return token = 4 ;
+            case 58 :
                 pos++;
-                return token = 6 /* SyntaxKind.ColonToken */;
-            case 44 /* CharacterCodes.comma */:
+                return token = 6 ;
+            case 44 :
                 pos++;
-                return token = 5 /* SyntaxKind.CommaToken */;
-            // strings
-            case 34 /* CharacterCodes.doubleQuote */:
+                return token = 5 ;
+            case 34 :
                 pos++;
                 value = scanString();
-                return token = 10 /* SyntaxKind.StringLiteral */;
-            // comments
-            case 47 /* CharacterCodes.slash */: {
+                return token = 10 ;
+            case 47 : {
                 const start = pos - 1;
-                // Single-line comment
-                if (text.charCodeAt(pos + 1) === 47 /* CharacterCodes.slash */) {
+                if (text.charCodeAt(pos + 1) === 47 ) {
                     pos += 2;
                     while (pos < len) {
                         if (isLineBreak(text.charCodeAt(pos))) {
@@ -1338,16 +1156,15 @@ function createScanner(text, ignoreTrivia = false) {
                         pos++;
                     }
                     value = text.substring(start, pos);
-                    return token = 12 /* SyntaxKind.LineCommentTrivia */;
+                    return token = 12 ;
                 }
-                // Multi-line comment
-                if (text.charCodeAt(pos + 1) === 42 /* CharacterCodes.asterisk */) {
+                if (text.charCodeAt(pos + 1) === 42 ) {
                     pos += 2;
-                    const safeLength = len - 1; // For lookahead.
+                    const safeLength = len - 1;
                     let commentClosed = false;
                     while (pos < safeLength) {
                         const ch = text.charCodeAt(pos);
-                        if (ch === 42 /* CharacterCodes.asterisk */ && text.charCodeAt(pos + 1) === 47 /* CharacterCodes.slash */) {
+                        if (ch === 42  && text.charCodeAt(pos + 1) === 47 ) {
                             pos += 2;
                             commentClosed = true;
                             break;
@@ -1356,59 +1173,50 @@ function createScanner(text, ignoreTrivia = false) {
                     }
                     if (!commentClosed) {
                         pos++;
-                        scanError = 1 /* ScanError.UnexpectedEndOfComment */;
+                        scanError = 1 ;
                     }
                     value = text.substring(start, pos);
-                    return token = 13 /* SyntaxKind.BlockCommentTrivia */;
+                    return token = 13 ;
                 }
-                // just a single slash
                 value += String.fromCharCode(code);
                 pos++;
-                return token = 16 /* SyntaxKind.Unknown */;
+                return token = 16 ;
             }
-            // numbers
-            case 45 /* CharacterCodes.minus */:
+            case 45 :
                 value += String.fromCharCode(code);
                 pos++;
                 if (pos === len || !isDigit(text.charCodeAt(pos))) {
-                    return token = 16 /* SyntaxKind.Unknown */;
+                    return token = 16 ;
                 }
-            // found a minus, followed by a number so
-            // we fall through to proceed with scanning
-            // numbers
-            case 48 /* CharacterCodes._0 */:
-            case 49 /* CharacterCodes._1 */:
-            case 50 /* CharacterCodes._2 */:
-            case 51 /* CharacterCodes._3 */:
-            case 52 /* CharacterCodes._4 */:
-            case 53 /* CharacterCodes._5 */:
-            case 54 /* CharacterCodes._6 */:
-            case 55 /* CharacterCodes._7 */:
-            case 56 /* CharacterCodes._8 */:
-            case 57 /* CharacterCodes._9 */:
+            case 48 :
+            case 49 :
+            case 50 :
+            case 51 :
+            case 52 :
+            case 53 :
+            case 54 :
+            case 55 :
+            case 56 :
+            case 57 :
                 value += scanNumber();
-                return token = 11 /* SyntaxKind.NumericLiteral */;
-            // literals and unknown symbols
+                return token = 11 ;
             default:
-                // is a literal? Read the full word.
                 while (pos < len && isUnknownContentCharacter(code)) {
                     pos++;
                     code = text.charCodeAt(pos);
                 }
                 if (tokenOffset !== pos) {
                     value = text.substring(tokenOffset, pos);
-                    // keywords: true, false, null
                     switch (value) {
-                        case 'true': return token = 8 /* SyntaxKind.TrueKeyword */;
-                        case 'false': return token = 9 /* SyntaxKind.FalseKeyword */;
-                        case 'null': return token = 7 /* SyntaxKind.NullKeyword */;
+                        case 'true': return token = 8 ;
+                        case 'false': return token = 9 ;
+                        case 'null': return token = 7 ;
                     }
-                    return token = 16 /* SyntaxKind.Unknown */;
+                    return token = 16 ;
                 }
-                // some
                 value += String.fromCharCode(code);
                 pos++;
-                return token = 16 /* SyntaxKind.Unknown */;
+                return token = 16 ;
         }
     }
     function isUnknownContentCharacter(code) {
@@ -1416,14 +1224,14 @@ function createScanner(text, ignoreTrivia = false) {
             return false;
         }
         switch (code) {
-            case 125 /* CharacterCodes.closeBrace */:
-            case 93 /* CharacterCodes.closeBracket */:
-            case 123 /* CharacterCodes.openBrace */:
-            case 91 /* CharacterCodes.openBracket */:
-            case 34 /* CharacterCodes.doubleQuote */:
-            case 58 /* CharacterCodes.colon */:
-            case 44 /* CharacterCodes.comma */:
-            case 47 /* CharacterCodes.slash */:
+            case 125 :
+            case 93 :
+            case 123 :
+            case 91 :
+            case 34 :
+            case 58 :
+            case 44 :
+            case 47 :
                 return false;
         }
         return true;
@@ -1432,7 +1240,7 @@ function createScanner(text, ignoreTrivia = false) {
         let result;
         do {
             result = scanNext();
-        } while (result >= 12 /* SyntaxKind.LineCommentTrivia */ && result <= 15 /* SyntaxKind.Trivia */);
+        } while (result >= 12  && result <= 15 );
         return result;
     }
     return {
@@ -1447,20 +1255,16 @@ function createScanner(text, ignoreTrivia = false) {
     };
 }
 function isWhitespace(ch) {
-    return ch === 32 /* CharacterCodes.space */ || ch === 9 /* CharacterCodes.tab */ || ch === 11 /* CharacterCodes.verticalTab */ || ch === 12 /* CharacterCodes.formFeed */ ||
-        ch === 160 /* CharacterCodes.nonBreakingSpace */ || ch === 5760 /* CharacterCodes.ogham */ || ch >= 8192 /* CharacterCodes.enQuad */ && ch <= 8203 /* CharacterCodes.zeroWidthSpace */ ||
-        ch === 8239 /* CharacterCodes.narrowNoBreakSpace */ || ch === 8287 /* CharacterCodes.mathematicalSpace */ || ch === 12288 /* CharacterCodes.ideographicSpace */ || ch === 65279 /* CharacterCodes.byteOrderMark */;
+    return ch === 32  || ch === 9  || ch === 11  || ch === 12  ||
+        ch === 160  || ch === 5760  || ch >= 8192  && ch <= 8203  ||
+        ch === 8239  || ch === 8287  || ch === 12288  || ch === 65279 ;
 }
 function isLineBreak(ch) {
-    return ch === 10 /* CharacterCodes.lineFeed */ || ch === 13 /* CharacterCodes.carriageReturn */ || ch === 8232 /* CharacterCodes.lineSeparator */ || ch === 8233 /* CharacterCodes.paragraphSeparator */;
+    return ch === 10  || ch === 13  || ch === 8232  || ch === 8233 ;
 }
 function isDigit(ch) {
-    return ch >= 48 /* CharacterCodes._0 */ && ch <= 57 /* CharacterCodes._9 */;
+    return ch >= 48  && ch <= 57 ;
 }
-/**
- * Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
- * Therefore always check the errors list to find out if the input was valid.
- */
 function parse(text, errors = [], options = ParseOptions.DEFAULT) {
     let currentProperty = null;
     let currentParent = [];
@@ -1505,105 +1309,6 @@ function parse(text, errors = [], options = ParseOptions.DEFAULT) {
     visit(text, visitor, options);
     return currentParent[0];
 }
-/**
- * Parses the given text and returns a tree representation the JSON content. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
- */
-function parseTree(text, errors = [], options = ParseOptions.DEFAULT) {
-    let currentParent = { type: 'array', offset: -1, length: -1, children: [], parent: undefined }; // artificial root
-    function ensurePropertyComplete(endOffset) {
-        if (currentParent.type === 'property') {
-            currentParent.length = endOffset - currentParent.offset;
-            currentParent = currentParent.parent;
-        }
-    }
-    function onValue(valueNode) {
-        currentParent.children.push(valueNode);
-        return valueNode;
-    }
-    const visitor = {
-        onObjectBegin: (offset) => {
-            currentParent = onValue({ type: 'object', offset, length: -1, parent: currentParent, children: [] });
-        },
-        onObjectProperty: (name, offset, length) => {
-            currentParent = onValue({ type: 'property', offset, length: -1, parent: currentParent, children: [] });
-            currentParent.children.push({ type: 'string', value: name, offset, length, parent: currentParent });
-        },
-        onObjectEnd: (offset, length) => {
-            currentParent.length = offset + length - currentParent.offset;
-            currentParent = currentParent.parent;
-            ensurePropertyComplete(offset + length);
-        },
-        onArrayBegin: (offset, length) => {
-            currentParent = onValue({ type: 'array', offset, length: -1, parent: currentParent, children: [] });
-        },
-        onArrayEnd: (offset, length) => {
-            currentParent.length = offset + length - currentParent.offset;
-            currentParent = currentParent.parent;
-            ensurePropertyComplete(offset + length);
-        },
-        onLiteralValue: (value, offset, length) => {
-            onValue({ type: getNodeType(value), offset, length, parent: currentParent, value });
-            ensurePropertyComplete(offset + length);
-        },
-        onSeparator: (sep, offset, length) => {
-            if (currentParent.type === 'property') {
-                if (sep === ':') {
-                    currentParent.colonOffset = offset;
-                }
-                else if (sep === ',') {
-                    ensurePropertyComplete(offset);
-                }
-            }
-        },
-        onError: (error, offset, length) => {
-            errors.push({ error, offset, length });
-        }
-    };
-    visit(text, visitor, options);
-    const result = currentParent.children[0];
-    if (result) {
-        delete result.parent;
-    }
-    return result;
-}
-/**
- * Finds the node at the given path in a JSON DOM.
- */
-function findNodeAtLocation(root, path) {
-    if (!root) {
-        return undefined;
-    }
-    let node = root;
-    for (const segment of path) {
-        if (typeof segment === 'string') {
-            if (node.type !== 'object' || !Array.isArray(node.children)) {
-                return undefined;
-            }
-            let found = false;
-            for (const propertyNode of node.children) {
-                if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment) {
-                    node = propertyNode.children[1];
-                    found = true;
-                    break;
-                }
-            }
-            if (!found) {
-                return undefined;
-            }
-        }
-        else {
-            const index = segment;
-            if (node.type !== 'array' || index < 0 || !Array.isArray(node.children) || index >= node.children.length) {
-                return undefined;
-            }
-            node = node.children[index];
-        }
-    }
-    return node;
-}
-/**
- * Parses the given text and invokes the visitor functions for each object, array and literal reached.
- */
 function visit(text, visitor, options = ParseOptions.DEFAULT) {
     const _scanner = createScanner(text, false);
     function toNoArgVisit(visitFunction) {
@@ -1619,42 +1324,42 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
         while (true) {
             const token = _scanner.scan();
             switch (_scanner.getTokenError()) {
-                case 4 /* ScanError.InvalidUnicode */:
-                    handleError(14 /* ParseErrorCode.InvalidUnicode */);
+                case 4 :
+                    handleError(14 );
                     break;
-                case 5 /* ScanError.InvalidEscapeCharacter */:
-                    handleError(15 /* ParseErrorCode.InvalidEscapeCharacter */);
+                case 5 :
+                    handleError(15 );
                     break;
-                case 3 /* ScanError.UnexpectedEndOfNumber */:
-                    handleError(13 /* ParseErrorCode.UnexpectedEndOfNumber */);
+                case 3 :
+                    handleError(13 );
                     break;
-                case 1 /* ScanError.UnexpectedEndOfComment */:
+                case 1 :
                     if (!disallowComments) {
-                        handleError(11 /* ParseErrorCode.UnexpectedEndOfComment */);
+                        handleError(11 );
                     }
                     break;
-                case 2 /* ScanError.UnexpectedEndOfString */:
-                    handleError(12 /* ParseErrorCode.UnexpectedEndOfString */);
+                case 2 :
+                    handleError(12 );
                     break;
-                case 6 /* ScanError.InvalidCharacter */:
-                    handleError(16 /* ParseErrorCode.InvalidCharacter */);
+                case 6 :
+                    handleError(16 );
                     break;
             }
             switch (token) {
-                case 12 /* SyntaxKind.LineCommentTrivia */:
-                case 13 /* SyntaxKind.BlockCommentTrivia */:
+                case 12 :
+                case 13 :
                     if (disallowComments) {
-                        handleError(10 /* ParseErrorCode.InvalidCommentToken */);
+                        handleError(10 );
                     }
                     else {
                         onComment();
                     }
                     break;
-                case 16 /* SyntaxKind.Unknown */:
-                    handleError(1 /* ParseErrorCode.InvalidSymbol */);
+                case 16 :
+                    handleError(1 );
                     break;
-                case 15 /* SyntaxKind.Trivia */:
-                case 14 /* SyntaxKind.LineBreakTrivia */:
+                case 15 :
+                case 14 :
                     break;
                 default:
                     return token;
@@ -1665,7 +1370,7 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
         onError(error);
         if (skipUntilAfter.length + skipUntil.length > 0) {
             let token = _scanner.getToken();
-            while (token !== 17 /* SyntaxKind.EOF */) {
+            while (token !== 17 ) {
                 if (skipUntilAfter.indexOf(token) !== -1) {
                     scanNext();
                     break;
@@ -1690,28 +1395,28 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
     }
     function parseLiteral() {
         switch (_scanner.getToken()) {
-            case 11 /* SyntaxKind.NumericLiteral */: {
+            case 11 : {
                 let value = 0;
                 try {
                     value = JSON.parse(_scanner.getTokenValue());
                     if (typeof value !== 'number') {
-                        handleError(2 /* ParseErrorCode.InvalidNumberFormat */);
+                        handleError(2 );
                         value = 0;
                     }
                 }
                 catch (e) {
-                    handleError(2 /* ParseErrorCode.InvalidNumberFormat */);
+                    handleError(2 );
                 }
                 onLiteralValue(value);
                 break;
             }
-            case 7 /* SyntaxKind.NullKeyword */:
+            case 7 :
                 onLiteralValue(null);
                 break;
-            case 8 /* SyntaxKind.TrueKeyword */:
+            case 8 :
                 onLiteralValue(true);
                 break;
-            case 9 /* SyntaxKind.FalseKeyword */:
+            case 9 :
                 onLiteralValue(false);
                 break;
             default:
@@ -1721,113 +1426,113 @@ function visit(text, visitor, options = ParseOptions.DEFAULT) {
         return true;
     }
     function parseProperty() {
-        if (_scanner.getToken() !== 10 /* SyntaxKind.StringLiteral */) {
-            handleError(3 /* ParseErrorCode.PropertyNameExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);
+        if (_scanner.getToken() !== 10 ) {
+            handleError(3 , [], [2 , 5 ]);
             return false;
         }
         parseString(false);
-        if (_scanner.getToken() === 6 /* SyntaxKind.ColonToken */) {
+        if (_scanner.getToken() === 6 ) {
             onSeparator(':');
-            scanNext(); // consume colon
+            scanNext();
             if (!parseValue()) {
-                handleError(4 /* ParseErrorCode.ValueExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);
+                handleError(4 , [], [2 , 5 ]);
             }
         }
         else {
-            handleError(5 /* ParseErrorCode.ColonExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);
+            handleError(5 , [], [2 , 5 ]);
         }
         return true;
     }
     function parseObject() {
         onObjectBegin();
-        scanNext(); // consume open brace
+        scanNext();
         let needsComma = false;
-        while (_scanner.getToken() !== 2 /* SyntaxKind.CloseBraceToken */ && _scanner.getToken() !== 17 /* SyntaxKind.EOF */) {
-            if (_scanner.getToken() === 5 /* SyntaxKind.CommaToken */) {
+        while (_scanner.getToken() !== 2  && _scanner.getToken() !== 17 ) {
+            if (_scanner.getToken() === 5 ) {
                 if (!needsComma) {
-                    handleError(4 /* ParseErrorCode.ValueExpected */, [], []);
+                    handleError(4 , [], []);
                 }
                 onSeparator(',');
-                scanNext(); // consume comma
-                if (_scanner.getToken() === 2 /* SyntaxKind.CloseBraceToken */ && allowTrailingComma) {
+                scanNext();
+                if (_scanner.getToken() === 2  && allowTrailingComma) {
                     break;
                 }
             }
             else if (needsComma) {
-                handleError(6 /* ParseErrorCode.CommaExpected */, [], []);
+                handleError(6 , [], []);
             }
             if (!parseProperty()) {
-                handleError(4 /* ParseErrorCode.ValueExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);
+                handleError(4 , [], [2 , 5 ]);
             }
             needsComma = true;
         }
         onObjectEnd();
-        if (_scanner.getToken() !== 2 /* SyntaxKind.CloseBraceToken */) {
-            handleError(7 /* ParseErrorCode.CloseBraceExpected */, [2 /* SyntaxKind.CloseBraceToken */], []);
+        if (_scanner.getToken() !== 2 ) {
+            handleError(7 , [2 ], []);
         }
         else {
-            scanNext(); // consume close brace
+            scanNext();
         }
         return true;
     }
     function parseArray() {
         onArrayBegin();
-        scanNext(); // consume open bracket
+        scanNext();
         let needsComma = false;
-        while (_scanner.getToken() !== 4 /* SyntaxKind.CloseBracketToken */ && _scanner.getToken() !== 17 /* SyntaxKind.EOF */) {
-            if (_scanner.getToken() === 5 /* SyntaxKind.CommaToken */) {
+        while (_scanner.getToken() !== 4  && _scanner.getToken() !== 17 ) {
+            if (_scanner.getToken() === 5 ) {
                 if (!needsComma) {
-                    handleError(4 /* ParseErrorCode.ValueExpected */, [], []);
+                    handleError(4 , [], []);
                 }
                 onSeparator(',');
-                scanNext(); // consume comma
-                if (_scanner.getToken() === 4 /* SyntaxKind.CloseBracketToken */ && allowTrailingComma) {
+                scanNext();
+                if (_scanner.getToken() === 4  && allowTrailingComma) {
                     break;
                 }
             }
             else if (needsComma) {
-                handleError(6 /* ParseErrorCode.CommaExpected */, [], []);
+                handleError(6 , [], []);
             }
             if (!parseValue()) {
-                handleError(4 /* ParseErrorCode.ValueExpected */, [], [4 /* SyntaxKind.CloseBracketToken */, 5 /* SyntaxKind.CommaToken */]);
+                handleError(4 , [], [4 , 5 ]);
             }
             needsComma = true;
         }
         onArrayEnd();
-        if (_scanner.getToken() !== 4 /* SyntaxKind.CloseBracketToken */) {
-            handleError(8 /* ParseErrorCode.CloseBracketExpected */, [4 /* SyntaxKind.CloseBracketToken */], []);
+        if (_scanner.getToken() !== 4 ) {
+            handleError(8 , [4 ], []);
         }
         else {
-            scanNext(); // consume close bracket
+            scanNext();
         }
         return true;
     }
     function parseValue() {
         switch (_scanner.getToken()) {
-            case 3 /* SyntaxKind.OpenBracketToken */:
+            case 3 :
                 return parseArray();
-            case 1 /* SyntaxKind.OpenBraceToken */:
+            case 1 :
                 return parseObject();
-            case 10 /* SyntaxKind.StringLiteral */:
+            case 10 :
                 return parseString(true);
             default:
                 return parseLiteral();
         }
     }
     scanNext();
-    if (_scanner.getToken() === 17 /* SyntaxKind.EOF */) {
+    if (_scanner.getToken() === 17 ) {
         if (options.allowEmptyContent) {
             return true;
         }
-        handleError(4 /* ParseErrorCode.ValueExpected */, [], []);
+        handleError(4 , [], []);
         return false;
     }
     if (!parseValue()) {
-        handleError(4 /* ParseErrorCode.ValueExpected */, [], []);
+        handleError(4 , [], []);
         return false;
     }
-    if (_scanner.getToken() !== 17 /* SyntaxKind.EOF */) {
-        handleError(9 /* ParseErrorCode.EndOfFileExpected */, [], []);
+    if (_scanner.getToken() !== 17 ) {
+        handleError(9 , [], []);
     }
     return true;
 }
@@ -1848,11 +1553,6 @@ function getNodeType(value) {
         default: return 'null';
     }
 }
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
 var _a$1, _b$1;
 class StringIterator {
     constructor() {
@@ -1894,12 +1594,11 @@ class ConfigKeysIterator {
         return this._to < this._value.length;
     }
     next() {
-        // this._data = key.split(/[\\/]/).filter(s => !!s);
         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 /* CharCode.Period */) {
+            if (ch === 46 ) {
                 if (justSeps) {
                     this._from++;
                 }
@@ -1934,7 +1633,7 @@ class PathIterator {
         this._valueLen = key.length;
         for (let pos = key.length - 1; pos >= 0; pos--, this._valueLen--) {
             const ch = this._value.charCodeAt(pos);
-            if (!((ch === 47 /* CharCode.Slash */ || this._splitOnBackslash && ch === 92) /* CharCode.Backslash */)) {
+            if (!((ch === 47  || this._splitOnBackslash && ch === 92) )) {
                 break;
             }
         }
@@ -1944,12 +1643,11 @@ class PathIterator {
         return this._to < this._valueLen;
     }
     next() {
-        // this._data = key.split(/[\\/]/).filter(s => !!s);
         this._from = this._to;
         let justSeps = true;
         for (; this._to < this._valueLen; this._to++) {
             const ch = this._value.charCodeAt(this._to);
-            if (ch === 47 /* CharCode.Slash */ || this._splitOnBackslash && ch === 92 /* CharCode.Backslash */) {
+            if (ch === 47  || this._splitOnBackslash && ch === 92 ) {
                 if (justSeps) {
                     this._from++;
                 }
@@ -1983,31 +1681,31 @@ class UriIterator {
         this._value = key;
         this._states = [];
         if (this._value.scheme) {
-            this._states.push(1 /* UriIteratorState.Scheme */);
+            this._states.push(1 );
         }
         if (this._value.authority) {
-            this._states.push(2 /* UriIteratorState.Authority */);
+            this._states.push(2 );
         }
         if (this._value.path) {
-            this._pathIterator = (/*#__PURE__*/ new PathIterator(false, !this._ignorePathCasing(key)));
+            this._pathIterator = ( (new PathIterator(false, !this._ignorePathCasing(key))));
             this._pathIterator.reset(key.path);
             if (this._pathIterator.value()) {
-                this._states.push(3 /* UriIteratorState.Path */);
+                this._states.push(3 );
             }
         }
         if (!this._ignoreQueryAndFragment(key)) {
             if (this._value.query) {
-                this._states.push(4 /* UriIteratorState.Query */);
+                this._states.push(4 );
             }
             if (this._value.fragment) {
-                this._states.push(5 /* UriIteratorState.Fragment */);
+                this._states.push(5 );
             }
         }
         this._stateIdx = 0;
         return this;
     }
     next() {
-        if (this._states[this._stateIdx] === 3 /* UriIteratorState.Path */ && this._pathIterator.hasNext()) {
+        if (this._states[this._stateIdx] === 3  && this._pathIterator.hasNext()) {
             this._pathIterator.next();
         }
         else {
@@ -2016,41 +1714,41 @@ class UriIterator {
         return this;
     }
     hasNext() {
-        return (this._states[this._stateIdx] === 3 /* UriIteratorState.Path */ && this._pathIterator.hasNext())
+        return (this._states[this._stateIdx] === 3  && this._pathIterator.hasNext())
             || this._stateIdx < this._states.length - 1;
     }
     cmp(a) {
-        if (this._states[this._stateIdx] === 1 /* UriIteratorState.Scheme */) {
+        if (this._states[this._stateIdx] === 1 ) {
             return compareIgnoreCase(a, this._value.scheme);
         }
-        else if (this._states[this._stateIdx] === 2 /* UriIteratorState.Authority */) {
+        else if (this._states[this._stateIdx] === 2 ) {
             return compareIgnoreCase(a, this._value.authority);
         }
-        else if (this._states[this._stateIdx] === 3 /* UriIteratorState.Path */) {
+        else if (this._states[this._stateIdx] === 3 ) {
             return this._pathIterator.cmp(a);
         }
-        else if (this._states[this._stateIdx] === 4 /* UriIteratorState.Query */) {
+        else if (this._states[this._stateIdx] === 4 ) {
             return compare$1(a, this._value.query);
         }
-        else if (this._states[this._stateIdx] === 5 /* UriIteratorState.Fragment */) {
+        else if (this._states[this._stateIdx] === 5 ) {
             return compare$1(a, this._value.fragment);
         }
         throw new Error();
     }
     value() {
-        if (this._states[this._stateIdx] === 1 /* UriIteratorState.Scheme */) {
+        if (this._states[this._stateIdx] === 1 ) {
             return this._value.scheme;
         }
-        else if (this._states[this._stateIdx] === 2 /* UriIteratorState.Authority */) {
+        else if (this._states[this._stateIdx] === 2 ) {
             return this._value.authority;
         }
-        else if (this._states[this._stateIdx] === 3 /* UriIteratorState.Path */) {
+        else if (this._states[this._stateIdx] === 3 ) {
             return this._pathIterator.value();
         }
-        else if (this._states[this._stateIdx] === 4 /* UriIteratorState.Query */) {
+        else if (this._states[this._stateIdx] === 4 ) {
             return this._value.query;
         }
-        else if (this._states[this._stateIdx] === 5 /* UriIteratorState.Fragment */) {
+        else if (this._states[this._stateIdx] === 5 ) {
             return this._value.fragment;
         }
         throw new Error();
@@ -2097,16 +1795,24 @@ class TernarySearchTree {
         this._iter = segments;
     }
     static forUris(ignorePathCasing = () => false, ignoreQueryAndFragment = () => false) {
-        return (/*#__PURE__*/ new TernarySearchTree((/*#__PURE__*/ new UriIterator(ignorePathCasing, ignoreQueryAndFragment))));
+        return (
+             (new TernarySearchTree( (new UriIterator(ignorePathCasing, ignoreQueryAndFragment))))
+        );
     }
     static forPaths(ignorePathCasing = false) {
-        return (/*#__PURE__*/ new TernarySearchTree((/*#__PURE__*/ new PathIterator(undefined, !ignorePathCasing))));
+        return (
+             (new TernarySearchTree( (new PathIterator(undefined, !ignorePathCasing))))
+        );
     }
     static forStrings() {
-        return (/*#__PURE__*/ new TernarySearchTree((/*#__PURE__*/ new StringIterator())));
+        return (
+             (new TernarySearchTree( (new StringIterator())))
+        );
     }
     static forConfigKeys() {
-        return (/*#__PURE__*/ new TernarySearchTree((/*#__PURE__*/ new ConfigKeysIterator())));
+        return (
+             (new TernarySearchTree( (new ConfigKeysIterator())))
+        );
     }
     clear() {
         this._root = undefined;
@@ -2131,90 +1837,78 @@ class TernarySearchTree {
         const iter = this._iter.reset(key);
         let node;
         if (!this._root) {
-            this._root = (/*#__PURE__*/ new TernarySearchTreeNode());
+            this._root = ( (new TernarySearchTreeNode()));
             this._root.segment = iter.value();
         }
         const stack = [];
-        // find insert_node
         node = this._root;
         while (true) {
             const val = iter.cmp(node.segment);
             if (val > 0) {
-                // left
                 if (!node.left) {
-                    node.left = (/*#__PURE__*/ new TernarySearchTreeNode());
+                    node.left = ( (new TernarySearchTreeNode()));
                     node.left.segment = iter.value();
                 }
-                stack.push([-1 /* Dir.Left */, node]);
+                stack.push([-1 , node]);
                 node = node.left;
             }
             else if (val < 0) {
-                // right
                 if (!node.right) {
-                    node.right = (/*#__PURE__*/ new TernarySearchTreeNode());
+                    node.right = ( (new TernarySearchTreeNode()));
                     node.right.segment = iter.value();
                 }
-                stack.push([1 /* Dir.Right */, node]);
+                stack.push([1 , node]);
                 node = node.right;
             }
             else if (iter.hasNext()) {
-                // mid
                 iter.next();
                 if (!node.mid) {
-                    node.mid = (/*#__PURE__*/ new TernarySearchTreeNode());
+                    node.mid = ( (new TernarySearchTreeNode()));
                     node.mid.segment = iter.value();
                 }
-                stack.push([0 /* Dir.Mid */, node]);
+                stack.push([0 , node]);
                 node = node.mid;
             }
             else {
                 break;
             }
         }
-        // set value
         const oldElement = node.value;
         node.value = element;
         node.key = key;
-        // balance
         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) {
-                // needs rotate
                 const d1 = stack[i][0];
                 const d2 = stack[i + 1][0];
-                if (d1 === 1 /* Dir.Right */ && d2 === 1 /* Dir.Right */) {
-                    //right, right -> rotate left
+                if (d1 === 1  && d2 === 1 ) {
                     stack[i][1] = node.rotateLeft();
                 }
-                else if (d1 === -1 /* Dir.Left */ && d2 === -1 /* Dir.Left */) {
-                    // left, left -> rotate right
+                else if (d1 === -1  && d2 === -1 ) {
                     stack[i][1] = node.rotateRight();
                 }
-                else if (d1 === 1 /* Dir.Right */ && d2 === -1 /* Dir.Left */) {
-                    // right, left -> double rotate right, left
+                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 /* Dir.Left */ && d2 === 1 /* Dir.Right */) {
-                    // left, right -> double rotate left, right
+                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();
                 }
-                // patch path to parent
                 if (i > 0) {
                     switch (stack[i - 1][0]) {
-                        case -1 /* Dir.Left */:
+                        case -1 :
                             stack[i - 1][1].left = stack[i][1];
                             break;
-                        case 1 /* Dir.Right */:
+                        case 1 :
                             stack[i - 1][1].right = stack[i][1];
                             break;
-                        case 0 /* Dir.Mid */:
+                        case 0 :
                             stack[i - 1][1].mid = stack[i][1];
                             break;
                     }
@@ -2235,15 +1929,12 @@ class TernarySearchTree {
         while (node) {
             const val = iter.cmp(node.segment);
             if (val > 0) {
-                // left
                 node = node.left;
             }
             else if (val < 0) {
-                // right
                 node = node.right;
             }
             else if (iter.hasNext()) {
-                // mid
                 iter.next();
                 node = node.mid;
             }
@@ -2267,23 +1958,19 @@ class TernarySearchTree {
         const iter = this._iter.reset(key);
         const stack = [];
         let node = this._root;
-        // find node
         while (node) {
             const val = iter.cmp(node.segment);
             if (val > 0) {
-                // left
-                stack.push([-1 /* Dir.Left */, node]);
+                stack.push([-1 , node]);
                 node = node.left;
             }
             else if (val < 0) {
-                // right
-                stack.push([1 /* Dir.Right */, node]);
+                stack.push([1 , node]);
                 node = node.right;
             }
             else if (iter.hasNext()) {
-                // mid
                 iter.next();
-                stack.push([0 /* Dir.Mid */, node]);
+                stack.push([0 , node]);
                 node = node.mid;
             }
             else {
@@ -2291,25 +1978,20 @@ class TernarySearchTree {
             }
         }
         if (!node) {
-            // node not found
             return;
         }
         if (superStr) {
-            // removing children, reset height
             node.left = undefined;
             node.mid = undefined;
             node.right = undefined;
             node.height = 1;
         }
         else {
-            // removing element
             node.key = undefined;
             node.value = undefined;
         }
-        // BST node removal
         if (!node.mid && !node.value) {
             if (node.left && node.right) {
-                // full node
                 const min = this._min(node.right);
                 const { key, value, segment } = min;
                 this._delete(min.key, false);
@@ -2318,18 +2000,17 @@ class TernarySearchTree {
                 node.segment = segment;
             }
             else {
-                // empty or half empty
                 const newChild = node.left ?? node.right;
                 if (stack.length > 0) {
                     const [dir, parent] = stack[stack.length - 1];
                     switch (dir) {
-                        case -1 /* Dir.Left */:
+                        case -1 :
                             parent.left = newChild;
                             break;
-                        case 0 /* Dir.Mid */:
+                        case 0 :
                             parent.mid = newChild;
                             break;
-                        case 1 /* Dir.Right */:
+                        case 1 :
                             parent.right = newChild;
                             break;
                     }
@@ -2339,45 +2020,37 @@ class TernarySearchTree {
                 }
             }
         }
-        // AVL balance
         for (let i = stack.length - 1; i >= 0; i--) {
             const node = stack[i][1];
             node.updateHeight();
             const bf = node.balanceFactor();
             if (bf > 1) {
-                // right heavy
                 if (node.right.balanceFactor() >= 0) {
-                    // right, right -> rotate left
                     stack[i][1] = node.rotateLeft();
                 }
                 else {
-                    // right, left -> double rotate
                     node.right = node.right.rotateRight();
                     stack[i][1] = node.rotateLeft();
                 }
             }
             else if (bf < -1) {
-                // left heavy
                 if (node.left.balanceFactor() <= 0) {
-                    // left, left -> rotate right
                     stack[i][1] = node.rotateRight();
                 }
                 else {
-                    // left, right -> double rotate
                     node.left = node.left.rotateLeft();
                     stack[i][1] = node.rotateRight();
                 }
             }
-            // patch path to parent
             if (i > 0) {
                 switch (stack[i - 1][0]) {
-                    case -1 /* Dir.Left */:
+                    case -1 :
                         stack[i - 1][1].left = stack[i][1];
                         break;
-                    case 1 /* Dir.Right */:
+                    case 1 :
                         stack[i - 1][1].right = stack[i][1];
                         break;
-                    case 0 /* Dir.Mid */:
+                    case 0 :
                         stack[i - 1][1].mid = stack[i][1];
                         break;
                 }
@@ -2400,15 +2073,12 @@ class TernarySearchTree {
         while (node) {
             const val = iter.cmp(node.segment);
             if (val > 0) {
-                // left
                 node = node.left;
             }
             else if (val < 0) {
-                // right
                 node = node.right;
             }
             else if (iter.hasNext()) {
-                // mid
                 iter.next();
                 candidate = node.value || candidate;
                 node = node.mid;
@@ -2425,20 +2095,16 @@ class TernarySearchTree {
         while (node) {
             const val = iter.cmp(node.segment);
             if (val > 0) {
-                // left
                 node = node.left;
             }
             else if (val < 0) {
-                // right
                 node = node.right;
             }
             else if (iter.hasNext()) {
-                // mid
                 iter.next();
                 node = node.mid;
             }
             else {
-                // collect
                 if (!node.mid) {
                     return undefined;
                 }
@@ -2463,7 +2129,6 @@ class TernarySearchTree {
         return result[Symbol.iterator]();
     }
     _dfsEntries(node, bucket) {
-        // DFS
         if (!node) {
             return;
         }
@@ -2480,7 +2145,6 @@ class TernarySearchTree {
             this._dfsEntries(node.right, bucket);
         }
     }
-    // for debug/testing
     _isBalanced() {
         const nodeIsBalanced = (node) => {
             if (!node) {
@@ -2505,16 +2169,16 @@ class ResourceMap {
     constructor(mapOrKeyFn, toKey) {
         this[_a$1] = 'ResourceMap';
         if (mapOrKeyFn instanceof ResourceMap) {
-            this.map = (/*#__PURE__*/ new Map(mapOrKeyFn.map));
+            this.map = ( (new Map(mapOrKeyFn.map)));
             this.toKey = toKey ?? ResourceMap.defaultToKey;
         }
         else {
-            this.map = (/*#__PURE__*/ new Map());
+            this.map = ( (new Map()));
             this.toKey = mapOrKeyFn ?? ResourceMap.defaultToKey;
         }
     }
     set(resource, value) {
-        this.map.set(this.toKey(resource), (/*#__PURE__*/ new ResourceMapEntry(resource, value)));
+        this.map.set(this.toKey(resource), ( (new ResourceMapEntry(resource, value))));
         return this;
     }
     get(resource) {
@@ -2541,17 +2205,17 @@ class ResourceMap {
         }
     }
     *values() {
-        for (const entry of (/*#__PURE__*/ this.map.values())) {
+        for (const entry of ( (this.map.values()))) {
             yield entry.value;
         }
     }
     *keys() {
-        for (const entry of (/*#__PURE__*/ this.map.values())) {
+        for (const entry of ( (this.map.values()))) {
             yield entry.uri;
         }
     }
     *entries() {
-        for (const entry of (/*#__PURE__*/ this.map.values())) {
+        for (const entry of ( (this.map.values()))) {
             yield [entry.uri, entry.value];
         }
     }
@@ -2561,15 +2225,15 @@ class ResourceMap {
         }
     }
 }
-ResourceMap.defaultToKey = (resource) => (/*#__PURE__*/ resource.toString());
+ResourceMap.defaultToKey = (resource) => ( (resource.toString()));
 class ResourceSet {
     constructor(entriesOrKey, toKey) {
         this[_b$1] = 'ResourceSet';
         if (!entriesOrKey || typeof entriesOrKey === 'function') {
-            this._map = (/*#__PURE__*/ new ResourceMap(entriesOrKey));
+            this._map = ( (new ResourceMap(entriesOrKey)));
         }
         else {
-            this._map = (/*#__PURE__*/ new ResourceMap(toKey));
+            this._map = ( (new ResourceMap(toKey)));
             entriesOrKey.forEach(this.add, this);
         }
     }
@@ -2596,27 +2260,28 @@ class ResourceSet {
         return this._map.entries();
     }
     keys() {
-        return (/*#__PURE__*/ this._map.keys());
+        return (
+             (this._map.keys())
+        );
     }
     values() {
-        return (/*#__PURE__*/ this._map.keys());
+        return (
+             (this._map.keys())
+        );
     }
     [(_b$1 = Symbol.toStringTag, Symbol.iterator)]() {
-        return (/*#__PURE__*/ this.keys());
+        return (
+             (this.keys())
+        );
     }
 }
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
 class ConfigurationModel {
     constructor(_contents = {}, _keys = [], _overrides = []) {
         this._contents = _contents;
         this._keys = _keys;
         this._overrides = _overrides;
         this.frozen = false;
-        this.overrideConfigurations = (/*#__PURE__*/ new Map());
+        this.overrideConfigurations = ( (new Map()));
     }
     get contents() {
         return this.checkAndFreeze(this._contents);
@@ -2628,7 +2293,7 @@ class ConfigurationModel {
         return this.checkAndFreeze(this._keys);
     }
     isEmpty() {
-        return this._keys.length === 0 && (/*#__PURE__*/ Object.keys(this._contents)).length === 0 && this._overrides.length === 0;
+        return this._keys.length === 0 && ( (Object.keys(this._contents))).length === 0 && this._overrides.length === 0;
     }
     isFrozen() {
         return this.frozen;
@@ -2692,32 +2357,29 @@ class ConfigurationModel {
                 }
             }
         }
-        return (/*#__PURE__*/ new ConfigurationModel(contents, keys, overrides));
+        return (
+             (new ConfigurationModel(contents, keys, overrides))
+        );
     }
     freeze() {
         this.frozen = true;
         return this;
     }
     clone() {
-        return (/*#__PURE__*/ new ConfigurationModel(
-            deepClone(this.contents),
-            [...this.keys],
-            deepClone(this.overrides)
-        ));
+        return (
+             (new ConfigurationModel(deepClone(this.contents), [...this.keys], deepClone(this.overrides)))
+        );
     }
     createOverrideConfigurationModel(identifier) {
         const overrideContents = this.getContentsForOverrideIdentifer(identifier);
-        if (!overrideContents || typeof overrideContents !== 'object' || !(/*#__PURE__*/ Object.keys(overrideContents)).length) {
-            // If there are no valid overrides, return self
+        if (!overrideContents || typeof overrideContents !== 'object' || !( (Object.keys(overrideContents))).length) {
             return this;
         }
         const contents = {};
-        for (const key of distinct([...(/*#__PURE__*/ Object.keys(this.contents)), ...(/*#__PURE__*/ Object.keys(overrideContents))])) {
+        for (const key of distinct([...( (Object.keys(this.contents))), ...( (Object.keys(overrideContents)))])) {
             let contentsForKey = this.contents[key];
             const overrideContentsForKey = overrideContents[key];
-            // If there are override contents for the key, clone and merge otherwise use base contents
             if (overrideContentsForKey) {
-                // Clone and merge only if base contents and override contents are of type object otherwise just override
                 if (typeof contentsForKey === 'object' && typeof overrideContentsForKey === 'object') {
                     contentsForKey = deepClone(contentsForKey);
                     this.mergeContents(contentsForKey, overrideContentsForKey);
@@ -2728,10 +2390,12 @@ class ConfigurationModel {
             }
             contents[key] = contentsForKey;
         }
-        return (/*#__PURE__*/ new ConfigurationModel(contents, this.keys, this.overrides));
+        return (
+             (new ConfigurationModel(contents, this.keys, this.overrides))
+        );
     }
     mergeContents(source, target) {
-        for (const key of (/*#__PURE__*/ Object.keys(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]);
@@ -2768,7 +2432,6 @@ class ConfigurationModel {
                 mergeContents(override.contents);
             }
         }
-        // Merge contents of the identifier only at the end to take precedence.
         mergeContents(contentsForIdentifierOnly);
         return contents;
     }
@@ -2779,7 +2442,6 @@ class ConfigurationModel {
             keys: this.keys
         };
     }
-    // Update methods
     setValue(key, value) {
         this.addKey(key);
         addToValueTree(this.contents, key, value, e => { throw new Error(e); });
@@ -2816,7 +2478,7 @@ class ConfigurationModelParser {
         this._parseErrors = [];
     }
     get configurationModel() {
-        return this._configurationModel || (/*#__PURE__*/ new ConfigurationModel());
+        return this._configurationModel || ( (new ConfigurationModel()));
     }
     get restrictedConfigurations() {
         return this._restrictedConfigurations;
@@ -2838,7 +2500,7 @@ class ConfigurationModelParser {
     parseRaw(raw, options) {
         this._raw = raw;
         const { contents, keys, overrides, restricted } = this.doParseRaw(raw, options);
-        this._configurationModel = (/*#__PURE__*/ new ConfigurationModel(contents, keys, overrides));
+        this._configurationModel = ( (new ConfigurationModel(contents, keys, overrides)));
         this._restrictedConfigurations = restricted || [];
     }
     doParseContent(content) {
@@ -2895,11 +2557,11 @@ class ConfigurationModelParser {
         return raw;
     }
     doParseRaw(raw, options) {
-        const configurationProperties = (/*#__PURE__*/ Registry.as(Extensions$2.Configuration)).getConfigurationProperties();
+        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 = (/*#__PURE__*/ Object.keys(raw));
+        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 };
     }
@@ -2917,11 +2579,10 @@ class ConfigurationModelParser {
             }
             else {
                 const propertySchema = configurationProperties[key];
-                const scope = propertySchema ? typeof propertySchema.scope !== 'undefined' ? propertySchema.scope : 3 /* ConfigurationScope.WINDOW */ : undefined;
+                const scope = propertySchema ? typeof propertySchema.scope !== 'undefined' ? propertySchema.scope : 3  : undefined;
                 if (propertySchema?.restricted) {
                     restricted.push(key);
                 }
-                // Load unregistered configurations always.
                 if (scope === undefined || options.scopes === undefined || options.scopes.includes(scope)) {
                     if (!(options.skipRestricted && propertySchema?.restricted)) {
                         raw[key] = properties[key];
@@ -2933,7 +2594,7 @@ class ConfigurationModelParser {
     }
     toOverrides(raw, conflictReporter) {
         const overrides = [];
-        for (const key of (/*#__PURE__*/ Object.keys(raw))) {
+        for (const key of ( (Object.keys(raw)))) {
             if (OVERRIDE_PROPERTY_REGEX.test(key)) {
                 const overrideRaw = {};
                 for (const keyInOverrideRaw in raw[key]) {
@@ -2941,7 +2602,7 @@ class ConfigurationModelParser {
                 }
                 overrides.push({
                     identifiers: overrideIdentifiersFromKey(key),
-                    keys: (/*#__PURE__*/ Object.keys(overrideRaw)),
+                    keys: ( (Object.keys(overrideRaw))),
                     contents: toValuesTree(overrideRaw, conflictReporter)
                 });
             }
@@ -2955,23 +2616,24 @@ class UserSettings extends Disposable {
         this.userSettingsResource = userSettingsResource;
         this.scopes = scopes;
         this.fileService = fileService;
-        this._onDidChange = this._register((/*#__PURE__*/ new Emitter()));
+        this._onDidChange = this._register(( (new Emitter())));
         this.onDidChange = this._onDidChange.event;
-        this.parser = (/*#__PURE__*/ new ConfigurationModelParser((/*#__PURE__*/ this.userSettingsResource.toString())));
+        this.parser = ( (new ConfigurationModelParser( (this.userSettingsResource.toString()))));
         this.parseOptions = { scopes: this.scopes };
         this._register(this.fileService.watch(extUri.dirname(this.userSettingsResource)));
-        // Also listen to the resource incase the resource is a symlink - https://github.com/microsoft/vscode/issues/118134
         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 /* FileOperation.CREATE */) || e.isOperation(3 /* FileOperation.COPY */) || e.isOperation(1 /* FileOperation.DELETE */) || e.isOperation(4 /* FileOperation.WRITE */)) && extUri.isEqual(e.resource, userSettingsResource)))(() => this._onDidChange.fire()));
+        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((/*#__PURE__*/ content.value.toString()) || '{}', this.parseOptions);
+            this.parser.parse(( (content.value.toString())) || '{}', this.parseOptions);
             return this.parser.configurationModel;
         }
         catch (e) {
-            return (/*#__PURE__*/ new ConfigurationModel());
+            return (
+                 (new ConfigurationModel())
+            );
         }
     }
     reparse() {
@@ -2983,7 +2645,7 @@ class UserSettings extends Disposable {
     }
 }
 class Configuration {
-    constructor(_defaultConfiguration, _policyConfiguration, _applicationConfiguration, _localUserConfiguration, _remoteUserConfiguration = (/*#__PURE__*/ new ConfigurationModel()), _workspaceConfiguration = (/*#__PURE__*/ new ConfigurationModel()), _folderConfigurations = (/*#__PURE__*/ new ResourceMap$1()), _memoryConfiguration = (/*#__PURE__*/ new ConfigurationModel()), _memoryConfigurationByResource = (/*#__PURE__*/ new ResourceMap$1()), _freeze = true) {
+    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;
@@ -2995,7 +2657,7 @@ class Configuration {
         this._memoryConfigurationByResource = _memoryConfigurationByResource;
         this._freeze = _freeze;
         this._workspaceConsolidatedConfiguration = null;
-        this._foldersConsolidatedConfigurations = (/*#__PURE__*/ new ResourceMap$1());
+        this._foldersConsolidatedConfigurations = ( (new ResourceMap$1()));
         this._userConfiguration = null;
     }
     getValue(section, overrides, workspace) {
@@ -3007,7 +2669,7 @@ class Configuration {
         if (overrides.resource) {
             memoryConfiguration = this._memoryConfigurationByResource.get(overrides.resource);
             if (!memoryConfiguration) {
-                memoryConfiguration = (/*#__PURE__*/ new ConfigurationModel());
+                memoryConfiguration = ( (new ConfigurationModel()));
                 this._memoryConfigurationByResource.set(overrides.resource, memoryConfiguration);
             }
         }
@@ -3034,7 +2696,7 @@ class Configuration {
         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; //Check on workspace exists or not because _workspaceConfiguration is never null
+        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);
@@ -3302,7 +2964,7 @@ class Configuration {
                 overrides: this._workspaceConfiguration.overrides,
                 keys: this._workspaceConfiguration.keys
             },
-            folders: [...(/*#__PURE__*/ this._folderConfigurations.keys())].reduce((result, folder) => {
+            folders: [...( (this._folderConfigurations.keys()))].reduce((result, folder) => {
                 const { contents, overrides, keys } = this._folderConfigurations.get(folder);
                 result.push([folder, { contents, overrides, keys }]);
                 return result;
@@ -3310,28 +2972,28 @@ class Configuration {
         };
     }
     allKeys() {
-        const keys = (/*#__PURE__*/ new Set());
+        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 [...(/*#__PURE__*/ keys.values())];
+        return [...( (keys.values()))];
     }
     allOverrideIdentifiers() {
-        const keys = (/*#__PURE__*/ new Set());
+        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 [...(/*#__PURE__*/ keys.values())];
+        return [...( (keys.values()))];
     }
     getAllKeysForOverrideIdentifier(overrideIdentifier) {
-        const keys = (/*#__PURE__*/ new Set());
+        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 [...(/*#__PURE__*/ keys.values())];
+        return [...( (keys.values()))];
     }
     static parse(data) {
         const defaultConfiguration = this.parseConfigurationModel(data.defaults);
@@ -3342,22 +3004,24 @@ class Configuration {
         const folders = data.folders.reduce((result, value) => {
             result.set(URI.revive(value[0]), this.parseConfigurationModel(value[1]));
             return result;
-        }, (/*#__PURE__*/ new ResourceMap$1()));
-        return (/*#__PURE__*/ new Configuration(
-            defaultConfiguration,
-            policyConfiguration,
-            applicationConfiguration,
-            userConfiguration,
-            (/*#__PURE__*/ new ConfigurationModel()),
-            workspaceConfiguration,
-            folders,
-            (/*#__PURE__*/ new ConfigurationModel()),
-            (/*#__PURE__*/ new ResourceMap$1()),
-            false
-        ));
+        }, ( (new ResourceMap$1())));
+        return (
+             (new Configuration(
+                defaultConfiguration,
+                policyConfiguration,
+                applicationConfiguration,
+                userConfiguration,
+                 (new ConfigurationModel()),
+                workspaceConfiguration,
+                folders,
+                 (new ConfigurationModel()),
+                 (new ResourceMap$1()),
+                false
+            ))
+        );
     }
     static parseConfigurationModel(model) {
-        return (/*#__PURE__*/ new ConfigurationModel(model.contents, model.keys, model.overrides)).freeze();
+        return ( (new ConfigurationModel(model.contents, model.keys, model.overrides))).freeze();
     }
 }
 function compare(from, to) {
@@ -3408,24 +3072,12 @@ function compareConfigurationContents(to, from) {
     }
     return { added, removed, updated };
 }
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
 function isWorkspaceIdentifier(obj) {
     const workspaceIdentifier = obj;
     return typeof workspaceIdentifier?.id === 'string' && URI.isUri(workspaceIdentifier.configPath);
 }
 class WorkspaceFolder {
-    constructor(data, 
-    /**
-     * Provides access to the original metadata for this workspace
-     * folder. This can be different from the metadata provided in
-     * this class:
-     * - raw paths can be relative
-     * - raw paths are not normalized
-     */
+    constructor(data,
     raw) {
         this.raw = raw;
         this.uri = data.uri;
@@ -3439,11 +3091,145 @@ class WorkspaceFolder {
         return { uri: this.uri, name: this.name, index: this.index };
     }
 }
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
+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);
+        }
+    }
+    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);
+            }
+            else {
+                console.log(`[main ${now()}]`, message, ...args);
+            }
+        }
+    }
+    debug(message, ...args) {
+        if (this.getLevel() <= LogLevel.Debug) {
+            if (this.useColors) {
+                console.log(`\x1b[90m[main ${now()}]\x1b[0m`, message, ...args);
+            }
+            else {
+                console.log(`[main ${now()}]`, message, ...args);
+            }
+        }
+    }
+    info(message, ...args) {
+        if (this.getLevel() <= LogLevel.Info) {
+            if (this.useColors) {
+                console.log(`\x1b[90m[main ${now()}]\x1b[0m`, message, ...args);
+            }
+            else {
+                console.log(`[main ${now()}]`, message, ...args);
+            }
+        }
+    }
+    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);
+            }
+        }
+    }
+    error(message, ...args) {
+        if (this.getLevel() <= LogLevel.Error) {
+            if (this.useColors) {
+                console.error(`\x1b[91m[main ${now()}]\x1b[0m`, message, ...args);
+            }
+            else {
+                console.error(`[main ${now()}]`, message, ...args);
+            }
+        }
+    }
+    critical(message, ...args) {
+        if (this.getLevel() <= LogLevel.Critical) {
+            if (this.useColors) {
+                console.error(`\x1b[90m[main ${now()}]\x1b[0m`, message, ...args);
+            }
+            else {
+                console.error(`[main ${now()}]`, message, ...args);
+            }
+        }
+    }
+    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);
+    }
+    flush() {
+        this.logger.flush();
+    }
+}
 function isConfigurationOverrides(thing) {
     return thing
         && typeof thing === 'object'
@@ -3452,9 +3238,14 @@ function isConfigurationOverrides(thing) {
 }
 class StandaloneConfigurationService {
     constructor() {
-        this._onDidChangeConfiguration = (/*#__PURE__*/ new Emitter());
+        this._onDidChangeConfiguration = ( (new Emitter()));
         this.onDidChangeConfiguration = this._onDidChangeConfiguration.event;
-        this._configuration = (/*#__PURE__*/ new Configuration$1((/*#__PURE__*/ new DefaultConfigurationModel()), (/*#__PURE__*/ new ConfigurationModel$1()), (/*#__PURE__*/ new ConfigurationModel$1()), (/*#__PURE__*/ new ConfigurationModel$1())));
+        this._configuration = ( (new Configuration$1(
+             (new DefaultConfigurationModel()),
+             (new ConfigurationModel$1()),
+             (new ConfigurationModel$1()),
+             (new ConfigurationModel$1())
+        )));
     }
     getValue(arg1, arg2) {
         const section = typeof arg1 === 'string' ? arg1 : undefined;
@@ -3473,8 +3264,8 @@ class StandaloneConfigurationService {
             changedKeys.push(key);
         }
         if (changedKeys.length > 0) {
-            const configurationChangeEvent = (/*#__PURE__*/ new ConfigurationChangeEvent({ keys: changedKeys, overrides: [] }, previous, this._configuration));
-            configurationChangeEvent.source = 8 /* ConfigurationTarget.MEMORY */;
+            const configurationChangeEvent = ( (new ConfigurationChangeEvent({ keys: changedKeys, overrides: [] }, previous, this._configuration)));
+            configurationChangeEvent.source = 8 ;
             configurationChangeEvent.sourceConfig = null;
             this._onDidChangeConfiguration.fire(configurationChangeEvent);
         }
@@ -3487,7 +3278,9 @@ class StandaloneConfigurationService {
         return this._configuration.inspect(key, options, undefined);
     }
     keys() {
-        return (/*#__PURE__*/ this._configuration.keys(undefined));
+        return (
+             (this._configuration.keys(undefined))
+        );
     }
     reloadConfiguration() {
         return Promise.resolve(undefined);
@@ -3508,19 +3301,14 @@ class StandaloneConfigurationService {
         };
     }
 }
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
 const hasOwnProperty = Object.prototype.hasOwnProperty;
 const NULL_LANGUAGE_ID = 'vs.editor.nullLanguage';
 class LanguageIdCodec {
     constructor() {
         this._languageIdToLanguage = [];
-        this._languageToLanguageId = (/*#__PURE__*/ new Map());
-        this._register(NULL_LANGUAGE_ID, 0 /* LanguageId.Null */);
-        this._register(PLAINTEXT_LANGUAGE_ID, 1 /* LanguageId.PlainText */);
+        this._languageToLanguageId = ( (new Map()));
+        this._register(NULL_LANGUAGE_ID, 0 );
+        this._register(PLAINTEXT_LANGUAGE_ID, 1 );
         this._nextLanguageId = 2;
     }
     _register(language, languageId) {
@@ -3535,7 +3323,7 @@ class LanguageIdCodec {
         this._register(language, languageId);
     }
     encodeLanguageId(languageId) {
-        return this._languageToLanguageId.get(languageId) || 0 /* LanguageId.Null */;
+        return this._languageToLanguageId.get(languageId) || 0 ;
     }
     decodeLanguageId(languageId) {
         return this._languageIdToLanguage[languageId] || NULL_LANGUAGE_ID;
@@ -3544,11 +3332,11 @@ class LanguageIdCodec {
 class LanguagesRegistry extends Disposable {
     constructor(useModesRegistry = true, warnOnOverwrite = false) {
         super();
-        this._onDidChange = this._register((/*#__PURE__*/ new Emitter()));
+        this._onDidChange = this._register(( (new Emitter())));
         this.onDidChange = this._onDidChange.event;
         LanguagesRegistry.instanceCount++;
         this._warnOnOverwrite = warnOnOverwrite;
-        this.languageIdCodec = (/*#__PURE__*/ new LanguageIdCodec());
+        this.languageIdCodec = ( (new LanguageIdCodec()));
         this._dynamicLanguages = [];
         this._languages = {};
         this._mimeTypesMap = {};
@@ -3585,11 +3373,10 @@ class LanguagesRegistry extends Disposable {
         for (const d of desc) {
             this._registerLanguage(d);
         }
-        // Rebuild fast path maps
         this._mimeTypesMap = {};
         this._nameMap = {};
         this._lowercaseNameMap = {};
-        (/*#__PURE__*/ Object.keys(this._languages)).forEach((langId) => {
+        ( (Object.keys(this._languages))).forEach((langId) => {
             const language = this._languages[langId];
             if (language.name) {
                 this._nameMap[language.name] = language.identifier;
@@ -3601,7 +3388,7 @@ class LanguagesRegistry extends Disposable {
                 this._mimeTypesMap[mimetype] = language.identifier;
             });
         });
-        (/*#__PURE__*/ Registry.as(Extensions$2.Configuration)).registerOverrideIdentifiers(this.getRegisteredLanguageIds());
+        ( (Registry.as(Extensions$2.Configuration))).registerOverrideIdentifiers(this.getRegisteredLanguageIds());
         this._onDidChange.fire();
     }
     _registerLanguage(lang) {
@@ -3639,7 +3426,6 @@ class LanguagesRegistry extends Disposable {
         }
         if (Array.isArray(lang.extensions)) {
             if (lang.configuration) {
-                // insert first as this appears to be the 'primary' language definition
                 resolvedLanguage.extensions = lang.extensions.concat(resolvedLanguage.extensions);
             }
             else {
@@ -3666,13 +3452,12 @@ class LanguagesRegistry extends Disposable {
                 firstLineRegexStr = '^' + firstLineRegexStr;
             }
             try {
-                const firstLineRegex = (/*#__PURE__*/ new RegExp(firstLineRegexStr));
+                const firstLineRegex = ( (new RegExp(firstLineRegexStr)));
                 if (!regExpLeadsToEndlessLoop(firstLineRegex)) {
                     registerPlatformLanguageAssociation({ id: langId, mime: primaryMime, firstline: firstLineRegex }, this._warnOnOverwrite);
                 }
             }
             catch (err) {
-                // Most likely, the regex was bad
                 onUnexpectedError(err);
             }
         }
@@ -3680,7 +3465,6 @@ class LanguagesRegistry extends Disposable {
         let langAliases = null;
         if (typeof lang.aliases !== 'undefined' && Array.isArray(lang.aliases)) {
             if (lang.aliases.length === 0) {
-                // signal that this language should not get a name
                 langAliases = [null];
             }
             else {
@@ -3717,7 +3501,9 @@ class LanguagesRegistry extends Disposable {
         return hasOwnProperty.call(this._languages, languageId);
     }
     getRegisteredLanguageIds() {
-        return (/*#__PURE__*/ Object.keys(this._languages));
+        return (
+             (Object.keys(this._languages))
+        );
     }
     getSortedRegisteredLanguageNames() {
         const result = [];
@@ -3794,11 +3580,6 @@ class LanguagesRegistry extends Disposable {
     }
 }
 LanguagesRegistry.instanceCount = 0;
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
 class TraitRenderer {
     constructor(trait) {
         this.trait = trait;
@@ -3859,12 +3640,14 @@ class Trait {
         this.length = 0;
         this.indexes = [];
         this.sortedIndexes = [];
-        this._onChange = (/*#__PURE__*/ new Emitter());
+        this._onChange = ( (new Emitter()));
         this.onChange = this._onChange.event;
     }
     get name() { return this._trait; }
     get renderer() {
-        return (/*#__PURE__*/ new TraitRenderer(this));
+        return (
+             (new TraitRenderer(this))
+        );
     }
     splice(start, deleteCount, elements) {
         deleteCount = Math.max(0, Math.min(deleteCount, this.length - start));
@@ -3890,12 +3673,6 @@ class Trait {
     unrender(container) {
         container.classList.remove(this._trait);
     }
-    /**
-     * Sets the indexes which should have this trait.
-     *
-     * @param indexes Indexes which should have this trait.
-     * @return The old indexes which had this trait.
-     */
     set(indexes, browserEvent) {
         return this._set(indexes, [...indexes].sort(numericSort), browserEvent);
     }
@@ -3936,11 +3713,6 @@ class SelectionTrait extends Trait {
         }
     }
 }
-/**
- * The TraitSpliceable is used as a util class to be able
- * to preserve traits across splice calls, given an identity
- * provider.
- */
 class TraitSpliceable {
     constructor(trait, view, identityProvider) {
         this.trait = trait;
@@ -3951,8 +3723,8 @@ class TraitSpliceable {
         if (!this.identityProvider) {
             return this.trait.splice(start, deleteCount, elements.map(() => false));
         }
-        const pastElementsWithTrait = this.trait.get().map(i => (/*#__PURE__*/ this.identityProvider.getId(this.view.element(i)).toString()));
-        const elementsWithTrait = elements.map(e => pastElementsWithTrait.indexOf((/*#__PURE__*/ this.identityProvider.getId(e).toString())) > -1);
+        const pastElementsWithTrait = this.trait.get().map(i => ( (this.identityProvider.getId(this.view.element(i)).toString())));
+        const elementsWithTrait = elements.map(e => pastElementsWithTrait.indexOf(( (this.identityProvider.getId(e).toString()))) > -1);
         this.trait.splice(start, deleteCount, elementsWithTrait);
     }
 }
@@ -3975,28 +3747,28 @@ class KeyboardController {
     constructor(list, view, options) {
         this.list = list;
         this.view = view;
-        this.disposables = (/*#__PURE__*/ new DisposableStore());
-        this.multipleSelectionDisposables = (/*#__PURE__*/ new DisposableStore());
-        this.onKeyDown.filter(e => e.keyCode === 3 /* KeyCode.Enter */).on(this.onEnter, this, this.disposables);
-        this.onKeyDown.filter(e => e.keyCode === 16 /* KeyCode.UpArrow */).on(this.onUpArrow, this, this.disposables);
-        this.onKeyDown.filter(e => e.keyCode === 18 /* KeyCode.DownArrow */).on(this.onDownArrow, this, this.disposables);
-        this.onKeyDown.filter(e => e.keyCode === 11 /* KeyCode.PageUp */).on(this.onPageUpArrow, this, this.disposables);
-        this.onKeyDown.filter(e => e.keyCode === 12 /* KeyCode.PageDown */).on(this.onPageDownArrow, this, this.disposables);
-        this.onKeyDown.filter(e => e.keyCode === 9 /* KeyCode.Escape */).on(this.onEscape, this, this.disposables);
+        this.disposables = ( (new DisposableStore()));
+        this.multipleSelectionDisposables = ( (new DisposableStore()));
+        this.onKeyDown.filter(e => e.keyCode === 3 ).on(this.onEnter, this, this.disposables);
+        this.onKeyDown.filter(e => e.keyCode === 16 ).on(this.onUpArrow, this, this.disposables);
+        this.onKeyDown.filter(e => e.keyCode === 18 ).on(this.onDownArrow, this, this.disposables);
+        this.onKeyDown.filter(e => e.keyCode === 11 ).on(this.onPageUpArrow, this, this.disposables);
+        this.onKeyDown.filter(e => e.keyCode === 12 ).on(this.onPageDownArrow, this, this.disposables);
+        this.onKeyDown.filter(e => e.keyCode === 9 ).on(this.onEscape, this, this.disposables);
         if (options.multipleSelectionSupport !== false) {
-            this.onKeyDown.filter(e => (isMacintosh ? e.metaKey : e.ctrlKey) && e.keyCode === 31 /* KeyCode.KeyA */).on(this.onCtrlA, this, this.multipleSelectionDisposables);
+            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((/*#__PURE__*/ new DomEmitter(this.view.domNode, 'keydown'))).event)
+        return this.disposables.add(Event.chain(this.disposables.add(( (new DomEmitter(this.view.domNode, 'keydown')))).event)
             .filter(e => !isInputElement(e.target))
-            .map(e => (/*#__PURE__*/ new StandardKeyboardEvent(e))));
+            .map(e => ( (new StandardKeyboardEvent(e)))));
     }
     updateOptions(optionsUpdate) {
         if (optionsUpdate.multipleSelectionSupport !== undefined) {
             this.multipleSelectionDisposables.clear();
             if (optionsUpdate.multipleSelectionSupport) {
-                this.onKeyDown.filter(e => (isMacintosh ? e.metaKey : e.ctrlKey) && e.keyCode === 31 /* KeyCode.KeyA */).on(this.onCtrlA, this, this.multipleSelectionDisposables);
+                this.onKeyDown.filter(e => (isMacintosh ? e.metaKey : e.ctrlKey) && e.keyCode === 31 ).on(this.onCtrlA, this, this.multipleSelectionDisposables);
             }
         }
     }
@@ -4063,24 +3835,24 @@ class KeyboardController {
     }
 }
 var TypeNavigationMode;
-(/*#__PURE__*/ (function(TypeNavigationMode) {
+( ((function(TypeNavigationMode) {
     TypeNavigationMode[TypeNavigationMode["Automatic"] = 0] = "Automatic";
     TypeNavigationMode[TypeNavigationMode["Trigger"] = 1] = "Trigger";
-})(TypeNavigationMode || (TypeNavigationMode = {})));
+})(TypeNavigationMode || (TypeNavigationMode = {}))));
 var TypeNavigationControllerState;
-(/*#__PURE__*/ (function(TypeNavigationControllerState) {
+( ((function(TypeNavigationControllerState) {
     TypeNavigationControllerState[TypeNavigationControllerState["Idle"] = 0] = "Idle";
     TypeNavigationControllerState[TypeNavigationControllerState["Typing"] = 1] = "Typing";
-})(TypeNavigationControllerState || (TypeNavigationControllerState = {})));
+})(TypeNavigationControllerState || (TypeNavigationControllerState = {}))));
 const DefaultKeyboardNavigationDelegate = new class {
     mightProducePrintableCharacter(event) {
         if (event.ctrlKey || event.metaKey || event.altKey) {
             return false;
         }
-        return ((event.keyCode >= 31 /* KeyCode.KeyA */ && event.keyCode <= 56) /* KeyCode.KeyZ */)
-            || ((event.keyCode >= 21 /* KeyCode.Digit0 */ && event.keyCode <= 30) /* KeyCode.Digit9 */)
-            || ((event.keyCode >= 93 /* KeyCode.Numpad0 */ && event.keyCode <= 102) /* KeyCode.Numpad9 */)
-            || ((event.keyCode >= 80 /* KeyCode.Semicolon */ && event.keyCode <= 90) /* KeyCode.Quote */);
+        return ((event.keyCode >= 31  && event.keyCode <= 56) )
+            || ((event.keyCode >= 21  && event.keyCode <= 30) )
+            || ((event.keyCode >= 93  && event.keyCode <= 102) )
+            || ((event.keyCode >= 80  && event.keyCode <= 90) );
     }
 };
 class TypeNavigationController {
@@ -4095,8 +3867,8 @@ class TypeNavigationController {
         this.mode = TypeNavigationMode.Automatic;
         this.triggered = false;
         this.previouslyFocused = -1;
-        this.enabledDisposables = (/*#__PURE__*/ new DisposableStore());
-        this.disposables = (/*#__PURE__*/ new DisposableStore());
+        this.enabledDisposables = ( (new DisposableStore()));
+        this.disposables = ( (new DisposableStore()));
         this.updateOptions(list.options);
     }
     updateOptions(options) {
@@ -4116,10 +3888,10 @@ class TypeNavigationController {
             return;
         }
         let typing = false;
-        const onChar = this.enabledDisposables.add(Event.chain(this.enabledDisposables.add((/*#__PURE__*/ new DomEmitter(this.view.domNode, 'keydown'))).event))
+        const onChar = this.enabledDisposables.add(Event.chain(this.enabledDisposables.add(( (new DomEmitter(this.view.domNode, 'keydown')))).event))
             .filter(e => !isInputElement(e.target))
             .filter(() => this.mode === TypeNavigationMode.Automatic || this.triggered)
-            .map(event => (/*#__PURE__*/ new StandardKeyboardEvent(event)))
+            .map(event => ( (new StandardKeyboardEvent(event))))
             .filter(e => typing || this.keyboardNavigationEventFilter(e))
             .filter(e => this.delegate.mightProducePrintableCharacter(e))
             .forEach(stopEvent)
@@ -4145,8 +3917,6 @@ class TypeNavigationController {
     onClear() {
         const focus = this.list.getFocus();
         if (focus.length > 0 && focus[0] === this.previouslyFocused) {
-            // List: re-announce element on typing end since typed keys will interrupt aria label of focused element
-            // Do not announce if there was a focus change at the end to prevent duplication https://github.com/microsoft/vscode/issues/95961
             const ariaLabel = this.list.options.accessibilityProvider?.getAriaLabel(this.list.element(focus[0]));
             if (ariaLabel) {
                 alert(ariaLabel);
@@ -4167,7 +3937,7 @@ class TypeNavigationController {
         for (let i = 0; i < this.list.length; i++) {
             const index = (start + i + delta) % this.list.length;
             const label = this.keyboardNavigationLabelProvider.getKeyboardNavigationLabel(this.view.element(index));
-            const labelStr = label && (/*#__PURE__*/ label.toString());
+            const labelStr = label && ( (label.toString()));
             if (typeof labelStr === 'undefined' || matchesPrefix(word, labelStr)) {
                 this.previouslyFocused = start;
                 this.list.setFocus([index]);
@@ -4186,11 +3956,11 @@ class DOMFocusController {
     constructor(list, view) {
         this.list = list;
         this.view = view;
-        this.disposables = (/*#__PURE__*/ new DisposableStore());
-        const onKeyDown = this.disposables.add(Event.chain(this.disposables.add((/*#__PURE__*/ new DomEmitter(view.domNode, 'keydown'))).event))
+        this.disposables = ( (new DisposableStore()));
+        const onKeyDown = this.disposables.add(Event.chain(this.disposables.add(( (new DomEmitter(view.domNode, 'keydown')))).event))
             .filter(e => !isInputElement(e.target))
-            .map(e => (/*#__PURE__*/ new StandardKeyboardEvent(e)));
-        onKeyDown.filter(e => e.keyCode === 2 /* KeyCode.Tab */ && !e.ctrlKey && !e.metaKey && !e.shiftKey && !e.altKey)
+            .map(e => ( (new StandardKeyboardEvent(e))));
+        onKeyDown.filter(e => e.keyCode === 2  && !e.ctrlKey && !e.metaKey && !e.shiftKey && !e.altKey)
             .on(this.onTab, this, this.disposables);
     }
     onTab(e) {
@@ -4237,8 +4007,8 @@ const DefaultMultipleSelectionController = {
 class MouseController {
     constructor(list) {
         this.list = list;
-        this.disposables = (/*#__PURE__*/ new DisposableStore());
-        this._onPointer = (/*#__PURE__*/ new Emitter());
+        this.disposables = ( (new DisposableStore()));
+        this._onPointer = ( (new Emitter()));
         this.onPointer = this._onPointer.event;
         if (list.options.multipleSelectionSupport !== false) {
             this.multipleSelectionController = this.list.options.multipleSelectionController || DefaultMultipleSelectionController;
@@ -4378,20 +4148,20 @@ class DefaultStyleController {
             if (styles.listBackground.isOpaque()) {
                 content.push(`.monaco-list${suffix} .monaco-list-rows { background: ${styles.listBackground}; }`);
             }
-            else if (!isMacintosh) { // subpixel AA doesn't exist in macOS
+            else if (!isMacintosh) {
                 console.warn(`List with id '${this.selectorSuffix}' was styled with a non-opaque background color. This will break sub-pixel antialiasing.`);
             }
         }
         if (styles.listFocusBackground) {
             content.push(`.monaco-list${suffix}:focus .monaco-list-row.focused { background-color: ${styles.listFocusBackground}; }`);
-            content.push(`.monaco-list${suffix}:focus .monaco-list-row.focused:hover { background-color: ${styles.listFocusBackground}; }`); // overwrite :hover style in this case!
+            content.push(`.monaco-list${suffix}:focus .monaco-list-row.focused:hover { background-color: ${styles.listFocusBackground}; }`);
         }
         if (styles.listFocusForeground) {
             content.push(`.monaco-list${suffix}:focus .monaco-list-row.focused { color: ${styles.listFocusForeground}; }`);
         }
         if (styles.listActiveSelectionBackground) {
             content.push(`.monaco-list${suffix}:focus .monaco-list-row.selected { background-color: ${styles.listActiveSelectionBackground}; }`);
-            content.push(`.monaco-list${suffix}:focus .monaco-list-row.selected:hover { background-color: ${styles.listActiveSelectionBackground}; }`); // overwrite :hover style in this case!
+            content.push(`.monaco-list${suffix}:focus .monaco-list-row.selected:hover { background-color: ${styles.listActiveSelectionBackground}; }`);
         }
         if (styles.listActiveSelectionForeground) {
             content.push(`.monaco-list${suffix}:focus .monaco-list-row.selected { color: ${styles.listActiveSelectionForeground}; }`);
@@ -4416,18 +4186,18 @@ class DefaultStyleController {
         }
         if (styles.listInactiveFocusForeground) {
             content.push(`.monaco-list${suffix} .monaco-list-row.focused { color:  ${styles.listInactiveFocusForeground}; }`);
-            content.push(`.monaco-list${suffix} .monaco-list-row.focused:hover { color:  ${styles.listInactiveFocusForeground}; }`); // overwrite :hover style in this case!
+            content.push(`.monaco-list${suffix} .monaco-list-row.focused:hover { color:  ${styles.listInactiveFocusForeground}; }`);
         }
         if (styles.listInactiveSelectionIconForeground) {
             content.push(`.monaco-list${suffix} .monaco-list-row.focused .codicon { color:  ${styles.listInactiveSelectionIconForeground}; }`);
         }
         if (styles.listInactiveFocusBackground) {
             content.push(`.monaco-list${suffix} .monaco-list-row.focused { background-color:  ${styles.listInactiveFocusBackground}; }`);
-            content.push(`.monaco-list${suffix} .monaco-list-row.focused:hover { background-color:  ${styles.listInactiveFocusBackground}; }`); // overwrite :hover style in this case!
+            content.push(`.monaco-list${suffix} .monaco-list-row.focused:hover { background-color:  ${styles.listInactiveFocusBackground}; }`);
         }
         if (styles.listInactiveSelectionBackground) {
             content.push(`.monaco-list${suffix} .monaco-list-row.selected { background-color:  ${styles.listInactiveSelectionBackground}; }`);
-            content.push(`.monaco-list${suffix} .monaco-list-row.selected:hover { background-color:  ${styles.listInactiveSelectionBackground}; }`); // overwrite :hover style in this case!
+            content.push(`.monaco-list${suffix} .monaco-list-row.selected:hover { background-color:  ${styles.listInactiveSelectionBackground}; }`);
         }
         if (styles.listInactiveSelectionForeground) {
             content.push(`.monaco-list${suffix} .monaco-list-row.selected { color: ${styles.listInactiveSelectionForeground}; }`);
@@ -4481,20 +4251,20 @@ class DefaultStyleController {
     }
 }
 const defaultStyles = {
-    listFocusBackground: (/*#__PURE__*/ Color$1.fromHex('#7FB0D0')),
-    listActiveSelectionBackground: (/*#__PURE__*/ Color$1.fromHex('#0E639C')),
-    listActiveSelectionForeground: (/*#__PURE__*/ Color$1.fromHex('#FFFFFF')),
-    listActiveSelectionIconForeground: (/*#__PURE__*/ Color$1.fromHex('#FFFFFF')),
-    listFocusAndSelectionOutline: (/*#__PURE__*/ Color$1.fromHex('#90C2F9')),
-    listFocusAndSelectionBackground: (/*#__PURE__*/ Color$1.fromHex('#094771')),
-    listFocusAndSelectionForeground: (/*#__PURE__*/ Color$1.fromHex('#FFFFFF')),
-    listInactiveSelectionBackground: (/*#__PURE__*/ Color$1.fromHex('#3F3F46')),
-    listInactiveSelectionIconForeground: (/*#__PURE__*/ Color$1.fromHex('#FFFFFF')),
-    listHoverBackground: (/*#__PURE__*/ Color$1.fromHex('#2A2D2E')),
-    listDropBackground: (/*#__PURE__*/ Color$1.fromHex('#383B3D')),
-    treeIndentGuidesStroke: (/*#__PURE__*/ Color$1.fromHex('#a9a9a9')),
-    tableColumnsBorder: (/*#__PURE__*/ (/*#__PURE__*/ Color$1.fromHex('#cccccc')).transparent(0.2)),
-    tableOddRowsBackgroundColor: (/*#__PURE__*/ (/*#__PURE__*/ Color$1.fromHex('#cccccc')).transparent(0.04))
+    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,
@@ -4507,7 +4277,6 @@ const DefaultOptions = {
         drop() { }
     }
 };
-// TODO@Joao: move these utils into a SortedArray class
 function getContiguousRangeContaining(range, value) {
     const index = range.indexOf(value);
     if (index === -1) {
@@ -4525,10 +4294,6 @@ function getContiguousRangeContaining(range, value) {
     }
     return result;
 }
-/**
- * Given two sorted collections of numbers, returns the intersection
- * between them (OR).
- */
 function disjunction(one, other) {
     const result = [];
     let i = 0, j = 0;
@@ -4554,10 +4319,6 @@ function disjunction(one, other) {
     }
     return result;
 }
-/**
- * Given two sorted collections of numbers, returns the relative
- * complement between them (XOR).
- */
 function relativeComplement(one, other) {
     const result = [];
     let i = 0, j = 0;
@@ -4639,7 +4400,6 @@ class AccessibiltyRenderer {
         }
     }
     disposeTemplate(templateData) {
-        // noop
     }
 }
 class ListViewDragAndDrop {
@@ -4677,80 +4437,65 @@ class ListViewDragAndDrop {
         this.dnd.drop(data, targetElement, targetIndex, originalEvent);
     }
 }
-/**
- * The {@link List} is a virtual scrolling widget, built on top of the {@link ListView}
- * widget.
- *
- * Features:
- * - Customizable keyboard and mouse support
- * - Element traits: focus, selection, achor
- * - Accessibility support
- * - Touch support
- * - Performant template-based rendering
- * - Horizontal scrolling
- * - Variable element height support
- * - Dynamic element height support
- * - Drag-and-drop support
- */
 class List {
     constructor(user, container, virtualDelegate, renderers, _options = DefaultOptions) {
         this.user = user;
         this._options = _options;
-        this.focus = (/*#__PURE__*/ new Trait('focused'));
-        this.anchor = (/*#__PURE__*/ new Trait('anchor'));
-        this.eventBufferer = (/*#__PURE__*/ new EventBufferer());
+        this.focus = ( (new Trait('focused')));
+        this.anchor = ( (new Trait('anchor')));
+        this.eventBufferer = ( (new EventBufferer()));
         this._ariaLabel = '';
-        this.disposables = (/*#__PURE__*/ new DisposableStore());
-        this._onDidDispose = (/*#__PURE__*/ new Emitter());
+        this.disposables = ( (new DisposableStore()));
+        this._onDidDispose = ( (new Emitter()));
         this.onDidDispose = this._onDidDispose.event;
         const role = this._options.accessibilityProvider && this._options.accessibilityProvider.getWidgetRole ? this._options.accessibilityProvider?.getWidgetRole() : 'list';
-        this.selection = (/*#__PURE__*/ new SelectionTrait(role !== 'listbox'));
+        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) {
-            baseRenderers.push((/*#__PURE__*/ new AccessibiltyRenderer(this.accessibilityProvider)));
+            baseRenderers.push(( (new AccessibiltyRenderer(this.accessibilityProvider))));
             this.accessibilityProvider.onDidChangeActiveDescendant?.(this.onDidChangeActiveDescendant, this, this.disposables);
         }
-        renderers = renderers.map(r => (/*#__PURE__*/ new PipelineRenderer(r.templateId, [...baseRenderers, r])));
+        renderers = renderers.map(r => ( (new PipelineRenderer(r.templateId, [...baseRenderers, r]))));
         const viewOptions = {
             ..._options,
-            dnd: _options.dnd && (/*#__PURE__*/ new ListViewDragAndDrop(this, _options.dnd))
+            dnd: _options.dnd && ( (new ListViewDragAndDrop(this, _options.dnd)))
         };
-        this.view = (/*#__PURE__*/ new ListView(container, virtualDelegate, renderers, viewOptions));
+        this.view = ( (new ListView(container, virtualDelegate, renderers, viewOptions)));
         this.view.domNode.setAttribute('role', role);
         if (_options.styleController) {
             this.styleController = _options.styleController(this.view.domId);
         }
         else {
             const styleElement = createStyleSheet(this.view.domNode);
-            this.styleController = (/*#__PURE__*/ new DefaultStyleController(styleElement, this.view.domId));
+            this.styleController = ( (new DefaultStyleController(styleElement, this.view.domId)));
         }
-        this.spliceable = (/*#__PURE__*/ new CombinedSpliceable([
-            (/*#__PURE__*/ new TraitSpliceable(this.focus, this.view, _options.identityProvider)),
-            (/*#__PURE__*/ new TraitSpliceable(this.selection, this.view, _options.identityProvider)),
-            (/*#__PURE__*/ new TraitSpliceable(this.anchor, this.view, _options.identityProvider)),
+        this.spliceable = ( (new CombinedSpliceable([
+            ( (new TraitSpliceable(this.focus, this.view, _options.identityProvider))),
+            ( (new TraitSpliceable(this.selection, this.view, _options.identityProvider))),
+            ( (new TraitSpliceable(this.anchor, this.view, _options.identityProvider))),
             this.view
-        ]));
+        ])));
         this.disposables.add(this.focus);
         this.disposables.add(this.selection);
         this.disposables.add(this.anchor);
         this.disposables.add(this.view);
         this.disposables.add(this._onDidDispose);
-        this.disposables.add((/*#__PURE__*/ new DOMFocusController(this, this.view)));
+        this.disposables.add(( (new DOMFocusController(this, this.view))));
         if (typeof _options.keyboardSupport !== 'boolean' || _options.keyboardSupport) {
-            this.keyboardController = (/*#__PURE__*/ new KeyboardController(this, this.view, _options));
+            this.keyboardController = ( (new KeyboardController(this, this.view, _options)));
             this.disposables.add(this.keyboardController);
         }
         if (_options.keyboardNavigationLabelProvider) {
             const delegate = _options.keyboardNavigationDelegate || DefaultKeyboardNavigationDelegate;
-            this.typeNavigationController = (/*#__PURE__*/ new TypeNavigationController(
+            this.typeNavigationController = ( (new TypeNavigationController(
                 this,
                 this.view,
                 _options.keyboardNavigationLabelProvider,
                 _options.keyboardNavigationEventFilter ?? (() => true),
                 delegate
-            ));
+            )));
             this.disposables.add(this.typeNavigationController);
         }
         this.mouseController = this.createMouseController(_options);
@@ -4783,25 +4528,18 @@ class List {
     get onMouseOut() { return this.view.onMouseOut; }
     get onTouchStart() { return this.view.onTouchStart; }
     get onTap() { return this.view.onTap; }
-    /**
-     * Possible context menu trigger events:
-     * - ContextMenu key
-     * - Shift F10
-     * - Ctrl Option Shift M (macOS with VoiceOver)
-     * - Mouse right click
-     */
     get onContextMenu() {
         let didJustPressContextMenuKey = false;
-        const fromKeyDown = this.disposables.add(Event.chain(this.disposables.add((/*#__PURE__*/ new DomEmitter(this.view.domNode, 'keydown'))).event))
-            .map(e => (/*#__PURE__*/ new StandardKeyboardEvent(e)))
-            .filter(e => didJustPressContextMenuKey = e.keyCode === 58 /* KeyCode.ContextMenu */ || ((e.shiftKey && e.keyCode === 68) /* KeyCode.F10 */))
+        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((/*#__PURE__*/ new DomEmitter(this.view.domNode, 'keyup'))).event))
+        const fromKeyUp = this.disposables.add(Event.chain(this.disposables.add(( (new DomEmitter(this.view.domNode, 'keyup')))).event))
             .forEach(() => didJustPressContextMenuKey = false)
-            .map(e => (/*#__PURE__*/ new StandardKeyboardEvent(e)))
-            .filter(e => e.keyCode === 58 /* KeyCode.ContextMenu */ || ((e.shiftKey && e.keyCode === 68) /* KeyCode.F10 */))
+            .map(e => ( (new StandardKeyboardEvent(e))))
+            .filter(e => e.keyCode === 58  || ((e.shiftKey && e.keyCode === 68) ))
             .map(stopEvent)
             .map(({ browserEvent }) => {
             const focus = this.getFocus();
@@ -4817,13 +4555,15 @@ class List {
             .event;
         return Event.any(fromKeyDown, fromKeyUp, fromMouse);
     }
-    get onKeyDown() { return this.disposables.add((/*#__PURE__*/ new DomEmitter(this.view.domNode, 'keydown'))).event; }
-    get onKeyUp() { return this.disposables.add((/*#__PURE__*/ new DomEmitter(this.view.domNode, 'keyup'))).event; }
-    get onKeyPress() { return this.disposables.add((/*#__PURE__*/ new DomEmitter(this.view.domNode, 'keypress'))).event; }
-    get onDidFocus() { return Event.signal(this.disposables.add((/*#__PURE__*/ new DomEmitter(this.view.domNode, 'focus', true))).event); }
-    get onDidBlur() { return Event.signal(this.disposables.add((/*#__PURE__*/ new DomEmitter(this.view.domNode, 'blur', true))).event); }
+    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 (/*#__PURE__*/ new MouseController(this));
+        return (
+             (new MouseController(this))
+        );
     }
     updateOptions(optionsUpdate = {}) {
         this._options = { ...this._options, ...optionsUpdate };
@@ -4997,13 +4737,11 @@ class List {
             const previousScrollTop = this.view.getScrollTop();
             let nextpageScrollTop = previousScrollTop + this.view.renderHeight;
             if (lastPageIndex > currentlyFocusedElementIndex) {
-                // scroll last page element to the top only if the last page element is below the focused element
                 nextpageScrollTop -= this.view.elementHeight(lastPageIndex);
             }
             this.view.setScrollTop(nextpageScrollTop);
             if (this.view.getScrollTop() !== previousScrollTop) {
                 this.setFocus([]);
-                // Let the scroll event listener run
                 await timeout(0);
                 await this.focusNextPage(browserEvent, filter);
             }
@@ -5033,7 +4771,6 @@ class List {
             this.view.setScrollTop(scrollTop - this.view.renderHeight);
             if (this.view.getScrollTop() !== previousScrollTop) {
                 this.setFocus([]);
-                // Let the scroll event listener run
                 await timeout(0);
                 await this.focusPreviousPage(browserEvent, filter);
             }
@@ -5100,7 +4837,6 @@ class List {
         const elementTop = this.view.elementTop(index);
         const elementHeight = this.view.elementHeight(index);
         if (isNumber(relativeTop)) {
-            // y = mx + b
             const m = elementHeight - this.view.renderHeight;
             this.view.setScrollTop(m * clamp(relativeTop, 0, 1) + elementTop);
         }
@@ -5116,10 +4852,6 @@ class List {
             }
         }
     }
-    /**
-     * Returns the relative position of an element rendered in the list.
-     * Returns `null` if the element isn't *entirely* in the visible viewport.
-     */
     getRelativeTop(index) {
         if (index < 0 || index >= this.length) {
             throw new ListError(this.user, `Invalid index ${index}`);
@@ -5130,7 +4862,6 @@ class List {
         if (elementTop < scrollTop || elementTop + elementHeight > scrollTop + this.view.renderHeight) {
             return null;
         }
-        // y = mx + b
         const m = elementHeight - this.view.renderHeight;
         return Math.abs((scrollTop - elementTop) / m);
     }
@@ -5179,11 +4910,6 @@ class List {
         this._onDidDispose.dispose();
     }
 }
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
 function roundFloat(number, decimalPoints) {
     const decimal = Math.pow(10, decimalPoints);
     return Math.round(number * decimal) / decimal;
@@ -5211,12 +4937,6 @@ class HSLA {
     static equals(a, b) {
         return a.h === b.h && a.s === b.s && a.l === b.l && a.a === b.a;
     }
-    /**
-     * Converts an RGB color value to HSL. Conversion formula
-     * adapted from http://en.wikipedia.org/wiki/HSL_color_space.
-     * Assumes r, g, and b are contained in the set [0, 255] and
-     * returns h in the set [0, 360], s, and l in the set [0, 1].
-     */
     static fromRGBA(rgba) {
         const r = rgba.r / 255;
         const g = rgba.g / 255;
@@ -5244,7 +4964,9 @@ class HSLA {
             h *= 60;
             h = Math.round(h);
         }
-        return (/*#__PURE__*/ new HSLA(h, s, l, a));
+        return (
+             (new HSLA(h, s, l, a))
+        );
     }
     static _hue2rgb(p, q, t) {
         if (t < 0) {
@@ -5264,18 +4986,12 @@ class HSLA {
         }
         return p;
     }
-    /**
-     * Converts an HSL color value to RGB. Conversion formula
-     * adapted from http://en.wikipedia.org/wiki/HSL_color_space.
-     * Assumes h in the set [0, 360] s, and l are contained in the set [0, 1] and
-     * returns r, g, and b in the set [0, 255].
-     */
     static toRGBA(hsla) {
         const h = hsla.h / 360;
         const { s, l, a } = hsla;
         let r, g, b;
         if (s === 0) {
-            r = g = b = l; // achromatic
+            r = g = b = l;
         }
         else {
             const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
@@ -5284,7 +5000,9 @@ class HSLA {
             g = HSLA._hue2rgb(p, q, h);
             b = HSLA._hue2rgb(p, q, h - 1 / 3);
         }
-        return (/*#__PURE__*/ new RGBA(Math.round(r * 255), Math.round(g * 255), Math.round(b * 255), a));
+        return (
+             (new RGBA(Math.round(r * 255), Math.round(g * 255), Math.round(b * 255), a))
+        );
     }
 }
 class HSVA {
@@ -5298,7 +5016,6 @@ class HSVA {
     static equals(a, b) {
         return a.h === b.h && a.s === b.s && a.v === b.v && a.a === b.a;
     }
-    // from http://www.rapidtables.com/convert/color/rgb-to-hsv.htm
     static fromRGBA(rgba) {
         const r = rgba.r / 255;
         const g = rgba.g / 255;
@@ -5320,9 +5037,10 @@ class HSVA {
         else {
             m = ((r - g) / delta) + 4;
         }
-        return (/*#__PURE__*/ new HSVA(Math.round(m * 60), s, cmax, rgba.a));
+        return (
+             (new HSVA(Math.round(m * 60), s, cmax, rgba.a))
+        );
     }
-    // from http://www.rapidtables.com/convert/color/hsv-to-rgb.htm
     static toRGBA(hsva) {
         const { h, s, v, a } = hsva;
         const c = v * s;
@@ -5356,7 +5074,9 @@ class HSVA {
         r = Math.round((r + m) * 255);
         g = Math.round((g + m) * 255);
         b = Math.round((b + m) * 255);
-        return (/*#__PURE__*/ new RGBA(r, g, b, a));
+        return (
+             (new RGBA(r, g, b, a))
+        );
     }
 }
 class Color {
@@ -5399,10 +5119,6 @@ class Color {
     equals(other) {
         return !!other && RGBA.equals(this.rgba, other.rgba) && HSLA.equals(this.hsla, other.hsla) && HSVA.equals(this.hsva, other.hsva);
     }
-    /**
-     * http://www.w3.org/TR/WCAG20/#relativeluminancedef
-     * Returns the number in the set [0, 1]. O => Darkest Black. 1 => Lightest white.
-     */
     getRelativeLuminance() {
         const R = Color._relativeLuminanceForComponent(this.rgba.r);
         const G = Color._relativeLuminanceForComponent(this.rgba.g);
@@ -5414,27 +5130,15 @@ class Color {
         const c = color / 255;
         return (c <= 0.03928) ? c / 12.92 : Math.pow(((c + 0.055) / 1.055), 2.4);
     }
-    /**
-     * http://www.w3.org/TR/WCAG20/#contrast-ratiodef
-     * Returns the contrast ration number in the set [1, 21].
-     */
     getContrastRatio(another) {
         const lum1 = this.getRelativeLuminance();
         const lum2 = another.getRelativeLuminance();
         return lum1 > lum2 ? (lum1 + 0.05) / (lum2 + 0.05) : (lum2 + 0.05) / (lum1 + 0.05);
     }
-    /**
-     *	http://24ways.org/2010/calculating-color-contrast
-     *  Return 'true' if darker color otherwise 'false'
-     */
     isDarker() {
         const yiq = (this.rgba.r * 299 + this.rgba.g * 587 + this.rgba.b * 114) / 1000;
         return yiq < 128;
     }
-    /**
-     *	http://24ways.org/2010/calculating-color-contrast
-     *  Return 'true' if lighter color otherwise 'false'
-     */
     isLighter() {
         const yiq = (this.rgba.r * 299 + this.rgba.g * 587 + this.rgba.b * 114) / 1000;
         return yiq >= 128;
@@ -5450,14 +5154,24 @@ class Color {
         return lum1 < lum2;
     }
     lighten(factor) {
-        return (/*#__PURE__*/ new Color((/*#__PURE__*/ new HSLA(this.hsla.h, this.hsla.s, this.hsla.l + this.hsla.l * factor, this.hsla.a))));
+        return (
+             (new Color(
+                 (new HSLA(this.hsla.h, this.hsla.s, this.hsla.l + this.hsla.l * factor, this.hsla.a))
+            ))
+        );
     }
     darken(factor) {
-        return (/*#__PURE__*/ new Color((/*#__PURE__*/ new HSLA(this.hsla.h, this.hsla.s, this.hsla.l - this.hsla.l * factor, this.hsla.a))));
+        return (
+             (new Color(
+                 (new HSLA(this.hsla.h, this.hsla.s, this.hsla.l - this.hsla.l * factor, this.hsla.a))
+            ))
+        );
     }
     transparent(factor) {
         const { r, g, b, a } = this.rgba;
-        return (/*#__PURE__*/ new Color((/*#__PURE__*/ new RGBA(r, g, b, a * factor))));
+        return (
+             (new Color( (new RGBA(r, g, b, a * factor))))
+        );
     }
     isTransparent() {
         return this.rgba.a === 0;
@@ -5466,11 +5180,14 @@ class Color {
         return this.rgba.a === 1;
     }
     opposite() {
-        return (/*#__PURE__*/ new Color((/*#__PURE__*/ new RGBA(255 - this.rgba.r, 255 - this.rgba.g, 255 - this.rgba.b, this.rgba.a))));
+        return (
+             (new Color(
+                 (new RGBA(255 - this.rgba.r, 255 - this.rgba.g, 255 - this.rgba.b, this.rgba.a))
+            ))
+        );
     }
     blend(c) {
         const rgba = c.rgba;
-        // Convert to 0..1 opacity
         const thisA = this.rgba.a;
         const colorA = rgba.a;
         const a = thisA + colorA * (1 - thisA);
@@ -5480,21 +5197,23 @@ class Color {
         const r = this.rgba.r * thisA / a + rgba.r * colorA * (1 - thisA) / a;
         const g = this.rgba.g * thisA / a + rgba.g * colorA * (1 - thisA) / a;
         const b = this.rgba.b * thisA / a + rgba.b * colorA * (1 - thisA) / a;
-        return (/*#__PURE__*/ new Color((/*#__PURE__*/ new RGBA(r, g, b, a))));
+        return (
+             (new Color( (new RGBA(r, g, b, a))))
+        );
     }
     makeOpaque(opaqueBackground) {
         if (this.isOpaque() || opaqueBackground.rgba.a !== 1) {
-            // only allow to blend onto a non-opaque color onto a opaque color
             return this;
         }
         const { r, g, b, a } = this.rgba;
-        // https://stackoverflow.com/questions/12228548/finding-equivalent-color-with-opacity
-        return (/*#__PURE__*/ new Color((/*#__PURE__*/ new RGBA(
-            opaqueBackground.rgba.r - a * (opaqueBackground.rgba.r - r),
-            opaqueBackground.rgba.g - a * (opaqueBackground.rgba.g - g),
-            opaqueBackground.rgba.b - a * (opaqueBackground.rgba.b - b),
-            1
-        ))));
+        return (
+             (new Color( (new RGBA(
+                opaqueBackground.rgba.r - a * (opaqueBackground.rgba.r - r),
+                opaqueBackground.rgba.g - a * (opaqueBackground.rgba.g - g),
+                opaqueBackground.rgba.b - a * (opaqueBackground.rgba.b - b),
+                1
+            ))))
+        );
     }
     flatten(...backgrounds) {
         const background = backgrounds.reduceRight((accumulator, color) => {
@@ -5504,11 +5223,13 @@ class Color {
     }
     static _flatten(foreground, background) {
         const backgroundAlpha = 1 - foreground.rgba.a;
-        return (/*#__PURE__*/ new Color((/*#__PURE__*/ new RGBA(
-            backgroundAlpha * background.rgba.r + foreground.rgba.a * foreground.rgba.r,
-            backgroundAlpha * background.rgba.g + foreground.rgba.a * foreground.rgba.g,
-            backgroundAlpha * background.rgba.b + foreground.rgba.a * foreground.rgba.b
-        ))));
+        return (
+             (new Color( (new RGBA(
+                backgroundAlpha * background.rgba.r + foreground.rgba.a * foreground.rgba.r,
+                backgroundAlpha * background.rgba.g + foreground.rgba.a * foreground.rgba.g,
+                backgroundAlpha * background.rgba.b + foreground.rgba.a * foreground.rgba.b
+            ))))
+        );
     }
     toString() {
         if (!this._toString) {
@@ -5524,7 +5245,9 @@ class Color {
         const lum1 = of.getRelativeLuminance();
         const lum2 = relative.getRelativeLuminance();
         factor = factor * (lum2 - lum1) / lum2;
-        return (/*#__PURE__*/ of.lighten(factor));
+        return (
+             (of.lighten(factor))
+        );
     }
     static getDarkerColor(of, relative, factor) {
         if (of.isDarkerThan(relative)) {
@@ -5534,20 +5257,22 @@ class Color {
         const lum1 = of.getRelativeLuminance();
         const lum2 = relative.getRelativeLuminance();
         factor = factor * (lum1 - lum2) / lum1;
-        return (/*#__PURE__*/ of.darken(factor));
+        return (
+             (of.darken(factor))
+        );
     }
 }
-Color.white = (/*#__PURE__*/ new Color((/*#__PURE__*/ new RGBA(255, 255, 255, 1))));
-Color.black = (/*#__PURE__*/ new Color((/*#__PURE__*/ new RGBA(0, 0, 0, 1))));
-Color.red = (/*#__PURE__*/ new Color((/*#__PURE__*/ new RGBA(255, 0, 0, 1))));
-Color.blue = (/*#__PURE__*/ new Color((/*#__PURE__*/ new RGBA(0, 0, 255, 1))));
-Color.green = (/*#__PURE__*/ new Color((/*#__PURE__*/ new RGBA(0, 255, 0, 1))));
-Color.cyan = (/*#__PURE__*/ new Color((/*#__PURE__*/ new RGBA(0, 255, 255, 1))));
-Color.lightgrey = (/*#__PURE__*/ new Color((/*#__PURE__*/ new RGBA(211, 211, 211, 1))));
-Color.transparent = (/*#__PURE__*/ new Color((/*#__PURE__*/ new RGBA(0, 0, 0, 0))));
-(/*#__PURE__*/ (function(Color) {
-    (/*#__PURE__*/ (function(Format) {
-        (/*#__PURE__*/ (function(CSS) {
+Color.white = ( (new Color( (new RGBA(255, 255, 255, 1)))));
+Color.black = ( (new Color( (new RGBA(0, 0, 0, 1)))));
+Color.red = ( (new Color( (new RGBA(255, 0, 0, 1)))));
+Color.blue = ( (new Color( (new RGBA(0, 0, 255, 1)))));
+Color.green = ( (new Color( (new RGBA(0, 255, 0, 1)))));
+Color.cyan = ( (new Color( (new RGBA(0, 255, 255, 1)))));
+Color.lightgrey = ( (new Color( (new RGBA(211, 211, 211, 1)))));
+Color.transparent = ( (new Color( (new RGBA(0, 0, 0, 0)))));
+( ((function(Color) {
+    ( ((function(Format) {
+        ( ((function(CSS) {
             function formatRGB(color) {
                 if (color.rgba.a === 1) {
                     return `rgb(${color.rgba.r}, ${color.rgba.g}, ${color.rgba.b})`;
@@ -5571,20 +5296,13 @@ Color.transparent = (/*#__PURE__*/ new Color((/*#__PURE__*/ new RGBA(0, 0, 0, 0)
             }
             CSS.formatHSLA = formatHSLA;
             function _toTwoDigitHex(n) {
-                const r = (/*#__PURE__*/ n.toString(16));
+                const r = ( (n.toString(16)));
                 return r.length !== 2 ? '0' + r : r;
             }
-            /**
-             * Formats the color as #RRGGBB
-             */
             function formatHex(color) {
                 return `#${_toTwoDigitHex(color.rgba.r)}${_toTwoDigitHex(color.rgba.g)}${_toTwoDigitHex(color.rgba.b)}`;
             }
             CSS.formatHex = formatHex;
-            /**
-             * Formats the color as #RRGGBBAA
-             * If 'compact' is set, colors without transparancy will be printed as #RRGGBB
-             */
             function formatHexA(color, compact = false) {
                 if (compact && color.rgba.a === 1) {
                     return Color.Format.CSS.formatHex(color);
@@ -5592,9 +5310,6 @@ Color.transparent = (/*#__PURE__*/ new Color((/*#__PURE__*/ new RGBA(0, 0, 0, 0)
                 return `#${_toTwoDigitHex(color.rgba.r)}${_toTwoDigitHex(color.rgba.g)}${_toTwoDigitHex(color.rgba.b)}${_toTwoDigitHex(Math.round(color.rgba.a * 255))}`;
             }
             CSS.formatHexA = formatHexA;
-            /**
-             * The default format will use HEX if opaque and RGBA otherwise.
-             */
             function format(color) {
                 if (color.isOpaque()) {
                     return Color.Format.CSS.formatHex(color);
@@ -5602,120 +5317,105 @@ Color.transparent = (/*#__PURE__*/ new Color((/*#__PURE__*/ new RGBA(0, 0, 0, 0)
                 return Color.Format.CSS.formatRGBA(color);
             }
             CSS.format = format;
-            /**
-             * Converts an Hex color value to a Color.
-             * returns r, g, and b are contained in the set [0, 255]
-             * @param hex string (#RGB, #RGBA, #RRGGBB or #RRGGBBAA).
-             */
             function parseHex(hex) {
                 const length = hex.length;
                 if (length === 0) {
-                    // Invalid color
                     return null;
                 }
-                if (hex.charCodeAt(0) !== 35 /* CharCode.Hash */) {
-                    // Does not begin with a #
+                if (hex.charCodeAt(0) !== 35 ) {
                     return null;
                 }
                 if (length === 7) {
-                    // #RRGGBB format
                     const r = 16 * _parseHexDigit(hex.charCodeAt(1)) + _parseHexDigit(hex.charCodeAt(2));
                     const g = 16 * _parseHexDigit(hex.charCodeAt(3)) + _parseHexDigit(hex.charCodeAt(4));
                     const b = 16 * _parseHexDigit(hex.charCodeAt(5)) + _parseHexDigit(hex.charCodeAt(6));
-                    return (/*#__PURE__*/ new Color((/*#__PURE__*/ new RGBA(r, g, b, 1))));
+                    return (
+                         (new Color( (new RGBA(r, g, b, 1))))
+                    );
                 }
                 if (length === 9) {
-                    // #RRGGBBAA format
                     const r = 16 * _parseHexDigit(hex.charCodeAt(1)) + _parseHexDigit(hex.charCodeAt(2));
                     const g = 16 * _parseHexDigit(hex.charCodeAt(3)) + _parseHexDigit(hex.charCodeAt(4));
                     const b = 16 * _parseHexDigit(hex.charCodeAt(5)) + _parseHexDigit(hex.charCodeAt(6));
                     const a = 16 * _parseHexDigit(hex.charCodeAt(7)) + _parseHexDigit(hex.charCodeAt(8));
-                    return (/*#__PURE__*/ new Color((/*#__PURE__*/ new RGBA(r, g, b, a / 255))));
+                    return (
+                         (new Color( (new RGBA(r, g, b, a / 255))))
+                    );
                 }
                 if (length === 4) {
-                    // #RGB format
                     const r = _parseHexDigit(hex.charCodeAt(1));
                     const g = _parseHexDigit(hex.charCodeAt(2));
                     const b = _parseHexDigit(hex.charCodeAt(3));
-                    return (/*#__PURE__*/ new Color((/*#__PURE__*/ new RGBA(16 * r + r, 16 * g + g, 16 * b + b))));
+                    return (
+                         (new Color( (new RGBA(16 * r + r, 16 * g + g, 16 * b + b))))
+                    );
                 }
                 if (length === 5) {
-                    // #RGBA format
                     const r = _parseHexDigit(hex.charCodeAt(1));
                     const g = _parseHexDigit(hex.charCodeAt(2));
                     const b = _parseHexDigit(hex.charCodeAt(3));
                     const a = _parseHexDigit(hex.charCodeAt(4));
-                    return (/*#__PURE__*/ new Color((/*#__PURE__*/ new RGBA(16 * r + r, 16 * g + g, 16 * b + b, (16 * a + a) / 255))));
+                    return (
+                         (new Color(
+                             (new RGBA(16 * r + r, 16 * g + g, 16 * b + b, (16 * a + a) / 255))
+                        ))
+                    );
                 }
-                // Invalid color
                 return null;
             }
             CSS.parseHex = parseHex;
             function _parseHexDigit(charCode) {
                 switch (charCode) {
-                    case 48 /* CharCode.Digit0 */: return 0;
-                    case 49 /* CharCode.Digit1 */: return 1;
-                    case 50 /* CharCode.Digit2 */: return 2;
-                    case 51 /* CharCode.Digit3 */: return 3;
-                    case 52 /* CharCode.Digit4 */: return 4;
-                    case 53 /* CharCode.Digit5 */: return 5;
-                    case 54 /* CharCode.Digit6 */: return 6;
-                    case 55 /* CharCode.Digit7 */: return 7;
-                    case 56 /* CharCode.Digit8 */: return 8;
-                    case 57 /* CharCode.Digit9 */: return 9;
-                    case 97 /* CharCode.a */: return 10;
-                    case 65 /* CharCode.A */: return 10;
-                    case 98 /* CharCode.b */: return 11;
-                    case 66 /* CharCode.B */: return 11;
-                    case 99 /* CharCode.c */: return 12;
-                    case 67 /* CharCode.C */: return 12;
-                    case 100 /* CharCode.d */: return 13;
-                    case 68 /* CharCode.D */: return 13;
-                    case 101 /* CharCode.e */: return 14;
-                    case 69 /* CharCode.E */: return 14;
-                    case 102 /* CharCode.f */: return 15;
-                    case 70 /* CharCode.F */: return 15;
+                    case 48 : return 0;
+                    case 49 : return 1;
+                    case 50 : return 2;
+                    case 51 : return 3;
+                    case 52 : return 4;
+                    case 53 : return 5;
+                    case 54 : return 6;
+                    case 55 : return 7;
+                    case 56 : return 8;
+                    case 57 : return 9;
+                    case 97 : return 10;
+                    case 65 : return 10;
+                    case 98 : return 11;
+                    case 66 : return 11;
+                    case 99 : return 12;
+                    case 67 : return 12;
+                    case 100 : return 13;
+                    case 68 : return 13;
+                    case 101 : return 14;
+                    case 69 : return 14;
+                    case 102 : return 15;
+                    case 70 : return 15;
                 }
                 return 0;
             }
-        })(Format.CSS || (Format.CSS = {})));
-    })(Color.Format || (Color.Format = {})));
-})(Color || (Color = {})));
-
+        })(Format.CSS || (Format.CSS = {}))));
+    })(Color.Format || (Color.Format = {}))));
+})(Color || (Color = {}))));
 var _a, _b;
-// Monaco build process treeshaking is very aggressive and everything that is not used in monaco is removed
-// Unfortunately, it makes some class not respect anymore the interface they are supposed to implement
-// In this file we are restoring some method that are treeshaked out of monaco-editor but that are needed in this library
 if (SnippetParser.prototype.text == null) {
     SnippetParser.prototype.text = function (value) {
-        return this.parse(value).toString();
+        return ( this.parse(value).toString());
     };
 }
 else {
     console.warn('Useless polyfill: SnippetParser');
 }
-/**
- * Assign all properties of b to A
- */
 function polyfillPrototypeSimple(a, b) {
     Object.defineProperties(a, Object.getOwnPropertyDescriptors(b));
 }
-/**
- * Sometime, the simple prototype is not enough
- * It can happens if the function are returning or taking as parameter instances of the said class
- * In that case, we need to transform parameters to VSCode instances and result back to a monaco instance
- */
 function polyfillPrototype(a, b, toA, toB) {
     for (const key of Object.getOwnPropertyNames(b)) {
         if (!Object.hasOwnProperty.call(a, key)) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             a[key] = function (...args) {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 return toA(b[key].call(this, ...args.map(toB)));
             };
         }
     }
 }
+polyfillPrototypeSimple(LogService$1.prototype, LogService.prototype);
 polyfillPrototypeSimple(List$1.prototype, List.prototype);
 polyfillPrototypeSimple(WorkspaceFolder$1.prototype, WorkspaceFolder.prototype);
 polyfillPrototypeSimple(LanguagesRegistry$1.prototype, LanguagesRegistry.prototype);
@@ -5725,54 +5425,36 @@ polyfillPrototypeSimple(Configuration$1.prototype, Configuration.prototype);
 polyfillPrototypeSimple(TernarySearchTree$1.prototype, TernarySearchTree.prototype);
 polyfillPrototypeSimple(StandaloneConfigurationService$1.prototype, StandaloneConfigurationService.prototype);
 polyfillPrototypeSimple(LanguageService$1.prototype, LanguageService.prototype);
-polyfillPrototypeSimple(NoOpNotification$1.prototype, NoOpNotification.prototype);
+polyfillPrototypeSimple(NoOpNotification.prototype, NoOpNotification$1.prototype);
 polyfillPrototypeSimple(Themable$1.prototype, Themable.prototype);
 polyfillPrototypeSimple(ProgressBar$1.prototype, ProgressBar.prototype);
-const jsonContributionRegistry = Registry.as(Extensions.JSONContribution);
+const jsonContributionRegistry = ( Registry.as(Extensions.JSONContribution));
 jsonContributionRegistry.getSchemaContributions ?? (jsonContributionRegistry.getSchemaContributions = () => ({
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     schemas: jsonContributionRegistry.schemasById
 }));
-// @ts-ignore Override of a readonly property
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 jsonContributionRegistry.onDidChangeSchema ?? (jsonContributionRegistry.onDidChangeSchema = jsonContributionRegistry._onDidChangeSchema.event);
-const themeRegistry = Registry.as(Extensions$1.ThemingContribution);
-// @ts-ignore Override of a readonly property
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const themeRegistry = ( Registry.as(Extensions$1.ThemingContribution));
 themeRegistry.onThemingParticipantAdded ?? (themeRegistry.onThemingParticipantAdded = themeRegistry.onThemingParticipantAddedEmitter.event);
-const configurationRegistry = Registry.as(Extensions$2.Configuration);
-// @ts-ignore Override of a readonly property
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const configurationRegistry = ( Registry.as(Extensions$2.Configuration));
 configurationRegistry.onDidUpdateConfiguration ?? (configurationRegistry.onDidUpdateConfiguration = configurationRegistry._onDidUpdateConfiguration.event);
-// @ts-ignore Override of a readonly property
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 configurationRegistry.onDidSchemaChange ?? (configurationRegistry.onDidSchemaChange = configurationRegistry._onDidSchemaChange.event);
 configurationRegistry.notifyConfigurationSchemaUpdated ?? (configurationRegistry.notifyConfigurationSchemaUpdated = () => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     configurationRegistry._onDidSchemaChange.fire();
 });
-// @ts-ignore Override of a readonly property
-(_a = NoOpNotification$1.prototype).onDidClose ?? (_a.onDidClose = Event.None);
+(_a = NoOpNotification.prototype).onDidClose ?? (_a.onDidClose = Event.None);
 function polyfillQuickInput(fn) {
     return function () {
         const quickInput = fn.call(this);
-        // @ts-ignore Override of a readonly property
         quickInput.onDidTriggerButton ?? (quickInput.onDidTriggerButton = quickInput.onDidTriggerButtonEmitter.event);
         return quickInput;
     };
 }
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 QuickInputController.prototype.createQuickPick = polyfillQuickInput(QuickInputController.prototype.createQuickPick);
 QuickInputController.prototype.createInputBox = polyfillQuickInput(QuickInputController.prototype.createInputBox);
 const StandaloneUriLabelService = getSingletonServiceDescriptors().find(([id]) => id === ILabelService)[1].ctor;
 (_b = StandaloneUriLabelService.prototype).onDidChangeFormatters ?? (_b.onDidChangeFormatters = Event.None);
-// A lot of methods from VSBuffer are treeshaked out of monaco editor, we need to restore them here
-// Also we cannot just use the VSCode impl because:
-// - The vscode code receives instances created inside monaco code
-// - VSCode does `instanceof` on instances that need to work
 function toVSCodeVSBuffer(value) {
     if (value instanceof VSBuffer$1) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return VSBuffer.wrap(value.buffer);
     }
     return value;
@@ -5785,18 +5467,13 @@ function toMonacoVSBuffer(value) {
 }
 for (const key of Object.getOwnPropertyNames(VSBuffer)) {
     if (!Object.hasOwnProperty.call(VSBuffer$1, key)) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const method = VSBuffer[key];
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         VSBuffer[key] = VSBuffer$1[key] = function (...args) {
             return toMonacoVSBuffer(method.call(VSBuffer$1, ...args.map(toVSCodeVSBuffer)));
         };
     }
 }
 polyfillPrototype(VSBuffer$1.prototype, VSBuffer.prototype, toMonacoVSBuffer, toVSCodeVSBuffer);
-// Some methods of the Color class need to be restored, but they sometime return an instance of the Color class
-// We need the returned instance to be an instance of the monaco Color class (and not the VSCode one) because there is some `instanceof` in the monaco code
-// So we transform the returned VSCode Color instance to monaco Color instance in polyfilled methods
 function toMonacoColor(value) {
     if (value instanceof Color) {
         return new Color$1(value.rgba);
@@ -5805,11 +5482,9 @@ function toMonacoColor(value) {
 }
 function toVSCodeColor(value) {
     if (value instanceof Color$1) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return new Color(value.rgba);
     }
     return value;
 }
 polyfillPrototype(Color$1.prototype, Color.prototype, toMonacoColor, toVSCodeColor);
-
-export { ConfigurationModelParser as C, Emitter as E, NotImplementedError as N, ResourceSet as R, UserSettings as U, parseTree as a, isReadableStream as b, createScanner as c, disposed as d, peekStream as e, findNodeAtLocation as f, getErrorMessage as g, peekReadable as h, isWorkspaceIdentifier as i, bufferToReadable as j, consumeStream as k, isReadableBufferedStream as l, listenStream as m, bufferedStreamToBuffer as n, readableToBuffer as o, parse as p, newWriteableBufferStream as q, readonly as r, streamToBuffer as s, transform as t, newWriteableStream as u, visit as v, getNodeType as w };
+export { ConsoleMainLogger as C, Emitter as E, NotImplementedError as N, ResourceSet as R, UserSettings as U, isReadableStream as a, peekReadable as b, bufferToReadable as c, disposed as d, consumeStream as e, isReadableBufferedStream as f, bufferedStreamToBuffer as g, readableToBuffer as h, isWorkspaceIdentifier as i, newWriteableStream as j, parse as k, listenStream as l, getNodeType as m, newWriteableBufferStream as n, peekStream as p, readonly as r, streamToBuffer as s, transform as t };